zlogger 0.0.1

A lightweight, configurable Rust logging library with color support and file rotation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! # zlogger
//! 
//! ## Features
//! 
//! - Color-coded log levels for terminal output
//! - Environment variable configuration
//! - File logging with automatic rotation
//! - Multiple output targets (console, file, or both)
//! - Customizable log formats
//! - Thread-safe logging
//! 
//! ## Quick Start
//! 
//! ```rust
//! use colorful_logger::{init, info, warn, error};
//! 
//! // Initialize with default settings
//! init();
//! 
//! // Log messages
//! info!("Application started");
//! warn!("This is a warning");
//! error!("Something went wrong");
//! ```
//! 
//! ## Environment Variables
//! 
//! - `ZLOG_LEVEL`: Set log level (trace, debug, info, warn, error)
//! - `ZLOG_OUTPUT`: Set output target (console, file, both)
//! - `ZLOG_FILE`: Set log file path
//! - `ZLOG_MAX_SIZE`: Set max file size before rotation (in bytes)
//! - `ZLOG_MAX_FILES`: Set maximum number of rotated files to keep
//! - `ZLOG_COLOR`: Enable/disable colors (true/false)

pub mod logger;
pub mod config;
pub mod formatter;
pub mod rotation;
pub mod colors;

pub use logger::Logger;
pub use config::{Config, LogLevel, OutputTarget};

use std::sync::Once;

static INIT: Once = Once::new();

/// Initialize the global logger with default configuration
pub fn init() {
    INIT.call_once(|| {
        let config = Config::from_env();
        Logger::init(config).expect("Failed to initialize logger");
    });
}

/// Initialize the global logger with custom configuration
pub fn init_with_config(config: Config) {
    INIT.call_once(|| {
        Logger::init(config).expect("Failed to initialize logger");
    });
}

/// Log a trace message
#[macro_export]
macro_rules! trace {
    ($($arg:tt)*) => {
        $crate::logger::log($crate::LogLevel::Trace, format_args!($($arg)*))
    };
}

/// Log a debug message
#[macro_export]
macro_rules! debug {
    ($($arg:tt)*) => {
        $crate::logger::log($crate::LogLevel::Debug, format_args!($($arg)*))
    };
}

/// Log an info message
#[macro_export]
macro_rules! info {
    ($($arg:tt)*) => {
        $crate::logger::log($crate::LogLevel::Info, format_args!($($arg)*))
    };
}

/// Log a warning message
#[macro_export]
macro_rules! warn {
    ($($arg:tt)*) => {
        $crate::logger::log($crate::LogLevel::Warn, format_args!($($arg)*))
    };
}

/// Log an error message
#[macro_export]
macro_rules! error {
    ($($arg:tt)*) => {
        $crate::logger::log($crate::LogLevel::Error, format_args!($($arg)*))
    };
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_macros() {
        init();
        trace!("This is a trace message");
        debug!("This is a debug message");
        info!("This is an info message");
        warn!("This is a warning message");
        error!("This is an error message");
    }
}