json-subscriber 0.2.6

Customizable layer and subscriber for `tracing` that emits logs in JSON
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

use std::{collections::btree_map::Entry, fmt};

use tracing_core::field;

use crate::fields::JsonFieldsInner;

/// The [visitor] produced by [`JsonFields`]'s [`MakeVisitor`] implementation.
///
/// [visitor]: tracing_subscriber::field::Visit
/// [`MakeVisitor`]: tracing_subscriber::field::MakeVisitor
pub(crate) struct JsonVisitor<'a>(&'a mut JsonFieldsInner);

impl<'a> JsonVisitor<'a> {
    pub fn new(fields: &'a mut JsonFieldsInner) -> Self {
        Self(fields)
    }
}

impl field::Visit for JsonVisitor<'_> {
    /// Visit a double precision floating point value.
    fn record_f64(&mut self, field: &field::Field, value: f64) {
        let value = serde_json::Value::from(value);
        let entry = self.0.fields.entry(field.name());
        match entry {
            Entry::Vacant(vacant) => {
                self.0.version += 1;
                vacant.insert(value);
            },
            Entry::Occupied(mut entry) => {
                if entry.get() != &value {
                    self.0.version += 1;
                }
                entry.insert(value);
            },
        }
    }

    /// Visit a signed 64-bit integer value.
    fn record_i64(&mut self, field: &field::Field, value: i64) {
        let value = serde_json::Value::from(value);
        let entry = self.0.fields.entry(field.name());
        match entry {
            Entry::Vacant(vacant) => {
                self.0.version += 1;
                vacant.insert(value);
            },
            Entry::Occupied(mut entry) => {
                if entry.get() != &value {
                    self.0.version += 1;
                }
                entry.insert(value);
            },
        }
    }

    /// Visit an unsigned 64-bit integer value.
    fn record_u64(&mut self, field: &field::Field, value: u64) {
        let value = serde_json::Value::from(value);
        let entry = self.0.fields.entry(field.name());
        match entry {
            Entry::Vacant(vacant) => {
                self.0.version += 1;
                vacant.insert(value);
            },
            Entry::Occupied(mut entry) => {
                if entry.get() != &value {
                    self.0.version += 1;
                }
                entry.insert(value);
            },
        }
    }

    /// Visit a boolean value.
    fn record_bool(&mut self, field: &field::Field, value: bool) {
        let value = serde_json::Value::from(value);
        let entry = self.0.fields.entry(field.name());
        match entry {
            Entry::Vacant(vacant) => {
                self.0.version += 1;
                vacant.insert(value);
            },
            Entry::Occupied(mut entry) => {
                if entry.get() != &value {
                    self.0.version += 1;
                }
                entry.insert(value);
            },
        }
    }

    /// Visit a string value.
    fn record_str(&mut self, field: &field::Field, value: &str) {
        // We don't want to clone the `value` until we know we want to update it
        // so this closure is here to defer the actual value creation.
        let serde_value = || serde_json::Value::from(value);
        let entry = self.0.fields.entry(field.name());
        match entry {
            Entry::Vacant(vacant) => {
                self.0.version += 1;
                vacant.insert(serde_value());
            },
            Entry::Occupied(mut entry) => {
                if entry.get() != value {
                    self.0.version += 1;
                }
                entry.insert(serde_value());
            },
        }
    }

    fn record_debug(&mut self, field: &field::Field, value: &dyn fmt::Debug) {
        match field.name() {
            // Skip fields that are actually log metadata that have already been handled
            #[cfg(feature = "tracing-log")]
            name if name.starts_with("log.") => (),
            name if name.starts_with("r#") => {
                self.0
                    .fields
                    .insert(&name[2..], serde_json::Value::from(format!("{value:?}")));
            },
            name => {
                self.0
                    .fields
                    .insert(name, serde_json::Value::from(format!("{value:?}")));
            },
        }
    }
}