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
|
use std::sync::{Arc, Mutex};
use tracing::subscriber::with_default;
use tracing_core::span::{Attributes, Record};
use tracing_core::{span, Event, Level, LevelFilter, Metadata, Subscriber};
use tracing_log::{LogTracer, NormalizeEvent};
struct State {
last_normalized_metadata: Mutex<(bool, Option<OwnedMetadata>)>,
}
#[derive(PartialEq, Debug)]
struct OwnedMetadata {
name: String,
target: String,
level: Level,
module_path: Option<String>,
file: Option<String>,
line: Option<u32>,
}
struct TestSubscriber(Arc<State>);
impl Subscriber for TestSubscriber {
fn enabled(&self, meta: &Metadata<'_>) -> bool {
dbg!(meta);
true
}
fn max_level_hint(&self) -> Option<LevelFilter> {
Some(LevelFilter::from_level(Level::INFO))
}
fn new_span(&self, _span: &Attributes<'_>) -> span::Id {
span::Id::from_u64(42)
}
fn record(&self, _span: &span::Id, _values: &Record<'_>) {}
fn record_follows_from(&self, _span: &span::Id, _follows: &span::Id) {}
fn event(&self, event: &Event<'_>) {
dbg!(event);
*self.0.last_normalized_metadata.lock().unwrap() = (
event.is_log(),
event.normalized_metadata().map(|normalized| OwnedMetadata {
name: normalized.name().to_string(),
target: normalized.target().to_string(),
level: *normalized.level(),
module_path: normalized.module_path().map(String::from),
file: normalized.file().map(String::from),
line: normalized.line(),
}),
)
}
fn enter(&self, _span: &span::Id) {}
fn exit(&self, _span: &span::Id) {}
}
#[test]
fn normalized_metadata() {
LogTracer::init().unwrap();
let me = Arc::new(State {
last_normalized_metadata: Mutex::new((false, None)),
});
let state = me.clone();
with_default(TestSubscriber(me), || {
log::info!("expected info log");
log::debug!("unexpected debug log");
let log = log::Record::builder()
.args(format_args!("Error!"))
.level(log::Level::Info)
.build();
log::logger().log(&log);
last(
&state,
true,
Some(OwnedMetadata {
name: "log event".to_string(),
target: "".to_string(),
level: Level::INFO,
module_path: None,
file: None,
line: None,
}),
);
let log = log::Record::builder()
.args(format_args!("Error!"))
.level(log::Level::Info)
.target("log_tracer_target")
.file(Some("server.rs"))
.line(Some(144))
.module_path(Some("log_tracer"))
.build();
log::logger().log(&log);
last(
&state,
true,
Some(OwnedMetadata {
name: "log event".to_string(),
target: "log_tracer_target".to_string(),
level: Level::INFO,
module_path: Some("log_tracer".to_string()),
file: Some("server.rs".to_string()),
line: Some(144),
}),
);
tracing::info!("test with a tracing info");
last(&state, false, None);
})
}
fn last(state: &State, should_be_log: bool, expected: Option<OwnedMetadata>) {
let lock = state.last_normalized_metadata.lock().unwrap();
let (is_log, metadata) = &*lock;
dbg!(&metadata);
assert_eq!(dbg!(*is_log), should_be_log);
assert_eq!(metadata.as_ref(), expected.as_ref());
}
|
