vendor/tracing-log/tests/log_tracer.rs

   1 use std::sync::{Arc, Mutex};
   2 use tracing::subscriber::with_default;
   3 use tracing_core::span::{Attributes, Record};
   4 use tracing_core::{span, Event, Level, Metadata, Subscriber};
   5 use tracing_log::{LogTracer, NormalizeEvent};
   6
   7 struct State {
   8     last_normalized_metadata: Mutex<(bool, Option<OwnedMetadata>)>,
   9 }
  10
  11 #[derive(PartialEq, Debug)]
  12 struct OwnedMetadata {
  13     name: String,
  14     target: String,
  15     level: Level,
  16     module_path: Option<String>,
  17     file: Option<String>,
  18     line: Option<u32>,
  19 }
  20
  21 struct TestSubscriber(Arc<State>);
  22
  23 impl Subscriber for TestSubscriber {
  24     fn enabled(&self, meta: &Metadata<'_>) -> bool {
  25         dbg!(meta);
  26         true
  27     }
  28
  29     fn new_span(&self, _span: &Attributes<'_>) -> span::Id {
  30         span::Id::from_u64(42)
  31     }
  32
  33     fn record(&self, _span: &span::Id, _values: &Record<'_>) {}
  34
  35     fn record_follows_from(&self, _span: &span::Id, _follows: &span::Id) {}
  36
  37     fn event(&self, event: &Event<'_>) {
  38         dbg!(event);
  39         *self.0.last_normalized_metadata.lock().unwrap() = (
  40             event.is_log(),
  41             event.normalized_metadata().map(|normalized| OwnedMetadata {
  42                 name: normalized.name().to_string(),
  43                 target: normalized.target().to_string(),
  44                 level: *normalized.level(),
  45                 module_path: normalized.module_path().map(String::from),
  46                 file: normalized.file().map(String::from),
  47                 line: normalized.line(),
  48             }),
  49         )
  50     }
  51
  52     fn enter(&self, _span: &span::Id) {}
  53
  54     fn exit(&self, _span: &span::Id) {}
  55 }
  56
  57 #[test]
  58 fn normalized_metadata() {
  59     LogTracer::init().unwrap();
  60     let me = Arc::new(State {
  61         last_normalized_metadata: Mutex::new((false, None)),
  62     });
  63     let state = me.clone();
  64
  65     with_default(TestSubscriber(me), || {
  66         let log = log::Record::builder()
  67             .args(format_args!("Error!"))
  68             .level(log::Level::Info)
  69             .build();
  70         log::logger().log(&log);
  71         last(
  72             &state,
  73             true,
  74             Some(OwnedMetadata {
  75                 name: "log event".to_string(),
  76                 target: "".to_string(),
  77                 level: Level::INFO,
  78                 module_path: None,
  79                 file: None,
  80                 line: None,
  81             }),
  82         );
  83
  84         let log = log::Record::builder()
  85             .args(format_args!("Error!"))
  86             .level(log::Level::Info)
  87             .target("log_tracer_target")
  88             .file(Some("server.rs"))
  89             .line(Some(144))
  90             .module_path(Some("log_tracer"))
  91             .build();
  92         log::logger().log(&log);
  93         last(
  94             &state,
  95             true,
  96             Some(OwnedMetadata {
  97                 name: "log event".to_string(),
  98                 target: "log_tracer_target".to_string(),
  99                 level: Level::INFO,
 100                 module_path: Some("log_tracer".to_string()),
 101                 file: Some("server.rs".to_string()),
 102                 line: Some(144),
 103             }),
 104         );
 105
 106         tracing::info!("test with a tracing info");
 107         last(&state, false, None);
 108     })
 109 }
 110
 111 fn last(state: &State, should_be_log: bool, expected: Option<OwnedMetadata>) {
 112     let lock = state.last_normalized_metadata.lock().unwrap();
 113     let (is_log, metadata) = &*lock;
 114     dbg!(&metadata);
 115     assert_eq!(dbg!(*is_log), should_be_log);
 116     assert_eq!(metadata.as_ref(), expected.as_ref());
 117 }