Struct LoggerConfig 

pub struct LoggerConfig {
    pub show_file_info: bool,
    pub show_date_in_stdout: bool,
    pub use_colors: bool,
    pub level: LevelFilter,
    pub module_filters: ModuleFilters,
}

Configuration for the logger.

Fields

show_file_info: bool

Whether to show file and line information in log messages

show_date_in_stdout: bool

Whether to show date in stdout logs (always shown in file logs)

use_colors: bool

Whether to use colors in stdout logs

level: LevelFilter

Minimum log level to display

module_filters: ModuleFilters

Module-level log filters

Implementations

impl LoggerConfig

pub fn new() -> Self

pub fn builder() -> LoggerConfigBuilder

Examples found in repository

examples/stdout_only.rs (line 15)

fn main() {
    // Initialize logger with stdout only (no file output) with colors
    let config = LoggerConfig::builder()
        .level(LevelFilter::Debug) // Show Debug level and above
        .show_file_info(false) // Don't show file and line information
        .use_colors(true) // Use colors in output
        .build();

    if let Err(e) = init_stdout_logger(config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Output will only appear on stdout.");
    println!("Notice that TRACE level messages won't show because we set Debug as minimum level.");
    println!("Also note that file and line information is hidden for cleaner output.");

    // Log messages at different levels to demonstrate filtering
    trace!("This is a TRACE message - you won't see this");
    debug!("This is a DEBUG message - visible");
    info!("This is an INFO message - visible");
    warn!("This is a WARNING message - visible");
    error!("This is an ERROR message - visible");

    // Log messages with dynamic content
    for i in 1..=3 {
        let value = i * 10;
        debug!("Debug calculation: {i} * 10 = {value}");
        info!("Processing item #{i} with value {value}");
    }

    info!("Example completed");
}

examples/basic_usage.rs (line 21)

fn main() {
    // Initialize logger with file output and colored stdout
    let log_path = "application.log";

    // Create a custom configuration with the builder pattern
    // This shows how to configure every aspect of the logger
    let config = LoggerConfig::builder()
        .level(LevelFilter::Trace) // Show all log levels, including TRACE
        .show_file_info(true) // Include file and line info in logs
        .show_date_in_stdout(false) // Only show time (HH:MM:SS) in console output
        .use_colors(true) // Use colors for different log levels
        .build();

    if let Err(e) = init_logger_with_config(Some(log_path), config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Check {log_path} for log output.");
    println!("Log messages will appear both on stdout and in the log file.");
    println!("Notice that stdout logs show time only while the file includes dates.");

    // Log messages at different levels to demonstrate the hierarchy
    // All of these will appear because we set level to Trace
    trace!("This is a TRACE message"); // Lowest level, normally hidden
    debug!("This is a DEBUG message"); // For developer information
    info!("This is an INFO message"); // Normal application events
    warn!("This is a WARNING message"); // Important but non-critical issues
    error!("This is an ERROR message"); // Critical issues that need attention

    // Simulate some application activity
    for i in 1..=5 {
        info!("Application is running... iteration {i}");
        sleep(Duration::from_millis(500));
    }

    // Log a final message
    info!("Application finished successfully");

    println!("\nAfter running this example, check the 'application.log' file");
    println!("to see how logs are formatted differently for file output.");
}

examples/log_level_numeric.rs (line 46)

fn main() {
    // Read LOG_LEVEL from environment
    let log_level = match std::env::var("LOG_LEVEL") {
        Ok(level) => match level.parse::<u8>() {
            Ok(level) => match level {
                0 => LevelFilter::Off,
                1 => LevelFilter::Error,
                2 => LevelFilter::Warn,
                3 => LevelFilter::Info,
                4 => LevelFilter::Debug,
                _ => LevelFilter::Trace,
            },
            Err(_) => LevelFilter::Warn,
        },
        Err(_) => LevelFilter::Warn,
    };

    // Configure logger with module filters
    if let Err(e) = init_logger_with_config(
        Some("log_level_numeric.log"),
        LoggerConfig::builder()
            .show_file_info(true)
            .level(log_level)
            .filter_module("log_level_numeric::noisy_library", LevelFilter::Error) // Only errors from noisy_library
            .build(),
    ) {
        eprintln!("Failed to initialize logger: {}", e);
        std::process::exit(1);
    }

    println!("=== LOG_LEVEL Numeric Example ===");
    println!(
        "Current LOG_LEVEL: {:?}",
        std::env::var("LOG_LEVEL").unwrap_or_else(|_| "not set (using Warn)".to_string())
    );
    println!("Effective level: {:?}", log_level);
    println!("\nLOG_LEVEL values:");
    println!("  0 = Off");
    println!("  1 = Error");
    println!("  2 = Warn");
    println!("  3 = Info");
    println!("  4 = Debug");
    println!("  5+ = Trace");
    println!("\n--- Application Logs ---\n");

    // Log messages at different levels
    trace!("This is a TRACE message (level 5+)");
    debug!("This is a DEBUG message (level 4)");
    info!("This is an INFO message (level 3)");
    warn!("This is a WARN message (level 2)");
    error!("This is an ERROR message (level 1)");

    // Call noisy library (its logs should be suppressed)
    println!("\nCalling noisy_library (its logs are filtered to Error only):");
    noisy_library::do_work();

    println!("\n--- End of Logs ---");
    println!("\nNote: Logs from 'noisy_library' are filtered to Error level only,");
    println!("so you should not see its debug, info, or warn messages.");
}

pub fn from_env() -> Self

Create a configuration from environment variables.

Reads configuration from:

• RUST_LOG for module-level filtering (e.g., “debug”, “my_crate=trace”)
• LOG_LEVEL for numeric log level (0=Off, 1=Error, 2=Warn, 3=Info, 4=Debug, 5+=Trace)

If both are set, RUST_LOG takes precedence for the default level.

pub fn production() -> Self

Examples found in repository

examples/production.rs (line 11)

fn main() {
    // Step 1: Compare production vs development logger output
    println!("=== PRODUCTION LOGGER SIMULATION ===");
    // Production config: no file info, INFO level minimum
    let prod_config = LoggerConfig::production();
    println!("Production settings:");
    println!(" - Log level: Info (no Debug or Trace messages)");
    println!(" - File info: Hidden (cleaner logs)");
    println!(" - Colors: Enabled (for better readability)");
    println!(" - Date in console: Hidden (time only for brevity)\n");

    // Manually format some logs with production settings
    format_and_print_logs("Production", &prod_config);

    // Reset logs
    println!("\n\n=== DEVELOPMENT LOGGER SIMULATION ===");
    // Development config: with file info, DEBUG level minimum
    let dev_config = LoggerConfig::development();
    println!("Development settings:");
    println!(" - Log level: Debug (includes debug messages)");
    println!(" - File info: Shown (helps with debugging)");
    println!(" - Colors: Enabled (for better readability)");
    println!(" - Date in console: Hidden (time only for brevity)\n");

    // Manually format logs with development settings
    format_and_print_logs("Development", &dev_config);

    println!("\nNote: In production mode, logs are more concise (no file info, only time)");
    println!(
        "but the log file still contains complete information including date and file details."
    );

    // Step 2: Initialize a real logger for demonstration
    println!("\n=== ACTUAL LOGGER IMPLEMENTATION ===");
    println!("Initializing a real logger with production settings...");
    if let Err(e) = fstdout_logger::init_production_logger(Some("prod.log")) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    // Log some real messages
    info!("This message was logged with the actual logger");
    debug!("Debug info won't appear in production mode");
    warn!("Warnings will appear");
    error!("Errors will appear too");

    println!("\nCheck 'prod.log' to see the file output format with full details!");
}

pub fn development() -> Self

Examples found in repository

examples/production.rs (line 24)

fn main() {
    // Step 1: Compare production vs development logger output
    println!("=== PRODUCTION LOGGER SIMULATION ===");
    // Production config: no file info, INFO level minimum
    let prod_config = LoggerConfig::production();
    println!("Production settings:");
    println!(" - Log level: Info (no Debug or Trace messages)");
    println!(" - File info: Hidden (cleaner logs)");
    println!(" - Colors: Enabled (for better readability)");
    println!(" - Date in console: Hidden (time only for brevity)\n");

    // Manually format some logs with production settings
    format_and_print_logs("Production", &prod_config);

    // Reset logs
    println!("\n\n=== DEVELOPMENT LOGGER SIMULATION ===");
    // Development config: with file info, DEBUG level minimum
    let dev_config = LoggerConfig::development();
    println!("Development settings:");
    println!(" - Log level: Debug (includes debug messages)");
    println!(" - File info: Shown (helps with debugging)");
    println!(" - Colors: Enabled (for better readability)");
    println!(" - Date in console: Hidden (time only for brevity)\n");

    // Manually format logs with development settings
    format_and_print_logs("Development", &dev_config);

    println!("\nNote: In production mode, logs are more concise (no file info, only time)");
    println!(
        "but the log file still contains complete information including date and file details."
    );

    // Step 2: Initialize a real logger for demonstration
    println!("\n=== ACTUAL LOGGER IMPLEMENTATION ===");
    println!("Initializing a real logger with production settings...");
    if let Err(e) = fstdout_logger::init_production_logger(Some("prod.log")) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    // Log some real messages
    info!("This message was logged with the actual logger");
    debug!("Debug info won't appear in production mode");
    warn!("Warnings will appear");
    error!("Errors will appear too");

    println!("\nCheck 'prod.log' to see the file output format with full details!");
}

Trait Implementations

impl Clone for LoggerConfig

fn clone(&self) -> LoggerConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LoggerConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LoggerConfig

fn default() -> Self

Creates a default configuration with fixed values.

To read from environment variables (RUST_LOG, LOG_LEVEL), use LoggerConfig::from_env() instead.

Default values:

• show_file_info: true
• show_date_in_stdout: false
• use_colors: true
• level: Info
• module_filters: Empty (all modules at Info level)