prologger 0.3.0

A production-grade, ergonomic Rust logging library with colored output, file rotation, and structured formatting.
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
134

//! JSON formatter — machine-readable structured log output.
//!
//! Produces output like:
//! ```json
//! {"timestamp":"2026-06-05T20:15:00.123Z","level":"INFO","target":"my_app::api","message":"Request processed"}
//! ```

use super::Format;
use log::Record;
use serde::Serialize;
use std::time::SystemTime;

/// A formatter that outputs log records as JSON objects (one per line).
///
/// Each line is a valid JSON object, making the output compatible with
/// log aggregation tools like Elasticsearch, Loki, and CloudWatch.
#[derive(Debug)]
pub struct JsonFormatter;

/// Internal struct for JSON serialization of a log record.
#[derive(Serialize)]
struct JsonRecord<'a> {
    timestamp: String,
    level: &'a str,
    target: &'a str,
    message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    module_path: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    file: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    line: Option<u32>,
}

impl JsonFormatter {
    /// Generates an ISO 8601 timestamp string.
    fn timestamp() -> String {
        let now = SystemTime::now();
        let duration = now
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap_or_default();

        let secs = duration.as_secs();
        let millis = duration.subsec_millis();

        let days = secs / 86400;
        let time_secs = secs % 86400;
        let hours = time_secs / 3600;
        let minutes = (time_secs % 3600) / 60;
        let seconds = time_secs % 60;

        let (year, month, day) = days_to_date(days);

        format!(
            "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03}Z",
            year, month, day, hours, minutes, seconds, millis
        )
    }
}

impl Format for JsonFormatter {
    fn format(&self, record: &Record) -> String {
        let json_record = JsonRecord {
            timestamp: Self::timestamp(),
            level: record.level().as_str(),
            target: record.target(),
            message: format!("{}", record.args()),
            module_path: record.module_path(),
            file: record.file(),
            line: record.line(),
        };

        match serde_json::to_string(&json_record) {
            Ok(json) => format!("{}\n", json),
            Err(e) => format!(
                "{{\"error\":\"failed to serialize log record\",\"detail\":\"{}\"}}\n",
                e
            ),
        }
    }
}

/// Converts days since Unix epoch to (year, month, day).
fn days_to_date(days_since_epoch: u64) -> (u64, u64, u64) {
    let z = days_since_epoch + 719468;
    let era = z / 146097;
    let doe = z - era * 146097;
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = doy - (153 * mp + 2) / 5 + 1;
    let m = if mp < 10 { mp + 3 } else { mp - 9 };
    let y = if m <= 2 { y + 1 } else { y };
    (y, m, d)
}

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

    #[test]
    fn test_json_format_is_valid_json() {
        let formatter = JsonFormatter;
        let record = log::Record::builder()
            .args(format_args!("test message"))
            .level(log::Level::Info)
            .target("test_mod")
            .build();

        let output = formatter.format(&record);
        let parsed: serde_json::Value = serde_json::from_str(output.trim()).unwrap();

        assert_eq!(parsed["level"], "INFO");
        assert_eq!(parsed["target"], "test_mod");
        assert_eq!(parsed["message"], "test message");
        assert!(parsed["timestamp"].is_string());
    }

    #[test]
    fn test_json_format_special_characters() {
        let formatter = JsonFormatter;
        let record = log::Record::builder()
            .args(format_args!("message with \"quotes\" and \\backslash"))
            .level(log::Level::Error)
            .target("test")
            .build();

        let output = formatter.format(&record);
        // Should be valid JSON even with special characters
        let parsed: Result<serde_json::Value, _> = serde_json::from_str(output.trim());
        assert!(parsed.is_ok());
    }
}