Add min_log_level config

Author: hramezani

src/bridges/tracing.rs

@@ -1378,7 +1378,7 @@ mod tests {
 
         let console_options = ConsoleOptions {
             target: Target::Pipe(output.clone()),
-            ..ConsoleOptions::default()
+            ..ConsoleOptions::default().with_min_log_level(Level::TRACE)
         };
 
         let handler = crate::configure()

src/config.rs

@@ -15,6 +15,7 @@ use opentelemetry_sdk::{
 use regex::Regex;
 
 use crate::ConfigureError;
+use tracing::Level;
 
 /// Whether to send logs to Logfire.
 #[derive(Default, Clone, Copy, Debug, PartialEq, Eq)]
@@ -69,6 +70,8 @@ impl From<bool> for SendToLogfire {
 pub struct ConsoleOptions {
     /// Where to send output
     pub(crate) target: Target,
+    /// The minimum log level to show in the console.
+    pub min_log_level: Level,
     // TODO: support the below configuration options (inherited from Python SDK)
 
     // /// Whether to show colors in the console.
@@ -83,13 +86,10 @@ pub struct ConsoleOptions {
     // ///
     // /// It includes the filename, log level, and line number.
     // verbose: bool,
-    // /// The minimum log level to show in the console.
-    // min_log_level: Level,
     // /// Whether to print the URL of the Logfire project after initialization.
     // show_project_link: bool,
 }
 
-#[expect(clippy::derivable_impls)] // When the other options are implemented, we will need this.
 impl Default for ConsoleOptions {
     fn default() -> Self {
         ConsoleOptions {
@@ -98,7 +98,7 @@ impl Default for ConsoleOptions {
             // include_timestamps: true,
             // include_tags: true,
             // verbose: false,
-            // min_log_level: Level::INFO,
+            min_log_level: Level::INFO,
             // show_project_link: true,
             target: Target::default(),
         }
@@ -114,6 +114,15 @@ impl ConsoleOptions {
     }
 }
 
+impl ConsoleOptions {
+    /// Set the minimum log level to show in the console.
+    #[must_use]
+    pub fn with_min_log_level(mut self, min_log_level: Level) -> Self {
+        self.min_log_level = min_log_level;
+        self
+    }
+}
+
 /// Whether to show colors in the console.
 #[derive(Default, Debug, Clone, Copy)]
 pub enum ConsoleColors {
@@ -367,4 +376,13 @@ mod tests {
         assert_eq!(SendToLogfire::from(true), SendToLogfire::Yes);
         assert_eq!(SendToLogfire::from(false), SendToLogfire::No);
     }
+
+    #[test]
+    fn test_console_option_with_min_log_level() {
+        let console_options = super::ConsoleOptions::default();
+        assert_eq!(console_options.min_log_level, tracing::Level::INFO);
+        let console_options =
+            super::ConsoleOptions::default().with_min_log_level(tracing::Level::DEBUG);
+        assert_eq!(console_options.min_log_level, tracing::Level::DEBUG);
+    }
 }

src/internal/exporters/console.rs

@@ -80,22 +80,22 @@ impl ConsoleWriter {
         self.with_writer(|w| {
             let mut buffer = BufWriter::new(w);
             for span in batch {
-                let _ = Self::span_to_writer(span, &mut buffer);
+                let _ = Self::span_to_writer(self, span, &mut buffer);
             }
         });
     }
 
     pub fn write_tracing_event(&self, event: &tracing::Event<'_>) {
         self.with_writer(|w| {
             let mut buffer = BufWriter::new(w);
-            let _ = Self::event_to_writer(event, &mut buffer);
+            let _ = Self::event_to_writer(self, event, &mut buffer);
         });
     }
 
     pub fn write_tracing_opentelemetry_data(&self, data: &OtelData) {
         self.with_writer(|w| {
             let mut buffer = BufWriter::new(w);
-            let _ = Self::otel_data_to_writer(data, &mut buffer);
+            let _ = Self::otel_data_to_writer(self, data, &mut buffer);
         });
     }
 
@@ -107,7 +107,7 @@ impl ConsoleWriter {
         }
     }
 
-    fn span_to_writer<W: io::Write>(span: &SpanData, w: &mut W) -> io::Result<()> {
+    fn span_to_writer<W: io::Write>(&self, span: &SpanData, w: &mut W) -> io::Result<()> {
         // only print for pending span and logs
         if span.get_span_type().is_none_or(|ty| ty == "span") {
             return Ok(());
@@ -128,6 +128,12 @@ impl ConsoleWriter {
                 "logfire.level_num" => {
                     if let Value::I64(val) = kv.value {
                         level = Some(val);
+                        if let Some(level) = level {
+                            // Filter out span below the minimum log level
+                            if level < level_to_level_number(self.options.min_log_level) {
+                                return Ok(());
+                            }
+                        }
                     }
                 }
                 "code.namespace" => target = Some(kv.value.as_str()),
@@ -183,9 +189,17 @@ impl ConsoleWriter {
         writeln!(w)
     }
 
-    fn event_to_writer<W: io::Write>(event: &tracing::Event<'_>, w: &mut W) -> io::Result<()> {
+    fn event_to_writer<W: io::Write>(
+        &self,
+        event: &tracing::Event<'_>,
+        w: &mut W,
+    ) -> io::Result<()> {
         let timestamp: DateTime<Utc> = Utc::now();
         let level = level_to_level_number(*event.metadata().level());
+        // Filter out event below the minimum log level
+        if level < level_to_level_number(self.options.min_log_level) {
+            return Ok(());
+        }
         let target = event.metadata().module_path();
 
         let mut visitor = FieldsVisitor {
@@ -226,6 +240,7 @@ impl ConsoleWriter {
     }
 
     fn otel_data_to_writer<W: io::Write>(
+        &self,
         data: &tracing_opentelemetry::OtelData,
         w: &mut W,
     ) -> io::Result<()> {
@@ -249,6 +264,12 @@ impl ConsoleWriter {
                 "logfire.level_num" => {
                     if let Value::I64(val) = kv.value {
                         level = Some(val);
+                        if let Some(level) = level {
+                            // Filter out data below the minimum log level
+                            if level < level_to_level_number(self.options.min_log_level) {
+                                return Ok(());
+                            }
+                        }
                     }
                 }
                 "code.namespace" => target = Some(kv.value.as_str()),
@@ -346,7 +367,9 @@ mod tests {
     fn test_print_to_console() {
         let output = Arc::new(Mutex::new(Vec::new()));
 
-        let console_options = ConsoleOptions::default().with_target(Target::Pipe(output.clone()));
+        let console_options = ConsoleOptions::default()
+            .with_target(Target::Pipe(output.clone()))
+            .with_min_log_level(Level::TRACE);
 
         let handler = crate::configure()
             .local()
@@ -386,4 +409,49 @@ mod tests {
         1970-01-01T00:00:00.000005Z ERROR logfire panic: oh no! location=src/internal/exporters/console.rs:369:17, backtrace=disabled backtrace
         "#);
     }
+
+    #[test]
+    fn test_print_to_console_with_min_log_level() {
+        let output = Arc::new(Mutex::new(Vec::new()));
+
+        let console_options = ConsoleOptions::default()
+            .with_target(Target::Pipe(output.clone()))
+            .with_min_log_level(Level::INFO);
+
+        let handler = crate::configure()
+            .local()
+            .send_to_logfire(false)
+            .with_console(Some(console_options))
+            .install_panic_handler()
+            .with_default_level_filter(LevelFilter::TRACE)
+            .finish()
+            .unwrap();
+
+        let guard = set_local_logfire(handler);
+
+        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            tracing::subscriber::with_default(guard.subscriber().clone(), || {
+                let root = crate::span!("root span").entered();
+                let _ = crate::span!("hello world span").entered();
+                let _ = crate::span!(level: Level::DEBUG, "debug span");
+                let _ = crate::span!(parent: &root, level: Level::DEBUG, "debug span with explicit parent");
+                crate::info!("hello world log");
+                panic!("oh no!");
+            });
+        }))
+        .unwrap_err();
+
+        guard.shutdown_handler.shutdown().unwrap();
+
+        let output = output.lock().unwrap();
+        let output = std::str::from_utf8(&output).unwrap();
+        let output = remap_timestamps_in_console_output(output);
+
+        assert_snapshot!(output, @r#"
+        1970-01-01T00:00:00.000000Z  INFO logfire::internal::exporters::console::tests root span
+        1970-01-01T00:00:00.000001Z  INFO logfire::internal::exporters::console::tests hello world span
+        1970-01-01T00:00:00.000004Z  INFO logfire::internal::exporters::console::tests hello world log
+        1970-01-01T00:00:00.000005Z ERROR logfire panic: oh no! location=src/internal/exporters/console.rs:369:17, backtrace=disabled backtrace
+        "#);
+    }
 }

src/lib.rs

@@ -498,7 +498,7 @@ impl LogfireConfigBuilder {
         } else {
             tracer_provider_builder =
                 tracer_provider_builder.with_id_generator(UlidIdGenerator::new());
-        };
+        }
 
         if let Some(resource) = advanced_options.resource.clone() {
             tracer_provider_builder = tracer_provider_builder.with_resource(resource);
@@ -597,7 +597,7 @@ impl LogfireConfigBuilder {
 
                 meter_provider_builder = meter_provider_builder.with_reader(metric_reader);
             }
-        };
+        }
 
         if let Some(metrics) = self.metrics.filter(|_| self.enable_metrics) {
             for reader in metrics.additional_readers {