nonblocking-logger 0.3.0

use nonblocking_logger::{
    LogLevel, Logger, debug, debug_with, error, error_with, info, info_with, log, trace,
    trace_with, warning, warning_with,
};

fn main() {
    println!("=== Macro Logging Example ===");

    info!("Application started");
    debug!("Debug mode enabled");
    warning!("This is a warning");
    error!("An error occurred");
    trace!("Tracing execution");

    println!("\n=== Formatting Examples ===");

    let user_id = 42;
    let username = "alice";
    let status = "active";

    info!("User {} ({}) is {}", user_id, username, status);

    let data = vec![1, 2, 3, 4, 5];
    let metadata =
        std::collections::HashMap::from([("version", "1.0.0"), ("environment", "development")]);

    debug!("Processing data: {:?}", data);
    debug!("Metadata: {:?}", metadata);

    let cpu_usage = 85.5;
    let memory_usage = 72.3;
    warning!(
        "High resource usage - CPU: {:.1}%, Memory: {:.1}%",
        cpu_usage,
        memory_usage
    );

    let error_code = 500;
    let endpoint = "/api/users";
    let timestamp = "2025-01-14 10:30:00";
    error!("HTTP {} error on {} at {}", error_code, endpoint, timestamp);

    log!(
        "Custom log level message with value: {}",
        42
    );

    println!("\n=== Lazy Evaluation Examples ===");

    fn expensive_computation() -> String {
        std::thread::sleep(std::time::Duration::from_millis(1));
        "expensive_result".to_string()
    }

    debug!("Expensive computation result: {}", expensive_computation());

    use nonblocking_logger::{debug_lazy, error_lazy, info_lazy, warning_lazy};

    debug_lazy!(|| "Lazy debug: {}", expensive_computation());
    info_lazy!(|| "Lazy info: {}", expensive_computation());
    warning_lazy!(|| "Lazy warning: {}", expensive_computation());
    error_lazy!(|| "Lazy error: {}", expensive_computation());

    println!("\n=== Different Format Specifiers ===");

    let number = 42;
    let float = 3.14159;
    let text = "hello";

    info!("Integer: {}, Float: {:.2}, Text: {}", number, float, text);
    info!(
        "Hex: 0x{:x}, Binary: 0b{:b}, Octal: 0o{:o}",
        number, number, number
    );
    info!(
        "Scientific: {:.2e}, Percentage: {:.1}%",
        float * 100.0,
        float * 100.0
    );

    println!("\n=== Structured Logging Example ===");

    let request_id = "req-12345";
    let method = "GET";
    let path = "/api/users/42";
    let response_time = 150;
    let status_code = 200;

    info!(
        "Request completed - ID: {}, {} {} -> {} ({}ms)",
        request_id, method, path, status_code, response_time
    );

    let error_message = "Connection timeout";
    let retry_count = 3;
    let max_retries = 5;

    error!(
        "Operation failed: {} (attempt {}/{}",
        error_message, retry_count, max_retries
    );

    println!("\n=== Performance Logging ===");

    let start_time = std::time::Instant::now();

    std::thread::sleep(std::time::Duration::from_millis(10));

    let duration = start_time.elapsed();
    info!(
        "Operation completed in {:.2}ms",
        duration.as_secs_f64() * 1000.0
    );

    println!("\n=== Custom Logger Examples ===");

    let debug_logger = Logger::with_level(LogLevel::Debug).stdout();
    let trace_logger = Logger::with_level(LogLevel::Trace).stdout();
    let error_logger = Logger::with_level(LogLevel::Error).stdout();

    println!("\n--- Using Custom Loggers with *_with! macros ---");

    info_with!(debug_logger, "This info message uses a debug-level logger");
    debug_with!(debug_logger, "This debug message will show (debug logger)");
    trace_with!(debug_logger, "This trace message won't show (debug logger)");

    info_with!(trace_logger, "This info message uses a trace-level logger");
    debug_with!(trace_logger, "This debug message will show (trace logger)");
    trace_with!(trace_logger, "This trace message will show (trace logger)");

    info_with!(error_logger, "This info message uses an error-level logger");
    debug_with!(error_logger, "This debug message won't show (error logger)");
    error_with!(error_logger, "This error message will show (error logger)");

    println!("\n--- Custom Logger with Formatting ---");

    let user_id = 42;
    let username = "bob";
    let action = "logout";

    info!(
        "Global: User {} ({}) performed {}",
        user_id, username, action
    );

    info_with!(
        debug_logger,
        "Custom: User {} ({}) performed {}",
        user_id,
        username,
        action
    );

    println!("\n--- Custom Logger for Different Components ---");

    let auth_logger = Logger::with_level(LogLevel::Info).stdout();
    let db_logger = Logger::with_level(LogLevel::Debug).stdout();
    let api_logger = Logger::with_level(LogLevel::Warning).stdout();

    info_with!(
        auth_logger,
        "Authentication: User {} logged in successfully",
        user_id
    );
    debug_with!(db_logger, "Database: Query executed in {}ms", 15);
    warning_with!(
        api_logger,
        "API: Rate limit approaching for user {}",
        user_id
    );

    println!("\n--- Lazy Evaluation with Custom Loggers ---");

    use nonblocking_logger::{debug_lazy_with, info_lazy_with, warning_lazy_with};

    info_lazy_with!(
        debug_logger,
        || "Lazy info with custom logger: {}",
        expensive_computation()
    );
    debug_lazy_with!(
        debug_logger,
        || "Lazy debug with custom logger: {}",
        expensive_computation()
    );
    warning_lazy_with!(
        api_logger,
        || "Lazy warning with custom logger: {}",
        expensive_computation()
    );

    println!("\n=== Conditional Logging ===");

    let debug_mode = true;
    let verbose_mode = false;

    if debug_mode {
        debug!("Debug mode is enabled");
    }

    if verbose_mode {
        trace!("Verbose mode is enabled");
    } else {
        trace!("Verbose mode is disabled");
    }

    println!("\n=== Example completed successfully! ===");
}