tracing-journald: make level mappings configurable

Author: Corentin Henry

tracing-journald/src/lib.rs

@@ -62,7 +62,7 @@ mod socket;
 /// names by translating `.`s into `_`s, stripping leading `_`s and non-ascii-alphanumeric
 /// characters other than `_`, and upcasing.
 ///
-/// Levels are mapped losslessly to journald `PRIORITY` values as follows:
+/// By default, levels are mapped losslessly to journald `PRIORITY` values as follows:
 ///
 /// - `ERROR` => Error (3)
 /// - `WARN` => Warning (4)
@@ -85,6 +85,7 @@ pub struct Subscriber {
     socket: UnixDatagram,
     field_prefix: Option<String>,
     syslog_identifier: String,
+    priority_mappings: PriorityMappings,
 }
 
 #[cfg(unix)]
@@ -109,6 +110,7 @@ impl Subscriber {
                     .map(|n| n.to_string_lossy().into_owned())
                     // If we fail to get the name of the current executable fall back to an empty string.
                     .unwrap_or_else(String::new),
+                priority_mappings: PriorityMappings::new(),
             };
             // Check that we can talk to journald, by sending empty payload which journald discards.
             // However if the socket didn't exist or if none listened we'd get an error here.
@@ -129,6 +131,12 @@ impl Subscriber {
         self
     }
 
+    /// Sets the mappings from the tracing level to the journald priorities.
+    pub fn with_priority_mappings(mut self, mappings: PriorityMappings) -> Self {
+        self.priority_mappings = mappings;
+        self
+    }
+
     /// Sets the syslog identifier for this logger.
     ///
     /// The syslog identifier comes from the classic syslog interface (`openlog()`
@@ -198,6 +206,20 @@ impl Subscriber {
         memfd::seal_fully(mem.as_raw_fd())?;
         socket::send_one_fd_to(&self.socket, mem.as_raw_fd(), JOURNALD_PATH)
     }
+
+    fn put_priority(&self, buf: &mut Vec<u8>, meta: &Metadata) {
+        put_field_wellformed(
+            buf,
+            "PRIORITY",
+            &[match *meta.level() {
+                Level::ERROR => self.priority_mappings.error.as_u8(),
+                Level::WARN => self.priority_mappings.warn.as_u8(),
+                Level::INFO => self.priority_mappings.info.as_u8(),
+                Level::DEBUG => self.priority_mappings.debug.as_u8(),
+                Level::TRACE => self.priority_mappings.trace.as_u8(),
+            }],
+        );
+    }
 }
 
 /// Construct a journald subscriber
@@ -252,7 +274,7 @@ where
         }
 
         // Record event fields
-        put_priority(&mut buf, event.metadata());
+        self.put_priority(&mut buf, event.metadata());
         put_metadata(&mut buf, event.metadata(), None);
         put_field_length_encoded(&mut buf, "SYSLOG_IDENTIFIER", |buf| {
             write!(buf, "{}", self.syslog_identifier).unwrap()
@@ -339,18 +361,151 @@ impl Visit for EventVisitor<'_> {
     }
 }
 
-fn put_priority(buf: &mut Vec<u8>, meta: &Metadata) {
-    put_field_wellformed(
-        buf,
-        "PRIORITY",
-        match *meta.level() {
-            Level::ERROR => b"3",
-            Level::WARN => b"4",
-            Level::INFO => b"5",
-            Level::DEBUG => b"6",
-            Level::TRACE => b"7",
-        },
-    );
+// Descriptions and examples taken from the Archlinux wiki:
+// https://wiki.archlinux.org/title/Systemd/Journal#Priority_level
+/// A priority (in syslog called severity code) is used to mark the
+/// importance of a message.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub enum Priority {
+    /// System is unusable.
+    ///
+    /// Examples:
+    ///
+    /// - severe Kernel BUG
+    /// - systemd dumped core
+    ///
+    /// This level should not be used by applications.
+    Emergency,
+    /// Should be corrected immediately.
+    ///
+    /// Examples:
+    ///
+    /// - Vital subsystem goes out of work, data loss:
+    /// - `kernel: BUG: unable to handle kernel paging request at ffffc90403238ffc`
+    Alert,
+    /// Critical conditions
+    ///
+    /// Examples:
+    ///
+    /// - Crashe, coredumps
+    /// - `systemd-coredump[25319]: Process 25310 (plugin-container) of user 1000 dumped core`
+    Critical,
+    /// Error conditions
+    ///
+    /// Examples:
+    ///
+    /// - Not severe error reported
+    /// - `kernel: usb 1-3: 3:1: cannot get freq at ep 0x84, systemd[1]: Failed unmounting /var`
+    /// - `libvirtd[1720]: internal error: Failed to initialize a valid firewall backend`
+    Error,
+    /// May indicate that an error will occur if action is not taken.
+    ///
+    /// Examples:
+    ///
+    /// - a non-root file system has only 1GB free
+    /// - `org.freedesktop. Notifications[1860]: (process:5999): Gtk-WARNING **: Locale not supported by C library. Using the fallback 'C' locale`
+    Warning,
+    /// Events that are unusual, but not error conditions.
+    ///
+    /// Examples:
+    ///
+    /// - `systemd[1]: var.mount: Directory /var to mount over is not empty, mounting anyway`
+    /// - `gcr-prompter[4997]: Gtk: GtkDialog mapped without a transient parent. This is discouraged`
+    Notice,
+    /// Normal operational messages that require no action.
+    ///
+    /// Example: `lvm[585]: 7 logical volume(s) in volume group "archvg" now active`
+    Informational,
+    /// Information useful to developers for debugging the
+    /// application.
+    ///
+    /// Example: `kdeinit5[1900]: powerdevil: Scheduling inhibition from ":1.14" "firefox" with cookie 13 and reason "screen"`
+    Debug,
+}
+
+impl Priority {
+    fn as_u8(&self) -> u8 {
+        match self {
+            Self::Emergency => b'0',
+            Self::Alert => b'1',
+            Self::Critical => b'2',
+            Self::Error => b'3',
+            Self::Warning => b'4',
+            Self::Notice => b'5',
+            Self::Informational => b'6',
+            Self::Debug => b'7',
+        }
+    }
+}
+
+/// Mappings from the tracing levels to the journald priorities.
+#[derive(Debug, Clone)]
+pub struct PriorityMappings {
+    /// Priority mapped to the `ERROR` level
+    pub error: Priority,
+    /// Priority mapped to the `WARN` level
+    pub warn: Priority,
+    /// Priority mapped to the `INFO` level
+    pub info: Priority,
+    /// Priority mapped to the `DEBUG` level
+    pub debug: Priority,
+    /// Priority mapped to the `TRACE` level
+    pub trace: Priority,
+}
+
+impl PriorityMappings {
+    /// Create new default mappings:
+    ///
+    /// - [`tracing::Level::ERROR`]: Error (3)
+    /// - [`tracing::Level::WARN`]: Warning (4)
+    /// - [`tracing::Level::INFO`]: Notice (5)
+    /// - [`tracing::Level::DEBUG`]: Informational (6)
+    /// - [`tracing::Level::TRACE`]: Debug (7)
+    pub fn new() -> PriorityMappings {
+        Self {
+            error: Priority::Error,
+            warn: Priority::Warning,
+            info: Priority::Notice,
+            debug: Priority::Informational,
+            trace: Priority::Debug,
+        }
+    }
+
+    /// Map the `ERROR` level to the given priority
+    pub fn with_error(mut self, priority: Priority) -> Self {
+        self.error = priority;
+        self
+    }
+
+    /// Map the `WARN` level to the given priority
+    pub fn with_warn(mut self, priority: Priority) -> Self {
+        self.warn = priority;
+        self
+    }
+
+    /// Map the `INFO` level to the given priority
+    pub fn with_info(mut self, priority: Priority) -> Self {
+        self.info = priority;
+        self
+    }
+
+    /// Map the `DEBUG` level to the given priority
+    pub fn with_debug(mut self, priority: Priority) -> Self {
+        self.debug = priority;
+        self
+    }
+
+    /// Map the `TRACE` level to the given priority
+    pub fn with_trace(mut self, priority: Priority) -> Self {
+        self.trace = priority;
+        self
+    }
+}
+
+impl Default for PriorityMappings {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 fn put_metadata(buf: &mut Vec<u8>, meta: &Metadata, prefix: Option<&str>) {