loggix 1.0.4

A powerful, structured logging library for Rust inspired by Logrus. Features thread-safe logging, structured fields, custom formatters, and beautiful terminal output.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use loggix::{Entry, Formatter, Level, Logger};
use serde_json::Value;
use std::error::Error;
use std::io::Write;
use std::sync::{Arc, Mutex};

#[derive(Debug, Clone, Default)]
struct TestWriter {
    buffer: Arc<Mutex<Vec<u8>>>,
}

impl TestWriter {
    fn new() -> Self {
        Self {
            buffer: Arc::new(Mutex::new(Vec::new())),
        }
    }

    fn get_output(&self) -> Vec<u8> {
        self.buffer.lock().unwrap().clone()
    }
}

impl Write for TestWriter {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        self.buffer.lock().unwrap().extend_from_slice(buf);
        Ok(buf.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

#[derive(Debug, Clone)]
struct TestFormatter {
    prefix: String,
}

impl TestFormatter {
    pub fn new(prefix: &str) -> Self {
        Self {
            prefix: prefix.to_string(),
        }
    }
}

impl Formatter for TestFormatter {
    fn format(&self, entry: &Entry) -> Result<Vec<u8>, Box<dyn Error>> {
        let mut output = Vec::new();
        write!(
            output,
            "{} [{}] {}: {}\n",
            self.prefix,
            entry.timestamp.format("%Y-%m-%d %H:%M:%S"),
            entry.level,
            entry.message
        )?;
        Ok(output)
    }
}

#[test]
fn test_custom_formatter() {
    // Create a test writer to capture output
    let writer = TestWriter::new();
    let writer_clone = writer.clone();

    // Create and set custom formatter
    let formatter = TestFormatter::new("TEST");
    let logger = Logger::new().formatter(formatter).output(writer).build();

    // Log a test message
    let test_message = "Custom formatted message";
    logger
        .log(Level::Info, test_message, std::collections::HashMap::new())
        .unwrap();

    // Get the output
    let output = String::from_utf8(writer_clone.get_output()).unwrap();

    // Verify the format
    assert!(output.starts_with("TEST ["));
    assert!(output.contains(&format!("] {}: {}", Level::Info, test_message)));
}

#[test]
fn test_custom_formatter_with_fields() {
    let writer = TestWriter::new();
    let writer_clone = writer.clone();

    let formatter = TestFormatter::new("TEST");
    let logger = Logger::new().formatter(formatter).output(writer).build();

    // Log with fields
    let mut fields = std::collections::HashMap::new();
    fields.insert("key1".to_string(), Value::String("value1".to_string()));
    fields.insert("key2".to_string(), Value::String("value2".to_string()));

    logger
        .log(Level::Info, "Message with fields", fields)
        .unwrap();

    let output = String::from_utf8(writer_clone.get_output()).unwrap();
    assert!(output.starts_with("TEST ["));
    assert!(output.contains("] INFO: Message with fields"));
}

#[test]
fn test_formatter_error_handling() {
    // Create a formatter that always fails
    #[derive(Debug, Clone)]
    struct FailingFormatter;

    impl Formatter for FailingFormatter {
        fn format(&self, _entry: &Entry) -> Result<Vec<u8>, Box<dyn Error>> {
            Err("Formatter error".into())
        }
    }

    let logger = Logger::new()
        .formatter(FailingFormatter)
        .output(TestWriter::new())
        .build();

    // The log should not panic even if formatter fails
    let result = logger.log(
        Level::Info,
        "This should handle formatter error gracefully",
        std::collections::HashMap::new(),
    );
    assert!(result.is_err());
}