feat: add a composable Layer

Author: snylonue

Cargo.toml

@@ -14,6 +14,8 @@ serde_json = "1.0.122"
 time = "0.3.36"
 tracing = "0.1.40"
 tracing-log = { version = "0.2.0", optional = true, default-features = false }
+tracing-subscriber = { version = "0.3.18", optional = true, default-features = false }
 
 [features]
 tracing-log = ["dep:tracing-log"]
+layer = ["dep:tracing-subscriber"]

src/lib.rs

@@ -16,51 +16,31 @@ pub fn prepare_database(conn: &Connection) -> rusqlite::Result<()> {
     conn.execute(SQL_SCHEMA, ()).map(|_| {})
 }
 
+/// A `Layer` to write events to a sqlite database.
+/// This type can be composed with other `Subscriber`s and `Layer`s.
 #[derive(Debug)]
-pub struct Subscriber {
-    id: AtomicU64,
+pub struct Layer {
     connection: Mutex<Connection>,
     max_level: LevelFilter,
     black_list: Option<Box<[&'static str]>>,
     white_list: Option<Box<[&'static str]>>,
 }
 
-impl Subscriber {
-    pub fn new(connection: Connection) -> Self {
-        Self::with_max_level(connection, LevelFilter::TRACE)
-    }
-
-    fn with_details(
-        connection: Mutex<Connection>,
-        max_level: LevelFilter,
-        black_list: Option<Box<[&'static str]>>,
-        white_list: Option<Box<[&'static str]>>,
-    ) -> Self {
-        Self {
-            id: AtomicU64::new(1),
-            connection,
-            max_level,
-            black_list,
-            white_list,
-        }
-    }
-
-    pub fn with_max_level(connection: Connection, max_level: LevelFilter) -> Self {
-        Self::with_details(Mutex::new(connection), max_level, None, None)
-    }
-
+impl Layer {
     pub fn black_list(&self) -> Option<&[&'static str]> {
         self.black_list.as_deref()
     }
 
     pub fn white_list(&self) -> Option<&[&'static str]> {
         self.white_list.as_deref()
     }
-}
 
-impl tracing::Subscriber for Subscriber {
+    pub fn max_level(&self) -> &LevelFilter {
+        &self.max_level
+    }
+
     fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool {
-        metadata.level() <= &self.max_level
+        metadata.level() <= self.max_level()
             && metadata.module_path().map_or(true, |m| {
                 let starts_with = |module: &&str| m.starts_with(module);
                 let has_module = |modules: &[&str]| modules.iter().any(starts_with);
@@ -73,16 +53,7 @@ impl tracing::Subscriber for Subscriber {
         Some(self.max_level)
     }
 
-    fn new_span(&self, _span: &span::Attributes<'_>) -> span::Id {
-        let id = self.id.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
-        span::Id::from_u64(id)
-    }
-
-    fn record(&self, _span: &span::Id, _values: &span::Record<'_>) {}
-
-    fn record_follows_from(&self, _span: &span::Id, _follows: &span::Id) {}
-
-    fn event(&self, event: &tracing::Event<'_>) {
+    fn on_event(&self, event: &tracing::Event<'_>) {
         #[cfg(feature = "tracing-log")]
         let normalized_meta = event.normalized_metadata();
         #[cfg(feature = "tracing-log")]
@@ -117,6 +88,85 @@ impl tracing::Subscriber for Subscriber {
         .unwrap();
     }
 
+    pub fn to_subscriber(self) -> Subscriber {
+        Subscriber::with_layer(self)
+    }
+}
+
+#[cfg(feature = "layer")]
+impl<S: tracing::Subscriber> tracing_subscriber::Layer<S> for Layer {
+    fn enabled(
+        &self,
+        metadata: &tracing::Metadata<'_>,
+        _: tracing_subscriber::layer::Context<'_, S>,
+    ) -> bool {
+        self.enabled(metadata)
+    }
+
+    fn on_event(&self, event: &tracing::Event<'_>, _: tracing_subscriber::layer::Context<'_, S>) {
+        self.on_event(event)
+    }
+}
+
+/// A simple `Subscriber` that wraps `Layer`[crate::Layer].
+#[derive(Debug)]
+pub struct Subscriber {
+    id: AtomicU64,
+    layer: Layer,
+}
+
+impl Subscriber {
+    pub fn new(connection: Connection) -> Self {
+        Self::with_max_level(connection, LevelFilter::TRACE)
+    }
+
+    fn with_layer(layer: Layer) -> Self {
+        Self {
+            id: AtomicU64::new(1),
+            layer,
+        }
+    }
+
+    pub fn with_max_level(connection: Connection, max_level: LevelFilter) -> Self {
+        Self::with_layer(Layer {
+            connection: Mutex::new(connection),
+            max_level,
+            black_list: None,
+            white_list: None,
+        })
+    }
+
+    pub fn black_list(&self) -> Option<&[&'static str]> {
+        self.layer.black_list()
+    }
+
+    pub fn white_list(&self) -> Option<&[&'static str]> {
+        self.layer.white_list()
+    }
+}
+
+impl tracing::Subscriber for Subscriber {
+    fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool {
+        self.layer.enabled(metadata)
+    }
+
+    fn max_level_hint(&self) -> Option<tracing::level_filters::LevelFilter> {
+        self.layer.max_level_hint()
+    }
+
+    fn new_span(&self, _span: &span::Attributes<'_>) -> span::Id {
+        let id = self.id.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
+        span::Id::from_u64(id)
+    }
+
+    fn record(&self, _span: &span::Id, _values: &span::Record<'_>) {}
+
+    fn record_follows_from(&self, _span: &span::Id, _follows: &span::Id) {}
+
+    fn event(&self, event: &tracing::Event<'_>) {
+        self.layer.on_event(event)
+    }
+
     fn enter(&self, _span: &span::Id) {}
 
     fn exit(&self, _span: &span::Id) {}
@@ -173,18 +223,28 @@ impl SubscriberBuilder {
     }
 
     pub fn build(self, conn: Connection) -> Subscriber {
-        Subscriber::with_details(
-            Mutex::new(conn),
-            self.max_level,
-            self.black_list,
-            self.white_list,
-        )
+        self.build_layer(conn).to_subscriber()
     }
 
     pub fn build_prepared(self, conn: Connection) -> Result<Subscriber, rusqlite::Error> {
         prepare_database(&conn)?;
 
-        Ok(self.build(conn))
+        self.build_layer_prepared(conn).map(|l| l.to_subscriber())
+    }
+
+    pub fn build_layer(self, conn: Connection) -> Layer {
+        Layer {
+            connection: Mutex::new(conn),
+            max_level: self.max_level,
+            black_list: self.black_list,
+            white_list: self.white_list,
+        }
+    }
+
+    pub fn build_layer_prepared(self, conn: Connection) -> Result<Layer, rusqlite::Error> {
+        prepare_database(&conn)?;
+
+        Ok(self.build_layer(conn))
     }
 }