muxado 0.5.3

The muxado stream multiplexing protocol
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 std::sync::atomic::AtomicU64;

use tracing::{
    debug,
    info,
    trace,
    warn,
    Event,
    Metadata,
    Subscriber,
};
use tracing_subscriber::{
    util::SubscriberInitExt,
    EnvFilter,
    Layer,
};

static CTR: AtomicU64 = AtomicU64::new(0);

struct Tagged(&'static str);

struct FieldBuilder(String);

impl tracing_core::field::Visit for FieldBuilder {
    fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
        self.0 += &*format!(" {field}={value:?}");
    }
}

impl<S> Layer<S> for Tagged
where
    S: Subscriber,
{
    fn on_event(&self, _event: &Event<'_>, _ctx: tracing_subscriber::layer::Context<'_, S>) {
        self.event(_event)
    }
}

impl Subscriber for Tagged {
    fn enabled(&self, _metadata: &Metadata<'_>) -> bool {
        true
    }

    fn new_span(&self, _span: &tracing_core::span::Attributes<'_>) -> tracing_core::span::Id {
        tracing_core::span::Id::from_u64(CTR.fetch_add(1, std::sync::atomic::Ordering::SeqCst))
    }

    fn record(&self, _span: &tracing_core::span::Id, _values: &tracing_core::span::Record<'_>) {}

    fn record_follows_from(
        &self,
        _span: &tracing_core::span::Id,
        _follows: &tracing_core::span::Id,
    ) {
    }

    fn event(&self, event: &Event<'_>) {
        let mut visitor = FieldBuilder(Default::default());
        event.record(&mut visitor);
        let meta = event.metadata();
        println!("{}: tag={}{}", meta.level(), self.0, visitor.0);
    }

    fn enter(&self, _span: &tracing_core::span::Id) {}
    fn exit(&self, _span: &tracing_core::span::Id) {}
}

fn main() {
    let filter_one = EnvFilter::new("debug"); // Everything at debug, foo at trace
    let filter_two = EnvFilter::new("info"); // Everything at info, foo still at trace
    let out_one = Tagged("one");
    let out_two = Tagged("two");

    let layered = filter_two
        .and_then(out_one)
        .and_then(filter_one)
        .with_subscriber(out_two);

    layered.init();

    warn!("warn");
    info!("info");
    debug!("debug");
    trace!("trace");
}