Merge branch 'samantehrani-trc-envfilter'

Author: emabee

CHANGELOG.md

@@ -5,9 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.31.6] - 2025-10-08
+
+Make sure that `tracing` does not get confused with blanks that are normally printed into
+`LogSpecification`'s `Display` String (issue [#200](https://github.com/emabee/flexi_logger/pull/200)),
+by providing a dedicated method.
+Kudos goes to [samantehrani](https://github.com/samantehrani).
+
 ## [0.31.5] - 2025-10-06
 
 Fix [issue #198](https://github.com/emabee/flexi_logger/issues/198).
+Kudos goes to [hasezoey](https://github.com/hasezoey).
 
 ## [0.31.4] - 2025-09-23
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flexi_logger"
-version = "0.31.5"
+version = "0.31.6"
 authors = ["emabee <[email protected]>"]
 categories = ["development-tools::debugging"]
 description = """

src/log_specification.rs

@@ -54,7 +54,8 @@ use std::{collections::HashMap, env};
 /// rustc (“extern crate” does not allow hyphens).
 #[derive(Clone, Debug, Default)]
 pub struct LogSpecification {
-    module_filters: Vec<ModuleFilter>,
+    /// List of module filters.
+    pub module_filters: Vec<ModuleFilter>,
     #[cfg(feature = "textfilter")]
     textfilter: Option<Box<Regex>>,
 }
@@ -429,10 +430,12 @@ impl LogSpecification {
             .find(|mod_filter| mod_filter.module_name.as_deref() == module)
             .map(|found_filter| found_filter.level_filter)
     }
-}
 
-impl std::fmt::Display for LogSpecification {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    pub(crate) fn to_string_int(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+        space: Space,
+    ) -> std::fmt::Result {
         let mut write_comma = false;
         // Optional: Default log level
         if let Some(last) = self.module_filters.last() {
@@ -442,24 +445,52 @@ impl std::fmt::Display for LogSpecification {
             }
         }
 
-        // TODO: global_pattern is not modelled into String representation, only into yaml file
+        // TODO: global_pattern (feature text_filter) is not modelled into String representation,
+        // only into yaml file
         // Optional: specify a regular expression to suppress all messages that don't match
         // w.write_all(b"#global_pattern = 'foo'\n")?;
 
         // Specific log levels per module
         for mf in &self.module_filters {
             if let Some(ref name) = mf.module_name {
                 if write_comma {
-                    write!(f, ", ")?;
+                    write!(f, ",{}", space.as_str())?;
                 }
-                write!(f, "{name} = {}", mf.level_filter.to_string().to_lowercase())?;
+                write!(
+                    f,
+                    "{name}{}={}{}",
+                    space.as_str(),
+                    space.as_str(),
+                    mf.level_filter.to_string().to_lowercase()
+                )?;
                 write_comma = true;
             }
         }
         Ok(())
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Space {
+    Yes,
+    #[cfg(feature = "trc")]
+    No,
+}
+impl Space {
+    fn as_str(&self) -> &str {
+        match self {
+            Space::Yes => " ",
+            #[cfg(feature = "trc")]
+            Space::No => "",
+        }
+    }
+}
+impl std::fmt::Display for LogSpecification {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_string_int(f, Space::Yes)
+    }
+}
+
 impl std::convert::TryFrom<&str> for LogSpecification {
     type Error = FlexiLoggerError;
     fn try_from(value: &str) -> Result<Self, Self::Error> {

src/trc.rs

@@ -11,6 +11,7 @@
 
 pub use crate::logger_handle::LogSpecSubscriber;
 use crate::{
+    log_specification::Space,
     logger::{create_specfile_watcher, synchronize_subscriber_with_specfile},
     writers::{FileLogWriterBuilder, FileLogWriterHandle},
 };
@@ -229,7 +230,12 @@ pub fn setup_tracing(
 struct LogSpecAsFilter(pub LogSpecification);
 impl From<LogSpecAsFilter> for EnvFilter {
     fn from(wrapped_logspec: LogSpecAsFilter) -> Self {
-        Self::new(wrapped_logspec.0.to_string())
+        Self::new(wrapped_logspec.to_string())
+    }
+}
+impl std::fmt::Display for LogSpecAsFilter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.to_string_int(f, Space::No)
     }
 }
 

src/writers/file_log_writer/builder.rs

@@ -1,7 +1,8 @@
 use crate::{
     default_format,
     writers::{FileLogWriter, FileLogWriterConfig, LogWriter},
-    Cleanup, Criterion, FileSpec, FlexiLoggerError, FormatFunction, Naming, WriteMode,
+    Cleanup, Criterion, FileSpec, FlexiLoggerError, FormatFunction, LogfileSelector, Naming,
+    WriteMode,
 };
 use std::{path::PathBuf, sync::Arc};
 
@@ -348,3 +349,25 @@ impl Drop for FileLogWriterHandle {
         self.0.shutdown();
     }
 }
+impl FileLogWriterHandle {
+    /// Returns the list of existing log files according to the current `FileSpec`.
+    ///
+    /// Depending on the given selector, the list may include the CURRENT log file
+    /// and the compressed files, if they exist.
+    ///
+    /// # Errors
+    ///
+    /// `FlexiLoggerError::Poison` if some mutex is poisoned.
+    pub fn existing_log_files(
+        &self,
+        selector: &LogfileSelector,
+    ) -> Result<Vec<PathBuf>, FlexiLoggerError> {
+        self.0.existing_log_files(selector)
+    }
+
+    // Allows checking the logs written so far to the writer
+    #[doc(hidden)]
+    pub fn validate_logs(&self, expected: &[(&'static str, &'static str, &'static str)]) {
+        self.0.validate_logs(expected);
+    }
+}

tests/test_trc.rs

@@ -9,17 +9,16 @@ mod a {
     use std::io::Write;
     use tracing::{debug, error, info, trace, warn};
 
-    const WAIT_MILLIS: u64 = 2000;
+    const WAIT_MILLIS: u64 = 1_500;
 
-    /// Test of the specfile feature
     #[test]
     fn test_specfile() {
         let specfile = super::test_utils::file("logspec.toml");
 
         std::fs::remove_file(&specfile).ok();
         assert!(!specfile.exists());
 
-        let _keep_alive_handles = flexi_logger::trc::setup_tracing(
+        let keep_alive_handles = flexi_logger::trc::setup_tracing(
             LogSpecification::info(),
             Some(&specfile),
             FileLogWriter::builder(FileSpec::default().directory(super::test_utils::dir()))
@@ -39,11 +38,8 @@ mod a {
 
         assert!(specfile.exists());
 
-        error!("This is an error-0");
-        warn!("This is a warning-0");
-        info!("This is an info-0");
-        debug!("This is a debug-0");
-        trace!("This is a trace-0");
+        write_logs(0);
+        super::b::write_logs(0);
 
         eprintln!(
             "[{}] ===== behave like many editors: rename and recreate; set to warn",
@@ -60,20 +56,18 @@ mod a {
                 .unwrap();
             file.write_all(
                 b"
-                global_level = 'warn'
-                [modules]
+                global_level = 'warn'\n\
+                [modules]\n\
+                'test_trc::b' = 'error'\n\
                 ",
             )
             .unwrap();
         }
 
         std::thread::sleep(std::time::Duration::from_millis(WAIT_MILLIS));
 
-        error!("This is an error-1");
-        warn!("This is a warning-1");
-        info!("This is an info-1");
-        debug!("This is a debug-1");
-        trace!("This is a trace-1");
+        write_logs(1);
+        super::b::write_logs(1);
 
         eprintln!(
             "[{}] ===== truncate and rewrite; set to error",
@@ -89,6 +83,7 @@ mod a {
                 "\
                 global_level = 'error'\n\
                 [modules]\n\
+                'test_trc::b' = 'debug'\n\
                 "
                 .as_bytes(),
             )
@@ -97,10 +92,45 @@ mod a {
 
         std::thread::sleep(std::time::Duration::from_millis(WAIT_MILLIS));
 
-        error!("This is an error-2");
-        warn!("This is a warning-2");
-        info!("This is an info-2");
-        debug!("This is a debug-2");
-        trace!("This is a trace-2");
+        write_logs(2);
+        super::b::write_logs(2);
+
+        std::thread::sleep(std::time::Duration::from_millis(WAIT_MILLIS));
+
+        keep_alive_handles.0.validate_logs(&[
+            ("ERROR", "test_trc::a", "0"),
+            ("WARN", "test_trc::a", "0"),
+            ("INFO", "test_trc::a", "0"),
+            ("ERROR", "test_trc::b", "0"),
+            ("WARN", "test_trc::b", "0"),
+            ("INFO", "test_trc::b", "0"),
+            ("ERROR", "test_trc::a:", "1"),
+            ("WARN", "test_trc::a:", "1"),
+            ("ERROR", "test_trc::b:", "1"),
+            ("ERROR", "test_trc::a:", "2"),
+            ("ERROR", "test_trc::b:", "2"),
+            ("WARN", "test_trc::b:", "2"),
+            ("INFO", "test_trc::b:", "2"),
+            ("DEBUG", "test_trc::b:", "2"),
+        ]);
+    }
+
+    pub(crate) fn write_logs(idx: u8) {
+        error!("Error from a::write_logs {idx}");
+        warn!("Warning from a::write_logs {idx}");
+        info!("Info from a::write_logs {idx}");
+        debug!("Debug from a::write_logs {idx}");
+        trace!("Trace from a::write_logs {idx}");
+    }
+}
+mod b {
+    use tracing::{debug, error, info, trace, warn};
+
+    pub(crate) fn write_logs(idx: u8) {
+        error!("Error from b::write_logs {idx}");
+        warn!("Warning from b::write_logs {idx}");
+        info!("Info from b::write_logs {idx}");
+        debug!("Debug from b::write_logs {idx}");
+        trace!("Trace from b::write_logs {idx}");
     }
 }