#![allow(dead_code)] use criterion::{black_box, measurement::WallTime, Bencher}; use tracing::{field, span, Event, Id, Metadata}; use std::{ fmt::{self, Write}, sync::{Mutex, MutexGuard}, }; pub fn for_all_recording( group: &mut criterion::BenchmarkGroup<'_, WallTime>, mut iter: impl FnMut(&mut Bencher<'_, WallTime>), ) { // first, run benchmarks with no subscriber group.bench_function("none", &mut iter); // then, run benchmarks with a scoped default subscriber tracing::subscriber::with_default(EnabledSubscriber, || { group.bench_function("scoped", &mut iter) }); let subscriber = VisitingSubscriber(Mutex::new(String::from(""))); tracing::subscriber::with_default(subscriber, || { group.bench_function("scoped_recording", &mut iter); }); // finally, set a global default subscriber, and run the benchmarks again. tracing::subscriber::set_global_default(EnabledSubscriber) .expect("global default should not have already been set!"); let _ = log::set_logger(&NOP_LOGGER); log::set_max_level(log::LevelFilter::Trace); group.bench_function("global", &mut iter); } pub fn for_all_dispatches( group: &mut criterion::BenchmarkGroup<'_, WallTime>, mut iter: impl FnMut(&mut Bencher<'_, WallTime>), ) { // first, run benchmarks with no subscriber group.bench_function("none", &mut iter); // then, run benchmarks with a scoped default subscriber tracing::subscriber::with_default(EnabledSubscriber, || { group.bench_function("scoped", &mut iter) }); // finally, set a global default subscriber, and run the benchmarks again. tracing::subscriber::set_global_default(EnabledSubscriber) .expect("global default should not have already been set!"); let _ = log::set_logger(&NOP_LOGGER); log::set_max_level(log::LevelFilter::Trace); group.bench_function("global", &mut iter); } const NOP_LOGGER: NopLogger = NopLogger; struct NopLogger; impl log::Log for NopLogger { fn enabled(&self, _metadata: &log::Metadata) -> bool { true } fn log(&self, record: &log::Record) { if self.enabled(record.metadata()) { let mut this = self; let _ = write!(this, "{}", record.args()); } } fn flush(&self) {} } impl Write for &NopLogger { fn write_str(&mut self, s: &str) -> std::fmt::Result { black_box(s); Ok(()) } } /// Simulates a subscriber that records span data. struct VisitingSubscriber(Mutex<String>); struct Visitor<'a>(MutexGuard<'a, String>); impl<'a> field::Visit for Visitor<'a> { fn record_debug(&mut self, _field: &field::Field, value: &dyn fmt::Debug) { let _ = write!(&mut *self.0, "{:?}", value); } } impl tracing::Subscriber for VisitingSubscriber { fn new_span(&self, span: &span::Attributes<'_>) -> Id { let mut visitor = Visitor(self.0.lock().unwrap()); span.record(&mut visitor); Id::from_u64(0xDEAD_FACE) } fn record(&self, _span: &Id, values: &span::Record<'_>) { let mut visitor = Visitor(self.0.lock().unwrap()); values.record(&mut visitor); } fn event(&self, event: &Event<'_>) { let mut visitor = Visitor(self.0.lock().unwrap()); event.record(&mut visitor); } fn record_follows_from(&self, span: &Id, follows: &Id) { let _ = (span, follows); } fn enabled(&self, metadata: &Metadata<'_>) -> bool { let _ = metadata; true } fn enter(&self, span: &Id) { let _ = span; } fn exit(&self, span: &Id) { let _ = span; } } /// A subscriber that is enabled but otherwise does nothing. struct EnabledSubscriber; impl tracing::Subscriber for EnabledSubscriber { fn new_span(&self, span: &span::Attributes<'_>) -> Id { let _ = span; Id::from_u64(0xDEAD_FACE) } fn event(&self, event: &Event<'_>) { let _ = event; } fn record(&self, span: &Id, values: &span::Record<'_>) { let _ = (span, values); } fn record_follows_from(&self, span: &Id, follows: &Id) { let _ = (span, follows); } fn enabled(&self, metadata: &Metadata<'_>) -> bool { let _ = metadata; true } fn enter(&self, span: &Id) { let _ = span; } fn exit(&self, span: &Id) { let _ = span; } }