zerolog 0.3.0

Simple low overhead easy to disable logging
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

use std::{mem::ManuallyDrop, panic::Location};

use chrono::{DateTime, Utc};
use serde::Serialize;

use crate::{log_attr::LogAttr, spans::SPAN_STACK, trim_fn_path, trim_src_path, LogLevel};

pub struct Log<A: LogAttr> {
    time: DateTime<Utc>,
    span: u64,
    level: LogLevel,
    msg: &'static str,
    caller: &'static Location<'static>,
    pub caller_fn: Option<&'static str>,
    print: bool,
    attrs: Option<A>,
}

impl Log<()> {
    #[track_caller]
    pub fn new(level: LogLevel, msg: &'static str) -> Self {
        let caller = Location::caller();
        let span = SPAN_STACK.with_borrow(|s| *s.last().unwrap());

        Log {
            time: Utc::now(),
            span: span.last_print_id,
            level,
            msg,
            caller,
            caller_fn: None,
            print: span.min_level.map(|min| min <= level).unwrap_or(false),
            attrs: Some(()),
        }
    }
}

impl<A: LogAttr> Log<A> {
    pub fn attr<T: Serialize>(mut self, name: &'static str, value: T) -> Log<impl LogAttr> {
        let log = Log {
            time: self.time,
            span: self.span,
            level: self.level,
            msg: self.msg,
            caller: self.caller,
            caller_fn: self.caller_fn,
            print: self.print,
            attrs: self.attrs.take().map(|a| a.add_attr(name, value)),
        };

        let _ = ManuallyDrop::new(self);
        log
    }
}

impl<A: LogAttr> Drop for Log<A> {
    fn drop(&mut self) {
        if !self.print {
            return;
        }

        println!("{{\
            \"timestamp\":{:?},\
            \"type\":\"logs\",\
            \"span\":{:?},\
            \"level\":\"{}\",\
            \"msg\":{:?},\
            \"caller\":\"{}:{}\",\
            \"caller_fn\":{:?},\
            \"attrs\":{}\
            }}",
            self.time.to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
            self.span,
            self.level,
            self.msg,
            trim_src_path(self.caller.file()), self.caller.line(),
            trim_fn_path(self.caller_fn.unwrap_or("")),
            serde_json::to_string(&self.attrs.take()).unwrap(),
        );
    }
}

#[macro_export]
macro_rules! log {
    ($level:expr, $name:expr) => {{
        let mut log = $crate::Log::new($level, $name);
        log.caller_fn = Some({
            fn f() {}
            fn type_name_of<T>(_: T) -> &'static str {
                std::any::type_name::<T>()
            }
            let name = type_name_of(f);

            // Find and cut the rest of the path
            &name[..name.len() - 3]
        });
        log
    }};
}