Function init_logger_with_config 

pub fn init_logger_with_config<P: AsRef<Path>>(
    file_path: Option<P>,
    config: LoggerConfig,
) -> Result<(), LogError>

Initialize a logger with custom configuration.

This gives full control over all configuration options.

Arguments

• file_path - Optional path to a log file. If None, logs will only go to stdout.
• config - Configuration options for the logger.

Returns

Ok(()) if initialization succeeded, or an error if it failed.

Example

use fstdout_logger::{init_logger_with_config, LoggerConfig};
use log::LevelFilter;

// Create a custom configuration
let config = LoggerConfig::builder()
    .level(LevelFilter::Debug)
    .show_file_info(false)
    .use_colors(true)
    .build();

init_logger_with_config(Some("app.log"), config)
    .expect("Failed to initialize logger");

Examples found in repository

examples/basic_usage.rs (line 28)

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 (lines 44-51)

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.");
}