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};
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()
}
}
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 {
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(),
}
}
pub fn with_max_level(mut self, level: LevelFilter) -> Self {
self.max_level = level;
self
}
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) {}
}