add tracing adapter behind optional feature flag

Cargo.toml

@@ -15,11 +15,22 @@ owo-colors = "4.2.3"
 chrono = { version = "0.4.43", default-features = false, features = ["clock"] }
 # Log impl
 log = { version = "0.4.29", optional = true, features = ["std"] }
+# Tracing impl
+tracing = { version = "0.1.44", optional = true, default-features = false }
+tracing-subscriber = { version = "0.3.22", optional = true, default-features = false, features = ["registry"] }
 
+[features]
+tracing = ["dep:tracing", "dep:tracing-subscriber"]
 
 [dev-dependencies]
 log = "0.4.29"
+tracing = "0.1.44"
+tracing-subscriber = "0.3.22"
 
 [[example]]
 name = "log_adapter"
 required-features = ["log"]
+
+[[example]]
+name = "tracing_adapter"
+required-features = ["tracing"]

README.md

@@ -21,6 +21,7 @@ sheen is inspired by [charmbracelet/log](https://github.com/charmbracelet/log),
 - Builder pattern configuration
 - Zero config defaults
 - `log` crate compatibility (optional feature flag)
+- `tracing` crate compatibility (optional feature flag)
 
 ## Installation
 
@@ -36,12 +37,19 @@ With `log` crate support:
 sheen = { version = "0.3", features = ["log"] }
 ```
 
+With `tracing` crate support:
+
+```toml
+[dependencies]
+sheen = { version = "0.3", features = ["tracing"] }
+```
+
 ## Quick Start
 
 ```rust
 fn main() {
     sheen::init();
-    
+
     sheen::info!("Server started", port = 3000);
     sheen::debug!("Loading config");
     sheen::warn!("Cache miss", key = "user_123");
@@ -117,6 +125,21 @@ fn main() {
 }
 ```
 
+## Tracing Crate Integration
+
+Enable the `tracing` feature to use sheen as a subscriber for the [`tracing`](https://crates.io/crates/tracing) crate. This captures events from any dependency that uses `tracing::info!()`, `tracing::warn!()`, etc.
+
+```rust
+use sheen::{Logger, Level, SheenLayer};
+
+fn main() {
+    SheenLayer::new(Logger::new().level(Level::Trace)).init();
+
+    tracing::info!("server started");
+    tracing::warn!("cache nearly full");
+}
+```
+
 ## Formatters
 
 ### Text (default)

examples/tracing_adapter.rs

@@ -0,0 +1,11 @@
+use sheen::{Level, Logger, SheenLayer};
+
+fn main() {
+    SheenLayer::new(Logger::new().level(Level::Trace)).init();
+
+    tracing::trace!("starting up");
+    tracing::debug!("loading configuration");
+    tracing::info!("server listening on port 3000");
+    tracing::warn!("cache is nearly full");
+    tracing::error!("failed to connect to database");
+}

src/level.rs

@@ -47,6 +47,32 @@ impl From<Level> for log::LevelFilter {
     }
 }
 
+#[cfg(feature = "tracing")]
+impl From<Level> for tracing::Level {
+    fn from(level: Level) -> Self {
+        match level {
+            Level::Trace => tracing::Level::TRACE,
+            Level::Debug => tracing::Level::DEBUG,
+            Level::Info => tracing::Level::INFO,
+            Level::Warn => tracing::Level::WARN,
+            Level::Error => tracing::Level::ERROR,
+        }
+    }
+}
+
+#[cfg(feature = "tracing")]
+impl From<tracing::Level> for Level {
+    fn from(level: tracing::Level) -> Self {
+        match level {
+            tracing::Level::TRACE => Level::Trace,
+            tracing::Level::DEBUG => Level::Debug,
+            tracing::Level::INFO => Level::Info,
+            tracing::Level::WARN => Level::Warn,
+            tracing::Level::ERROR => Level::Error,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/lib.rs

@@ -7,6 +7,12 @@ mod macros;
 #[cfg(feature = "log")]
 mod log_adapter;
 
+#[cfg(feature = "tracing")]
+mod tracing_adapter;
+
+#[cfg(feature = "tracing")]
+pub use tracing_adapter::SheenLayer;
+
 pub use formatter::{Formatter, JsonFormatter, LogFmtFormatter, TextFormatter};
 pub use global::{info, init, init_with};
 pub use level::Level;

src/tracing_adapter.rs

@@ -0,0 +1,72 @@
+use crate::Logger;
+
+pub struct SheenLayer {
+    logger: Logger,
+}
+
+impl SheenLayer {
+    pub fn new(logger: Logger) -> Self {
+        Self { logger }
+    }
+
+    pub fn init(self) {
+        use tracing_subscriber::prelude::*;
+        tracing_subscriber::registry().with(self).init();
+    }
+}
+
+struct FieldVisitor {
+    message: String,
+    fields: Vec<(String, String)>,
+}
+
+impl FieldVisitor {
+    fn new() -> Self {
+        Self {
+            message: String::new(),
+            fields: Vec::new(),
+        }
+    }
+}
+
+impl tracing::field::Visit for FieldVisitor {
+    fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
+        if field.name() == "message" {
+            self.message = format!("{:?}", value);
+        } else {
+            self.fields
+                .push((field.name().to_string(), format!("{:?}", value)));
+        }
+    }
+
+    fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
+        if field.name() == "message" {
+            self.message = value.to_string();
+        } else {
+            self.fields
+                .push((field.name().to_string(), value.to_string()));
+        }
+    }
+}
+
+impl<S: tracing::Subscriber> tracing_subscriber::Layer<S> for SheenLayer {
+    fn on_event(
+        &self,
+        event: &tracing::Event<'_>,
+        _ctx: tracing_subscriber::layer::Context<'_, S>,
+    ) {
+        let mut visitor = FieldVisitor::new();
+        event.record(&mut visitor);
+
+        let level = (*event.metadata().level()).into();
+        let target = event.metadata().target();
+
+        let mut extra: Vec<(&str, &dyn std::fmt::Debug)> =
+            vec![("target", &target as &dyn std::fmt::Debug)];
+        for (k, v) in &visitor.fields {
+            extra.push((k.as_str(), v as &dyn std::fmt::Debug));
+        }
+
+        self.logger.log(level, &visitor.message, &extra);
+    }
+}