log4rc 0.3.0

//! # log4rc - A log4j-like logging framework for Rust
//! 
//! This crate provides a simple, extensible logging framework similar to log4j.
//! 
//! ## Example
//! 
//! ```
//! use log4rc::{LogLevel, Logger};
//! 
//! Logger::init(LogLevel::Debug);
//! 
//! log4rc::trace!("This is a trace message");
//! log4rc::debug!("This is a debug message");
//! log4rc::info!("This is an info message");
//! log4rc::warn!("This is a warning message");
//! log4rc::error!("This is an error message");
//! ```

use std::{
    fs::{File, OpenOptions},
    io::{self, BufWriter, Write},
    path::Path,
    sync::{Arc, Mutex, RwLock},
    time,
};

/// Log levels compatible with log4j
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum LogLevel {
    /// The "trace" level.
    Trace,
    /// The "debug" level.
    Debug,
    /// The "info" level.
    Info,
    /// The "warn" level.
    Warn,
    /// The "error" level.
    Error,
}

impl LogLevel {
    /// Returns the string representation of the log level
    pub fn as_str(&self) -> &'static str {
        match self {
            LogLevel::Trace => "TRACE",
            LogLevel::Debug => "DEBUG",
            LogLevel::Info => "INFO",
            LogLevel::Warn => "WARN",
            LogLevel::Error => "ERROR",
        }
    }
}

/// Log event containing all information about a log message
pub struct LogEvent<'a> {
    /// The level of the log event
    pub level: LogLevel,
    /// The message to log
    pub message: &'a str,
    /// The timestamp when the event occurred
    pub timestamp: std::time::SystemTime,
}

/// Trait for formatting log events into strings
pub trait Layout: Send + Sync {
    /// Format a log event into a string
    fn format(&self, event: &LogEvent) -> String;
}

/// Simple layout that formats log events as "\[level\] message"
pub struct SimpleLayout;

impl Layout for SimpleLayout {
    fn format(&self, event: &LogEvent) -> String {
        format!("[{:<5}] {} {}", event.level.as_str(), get_now_str(event.timestamp), event.message)
    }
}

/// Trait for output targets (console, file, etc.)
pub trait Appender: Send + Sync {
    /// Append a log event to the output target
    fn append(&self, event: &LogEvent);
}

/// Console appender that writes to stdout
pub struct ConsoleAppender {
    layout: Box<dyn Layout>,
}

impl ConsoleAppender {
    /// Create a new console appender with a specific layout
    pub fn new(layout: Box<dyn Layout>) -> Self {
        Self { layout }
    }
}

impl Appender for ConsoleAppender {
    fn append(&self, event: &LogEvent) {
        println!("{}", self.layout.format(event));
    }
}

/// Appender that writes formatted log events to a file, appending to it.
///
/// The file is opened in append mode (created if it does not exist) and
/// flushed after every event so log output survives crashes. Write errors are
/// silently ignored: a logging appender should never crash the application.
///
/// Internally synchronized, so it is safe to share between threads even when
/// appenders run outside the global logger lock.
pub struct FileAppender {
    layout: Box<dyn Layout>,
    writer: Mutex<BufWriter<File>>,
}

impl FileAppender {
    /// Open (or create) `path` for appending, formatting events with `layout`.
    pub fn open(path: impl AsRef<Path>, layout: Box<dyn Layout>) -> io::Result<Self> {
        let file = OpenOptions::new().create(true).append(true).open(path)?;
        Ok(Self {
            layout,
            writer: Mutex::new(BufWriter::new(file)),
        })
    }
}

impl Appender for FileAppender {
    fn append(&self, event: &LogEvent) {
        let line = self.layout.format(event);
        if let Ok(mut writer) = self.writer.lock()
            && writeln!(writer, "{line}").is_ok()
        {
            let _ = writer.flush();
        }
    }
}

static LOGGER: RwLock<Option<Arc<Logger>>> = RwLock::new(None);

/// The logger struct that holds the current log level
pub struct Logger {
    level: LogLevel,
    appenders: Vec<Box<dyn Appender>>,
}

/// Builder for configuring a [`Logger`] with custom appenders.
///
/// Construct one with [`Logger::builder`], add appenders, then call
/// [`LoggerBuilder::build`] to get the logger or [`LoggerBuilder::init`] to
/// install it as the global logger.
pub struct LoggerBuilder {
    level: LogLevel,
    appenders: Vec<Box<dyn Appender>>,
}

impl LoggerBuilder {
    /// Set the log level. Defaults to the level passed to [`Logger::builder`].
    pub fn level(mut self, level: LogLevel) -> Self {
        self.level = level;
        self
    }

    /// Add an appender. May be called multiple times to add several appenders.
    pub fn appender(mut self, appender: Box<dyn Appender>) -> Self {
        self.appenders.push(appender);
        self
    }

    /// Build the configured logger.
    pub fn build(self) -> Logger {
        Logger {
            level: self.level,
            appenders: self.appenders,
        }
    }

    /// Build the logger and install it as the global logger,
    /// replacing any previously configured logger.
    pub fn init(self) {
        Logger::set_logger(self.build());
    }
}

fn get_now_str(sys_time: time::SystemTime) -> String {
    use chrono::{Local, DateTime};
    let dt = DateTime::<Local>::from(sys_time);
    dt.format("%Y-%m-%d %H:%M:%S").to_string()
}
impl Logger {
    /// Start building a logger with custom appenders.
    ///
    /// ```
    /// use log4rc::{LogLevel, Logger};
    ///
    /// Logger::builder(LogLevel::Debug)
    ///     .appender(Box::new(log4rc::ConsoleAppender::new(Box::new(log4rc::SimpleLayout))))
    ///     .init();
    /// ```
    pub fn builder(level: LogLevel) -> LoggerBuilder {
        LoggerBuilder {
            level,
            appenders: Vec::new(),
        }
    }

    /// Replace the global logger with a custom-built one.
    pub fn set_logger(logger: Logger) {
        *LOGGER.write().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(logger));
    }

    /// Initialize the logger with a specific log level.
    ///
    /// This configures a single [`ConsoleAppender`] with a [`SimpleLayout`].
    /// Calling this again replaces the previous logger, allowing the log level
    /// (and appenders) to be reconfigured at runtime. Use [`Logger::builder`]
    /// for full control over appenders.
    pub fn init(level: LogLevel) {
        Logger::set_logger(Logger {
            level,
            appenders: vec![Box::new(ConsoleAppender::new(Box::new(SimpleLayout)))],
        });
    }

    /// Get a handle to the current logger instance.
    ///
    /// Returns `None` if the logger has not been initialized yet. The returned
    /// handle is an [`Arc`] clone, so it does not hold the global logger lock;
    /// formatting and appending therefore run outside the lock and logging
    /// calls from different threads do not serialize on each other.
    pub fn get() -> Option<Arc<Logger>> {
        LOGGER.read().unwrap_or_else(|e| e.into_inner()).clone()
    }

    /// Check if a message at the specified level would be logged.
    ///
    /// Use this to skip expensive work (such as formatting) when the level is
    /// filtered out; the logging macros already do this internally.
    pub fn is_enabled(&self, level: LogLevel) -> bool {
        level >= self.level
    }

    /// Log a message at the specified level
    pub fn log(&self, level: LogLevel, message: &str) {
        if self.is_enabled(level) {
            let event = LogEvent {
                level,
                message,
                timestamp: std::time::SystemTime::now(),
            };
            
            for appender in &self.appenders {
                appender.append(&event);
            }
        }
    }
}

/// Macro for logging trace messages
#[macro_export]
macro_rules! trace {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get() {
            if logger.is_enabled($crate::LogLevel::Trace) {
                logger.log($crate::LogLevel::Trace, &format!($($arg)*));
            }
        }
    };
}

/// Macro for logging debug messages
#[macro_export]
macro_rules! debug {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get() {
            if logger.is_enabled($crate::LogLevel::Debug) {
                logger.log($crate::LogLevel::Debug, &format!($($arg)*));
            }
        }
    };
}

/// Macro for logging info messages
#[macro_export]
macro_rules! info {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get() {
            if logger.is_enabled($crate::LogLevel::Info) {
                logger.log($crate::LogLevel::Info, &format!($($arg)*));
            }
        }
    };
}

/// Macro for logging warning messages
#[macro_export]
macro_rules! warn {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get() {
            if logger.is_enabled($crate::LogLevel::Warn) {
                logger.log($crate::LogLevel::Warn, &format!($($arg)*));
            }
        }
    };
}

/// Macro for logging error messages
#[macro_export]
macro_rules! error {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get() {
            if logger.is_enabled($crate::LogLevel::Error) {
                logger.log($crate::LogLevel::Error, &format!($($arg)*));
            }
        }
    };
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;

    // The tests share the global logger, so serialize them to avoid races.
    static TEST_LOCK: Mutex<()> = Mutex::new(());

    #[test]
    fn init_reconfigures_logger() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        Logger::init(LogLevel::Error);
        assert_eq!(Logger::get().unwrap().level, LogLevel::Error);

        // A second init should replace the logger rather than silently no-op
        Logger::init(LogLevel::Trace);
        assert_eq!(Logger::get().unwrap().level, LogLevel::Trace);
    }

    #[test]
    fn is_enabled_filters_by_level() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        Logger::init(LogLevel::Info);
        let logger = Logger::get().unwrap();
        assert!(!logger.is_enabled(LogLevel::Trace));
        assert!(!logger.is_enabled(LogLevel::Debug));
        assert!(logger.is_enabled(LogLevel::Info));
        assert!(logger.is_enabled(LogLevel::Warn));
        assert!(logger.is_enabled(LogLevel::Error));
    }

    #[test]
    fn custom_appender_receives_events() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        struct CaptureAppender(Arc<Mutex<Vec<String>>>);

        impl Appender for CaptureAppender {
            fn append(&self, event: &LogEvent) {
                self.0.lock().unwrap().push(event.message.to_string());
            }
        }

        let buffer = Arc::new(Mutex::new(Vec::new()));
        Logger::builder(LogLevel::Info)
            .appender(Box::new(CaptureAppender(buffer.clone())))
            .init();

        crate::info!("hello {}", 42);
        crate::debug!("filtered at Info level");

        let messages = buffer.lock().unwrap();
        assert_eq!(messages.len(), 1);
        assert_eq!(messages[0], "hello 42");
    }

    #[test]
    fn file_appender_writes_to_disk() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let path = std::env::temp_dir().join(format!("log4rc-test-{}.log", std::process::id()));
        let _ = std::fs::remove_file(&path);

        Logger::builder(LogLevel::Info)
            .appender(Box::new(FileAppender::open(&path, Box::new(SimpleLayout)).unwrap()))
            .init();

        crate::info!("disk message");
        crate::debug!("filtered");

        let contents = std::fs::read_to_string(&path).unwrap();
        assert!(contents.contains("disk message"));
        assert!(!contents.contains("filtered"));

        let _ = std::fs::remove_file(&path);
    }

    #[test]
    fn concurrent_threads_log_to_file_without_loss() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let path = std::env::temp_dir().join(format!("log4rc-threaded-{}.log", std::process::id()));
        let _ = std::fs::remove_file(&path);

        Logger::builder(LogLevel::Info)
            .appender(Box::new(FileAppender::open(&path, Box::new(SimpleLayout)).unwrap()))
            .init();

        let threads: Vec<_> = (0..4)
            .map(|t| {
                std::thread::spawn(move || {
                    for i in 0..25 {
                        crate::info!("thread {} message {}", t, i);
                    }
                })
            })
            .collect();
        for thread in threads {
            thread.join().unwrap();
        }

        let contents = std::fs::read_to_string(&path).unwrap();
        assert_eq!(contents.lines().count(), 100);

        let _ = std::fs::remove_file(&path);
    }
}