tracing_setup/
buffered_layer.rs

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
crate::ix!();

#[derive(Debug)]
pub struct BufferedLayer {
    tag:           Option<String>,
    buffer:        Arc<Mutex<Vec<String>>>,
    event_printer: EventPrinter,
}

impl Flushable for BufferedLayer {

    fn flush(&self) {

        use colored::Colorize;

        if let Ok(mut buf) = self.buffer.lock() {

            if let Some(tag) = &self.tag {

                let msg = format!("---------------------------------------------------------[trace_events: {}]", tag);

                println!(
                    "{}",
                    msg.bright_blue(),
                );
            }

            for message in &*buf {
                println!("{}", message);
            }
            buf.clear();
        }
    }
}

impl Clone for BufferedLayer {

    fn clone(&self) -> Self {
        Self {
            tag:           self.tag.clone(),
            buffer:        Arc::clone(&self.buffer),
            event_printer: self.event_printer.clone()
        }
    }
}

impl Default for BufferedLayer {

    fn default() -> Self {
        Self {
            tag:           None,
            buffer:        Arc::new(Mutex::new(Vec::new())),
            event_printer: EventPrinter::default(),
        }
    }
}

impl BufferedLayer {

    pub fn new_with_tag(tag: &str) -> Self {
        Self {
            tag:           Some(tag.to_string()),
            buffer:        Arc::new(Mutex::new(Vec::new())),
            event_printer: EventPrinter::default(),
        }
    }
}

impl<S: Subscriber> tracing_subscriber::Layer<S> for BufferedLayer {

    fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {

        use std::fmt::Write;

        if let Ok(mut buf) = self.buffer.lock() {
            match self.event_printer {
                EventPrinter::FullWithHeader     => FullWithHeader::handle_buffer_write_event(event,&mut buf),
                EventPrinter::LogLineAndContents => LogLineAndContents::handle_buffer_write_event(event,&mut buf),
                EventPrinter::JustTheContents    => JustTheContents::handle_buffer_write_event(event,&mut buf),
            }
        }
    }
}