grow-graylog 0.2.0

Rust SDK for Graylog Open by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! `log::Log` implementation that forwards `log` records to a [`LogClient`].

use std::fmt;
use std::sync::Arc;

use log::kv::{self, VisitSource};
use log::{Level, LevelFilter, Log, Metadata, Record};

use super::{AttrValue, Attributes, LogClient, LogEntry, LogInput, Severity};

/// Forwards `log` records (message, target, file, line and key-values) to a [`LogClient`].
///
/// ```no_run
/// # use std::sync::Arc;
/// # use grow_graylog::logging::{LogBridge, LogClient};
/// # fn demo(client: Arc<dyn LogClient>) {
/// LogBridge::new(client).with_max_level(log::LevelFilter::Info).init().unwrap();
/// log::info!(user = "ada"; "signed in");
/// # }
/// ```
pub struct LogBridge {
    client: Arc<dyn LogClient>,
    max_level: LevelFilter,
    own_crate: String,
}

impl fmt::Debug for LogBridge {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LogBridge")
            .field("max_level", &self.max_level)
            .finish()
    }
}

/// Maps a `log` level to a severity.
pub(crate) fn severity_of(level: Level) -> Severity {
    match level {
        Level::Trace => Severity::Trace,
        Level::Debug => Severity::Debug,
        Level::Info => Severity::Info,
        Level::Warn => Severity::Warn,
        Level::Error => Severity::Error,
    }
}

struct KvVisitor<'a>(&'a mut Attributes);

impl<'kvs> VisitSource<'kvs> for KvVisitor<'_> {
    fn visit_pair(&mut self, key: kv::Key<'kvs>, value: kv::Value<'kvs>) -> Result<(), kv::Error> {
        let v: AttrValue = if let Some(b) = value.to_bool() {
            b.into()
        } else if let Some(i) = value.to_i64() {
            i.into()
        } else if let Some(f) = value.to_f64() {
            f.into()
        } else {
            value.to_string().into()
        };
        self.0.insert(key.as_str().to_string(), v);
        Ok(())
    }
}

impl LogBridge {
    /// Bridge forwarding `Info` and above.
    pub fn new(client: Arc<dyn LogClient>) -> Self {
        LogBridge {
            client,
            max_level: LevelFilter::Info,
            own_crate: module_path!()
                .split("::")
                .next()
                .unwrap_or_default()
                .to_string(),
        }
    }

    /// Changes the maximum level forwarded.
    pub fn with_max_level(mut self, level: LevelFilter) -> Self {
        self.max_level = level;
        self
    }

    /// Installs the bridge as the global `log` logger and sets the max level.
    pub fn init(self) -> Result<(), log::SetLoggerError> {
        let level = self.max_level;
        log::set_boxed_logger(Box::new(self))?;
        log::set_max_level(level);
        Ok(())
    }
}

impl Log for LogBridge {
    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
        let target = metadata.target();
        let own = target
            .strip_prefix(self.own_crate.as_str())
            .is_some_and(|rest| rest.is_empty() || rest.starts_with("::"));
        metadata.level() <= self.max_level && !own
    }

    fn log(&self, record: &Record<'_>) {
        if !self.enabled(record.metadata()) {
            return;
        }
        let mut attrs = Attributes::new();
        let _ = record.key_values().visit(&mut KvVisitor(&mut attrs));
        attrs.insert("log.target".into(), record.target().into());
        if let Some(file) = record.file() {
            attrs.insert("code.filepath".into(), file.into());
        }
        if let Some(line) = record.line() {
            attrs.insert("code.lineno".into(), line.into());
        }
        let input = LogInput::new(record.args().to_string())
            .severity(severity_of(record.level()))
            .attributes(attrs);
        self.client.send(LogEntry::Input(input));
    }

    fn flush(&self) {}
}