Skip to main content

next_rust_server/
log.rs

1//! Minimal structured logging.
2//!
3//! Log lines go to stderr as human readable text in development and as one
4//! JSON object per line in production (configurable). With the `tracing`
5//! feature, events are emitted through `tracing` instead so any subscriber
6//! (OpenTelemetry, Datadog, ...) can collect them.
7
8use std::sync::atomic::{AtomicU8, Ordering};
9
10static FORMAT: AtomicU8 = AtomicU8::new(0); // 0 pretty, 1 json
11static LEVEL: AtomicU8 = AtomicU8::new(2); // 0 error, 1 warn, 2 info, 3 debug, 4 trace
12
13pub fn configure(json: bool, level: &str) {
14    FORMAT.store(u8::from(json), Ordering::Relaxed);
15    let lvl = match level {
16        "error" => 0,
17        "warn" => 1,
18        "debug" => 3,
19        "trace" => 4,
20        _ => 2,
21    };
22    LEVEL.store(lvl, Ordering::Relaxed);
23}
24
25pub fn is_json() -> bool {
26    FORMAT.load(Ordering::Relaxed) == 1
27}
28
29fn enabled(level: u8) -> bool {
30    level <= LEVEL.load(Ordering::Relaxed)
31}
32
33fn emit(level: u8, label: &str, msg: &str, fields: &[(&str, String)]) {
34    if !enabled(level) {
35        return;
36    }
37    #[cfg(feature = "tracing")]
38    {
39        let rendered: String = fields.iter().map(|(k, v)| format!(" {k}={v}")).collect();
40        match level {
41            0 => tracing::error!("{msg}{rendered}"),
42            1 => tracing::warn!("{msg}{rendered}"),
43            2 => tracing::info!("{msg}{rendered}"),
44            _ => tracing::debug!("{msg}{rendered}"),
45        }
46        let _ = label;
47    }
48    #[cfg(not(feature = "tracing"))]
49    if is_json() {
50        let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis();
51        let mut obj = serde_json::Map::new();
52        obj.insert("ts".into(), (ts as u64).into());
53        obj.insert("level".into(), label.into());
54        obj.insert("msg".into(), msg.into());
55        for (k, v) in fields {
56            obj.insert((*k).into(), v.clone().into());
57        }
58        eprintln!("{}", serde_json::Value::Object(obj));
59    } else {
60        let color = match level {
61            0 => "\x1b[31m",
62            1 => "\x1b[33m",
63            _ => "\x1b[2m",
64        };
65        let rendered: String = fields.iter().map(|(k, v)| format!(" {k}={v}")).collect();
66        if std::env::var_os("NO_COLOR").is_some() {
67            eprintln!("{label:>5} {msg}{rendered}");
68        } else {
69            eprintln!("{color}{label:>5}\x1b[0m {msg}{rendered}");
70        }
71    }
72}
73
74pub fn error(msg: &str) {
75    emit(0, "error", msg, &[]);
76}
77
78pub fn warn(msg: &str) {
79    emit(1, "warn", msg, &[]);
80}
81
82pub fn info(msg: &str) {
83    emit(2, "info", msg, &[]);
84}
85
86pub fn debug(msg: &str) {
87    emit(3, "debug", msg, &[]);
88}
89
90/// Request log line.
91pub fn request(method: &str, path: &str, status: u16, millis: f64, request_id: Option<&str>) {
92    if !enabled(2) {
93        return;
94    }
95    if is_json() || cfg!(feature = "tracing") {
96        let mut fields = vec![
97            ("method", method.to_owned()),
98            ("path", path.to_owned()),
99            ("status", status.to_string()),
100            ("duration_ms", format!("{millis:.2}")),
101        ];
102        if let Some(id) = request_id {
103            fields.push(("request_id", id.to_owned()));
104        }
105        emit(2, "info", "request", &fields);
106    } else {
107        let color = match status {
108            500.. => "\x1b[31m",
109            400..=499 => "\x1b[33m",
110            300..=399 => "\x1b[36m",
111            _ => "\x1b[32m",
112        };
113        if std::env::var_os("NO_COLOR").is_some() {
114            eprintln!(" {method:<6} {path} {status} {millis:.1}ms");
115        } else {
116            eprintln!(" \x1b[1m{method:<6}\x1b[0m {path} {color}{status}\x1b[0m \x1b[2m{millis:.1}ms\x1b[0m");
117        }
118    }
119}