tracing-systemd 0.1.0

A tracing subscriber that logs to the systemd journal
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

use std::collections::BTreeMap;

/// Contains the FieldStorage struct and the SystemdVisitor struct
mod helper_structs;

mod impls;

use crate::formatting::*;

use helper_structs::*;
#[cfg(feature = "sd-journal")]
use sd_journal::*;

///A configurable tracing-subscriber layer compatible with journald.
///
///The layer used to format and log events. Can be configured to log to stdout, or directly to journald using the `sd-journal` feature.
///```rust  
///let systemd_layer = SystemdLayer::new()
///    .with_target(true)
///    .use_level_prefix(false)
///    .use_color(true);
///```
pub struct SystemdLayer {
    #[cfg(feature = "colored")]
    use_color: bool,

    log_thread_id: bool,
    span_separator: &'static str,
    message_separator: &'static str,
    level_separator: &'static str,
    log_target: bool,
    #[cfg(feature = "sd-journal")]
    use_sd_journal: bool,
    function_bracket_left: &'static str,
    function_bracket_right: &'static str,
    arguments_equality: &'static str,
    arguments_separator: &'static str,
    use_level_prefix: bool,
    thread_id_prefix: &'static str,
    thread_id_suffix: &'static str,
}

// Implementation of the Layer trait
impl<S> tracing_subscriber::Layer<S> for SystemdLayer
where
    S: tracing::Subscriber,
    S: for<'a> tracing_subscriber::registry::LookupSpan<'a>,
{
    fn on_event(&self, event: &tracing::Event<'_>, ctx: tracing_subscriber::layer::Context<'_, S>) {
        let scope = ctx.event_scope(event).unwrap();
        let mut spans = vec![];

        for span in scope.from_root() {
            let extensions = span.extensions();
            let storage = extensions.get::<SystemdFieldStorage>().unwrap();
            let data = &storage.0;
            spans.push(serde_json::json!({
                "target": event.metadata().target(),
                "name": span.name(),
                "level": event.metadata().level().to_string(),
                "fields": data,
            }));
        }

        let mut fields = BTreeMap::new();
        let mut visitor = SystemdVisitor(&mut fields);
        event.record(&mut visitor);

        let output = serde_json::json!({
            "target": event.metadata().target(),
            "name": event.metadata().name(),
            "level": event.metadata().level().to_string(),
            "fields": fields,
            "spans": spans,
        });

        let full_string = self.build_full_string(&output);

        #[cfg(feature = "sd-journal")]
        {
            match self.get_use_sd_journal() {
                true => {
                    let level = journal_level_from_tracing_level(event.metadata().level());
                    Journal::log_message(level, full_string).unwrap();
                }

                false => match self.get_use_level_prefix() {
                    true => {
                        let prefix = prefix_from_tracing_level(event.metadata().level());
                        println!("{}{}", prefix, full_string);
                    }
                    false => {
                        println!("{}", full_string);
                    }
                },
            }
        }

        #[cfg(not(feature = "sd-journal"))]
        {
            match self.get_use_level_prefix() {
                true => {
                    let prefix = prefix_from_tracing_level(event.metadata().level());
                    println!("{}{}", prefix, full_string)
                }
                false => {
                    println!("{}", full_string);
                }
            }

            println!("{}", full_string);
        }
    }

    fn on_new_span(
        &self,
        attrs: &tracing::span::Attributes,
        id: &tracing::span::Id,
        ctx: tracing_subscriber::layer::Context<'_, S>,
    ) {
        let mut fields = BTreeMap::new();
        let mut visitor = SystemdVisitor(&mut fields);
        attrs.record(&mut visitor);

        let storage = SystemdFieldStorage(fields);
        let span = ctx.span(id).unwrap();
        let mut extensions = span.extensions_mut();
        extensions.insert(storage);
    }
}