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}.

Installation

Add LogGit to your Cargo.toml:

[dependencies]
loggit = "0.1.0"

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

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

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

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

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.

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.

License

LogGit is licensed under the MIT License.