log4rc 0.4.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, PathBuf},
    sync::{
        atomic::{AtomicU64, Ordering},
        Arc, Mutex, RwLock,
    },
    time,
};

use flate2::{write::GzEncoder, Compression};

/// 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. When a size limit
/// is configured with [`FileAppender::builder`]'s `max_size`, the current file
/// is rolled over to a timestamped sibling (e.g. `app.log.20260809-102530-1`)
/// once the next line would exceed the limit. A `max_files` retention policy
/// (see [`FileAppenderBuilder::max_files`]) deletes the oldest rotated files
/// once the count is exceeded. With [`FileAppenderBuilder::compressed`],
/// rotated files are gzip-compressed (`.gz`) on rollover. 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>,
    path: PathBuf,
    max_size: Option<u64>,
    max_files: Option<usize>,
    compressed: bool,
    /// Monotonic roll counter so rotated names are never reused, even after
    /// retention deletes the oldest file (which would otherwise free its name).
    roll: AtomicU64,
    state: Mutex<Option<FileState>>,
}

/// The open log file plus the number of bytes written to it (including data
/// still buffered), used to decide when to roll the file over.
struct FileState {
    writer: BufWriter<File>,
    written: u64,
}

impl FileState {
    fn open(path: &Path) -> io::Result<Self> {
        let file = OpenOptions::new().create(true).append(true).open(path)?;
        let written = file.metadata().map_or(0, |m| m.len());
        Ok(Self {
            writer: BufWriter::new(file),
            written,
        })
    }
}

/// Builder for [`FileAppender`].
///
/// Construct one with [`FileAppender::builder`], optionally enable size-based
/// rotation with [`max_size`](Self::max_size), then call [`build`](Self::build).
pub struct FileAppenderBuilder {
    path: PathBuf,
    layout: Box<dyn Layout>,
    max_size: Option<u64>,
    max_files: Option<usize>,
    compressed: bool,
}

impl FileAppenderBuilder {
    /// Roll the file over to a timestamped sibling once it reaches `bytes`.
    pub fn max_size(mut self, bytes: u64) -> Self {
        self.max_size = Some(bytes);
        self
    }

    /// Keep at most `count` rotated files, deleting the oldest beyond that.
    ///
    /// `count = 0` keeps no rotated files; they are deleted as soon as they
    /// are rolled over. The active log file is never counted or deleted.
    pub fn max_files(mut self, count: usize) -> Self {
        self.max_files = Some(count);
        self
    }

    /// Compress rotated files to gzip (`.gz`) on rollover.
    ///
    /// If compression fails, the rotated file is kept uncompressed so no log
    /// data is lost.
    pub fn compressed(mut self) -> Self {
        self.compressed = true;
        self
    }

    /// Build the appender, opening (or creating) the log file.
    pub fn build(self) -> io::Result<FileAppender> {
        let state = FileState::open(&self.path)?;
        Ok(FileAppender {
            layout: self.layout,
            path: self.path,
            max_size: self.max_size,
            max_files: self.max_files,
            compressed: self.compressed,
            roll: AtomicU64::new(1),
            state: Mutex::new(Some(state)),
        })
    }
}

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> {
        Self::builder(path, layout).build()
    }

    /// Configure a [`FileAppender`], e.g. with size-based rotation.
    pub fn builder(path: impl AsRef<Path>, layout: Box<dyn Layout>) -> FileAppenderBuilder {
        FileAppenderBuilder {
            path: path.as_ref().to_path_buf(),
            layout,
            max_size: None,
            max_files: None,
            compressed: false,
        }
    }

    /// Flush and close the current file, rename it to a timestamped sibling,
    /// and open a fresh file in its place.
    fn rotate(&self, guard: &mut std::sync::MutexGuard<'_, Option<FileState>>) -> io::Result<()> {
        // Dropping the taken state closes the file, which rename needs on all
        // platforms.
        if let Some(mut state) = guard.take() {
            state.writer.flush()?;
        }
        let roll = self.roll.fetch_add(1, Ordering::Relaxed);
        let rotated = self.rotated_path(roll);
        if let Err(e) = std::fs::rename(&self.path, &rotated) {
            // Reopen the original file so logging can continue.
            **guard = Some(FileState::open(&self.path)?);
            return Err(e);
        }
        **guard = Some(FileState::open(&self.path)?);
        if self.compressed {
            // Keep the uncompressed file if compression fails: no data loss.
            let _ = self.compress(&rotated);
        }
        self.enforce_retention();
        Ok(())
    }

    /// Gzip `source` in place: write `source.gz`, then remove `source`.
    fn compress(&self, source: &Path) -> io::Result<()> {
        let gz_path = PathBuf::from(format!("{}.gz", source.display()));
        let file = File::create(&gz_path)?;
        let mut encoder = GzEncoder::new(file, Compression::default());
        let mut reader = File::open(source)?;
        io::copy(&mut reader, &mut encoder)?;
        encoder.finish()?;
        std::fs::remove_file(source)
    }

    fn rotated_path(&self, roll: u64) -> PathBuf {
        let ts = chrono::Local::now().format("%Y%m%d-%H%M%S");
        let mut candidate = PathBuf::from(format!("{}.{}-{}", self.path.display(), ts, roll));
        let mut n = roll + 1;
        while self.rotation_name_taken(&candidate) {
            candidate = PathBuf::from(format!("{}.{}-{}", self.path.display(), ts, n));
            n += 1;
        }
        candidate
    }

    /// Whether `candidate` (or its compressed counterpart) already exists.
    fn rotation_name_taken(&self, candidate: &Path) -> bool {
        candidate.exists()
            || (self.compressed
                && PathBuf::from(format!("{}.gz", candidate.display())).exists())
    }

    /// Delete the oldest rotated files once the count exceeds `max_files`.
    ///
    /// Rotated names are `path.<timestamp>` or `path.<timestamp>-<n>`, so the
    /// chronological order is `(timestamp, roll number)`. Failures are ignored
    /// to keep logging side-effect-free.
    fn enforce_retention(&self) {
        let Some(max_files) = self.max_files else { return };
        let dir = self
            .path
            .parent()
            .filter(|p| !p.as_os_str().is_empty())
            .unwrap_or_else(|| Path::new("."));
        let prefix = format!(
            "{}.",
            self.path
                .file_name()
                .map(|n| n.to_string_lossy().into_owned())
                .unwrap_or_default()
        );

        let Ok(entries) = std::fs::read_dir(dir) else { return };
        let mut rotated: Vec<PathBuf> = entries
            .flatten()
            .map(|e| e.path())
            .filter(|p| {
                p.file_name()
                    .and_then(|n| n.to_str())
                    .is_some_and(|n| n.starts_with(&prefix))
            })
            .collect();
        if rotated.len() <= max_files {
            return;
        }
        rotated.sort_by_key(|path| retention_key(path, &prefix));
        for old in rotated.iter().take(rotated.len() - max_files) {
            let _ = std::fs::remove_file(old);
        }
    }
}

/// Sort key for a rotated file name: `(timestamp, roll number)`.
///
/// Names look like `path.<YYYYMMDD-HHMMSS>` or `path.<YYYYMMDD-HHMMSS>-<n>`
/// (optionally followed by `.gz`), where the timestamp is exactly 15 chars.
fn retention_key(path: &Path, prefix: &str) -> (String, u64) {
    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or_default();
    let name = name.strip_suffix(".gz").unwrap_or(name);
    let rest = name.strip_prefix(prefix).unwrap_or(name);
    if rest.len() > 15 && rest.as_bytes()[15] == b'-' {
        (rest[..15].to_string(), rest[16..].parse().unwrap_or(0))
    } else {
        (rest.to_string(), 0)
    }
}

impl Appender for FileAppender {
    fn append(&self, event: &LogEvent) {
        let line = self.layout.format(event);
        let line_len = line.len() as u64 + 1;
        let Ok(mut guard) = self.state.lock() else { return };

        let needs_roll = self.max_size.is_some_and(|max| {
            guard
                .as_ref()
                .is_some_and(|state| state.written > 0 && state.written + line_len > max)
        });
        if needs_roll && self.rotate(&mut guard).is_err() {
            return;
        }

        let Some(state) = guard.as_mut() else { return };
        if writeln!(state.writer, "{line}").is_ok() {
            state.written += line_len;
            let _ = state.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::io::Read;
    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 file_appender_rotates_at_size_limit() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let dir = std::env::temp_dir();
        let prefix = format!("log4rc-roll-test-{}", std::process::id());
        let path = dir.join(format!("{prefix}.log"));

        // Remove any leftovers from a previously interrupted run.
        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
            let name = entry.file_name();
            if name.to_str().is_some_and(|n| n.starts_with(&prefix)) {
                let _ = std::fs::remove_file(entry.path());
            }
        }

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

        for i in 0..10 {
            crate::info!("message number {i} with padding to make the line longer");
        }

        let mut total_lines = 0;
        let mut file_count = 0;
        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
            let name = entry.file_name();
            let Some(name) = name.to_str() else { continue };
            if !name.starts_with(&prefix) {
                continue;
            }
            file_count += 1;
            total_lines += std::fs::read_to_string(entry.path())
                .unwrap()
                .lines()
                .count();
            let _ = std::fs::remove_file(entry.path());
        }

        assert_eq!(total_lines, 10, "all messages must survive rotation");
        assert!(file_count > 1, "expected rotation to produce multiple files");
    }

    #[test]
    fn rotated_files_are_compressed() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let dir = std::env::temp_dir();
        let prefix = format!("log4rc-gzip-test-{}", std::process::id());
        let path = dir.join(format!("{prefix}.log"));

        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
            let name = entry.file_name();
            if name.to_str().is_some_and(|n| n.starts_with(&prefix)) {
                let _ = std::fs::remove_file(entry.path());
            }
        }

        Logger::builder(LogLevel::Info)
            .appender(Box::new(
                FileAppender::builder(&path, Box::new(SimpleLayout))
                    .max_size(100)
                    .compressed()
                    .build()
                    .unwrap(),
            ))
            .init();

        for i in 0..10 {
            crate::info!("message number {i} with padding to make the line longer");
        }

        // The newest message stays in the active file.
        let current = std::fs::read_to_string(&path).unwrap();
        assert!(current.contains("message number 9"));

        // Every rotated file must be gzipped, and decompressing them all must
        // recover every message except the newest.
        let mut recovered = String::new();
        let mut rotated_count = 0;
        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
            let name = entry.file_name();
            let Some(name) = name.to_str() else { continue };
            if !name.starts_with(&prefix) {
                continue;
            }
            if name != format!("{prefix}.log") {
                rotated_count += 1;
                assert!(
                    name.ends_with(".gz"),
                    "rotated file was not compressed: {name}"
                );
                let file = std::fs::File::open(entry.path()).unwrap();
                let mut decoder = flate2::read::GzDecoder::new(file);
                decoder.read_to_string(&mut recovered).unwrap();
            }
            let _ = std::fs::remove_file(entry.path());
        }

        assert!(rotated_count > 0, "expected at least one rotation");
        for i in 0..9 {
            assert!(
                recovered.contains(&format!("message number {i}")),
                "rotated logs are missing message {i}"
            );
        }
    }

    #[test]
    fn file_appender_retains_only_max_files_rotations() {
        let _guard = TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let dir = std::env::temp_dir();
        let prefix = format!("log4rc-retain-test-{}", std::process::id());
        let path = dir.join(format!("{prefix}.log"));

        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
            let name = entry.file_name();
            if name.to_str().is_some_and(|n| n.starts_with(&prefix)) {
                let _ = std::fs::remove_file(entry.path());
            }
        }

        Logger::builder(LogLevel::Info)
            .appender(Box::new(
                FileAppender::builder(&path, Box::new(SimpleLayout))
                    .max_size(100)
                    .max_files(2)
                    .build()
                    .unwrap(),
            ))
            .init();

        for i in 0..10 {
            crate::info!("message number {i} with padding to make the line longer");
        }

        // The active file must hold the most recent message; retention must
        // keep the newest rotated files and prune the oldest.
        let current = std::fs::read_to_string(&path).unwrap();
        assert!(current.contains("message number 9"));

        let mut rotated_count = 0;
        let mut rotated_contents = String::new();
        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
            let name = entry.file_name();
            let Some(name) = name.to_str() else { continue };
            if !name.starts_with(&prefix) {
                continue;
            }
            if name != format!("{prefix}.log") {
                rotated_count += 1;
                rotated_contents.push_str(&std::fs::read_to_string(entry.path()).unwrap());
            }
            let _ = std::fs::remove_file(entry.path());
        }

        assert!(
            rotated_count <= 2,
            "expected at most 2 rotated files, found {rotated_count}"
        );
        assert!(
            rotated_contents.contains("message number 8"),
            "the newest rotated file must be retained"
        );
        assert!(
            !rotated_contents.contains("message number 0"),
            "the oldest rotated file must be pruned"
        );
    }

    #[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);
    }
}