Skip to main content

bitwarden_logging/
layer.rs

1//! Tracing subscriber layer for Flight Recorder.
2
3use std::sync::Arc;
4
5use tracing::{Event, Subscriber};
6use tracing_subscriber::{Layer, layer::Context};
7
8use crate::{
9    CircularBuffer, FlightRecorderConfig, FlightRecorderEvent, LocalBufferSink, sink::SinkSlot,
10    suppress::is_suppressed,
11};
12
13/// A tracing subscriber layer that captures log events into the active sink.
14///
15/// The sink starts as a [`LocalBufferSink`] over the layer's buffer. Events from the
16/// `bitwarden_logging` target, and events emitted inside
17/// [`without_flight_recorder`](crate::without_flight_recorder), are filtered out to prevent
18/// infinite recursion.
19pub struct FlightRecorderLayer {
20    buffer: Arc<CircularBuffer<FlightRecorderEvent>>,
21    sink: SinkSlot,
22    level: tracing::Level,
23}
24
25impl std::fmt::Debug for FlightRecorderLayer {
26    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
27        f.debug_struct("FlightRecorderLayer")
28            .field("level", &self.level)
29            .field("buffer", &self.buffer)
30            .finish()
31    }
32}
33
34impl FlightRecorderLayer {
35    /// Create a new FlightRecorderLayer with the given configuration.
36    #[must_use]
37    pub fn new(config: FlightRecorderConfig) -> Self {
38        let buffer = Arc::new(CircularBuffer::new(config.buffer_size));
39        let sink = SinkSlot::new(Arc::new(LocalBufferSink::new(Arc::clone(&buffer))));
40        Self {
41            buffer,
42            sink,
43            level: config.level,
44        }
45    }
46
47    /// Get a reference to the underlying buffer.
48    ///
49    /// This can be used to access the buffer for reading captured events.
50    pub fn buffer(&self) -> Arc<CircularBuffer<FlightRecorderEvent>> {
51        Arc::clone(&self.buffer)
52    }
53
54    pub(crate) fn sink(&self) -> SinkSlot {
55        self.sink.clone()
56    }
57}
58
59impl<S> Layer<S> for FlightRecorderLayer
60where
61    S: Subscriber,
62{
63    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
64        let metadata = event.metadata();
65
66        // Filter out our own logging to prevent recursion
67        if metadata.target().starts_with("bitwarden_logging") {
68            return;
69        }
70
71        // Skip events more verbose than configured level
72        if *metadata.level() > self.level {
73            return;
74        }
75
76        if is_suppressed() {
77            return;
78        }
79
80        self.sink.push(event.into());
81    }
82}
83
84#[cfg(test)]
85mod tests {
86    use std::num::NonZeroUsize;
87
88    use tracing_subscriber::layer::SubscriberExt;
89
90    use super::*;
91
92    #[test]
93    fn test_layer_creation() {
94        let config = FlightRecorderConfig::default();
95        let layer = FlightRecorderLayer::new(config);
96        let buffer = layer.buffer();
97
98        assert!(buffer.is_empty());
99        assert_eq!(buffer.len(), 0);
100    }
101
102    #[test]
103    fn test_layer_captures_events() {
104        let config = FlightRecorderConfig::default();
105        let layer = FlightRecorderLayer::new(config);
106        let buffer = layer.buffer();
107
108        let subscriber = tracing_subscriber::registry().with(layer);
109        tracing::subscriber::with_default(subscriber, || {
110            tracing::info!(target: "test::module", "hello from test");
111        });
112
113        let events = buffer.read();
114        assert_eq!(events.len(), 1);
115        assert_eq!(events[0].message, "hello from test");
116        assert_eq!(events[0].level, "INFO");
117    }
118
119    #[test]
120    fn test_layer_filters_own_crate() {
121        let config = FlightRecorderConfig::default();
122        let layer = FlightRecorderLayer::new(config);
123        let buffer = layer.buffer();
124
125        let subscriber = tracing_subscriber::registry().with(layer);
126        tracing::subscriber::with_default(subscriber, || {
127            tracing::info!(target: "bitwarden_logging::internal", "should be skipped");
128            tracing::info!(target: "bitwarden_logging", "should be skipped");
129            tracing::info!("should be skipped");
130        });
131
132        assert!(buffer.is_empty());
133    }
134
135    #[test]
136    fn test_layer_filters_by_level() {
137        let config = FlightRecorderConfig::new(
138            NonZeroUsize::new(100).expect("non-zero"),
139            tracing::Level::INFO,
140        );
141        let layer = FlightRecorderLayer::new(config);
142        let buffer = layer.buffer();
143
144        let subscriber = tracing_subscriber::registry().with(layer);
145        tracing::subscriber::with_default(subscriber, || {
146            tracing::debug!(target: "test::module", "should be skipped");
147            tracing::info!(target: "test::module", "should be captured");
148            tracing::warn!(target: "test::module", "should also be captured");
149        });
150
151        let events = buffer.read();
152        assert_eq!(events.len(), 2);
153        assert_eq!(events[0].level, "INFO");
154        assert_eq!(events[1].level, "WARN");
155    }
156
157    #[tokio::test]
158    async fn test_layer_skips_suppressed_events() {
159        let config = FlightRecorderConfig::default();
160        let layer = FlightRecorderLayer::new(config);
161        let buffer = layer.buffer();
162
163        let subscriber = tracing_subscriber::registry().with(layer);
164        let _guard = tracing::subscriber::set_default(subscriber);
165        crate::without_flight_recorder(async {
166            tracing::info!(target: "any_crate", "should be skipped");
167        })
168        .await;
169        tracing::info!(target: "any_crate", "should be captured");
170
171        let events = buffer.read();
172        assert_eq!(events.len(), 1);
173        assert_eq!(events[0].message, "should be captured");
174    }
175
176    #[test]
177    fn test_buffer_shared_via_arc() {
178        let config = FlightRecorderConfig::default();
179        let layer = FlightRecorderLayer::new(config);
180        let buffer1 = layer.buffer();
181        let buffer2 = layer.buffer();
182
183        assert!(Arc::ptr_eq(&buffer1, &buffer2));
184
185        let subscriber = tracing_subscriber::registry().with(layer);
186        tracing::subscriber::with_default(subscriber, || {
187            tracing::warn!(target: "test::module", "shared buffer test");
188        });
189
190        // Both handles see the same events
191        assert_eq!(buffer1.read().len(), 1);
192        assert_eq!(buffer2.read().len(), 1);
193    }
194
195    #[test]
196    fn test_layer_captures_structured_fields() {
197        let config = FlightRecorderConfig::default();
198        let layer = FlightRecorderLayer::new(config);
199        let buffer = layer.buffer();
200
201        let subscriber = tracing_subscriber::registry().with(layer);
202        tracing::subscriber::with_default(subscriber, || {
203            tracing::info!(target: "test::module", user_id = "abc-123", "login attempt");
204        });
205
206        let events = buffer.read();
207        assert_eq!(events.len(), 1);
208        assert_eq!(events[0].message, "login attempt");
209        assert_eq!(events[0].target, "test::module");
210        assert_eq!(
211            events[0].fields.get("user_id"),
212            Some(&"abc-123".to_string())
213        );
214    }
215}