Adding `loggit` library as a dependency

Run this command in a terminal, in your project's directory:

cargo add loggit

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

loggit = "0.1.9"

The loggit library will be automatically available globally. Read the loggit library documentation.

Back to the crate overview.

Readme

Loggit

Loggit is a lightweight, easy-to-use logging library for Rust. It provides ready-to-use logger macros that let you start logging with zero boilerplate. You simply import and use it; no additional setup is required for basic usage. However, if you need more control, you can customize the logging format, colors, and minimum logging level.

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 automaticaly 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
Load config from anywhere: Load your config from your file or load it from env or default files without any code!

Installation

Add LogGit to your Cargo.toml:

[dependencies]
loggit = "0.1.9"

or just write in the terminal:

cargo add loggit

Usage

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");
}

prints

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.");
}

set_log_level

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.");
    error!("The error message as well.");
}

global formating

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>"
    );

    info!("Info follows the standard formatting");
    info!("Warn follows the standard formatting");
    error!("This error message will follow the custom error format.");
}

level formating

Disable Colorized Output

Enable or disable colored output based on your preference:

use loggit::logger::set_colorized;

fn main() {
    // Enable colored output.
    set_colorized(false);
    
    info!("This info message will not be colorized");
}

set_colorized

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.");
}

set_print_to_terminal

Setting up logging to the file

Enable save 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");
}

set file format

Choose how oftenly 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 again change of the file
}

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 
}

Configurate logger using env 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 crate a config file with one of those names:

loggit.env
loggit.ini
loggit.json

And it will be loaded automatically

Documentation

A complete user documentation can be found here

Configuration

Internally, LogGit uses a simple configuration structure which holds:

Log Level: One of TRACE, DEBUG, INFO, WARN, or ERROR.
Terminal Output: A flag that determines if logs are printed to the terminal.
Colorization: A flag to enable or disable colored output.
Custom Formats: Individual formatters for each log level.
Custom file names: A format of a name that a file will take
File rotation: How oftenly will the file be changed
Compression method: To save space, you can specify the compression method.
Archives directory: A directory to store the archives in

The default configuration already provides sensible defaults, so you can get started right away. Customization is available for those who need advanced logging setups.

Contributing

Contributions and suggestions are welcome! Feel free to open issues or submit pull requests to help improve LogGit.

Testing

There are two types of tests:

unit tests that are stored in the src/tests/ folder.
integration tests that are stored in the tests/ folder.

Using cargo test is not recommended as it runs tests using multiple threads that doesn't respect the library logic, thus the next scripts are recommended:

test.sh for unit tests
int_test.sh for integration tests

Release notes

In order to read release notes for each version, click here

License

LogGit is licensed under the MIT License.

Adding loggit library as a dependency

Adding `loggit` library as a dependency