convey 0.2.0

A Rust create for outputting information and log messages for humans and machines
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

use crate::{components::text, span};
use log::Level;

#[derive(serde_derive::Serialize)]
pub struct LogMessage {
    level: log::Level,
    path: String,
    message: String,
    // TODO: time: chrono::Local,
}

impl crate::Render for LogMessage {
    crate::render_for_humans!(self -> [
        match self.level {
            Level::Error => span!(fg = "red", [text("ERROR"),]),
            Level::Warn => span!(fg = "yellow", [text("WARN "),]),
            Level::Info => span!(fg = "blue", [text("INFO "),]),
            Level::Debug => span!(fg = "cyan", [text("DEBUG "),]),
            Level::Trace => span!(fg = "white", [text("DEBUG  "),]),
        },
        if self.path.is_empty() {
            span!([text(": "),])
        } else {
            span!([
                text(" <"),
                text(&self.path),
                text("> "),
            ])
        },
        text(&self.message),
    ]);

    crate::render_json!();
}

impl log::Log for crate::Output {
    fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
        self.inner
            .lock()
            .ok()
            .and_then(|o| o.log_level)
            .map(|level| metadata.level() <= level)
            .unwrap_or(false)
    }

    fn log(&self, record: &log::Record<'_>) {
        if self.enabled(record.metadata()) {
            let _ = self.print(&LogMessage {
                level: record.level(),
                path: record
                    .module_path()
                    .map(|x| x.to_string())
                    .unwrap_or_default(),
                message: record.args().to_string(),
            });
        }
    }

    fn flush(&self) {
        let _ = self.flush();
    }
}