nonblocking_logger/

macros.rs

/// Macros for convenient logging with string formatting support
///
/// These macros provide a convenient way to log messages with format string support,
/// similar to the standard library's `println!` macro family.
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{info, debug, error};
///
/// fn main() {
///     let user_id = 42;
///     let status = "active";
///     
///     // Simple string
///     info!("User logged in");
///     
///     // With formatting
///     info!("User {} has status: {}", user_id, status);
///     
///     // With debug formatting
///     debug!("Debug info: {:?}", vec![1, 2, 3]);
///     
///     // Error with formatting
///     error!("Failed to process user {}: {}", user_id, "connection timeout");
/// }
/// ```

/// Log a message using format string syntax (always outputs, no level filtering)
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::log;
///
/// fn main() {
///     let count = 5;
///     
///     // Using global logger
///     log!("Processing {} items", count);
/// }
/// ```
#[macro_export]
macro_rules! log {
    ($($arg:tt)+) => {
        { let _ = $crate::log(&format!($($arg)+)); }
    };
}

/// Log a message with a specific logger using format string syntax (always outputs, no level filtering)
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{log_with, Logger};
///
/// fn main() {
///     let count = 5;
///     let logger = Logger::new().stdout();
///     
///     // Using specific logger
///     log_with!(logger, "Processing {} items", count);
/// }
/// ```
#[macro_export]
macro_rules! log_with {
    ($logger:expr, $($arg:tt)+) => {
        { let _ = $logger.log(&format!($($arg)+)); }
    };
}

/// Log an error message using format string syntax
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{error, error_with, Logger};
///
/// fn main() {
///     let error_code = 500;
///     
///     // Using global logger
///     error!("Server error: {}", error_code);
///     
///     // Using specific logger
///     let logger = Logger::new().stdout();
///     error_with!(logger, "Server error: {}", error_code);
/// }
/// ```
#[macro_export]
macro_rules! error {
    ($($arg:tt)+) => {
        { let _ = $crate::error(&format!($($arg)+)); }
    };
}

/// Log an error message using format string syntax with a specific logger
#[macro_export]
macro_rules! error_with {
    ($logger:expr, $($arg:tt)+) => {
        { let _ = $logger.error(&format!($($arg)+)); }
    };
}

/// Log a warning message using format string syntax
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{warning, warning_with, Logger};
///
/// fn main() {
///     let threshold = 80;
///     
///     // Using global logger
///     warning!("CPU usage is {}%", threshold);
///     
///     // Using specific logger
///     let logger = Logger::new().stdout();
///     warning_with!(logger, "CPU usage is {}%", threshold);
/// }
/// ```
#[macro_export]
macro_rules! warning {
    ($($arg:tt)+) => {
        { let _ = $crate::warning(&format!($($arg)+)); }
    };
}

/// Log a warning message using format string syntax with a specific logger
#[macro_export]
macro_rules! warning_with {
    ($logger:expr, $($arg:tt)+) => {
        { let _ = $logger.warning(&format!($($arg)+)); }
    };
}

/// Log an info message using format string syntax
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{info, info_with, Logger};
///
/// fn main() {
///     let user = "alice";
///     
///     // Using global logger
///     info!("User {} connected", user);
///     
///     // Using specific logger
///     let logger = Logger::new().stdout();
///     info_with!(logger, "User {} connected", user);
/// }
/// ```
#[macro_export]
macro_rules! info {
    ($($arg:tt)+) => {
        { let _ = $crate::info(&format!($($arg)+)); }
    };
}

/// Log an info message using format string syntax with a specific logger
#[macro_export]
macro_rules! info_with {
    ($logger:expr, $($arg:tt)+) => {
        { let _ = $logger.info(&format!($($arg)+)); }
    };
}

/// Log a debug message using format string syntax
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{debug, debug_with, Logger};
///
/// fn main() {
///     let data = vec![1, 2, 3];
///     
///     // Using global logger
///     debug!("Processing data: {:?}", data);
///     
///     // Using specific logger
///     let logger = Logger::new().stdout();
///     debug_with!(logger, "Processing data: {:?}", data);
/// }
/// ```
#[macro_export]
macro_rules! debug {
    ($($arg:tt)+) => {
        { let _ = $crate::debug(&format!($($arg)+)); }
    };
}

/// Log a debug message using format string syntax with a specific logger
#[macro_export]
macro_rules! debug_with {
    ($logger:expr, $($arg:tt)+) => {
        { let _ = $logger.debug(&format!($($arg)+)); }
    };
}

/// Log a trace message using format string syntax
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{trace, trace_with, Logger};
///
/// fn main() {
///     let step = "validation";
///     
///     // Using global logger
///     trace!("Entering {} step", step);
///     
///     // Using specific logger
///     let logger = Logger::new().stdout();
///     trace_with!(logger, "Entering {} step", step);
/// }
/// ```
#[macro_export]
macro_rules! trace {
    ($($arg:tt)+) => {
        { let _ = $crate::trace(&format!($($arg)+)); }
    };
}

/// Log a trace message using format string syntax with a specific logger
#[macro_export]
macro_rules! trace_with {
    ($logger:expr, $($arg:tt)+) => {
        { let _ = $logger.trace(&format!($($arg)+)); }
    };
}

/// Log a message with lazy evaluation using format string syntax
///
/// The closure is only executed if the log level is sufficient.
///
/// # Examples
///
/// ```rust
/// use nonblocking_logger::{log_lazy, log_lazy_with, Logger};
///
/// fn expensive_computation() -> String {
///     // Some expensive operation
///     "result".to_string()
/// }
///
/// fn main() {
///     let user_id = 42;
///     
///     // Using global logger
///     log_lazy!(|| "User {}: {}", user_id, expensive_computation());
///     
///     // Using specific logger
///     let logger = Logger::new().stdout();
///     log_lazy_with!(logger, || "User {}: {}", user_id, expensive_computation());
/// }
/// ```
#[macro_export]
macro_rules! log_lazy {
    (|| $($arg:tt)+) => {
        { let _ = $crate::log_lazy(|| format!($($arg)+)); }
    };
}

/// Log a message with lazy evaluation using format string syntax with a specific logger
#[macro_export]
macro_rules! log_lazy_with {
    ($logger:expr, || $($arg:tt)+) => {
        { let _ = $logger.log_lazy(|| format!($($arg)+)); }
    };
}

/// Log an error message with lazy evaluation using format string syntax
#[macro_export]
macro_rules! error_lazy {
    (|| $($arg:tt)+) => {
        { let _ = $crate::error_lazy(|| format!($($arg)+)); }
    };
}

/// Log an error message with lazy evaluation using format string syntax with a specific logger
#[macro_export]
macro_rules! error_lazy_with {
    ($logger:expr, || $($arg:tt)+) => {
        { let _ = $logger.error_lazy(|| format!($($arg)+)); }
    };
}

/// Log a warning message with lazy evaluation using format string syntax
#[macro_export]
macro_rules! warning_lazy {
    (|| $($arg:tt)+) => {
        { let _ = $crate::warning_lazy(|| format!($($arg)+)); }
    };
}

/// Log a warning message with lazy evaluation using format string syntax with a specific logger
#[macro_export]
macro_rules! warning_lazy_with {
    ($logger:expr, || $($arg:tt)+) => {
        { let _ = $logger.warning_lazy(|| format!($($arg)+)); }
    };
}

/// Log an info message with lazy evaluation using format string syntax
#[macro_export]
macro_rules! info_lazy {
    (|| $($arg:tt)+) => {
        { let _ = $crate::info_lazy(|| format!($($arg)+)); }
    };
}

/// Log an info message with lazy evaluation using format string syntax with a specific logger
#[macro_export]
macro_rules! info_lazy_with {
    ($logger:expr, || $($arg:tt)+) => {
        { let _ = $logger.info_lazy(|| format!($($arg)+)); }
    };
}

/// Log a debug message with lazy evaluation using format string syntax
#[macro_export]
macro_rules! debug_lazy {
    (|| $($arg:tt)+) => {
        { let _ = $crate::debug_lazy(|| format!($($arg)+)); }
    };
}

/// Log a debug message with lazy evaluation using format string syntax with a specific logger
#[macro_export]
macro_rules! debug_lazy_with {
    ($logger:expr, || $($arg:tt)+) => {
        { let _ = $logger.debug_lazy(|| format!($($arg)+)); }
    };
}

/// Log a trace message with lazy evaluation using format string syntax
#[macro_export]
macro_rules! trace_lazy {
    (|| $($arg:tt)+) => {
        { let _ = $crate::trace_lazy(|| format!($($arg)+)); }
    };
}

/// Log a trace message with lazy evaluation using format string syntax with a specific logger
#[macro_export]
macro_rules! trace_lazy_with {
    ($logger:expr, || $($arg:tt)+) => {
        { let _ = $logger.trace_lazy(|| format!($($arg)+)); }
    };
}

#[cfg(test)]
#[cfg(not(target_arch = "wasm32"))]
mod tests {

    #[test]
    fn test_log_macro() {
        let count = 5;
        log!("Processing {} items", count);
    }

    #[test]
    fn test_error_macro() {
        let error_code = 500;
        error!("Server error: {}", error_code);
    }

    #[test]
    fn test_warning_macro() {
        let threshold = 80;
        warning!("CPU usage is {}%", threshold);
    }

    #[test]
    fn test_info_macro() {
        let user = "alice";
        info!("User {} connected", user);
    }

    #[test]
    fn test_debug_macro() {
        let data = vec![1, 2, 3];
        debug!("Processing data: {:?}", data);
    }

    #[test]
    fn test_trace_macro() {
        let step = "validation";
        trace!("Entering {} step", step);
    }

    #[test]
    fn test_log_lazy_macro() {
        let user_id = 42;
        log_lazy!(|| "User {}: {}", user_id, "result");
    }

    #[test]
    fn test_error_lazy_macro() {
        let error_code = 500;
        error_lazy!(|| "Server error: {}", error_code);
    }

    #[test]
    fn test_warning_lazy_macro() {
        let threshold = 80;
        warning_lazy!(|| "CPU usage is {}%", threshold);
    }

    #[test]
    fn test_info_lazy_macro() {
        let user = "alice";
        info_lazy!(|| "User {} connected", user);
    }

    #[test]
    fn test_debug_lazy_macro() {
        let data = vec![1, 2, 3];
        debug_lazy!(|| "Processing data: {:?}", data);
    }

    #[test]
    fn test_trace_lazy_macro() {
        let step = "validation";
        trace_lazy!(|| "Entering {} step", step);
    }

    #[test]
    fn test_macro_with_multiple_args() {
        let user_id = 42;
        let action = "login";
        let timestamp = "2025-01-14 10:30:00";

        info!("User {} performed {} at {}", user_id, action, timestamp);
    }

    #[test]
    fn test_macro_with_debug_formatting() {
        let data = vec![1, 2, 3, 4, 5];
        let metadata = std::collections::HashMap::from([("key1", "value1"), ("key2", "value2")]);

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

    #[test]
    fn test_macro_with_no_args() {
        info!("Simple message without formatting");
    }

    #[test]
    fn test_log_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let count = 5;
        log_with!(
            logger,
            "Processing {} items with custom logger",
            count
        );
    }

    #[test]
    fn test_error_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let error_code = 500;
        error_with!(logger, "Server error with custom logger: {}", error_code);
    }

    #[test]
    fn test_warning_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let threshold = 80;
        warning_with!(logger, "CPU usage with custom logger is {}%", threshold);
    }

    #[test]
    fn test_info_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let user = "alice";
        info_with!(logger, "User {} connected with custom logger", user);
    }

    #[test]
    fn test_debug_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let data = vec![1, 2, 3];
        debug_with!(logger, "Processing data with custom logger: {:?}", data);
    }

    #[test]
    fn test_trace_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let step = "validation";
        trace_with!(logger, "Entering {} step with custom logger", step);
    }

    #[test]
    fn test_log_lazy_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let user_id = 42;
        log_lazy_with!(
            logger,
            || "User {} with custom logger: {}",
            user_id,
            "result"
        );
    }

    #[test]
    fn test_error_lazy_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let error_code = 500;
        error_lazy_with!(logger, || "Server error with custom logger: {}", error_code);
    }

    #[test]
    fn test_warning_lazy_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let threshold = 80;
        warning_lazy_with!(logger, || "CPU usage with custom logger is {}%", threshold);
    }

    #[test]
    fn test_info_lazy_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let user = "alice";
        info_lazy_with!(logger, || "User {} connected with custom logger", user);
    }

    #[test]
    fn test_debug_lazy_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let data = vec![1, 2, 3];
        debug_lazy_with!(logger, || "Processing data with custom logger: {:?}", data);
    }

    #[test]
    fn test_trace_lazy_macro_with_logger() {
        use crate::Logger;
        let logger = Logger::new().stdout();
        let step = "validation";
        trace_lazy_with!(logger, || "Entering {} step with custom logger", step);
    }

    #[test]
    fn test_macro_backward_compatibility() {
        let count = 5;
        log!(
            "Backward compatibility test: {} items",
            count
        );
        error!("Backward compatibility error test: {}", 500);
        warning!("Backward compatibility warning test: {}%", 80);
        info!("Backward compatibility info test: {}", "alice");
        debug!("Backward compatibility debug test: {:?}", vec![1, 2, 3]);
        trace!("Backward compatibility trace test: {}", "validation");
    }
}