Crate loggit 

Loggit: a zero-setup, color-aware, file-rotating logger for Rust applications.

Loggit is a lightweight logging library for Rust that provides built‑in logger macros (such as trace!, debug!, info!, warn!, and error!) to allow you to start logging with zero boilerplate. You can also customize the log level, format, colors, and output destination.

Features

• Zero Setup: Just import the library and start logging.
• Customizable: Change log formats, colors, and logging levels.
• Macros Provided: Includes trace!, debug!, info!, warn!, and error!.
• Flexible Formatting: Use custom templates with placeholders like {level}, {file}, {line}, and {message}.
• Saving log to files: Save your logs to files automatically by specifying filename format
• File rotation: Rotate your files by specifying time period or size
• Compress used files: Save your space by compressing used log files

Installation

Add the following to your Cargo.toml:

[dependencies]
loggit = "0.1.9"

Or use:

cargo add loggit

Usage Examples

Basic Logging

Simply import the logger macros and use it in your project:

use loggit::{trace, debug, info, warn, error};

fn main() {
    trace!("This is a trace message.");
    debug!("Debug message: variable value = {}", 42);
    info!("Informational message.");
    warn!("Warning: something might be off.");
    error!("Error occurred: {}", "example error");
}

Customizing the Log Level

Set the minimum log level so that only messages at that level and above are printed:

use loggit::logger::set_log_level;
use loggit::Level;

fn main() {
    // Set log level to DEBUG; TRACE messages will be ignored.
    set_log_level(Level::DEBUG);

    debug!("This is a debug message.");
    trace!("This trace message will not be logged.");
}

Customizing the Log Format

You can adjust the log format globally or per log level. Templates can include placeholders like {level}, {file}, {line}, and {message}. Colors can be configured by wrapping text with color tags.

Global Format Customization

use loggit::logger::set_global_formatting;

fn main() {
    // Set a global custom log format using color tags.
    set_global_formatting("<green>[{level}]<green> ({file}:{line}) - {message}");

    info!("This info message follows the new global format.");
    info!("The error message as well.");
}

Level-Specific Format Customization

use loggit::logger::set_level_formatting;
use loggit::Level;

fn main() {
    // Customize the ERROR log format specifically.
    set_level_formatting(
        Level::ERROR,
        "<red>[{level}]<red> <blue>({file}:{line})<blue> - <red>{message}<red>"
    );

    error!("This error message will follow the custom error format.");
}

Enabling Colorized Output

Enable or disable colored output based on your preference:

use loggit::logger::set_colorized;

fn main() {
    // Enable colored output.
    set_colorized(true);
    
    info!("This info message will be colorized as specified in the format.");
}

Customizing Terminal Output

Control whether messages are printed directly to the terminal:

use loggit::logger::set_print_to_terminal;

fn main() {
    // Disable terminal output (for example, if you want to log to a file instead).
    set_print_to_terminal(false);
    
    info!("This message will not be printed to the terminal.");
}

Setting up logging to a file

Enable saving all your logs to a file

use loggit::logger::set_file;

fn main() {
    // provide file name
    set_file("file_name.txt");
}

You can choose a format for the file name:

use loggit::logger::set_file;

fn main() {
    // provide file name
    set_file("{level}-log-on-{date}.txt");
}

Choose how often you change your file

use loggit::logger::{set_file, add_rotation};

fn main() {
    // provide file name
    set_file("{level}-log-on-{date}.txt");
    add_rotation("1 week"); // change the file every week
    add_rotation("5 MB"); // max file size 5 MB, then the file changes again
}

Save your space by compressing log files

use loggit::logger::{set_file, set_compression};

fn main() {
    // provide file name
    set_file("{level}-log-on-{date}.txt");
    set_compression("zip");
}

Choose the directory to save archived log files to

use loggit::logger::{set_file, set_compression, set_archive_dir};

fn main() {
    // provide file name
    set_file("{level}-log-on-{date}.txt");
    set_compression("zip");
    set_archive_dir("my_archives"); // all the archives will be stored in the `my_archives` directory
}

Configure logger using environment variables

colorized=false file_name="save_here.txt" cargo run

Importing config from files

use loggit::logger::{load_config_from_file};

fn main(){
   let _ = load_config_from_file("my_conf.json");
}

Or simply create a config file with one of those names:

• loggit.env
• loggit.ini
• loggit.json

And it will be loaded automatically

Modules

• logger: Contains functions to control logging configuration and macros to log messages.

Modules

logger

The logger module provides configuration functions and macros for logging.

Macros

debug

Logs a message at the DEBUG level. The message is formatted using standard Rust formatting.

error

Logs a message at the ERROR level. The message is formatted using standard Rust formatting.

info

Logs a message at the INFO level. The message is formatted using standard Rust formatting.

trace

Logs a message at the TRACE level. The message is formatted using standard Rust formatting.

warn

Logs a message at the WARN level. The message is formatted using standard Rust formatting.

Enums

Level

Represents the log level used throughout the application.