elfo-logger 0.1.8

Logging subsystem
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

use std::{
    error::Error,
    fmt::{self, Write},
};

use sharded_slab::Pool;
use tracing::field::{Field, Visit};

use crate::Shared;

const MAX_ERROR_SOURCES: u8 = 5;

pub(super) struct Visitor<'a> {
    pool: &'a Pool<String>,
    output: &'a mut String,
    simplify_message: bool,
}

impl<'a> Visitor<'a> {
    pub(super) fn new(shared: &'a Shared, output: &'a mut String, simplify_message: bool) -> Self {
        Self {
            pool: &shared.pool,
            output,
            simplify_message,
        }
    }

    pub(super) fn push(&mut self, str: &str) {
        self.output.push_str(str);
    }
}

impl Visit for Visitor<'_> {
    fn record_i64(&mut self, field: &Field, value: i64) {
        let _ = write!(self.output, "\t{}={}", field.name(), value);
    }

    fn record_u64(&mut self, field: &Field, value: u64) {
        let _ = write!(self.output, "\t{}={}", field.name(), value);
    }

    fn record_bool(&mut self, field: &Field, value: bool) {
        let _ = write!(self.output, "\t{}={}", field.name(), value);
    }

    fn record_str(&mut self, field: &Field, value: &str) {
        let name = field.name();

        // These fields are handled in the actor.
        if name == "actor_group" || name == "actor_key" {
            return;
        }

        if name == "message" && self.simplify_message {
            self.simplify_message = false;
            self.output.insert_str(0, value);
        } else {
            let _ = write!(self.output, "\t{}={}", name, value);
        }
    }

    fn record_error(&mut self, field: &Field, mut value: &(dyn Error + 'static)) {
        for i in 0..=MAX_ERROR_SOURCES {
            let prev_len = self.output.len();
            let suffix = Repeat(".source", i);

            if write!(self.output, "\t{}{}={}", field.name(), suffix, value).is_err() {
                self.output.truncate(prev_len);
            }

            if let Some(source) = value.source() {
                value = source;
            } else {
                break;
            }
        }
    }

    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
        let prev_len = self.output.len();

        let result = match field.name() {
            "message" if self.simplify_message && self.output.is_empty() => {
                self.simplify_message = false;
                write!(self.output, "{:?}", value)
            }
            "message" if self.simplify_message => {
                self.simplify_message = false;
                let mut result = Ok(());

                if let Some(id) = self.pool.create_with(|tmp| {
                    result = write!(tmp, "{:?}", value);
                    self.output.insert_str(0, tmp);
                }) {
                    self.pool.clear(id);
                }

                result
            }
            _ => write!(self.output, "\t{}={:?}", field.name(), value),
        };

        if result.is_err() {
            self.output.truncate(prev_len);
        }
    }
}

struct Repeat<'a>(&'a str, u8);

impl fmt::Display for Repeat<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for _ in 0..self.1 {
            f.write_str(self.0)?;
        }

        Ok(())
    }
}