defmt-decoder 1.1.0

Decodes defmt log frames
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

use log::{Log, Metadata, Record as LogRecord};
use std::io::{self, StderrLock, StdoutLock, Write};

use super::{
    format::{Formatter, HostFormatter},
    DefmtRecord,
};

pub(crate) struct StdoutLogger {
    formatter: Formatter,
    host_formatter: HostFormatter,
    should_log: Box<dyn Fn(&Metadata) -> bool + Sync + Send>,
}

impl Log for StdoutLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        (self.should_log)(metadata)
    }

    fn log(&self, record: &LogRecord) {
        if !self.enabled(record.metadata()) {
            return;
        }

        match DefmtRecord::new(record) {
            Some(record) => {
                // defmt goes to stdout, since it's the primary output produced by this tool.
                let sink = io::stdout().lock();
                if record.level().is_some() {
                    self.print_defmt_record(record, sink);
                } else {
                    self.print_defmt_record_without_format(record, sink);
                }
            }
            None => {
                // non-defmt logs go to stderr
                let sink = io::stderr().lock();
                self.print_host_record(record, sink);
            }
        }
    }

    fn flush(&self) {}
}

impl StdoutLogger {
    pub fn new(
        formatter: Formatter,
        host_formatter: HostFormatter,
        should_log: impl Fn(&Metadata) -> bool + Sync + Send + 'static,
    ) -> Box<Self> {
        Box::new(Self::new_unboxed(formatter, host_formatter, should_log))
    }

    pub fn new_unboxed(
        formatter: Formatter,
        host_formatter: HostFormatter,
        should_log: impl Fn(&Metadata) -> bool + Sync + Send + 'static,
    ) -> Self {
        Self {
            formatter,
            host_formatter,
            should_log: Box::new(should_log),
        }
    }

    fn print_defmt_record(&self, record: DefmtRecord, mut sink: StdoutLock) {
        let s = self.formatter.format(&record);
        writeln!(sink, "{s}").ok();
    }

    pub(super) fn print_defmt_record_without_format(
        &self,
        record: DefmtRecord,
        mut sink: StdoutLock,
    ) {
        let s = record.args().to_string();
        writeln!(sink, "{s}").ok();
    }

    pub(super) fn print_host_record(&self, record: &LogRecord, mut sink: StderrLock) {
        let s = self.host_formatter.format(record);
        writeln!(sink, "{s}").ok();
    }
}