trace4rs 0.5.1

log4rs like usability with the `tracing` crate as the base
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use tracing::{
    metadata::LevelFilter,
    Event,
};
use tracing_log::NormalizeEvent;
use tracing_subscriber::{
    layer::Context,
    Layer,
};

use super::{
    loggers::{
        EventFormatter,
        Logger,
    },
    span_broker::SpanBroker,
};
use crate::{
    appenders::{
        Appender,
        Appenders,
    },
    config::{
        AppenderId,
        Config,
    },
    error::Result,
};

pub type PolyLayer<S> = Box<dyn Layer<S> + Send + Sync + 'static>;

pub(crate) struct Layers<S = SpanBroker> {
    enabled:   bool,
    default:   PolyLayer<S>,
    loggers:   Vec<PolyLayer<S>>,
    appenders: Appenders,
}

impl Layers {
    /// If the files which are the target of appenders have been moved we
    /// abandon the moved files and remount at the correct path.
    pub fn correct_appender_paths(&self) -> Result<()> {
        self.appenders.correct_paths()
    }

    /// The default `Layers` backed by `broker` (`INFO` and above goes to
    /// stdout).
    pub fn default(broker: SpanBroker) -> Self {
        let stdout_appender = AppenderId("stdout".to_string());
        let appenders =
            Appenders::new(literally::hmap! {stdout_appender.clone() => Appender::new_console()});
        let default = Logger::new_erased(
            broker,
            LevelFilter::INFO,
            None,
            &[stdout_appender],
            &appenders,
            EventFormatter::Normal,
        );
        Self::new(default, vec![], appenders)
    }

    /// Create a new `Layers` from a default layer and a pre-generated vec of
    /// sub-layers.
    fn new(
        default: PolyLayer<SpanBroker>,
        loggers: Vec<PolyLayer<SpanBroker>>,
        appenders: Appenders,
    ) -> Self {
        Self {
            enabled: true,
            default,
            loggers,
            appenders,
        }
    }

    /// Generate a `Layers` from a config and back it with `broker`.
    ///
    /// # Errors
    /// An error may occur while building the appenders.
    pub fn from_config(broker: SpanBroker, config: &Config) -> Result<Layers> {
        let appenders = (&config.appenders).try_into()?;
        let layers: Vec<PolyLayer<_>> = config
            .loggers
            .iter()
            .map(|(targ, lg)| {
                Logger::new_erased(
                    broker.clone(),
                    lg.level.into(),
                    Some(targ.clone()),
                    lg.appenders.iter(),
                    &appenders,
                    lg.format.clone().into(),
                )
            })
            .collect();

        let default = Logger::new_erased(
            broker,
            config.default.level.into(),
            None,
            config.default.appenders.iter(),
            &appenders,
            config.default.format.clone().into(),
        );

        Ok(Layers::new(default, layers, appenders))
    }

    pub fn appenders(&self) -> &Appenders {
        &self.appenders
    }
}

impl<S> Layers<S> {
    /// Disable this subscriber.
    pub fn disable(&mut self) {
        self.enabled = false;
    }

    /// Enable this subscriber.
    pub fn enable(&mut self) {
        self.enabled = true;
    }
}

impl Layer<SpanBroker> for Layers<SpanBroker> {
    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, SpanBroker>) {
        if !self.enabled {
            return;
        }
        let mut any = false;
        let normalized_metadata = NormalizeEvent::normalized_metadata(event);
        let metadata = normalized_metadata
            .as_ref()
            .unwrap_or_else(|| event.metadata());

        for layer in &self.loggers {
            let enabled = layer.enabled(metadata, ctx.clone());
            any |= enabled;
            if enabled {
                layer.on_event(event, ctx.clone());
            }
        }
        // If no other layer logged this then the default one will
        if !any && self.default.enabled(metadata, ctx.clone()) {
            self.default.on_event(event, ctx);
        }
    }
}