Htrace 2.0.0

simple tracing system
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

use tracing::Metadata;
use crate::components::level::Level;

#[cfg(feature = "tracing_consumer")]
use tracing_subscriber::{Layer};
#[cfg(feature = "tracing_consumer")]
use tracing_subscriber::filter::dynamic_filter_fn;
#[cfg(feature = "tracing_consumer")]
use tracing_subscriber::layer::Context;

#[cfg(feature = "tracing_consumer")]
#[derive(Debug,Clone)]
pub enum HtraceBridgeSpanFilterList {
	/// Allow only some specific spans (empty list = deny all)
	Allow(Vec<String>),
	/// Deny some specific spans (empty list = allow all)
	Deny(Vec<String>),
}

#[cfg(feature = "tracing_consumer")]
impl Default for HtraceBridgeSpanFilterList {
	fn default() -> Self {
		HtraceBridgeSpanFilterList::Deny(vec![])
	}
}

#[derive(Clone)]
pub struct HtraceBridge {
	/// minimum level for backtrace (default warn, use None to disable, use Some(Level::min()) to enable all)
	pub min_level_backtrace: Option<Level>,

	/// Htrace.level::DEBUG is the minimum level (that must be set here), correspond to: Log.level::Trace is the maximum level
	#[cfg(feature = "log_consumer")]
	pub log_min_level: Level,
	/// Htrace.level::DEBUG is the minimum level (that must be set here), correspond to: Tracing.level::Trace is the maximum level
	#[cfg(feature = "tracing_consumer")]
	pub tracing_min_level: Level,

	/// span filter list for tracing
	#[cfg(feature = "tracing_consumer")]
	pub tracing_filter_span: HtraceBridgeSpanFilterList,
}

impl HtraceBridge {

	/// return if a level is a backtrace level (equal or above the "min_level_backtrace")
	pub fn isBacktrace(&self, level: &Level) -> bool {
		if let Some(backtracelevel) = self.min_level_backtrace
		{
			return level.tou8() >= backtracelevel.tou8();
		}
		return false;
	}


	#[cfg(feature = "log_consumer")]
	/// return if a level is a log level (equal or above the "log_min_level")
	pub fn isLog(&self, level: &Level) -> bool {
		return level.tou8() >= self.log_min_level.tou8();
	}

	#[cfg(feature = "tracing_consumer")]
	/// return if a level is a tracing level (equal or above the "min_level_tracing")
	pub fn isTracing(&self, level: &Level) -> bool {
		return level.tou8() >= self.tracing_min_level.tou8();
	}

	#[cfg(feature = "tracing_consumer")]
	/// return a filtered layer for tracing
    pub fn filtered<S>(self) -> impl Layer<S>
    where
        S: for<'a> tracing_subscriber::registry::LookupSpan<'a> + tracing::Subscriber,
    {
        let filter_list = self.tracing_filter_span.clone();
        let only_requests_or_user = dynamic_filter_fn(move |_meta: &Metadata<'_>, ctx: &Context<'_, S>| {
	        if let Some(span) = ctx.lookup_current()
            {
                match &filter_list {
                    HtraceBridgeSpanFilterList::Allow(allowed) => {
	                    //println!("span {} : ALLOW ? {}",&span.name(),allowed.contains(&span.name().to_string()));
                        if allowed.contains(&span.name().to_string()) {
                            return true;
                        }
                    }
                    HtraceBridgeSpanFilterList::Deny(denied) => {
	                    //println!("span {} : DENY ? {}",&span.name(),denied.contains(&span.name().to_string()));
                        if !denied.contains(&span.name().to_string()) {
                            return true;
                        }
                    }
                }
	            return false;
            };

	        return true;
        });

        self.with_filter(only_requests_or_user)
    }
}

impl Default for HtraceBridge {
	fn default() -> Self {
		HtraceBridge {
			min_level_backtrace: Some(Level::WARNING),
			#[cfg(feature = "log_consumer")]
			log_min_level: Level::DEBUG,
			#[cfg(feature = "tracing_consumer")]
			tracing_min_level: Level::DEBUG,
			#[cfg(feature = "tracing_consumer")]
			tracing_filter_span: Default::default(),
		}
	}
}