1#![doc(
98 html_logo_url = "https://raw.githubusercontent.com/tokio-rs/tracing/master/assets/logo-type.png",
99 issue_tracker_base_url = "https://github.com/tokio-rs/tracing/issues/"
100)]
101#![cfg_attr(docsrs, feature(doc_cfg), deny(rustdoc::broken_intra_doc_links))]
102#![warn(
103 missing_debug_implementations,
104 missing_docs,
105 rust_2018_idioms,
106 unreachable_pub,
107 bad_style,
108 dead_code,
109 improper_ctypes,
110 non_shorthand_field_patterns,
111 no_mangle_generic_items,
112 overflowing_literals,
113 path_statements,
114 patterns_in_fns_without_body,
115 private_in_public,
116 unconditional_recursion,
117 unused,
118 unused_allocation,
119 unused_comparisons,
120 unused_parens,
121 while_true
122)]
123use once_cell::sync::Lazy;
124
125use std::{fmt, io};
126
127use tracing_core::{
128 callsite::{self, Callsite},
129 dispatcher,
130 field::{self, Field, Visit},
131 identify_callsite,
132 metadata::{Kind, Level},
133 subscriber, Event, Metadata,
134};
135
136#[cfg(feature = "log-tracer")]
137#[cfg_attr(docsrs, doc(cfg(feature = "log-tracer")))]
138pub mod log_tracer;
139
140#[cfg(feature = "log-tracer")]
141#[cfg_attr(docsrs, doc(cfg(feature = "log-tracer")))]
142#[doc(inline)]
143pub use self::log_tracer::LogTracer;
144
145pub use log;
146
147#[cfg(all(feature = "interest-cache", feature = "log-tracer", feature = "std"))]
148mod interest_cache;
149
150#[cfg(all(feature = "interest-cache", feature = "log-tracer", feature = "std"))]
151#[cfg_attr(
152 docsrs,
153 doc(cfg(all(feature = "interest-cache", feature = "log-tracer", feature = "std")))
154)]
155pub use crate::interest_cache::InterestCacheConfig;
156
157pub fn format_trace(record: &log::Record<'_>) -> io::Result<()> {
159 dispatch_record(record);
160 Ok(())
161}
162
163pub(crate) fn dispatch_record(record: &log::Record<'_>) {
167 dispatcher::get_default(|dispatch| {
168 let filter_meta = record.as_trace();
169 if !dispatch.enabled(&filter_meta) {
170 return;
171 }
172
173 let (_, keys, meta) = loglevel_to_cs(record.level());
174
175 let log_module = record.module_path();
176 let log_file = record.file();
177 let log_line = record.line();
178
179 let module = log_module.as_ref().map(|s| s as &dyn field::Value);
180 let file = log_file.as_ref().map(|s| s as &dyn field::Value);
181 let line = log_line.as_ref().map(|s| s as &dyn field::Value);
182
183 dispatch.event(&Event::new(
184 meta,
185 &meta.fields().value_set(&[
186 (&keys.message, Some(record.args() as &dyn field::Value)),
187 (&keys.target, Some(&record.target())),
188 (&keys.module, module),
189 (&keys.file, file),
190 (&keys.line, line),
191 ]),
192 ));
193 });
194}
195
196pub trait AsLog: crate::sealed::Sealed {
199 type Log;
201 fn as_log(&self) -> Self::Log;
203}
204
205pub trait AsTrace: crate::sealed::Sealed {
208 type Trace;
210 fn as_trace(&self) -> Self::Trace;
212}
213
214impl<'a> crate::sealed::Sealed for Metadata<'a> {}
215
216impl<'a> AsLog for Metadata<'a> {
217 type Log = log::Metadata<'a>;
218 fn as_log(&self) -> Self::Log {
219 log::Metadata::builder()
220 .level(self.level().as_log())
221 .target(self.target())
222 .build()
223 }
224}
225impl<'a> crate::sealed::Sealed for log::Metadata<'a> {}
226
227impl<'a> AsTrace for log::Metadata<'a> {
228 type Trace = Metadata<'a>;
229 fn as_trace(&self) -> Self::Trace {
230 let cs_id = identify_callsite!(loglevel_to_cs(self.level()).0);
231 Metadata::new(
232 "log record",
233 self.target(),
234 self.level().as_trace(),
235 None,
236 None,
237 None,
238 field::FieldSet::new(FIELD_NAMES, cs_id),
239 Kind::EVENT,
240 )
241 }
242}
243
244struct Fields {
245 message: field::Field,
246 target: field::Field,
247 module: field::Field,
248 file: field::Field,
249 line: field::Field,
250}
251
252static FIELD_NAMES: &[&str] = &[
253 "message",
254 "log.target",
255 "log.module_path",
256 "log.file",
257 "log.line",
258];
259
260impl Fields {
261 fn new(cs: &'static dyn Callsite) -> Self {
262 let fieldset = cs.metadata().fields();
263 let message = fieldset.field("message").unwrap();
264 let target = fieldset.field("log.target").unwrap();
265 let module = fieldset.field("log.module_path").unwrap();
266 let file = fieldset.field("log.file").unwrap();
267 let line = fieldset.field("log.line").unwrap();
268 Fields {
269 message,
270 target,
271 module,
272 file,
273 line,
274 }
275 }
276}
277
278macro_rules! log_cs {
279 ($level:expr, $cs:ident, $meta:ident, $ty:ident) => {
280 struct $ty;
281 static $cs: $ty = $ty;
282 static $meta: Metadata<'static> = Metadata::new(
283 "log event",
284 "log",
285 $level,
286 ::core::option::Option::None,
287 ::core::option::Option::None,
288 ::core::option::Option::None,
289 field::FieldSet::new(FIELD_NAMES, identify_callsite!(&$cs)),
290 Kind::EVENT,
291 );
292
293 impl callsite::Callsite for $ty {
294 fn set_interest(&self, _: subscriber::Interest) {}
295 fn metadata(&self) -> &'static Metadata<'static> {
296 &$meta
297 }
298 }
299 };
300}
301
302log_cs!(
303 tracing_core::Level::TRACE,
304 TRACE_CS,
305 TRACE_META,
306 TraceCallsite
307);
308log_cs!(
309 tracing_core::Level::DEBUG,
310 DEBUG_CS,
311 DEBUG_META,
312 DebugCallsite
313);
314log_cs!(tracing_core::Level::INFO, INFO_CS, INFO_META, InfoCallsite);
315log_cs!(tracing_core::Level::WARN, WARN_CS, WARN_META, WarnCallsite);
316log_cs!(
317 tracing_core::Level::ERROR,
318 ERROR_CS,
319 ERROR_META,
320 ErrorCallsite
321);
322
323static TRACE_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&TRACE_CS));
324static DEBUG_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&DEBUG_CS));
325static INFO_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&INFO_CS));
326static WARN_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&WARN_CS));
327static ERROR_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&ERROR_CS));
328
329fn level_to_cs(level: Level) -> (&'static dyn Callsite, &'static Fields) {
330 match level {
331 Level::TRACE => (&TRACE_CS, &*TRACE_FIELDS),
332 Level::DEBUG => (&DEBUG_CS, &*DEBUG_FIELDS),
333 Level::INFO => (&INFO_CS, &*INFO_FIELDS),
334 Level::WARN => (&WARN_CS, &*WARN_FIELDS),
335 Level::ERROR => (&ERROR_CS, &*ERROR_FIELDS),
336 }
337}
338
339fn loglevel_to_cs(
340 level: log::Level,
341) -> (
342 &'static dyn Callsite,
343 &'static Fields,
344 &'static Metadata<'static>,
345) {
346 match level {
347 log::Level::Trace => (&TRACE_CS, &*TRACE_FIELDS, &TRACE_META),
348 log::Level::Debug => (&DEBUG_CS, &*DEBUG_FIELDS, &DEBUG_META),
349 log::Level::Info => (&INFO_CS, &*INFO_FIELDS, &INFO_META),
350 log::Level::Warn => (&WARN_CS, &*WARN_FIELDS, &WARN_META),
351 log::Level::Error => (&ERROR_CS, &*ERROR_FIELDS, &ERROR_META),
352 }
353}
354
355impl<'a> crate::sealed::Sealed for log::Record<'a> {}
356
357impl<'a> AsTrace for log::Record<'a> {
358 type Trace = Metadata<'a>;
359 fn as_trace(&self) -> Self::Trace {
360 let cs_id = identify_callsite!(loglevel_to_cs(self.level()).0);
361 Metadata::new(
362 "log record",
363 self.target(),
364 self.level().as_trace(),
365 self.file(),
366 self.line(),
367 self.module_path(),
368 field::FieldSet::new(FIELD_NAMES, cs_id),
369 Kind::EVENT,
370 )
371 }
372}
373
374impl crate::sealed::Sealed for tracing_core::Level {}
375
376impl AsLog for tracing_core::Level {
377 type Log = log::Level;
378 fn as_log(&self) -> log::Level {
379 match *self {
380 tracing_core::Level::ERROR => log::Level::Error,
381 tracing_core::Level::WARN => log::Level::Warn,
382 tracing_core::Level::INFO => log::Level::Info,
383 tracing_core::Level::DEBUG => log::Level::Debug,
384 tracing_core::Level::TRACE => log::Level::Trace,
385 }
386 }
387}
388
389impl crate::sealed::Sealed for log::Level {}
390
391impl AsTrace for log::Level {
392 type Trace = tracing_core::Level;
393 #[inline]
394 fn as_trace(&self) -> tracing_core::Level {
395 match self {
396 log::Level::Error => tracing_core::Level::ERROR,
397 log::Level::Warn => tracing_core::Level::WARN,
398 log::Level::Info => tracing_core::Level::INFO,
399 log::Level::Debug => tracing_core::Level::DEBUG,
400 log::Level::Trace => tracing_core::Level::TRACE,
401 }
402 }
403}
404
405impl crate::sealed::Sealed for log::LevelFilter {}
406
407impl AsTrace for log::LevelFilter {
408 type Trace = tracing_core::LevelFilter;
409 #[inline]
410 fn as_trace(&self) -> tracing_core::LevelFilter {
411 match self {
412 log::LevelFilter::Off => tracing_core::LevelFilter::OFF,
413 log::LevelFilter::Error => tracing_core::LevelFilter::ERROR,
414 log::LevelFilter::Warn => tracing_core::LevelFilter::WARN,
415 log::LevelFilter::Info => tracing_core::LevelFilter::INFO,
416 log::LevelFilter::Debug => tracing_core::LevelFilter::DEBUG,
417 log::LevelFilter::Trace => tracing_core::LevelFilter::TRACE,
418 }
419 }
420}
421
422impl crate::sealed::Sealed for tracing_core::LevelFilter {}
423
424impl AsLog for tracing_core::LevelFilter {
425 type Log = log::LevelFilter;
426 #[inline]
427 fn as_log(&self) -> Self::Log {
428 match *self {
429 tracing_core::LevelFilter::OFF => log::LevelFilter::Off,
430 tracing_core::LevelFilter::ERROR => log::LevelFilter::Error,
431 tracing_core::LevelFilter::WARN => log::LevelFilter::Warn,
432 tracing_core::LevelFilter::INFO => log::LevelFilter::Info,
433 tracing_core::LevelFilter::DEBUG => log::LevelFilter::Debug,
434 tracing_core::LevelFilter::TRACE => log::LevelFilter::Trace,
435 }
436 }
437}
438pub trait NormalizeEvent<'a>: crate::sealed::Sealed {
456 fn normalized_metadata(&'a self) -> Option<Metadata<'a>>;
462 fn is_log(&self) -> bool;
464}
465
466impl<'a> crate::sealed::Sealed for Event<'a> {}
467
468impl<'a> NormalizeEvent<'a> for Event<'a> {
469 fn normalized_metadata(&'a self) -> Option<Metadata<'a>> {
470 let original = self.metadata();
471 if self.is_log() {
472 let mut fields = LogVisitor::new_for(self, level_to_cs(*original.level()).1);
473 self.record(&mut fields);
474
475 Some(Metadata::new(
476 "log event",
477 fields.target.unwrap_or("log"),
478 *original.level(),
479 fields.file,
480 fields.line.map(|l| l as u32),
481 fields.module_path,
482 field::FieldSet::new(&["message"], original.callsite()),
483 Kind::EVENT,
484 ))
485 } else {
486 None
487 }
488 }
489
490 fn is_log(&self) -> bool {
491 self.metadata().callsite() == identify_callsite!(level_to_cs(*self.metadata().level()).0)
492 }
493}
494
495struct LogVisitor<'a> {
496 target: Option<&'a str>,
497 module_path: Option<&'a str>,
498 file: Option<&'a str>,
499 line: Option<u64>,
500 fields: &'static Fields,
501}
502
503impl<'a> LogVisitor<'a> {
504 fn new_for(_event: &'a Event<'a>, fields: &'static Fields) -> Self {
508 Self {
509 target: None,
510 module_path: None,
511 file: None,
512 line: None,
513 fields,
514 }
515 }
516}
517
518impl<'a> Visit for LogVisitor<'a> {
519 fn record_debug(&mut self, _field: &Field, _value: &dyn fmt::Debug) {}
520
521 fn record_u64(&mut self, field: &Field, value: u64) {
522 if field == &self.fields.line {
523 self.line = Some(value);
524 }
525 }
526
527 fn record_str(&mut self, field: &Field, value: &str) {
528 unsafe {
529 if field == &self.fields.file {
535 self.file = Some(&*(value as *const _));
536 } else if field == &self.fields.target {
537 self.target = Some(&*(value as *const _));
538 } else if field == &self.fields.module {
539 self.module_path = Some(&*(value as *const _));
540 }
541 }
542 }
543}
544
545mod sealed {
546 pub trait Sealed {}
547}
548
549#[cfg(test)]
550mod test {
551 use super::*;
552
553 fn test_callsite(level: log::Level) {
554 let record = log::Record::builder()
555 .args(format_args!("Error!"))
556 .level(level)
557 .target("myApp")
558 .file(Some("server.rs"))
559 .line(Some(144))
560 .module_path(Some("server"))
561 .build();
562
563 let meta = record.as_trace();
564 let (cs, _keys, _) = loglevel_to_cs(record.level());
565 let cs_meta = cs.metadata();
566 assert_eq!(
567 meta.callsite(),
568 cs_meta.callsite(),
569 "actual: {:#?}\nexpected: {:#?}",
570 meta,
571 cs_meta
572 );
573 assert_eq!(meta.level(), &level.as_trace());
574 }
575
576 #[test]
577 fn error_callsite_is_correct() {
578 test_callsite(log::Level::Error);
579 }
580
581 #[test]
582 fn warn_callsite_is_correct() {
583 test_callsite(log::Level::Warn);
584 }
585
586 #[test]
587 fn info_callsite_is_correct() {
588 test_callsite(log::Level::Info);
589 }
590
591 #[test]
592 fn debug_callsite_is_correct() {
593 test_callsite(log::Level::Debug);
594 }
595
596 #[test]
597 fn trace_callsite_is_correct() {
598 test_callsite(log::Level::Trace);
599 }
600}RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4