127 lines
3.6 KiB
Rust
127 lines
3.6 KiB
Rust
use std::sync::{Arc, Mutex};
|
|
use tracing::collect::with_default;
|
|
use tracing_core::span::{Attributes, Record};
|
|
use tracing_core::{span, Collect, Event, Level, LevelFilter, Metadata};
|
|
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 Collect 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) {}
|
|
|
|
fn current_span(&self) -> span::Current {
|
|
span::Current::unknown()
|
|
}
|
|
}
|
|
|
|
#[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());
|
|
}
|