bitwarden_logging/
layer.rs1use 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
13pub 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 #[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 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 if metadata.target().starts_with("bitwarden_logging") {
68 return;
69 }
70
71 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 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}