Struct FileAppender 

pub struct FileAppender { /* private fields */ }

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.

Implementations

impl FileAppender

pub fn open(path: impl AsRef<Path>, layout: Box<dyn Layout>) -> Result<Self>

Open (or create) path for appending, formatting events with layout.

Examples found in repository

examples/file_appender.rs (line 14)

fn main() {
    let log_path = std::env::temp_dir().join("log4rc-file-appender.log");

    Logger::builder(LogLevel::Info)
        .appender(Box::new(ConsoleAppender::new(Box::new(SimpleLayout))))
        .appender(Box::new(
            FileAppender::open(&log_path, Box::new(SimpleLayout))
                .expect("failed to open log file"),
        ))
        .init();

    log4rc::info!("Writing to console and file");
    log4rc::error!("An error also goes to both");
    log4rc::debug!("Filtered out at Info level");

    // Read the file back to prove the messages were written to disk.
    let mut contents = String::new();
    std::fs::File::open(&log_path)
        .expect("failed to reopen log file")
        .read_to_string(&mut contents)
        .expect("failed to read log file");

    println!("\n--- Contents of {} ---", log_path.display());
    print!("{contents}");
    let _ = std::fs::remove_file(&log_path);
}

pub fn builder( path: impl AsRef<Path>, layout: Box<dyn Layout>, ) -> FileAppenderBuilder

Configure a FileAppender, e.g. with size-based rotation.

Examples found in repository

examples/rolling_file_appender.rs (line 17)

fn main() {
    let dir = std::env::temp_dir();
    let prefix = format!("log4rc-rolling-{}", std::process::id());
    let log_path = dir.join(format!("{prefix}.log"));

    Logger::builder(LogLevel::Info)
        .appender(Box::new(
            FileAppender::builder(&log_path, Box::new(SimpleLayout))
                .max_size(100) // tiny limit so a few messages trigger a roll
                .max_files(3) // keep only the 3 newest rotated files
                .compressed() // gzip rotated files
                .build()
                .expect("failed to open log file"),
        ))
        .init();

    for i in 0..10 {
        log4rc::info!("This is message number {i:02} with some padding to grow the file");
    }

    // List the active file plus any rotated siblings.
    let mut files: Vec<_> = std::fs::read_dir(&dir)
        .unwrap()
        .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();
    files.sort();

    println!("--- Log files ---");
    let mut total_lines = 0;
    for path in &files {
        let contents = if path.to_string_lossy().ends_with(".gz") {
            let mut contents = String::new();
            let file = std::fs::File::open(path).expect("failed to open rotated file");
            GzDecoder::new(file)
                .read_to_string(&mut contents)
                .expect("failed to decompress rotated file");
            contents
        } else {
            std::fs::read_to_string(path).expect("failed to read log file")
        };
        let lines = contents.lines().count();
        total_lines += lines;
        println!("{} ({} lines):", path.display(), lines);
    }
    println!("total lines across files: {total_lines}");

    for path in files {
        let _ = std::fs::remove_file(path);
    }
}

Trait Implementations

impl Appender for FileAppender

fn append(&self, event: &LogEvent<'_>)

Append a log event to the output target