log2

log2 is an out-of-the-box logging library for Rust. It writes to stdout or to file asynchronously, and automatically rotates based on file size.

Features

stdout logging - Log to console with color support
file logging - Log to file with automatic rotation
log rotation - Rotate logs based on file size (default: 100MB, 10 files)
tee support - Log to both file and stdout simultaneously
module filtering - Filter logs by module path
custom formatting - Customize log output format
gzip compression - Compress rotated log files
globally static - No need to store the logger handle, lives for entire program duration

Add dependency

cargo add log2

Quick Start

Log to stdout

use log2::*;

fn main() {
    log2::start();

    info!("hello world");
}

Log to file

use log2::*;

fn main() {
    log2::open("app.log").start();

    info!("hello world");
}

Configuration

stdout with options

use log2::*;

fn main() {
    log2::stdout()
        .level("info")           // set log level: trace, debug, info, warn, error, off
        .module(false)           // hide module path
        .module_with_line(true)  // show module path with line number
        .start();

    trace!("verbose details");
    debug!("debug info");
    info!("general info");
    warn!("warning message");
    error!("error occurred");
}

file with options

use log2::*;

fn main() {
    log2::open("app.log")
        .size(100 * 1024 * 1024)  // max file size (default: 100MB)
        .rotate(20)               // max rotation count (default: 10)
        .tee(true)                // also log to stdout
        .module(true)             // show module path (default: true)
        .module_with_line(true)   // show module path with line number (default: false)
        .level("debug")           // set log level
        .compress(true)           // compress rotated files with gzip (default: false)
        .start();

    info!("logging to file with rotation");
}

API Reference

Functions

Function	Description
`log2::start()`	Start logging to stdout with default settings
`log2::stdout() -> Log2`	Create a stdout logger for configuration
`log2::open(path) -> Log2`	Create a file logger for configuration
`log2::set_level(level)`	Set global log level
`log2::handle() -> Option<RwLockWriteGuard>`	Get the global handle for manipulation
`log2::reset()`	Reset the global logger (useful for testing)

Log2 Builder Methods

Method	Description	Default
`.level(name)`	Set log level	"trace"
`.module(show)`	Show/hide module path	true
`.module_with_line(show)`	Show module path with line number	false
`.tee(stdout)`	Also output to stdout	false
`.size(bytes)`	Max file size before rotation	100MB
`.rotate(count)`	Number of rotated files to keep	10
`.compress(on)`	Compress rotated files with gzip	false
`.module_filter(fn)`	Filter logs by module path	none
`.format(fn)`	Custom log format function	built-in
`.start()`	Start the logger	-

Log Levels

trace - Most verbose
debug - Debug information
info - General information (default)
warn - Warning messages
error - Error messages
off - Disable all logging

Log Macros

use log2::*;

trace!("verbose: {}", value);
debug!("debug: {}", value);
info!("info: {}", value);
warn!("warning: {}", value);
error!("error: {}", value);

Handle API

You can manipulate the logger after starting:

use log2::*;

fn main() {
    log2::open("app.log").start();

    // Get handle to manipulate
    if let Some(mut handle) = log2::handle() {
        handle.flush();
        // handle.redirect("new.log");
        // handle.stop();
    }
}

Handle Methods

Method	Description
`stop()`	Stop the logger thread
`flush()`	Flush all pending logs
`redirect(path)`	Redirect log to a new file
`set_level(level)`	Change log level

Module Filtering

Filter logs by module path:

use log2::*;

fn main() {
    log2::stdout()
        .module_filter(|module| module.contains("my_app"))
        .start();

    my_crate::do_something();  // will be logged
    other_crate::do_something(); // will be filtered out
}

Custom Formatter

Create a custom log format:

use chrono::Local;
use log::Record;
use log2::*;

fn custom_format(record: &Record, tee: bool) -> String {
    if tee {
        // stdout format (with colors)
        format!(
            "[{}] [{}] {}\n",
            Local::now().format("%Y-%m-%d %H:%M:%S"),
            record.level(),
            record.args()
        )
    } else {
        // file format
        format!(
            "[{}] [{}] [{}] {}\n",
            Local::now().format("%Y-%m-%d %H:%M:%S"),
            record.level(),
            record.module_path().unwrap_or("unknown"),
            record.args()
        )
    }
}

fn main() {
    log2::open("app.log")
        .tee(true)
        .format(custom_format)
        .start();

    info!("custom formatted log");
}

File Rotation

When file size reaches the limit, log2 rotates files:

app.log      <- current log
app.1.log    <- most recent
app.2.log    <- older
...
app.9.log    <- oldest

With compression enabled:

app.log
app.1.log.gz
app.2.log.gz
...
app.9.log.gz

Testing

use log2::*;

#[test]
fn test_logging() {
    log2::stdout().start();
    info!("test message");
    log2::reset();  // clean up for next test
}

Dependencies

Add these to your Cargo.toml if you use custom features:

chrono = "0.4"   # for timestamp formatting
colored = "2"     # for colored output
flate2 = "1"      # for gzip compression

log2 0.2.4