From cc49774c726383691654ec072ee367d66985dffd Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Thu, 3 Feb 2022 15:48:11 -0800 Subject: [PATCH] implement `enabled_span` and `enabled_event` --- tracing/src/macros.rs | 76 ++++++++++++++++++++++++++++++++++------ tracing/tests/enabled.rs | 14 ++++++-- tracing/tests/macros.rs | 7 ++-- 3 files changed, 82 insertions(+), 15 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index ec680f43ba..c64c5069bc 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -884,9 +884,63 @@ macro_rules! event { /// } /// ``` /// +/// # Alternatives +/// +/// `enabled!` queries subscribers with [`Metadata`] where +/// [`is_event`] and [`is_span`] both return `false`. Alternatively, +/// use [`enabled_event`] or [`enabled_span`] to ensure one of these +/// returns true. +/// +/// +/// [`Metadata`]: crate::Metadata +/// [`is_event`]: crate::Metadata::is_event +/// [`is_span`]: crate::Metadata::is_span +/// [`enabled_event`]: crate::enabled_event +/// [`enabled_span`]: crate::enabled_span +/// #[macro_export] macro_rules! enabled { - (target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({ + ($($rest:tt)*)=> ( + $crate::_enabled!(kind: { $crate::metadata::Kind::HINT }, $($rest)*) + ) +} + +/// The same as [`enabled`], but queries subscribers with `Metadata` where +/// [`Metadata::is_event`] returns true. +/// +/// See also [`enabled_span`]. +/// +/// [`enabled`]: crate::enabled +/// [`Metadata::is_event`]: crate::Metadata::is_event +/// [`enabled_span`]: crate::enabled_span +/// +#[macro_export] +macro_rules! enabled_event { + ($($rest:tt)*)=> ( + $crate::_enabled!(kind: $crate::metadata::Kind::EVENT.hint(), $($rest)*) + ) +} + +/// The same as [`enabled`], but queries subscribers with `Metadata` where +/// [`Metadata::is_span`] returns true. +/// +/// See also [`enabled_event`]. +/// +/// [`enabled`]: crate::enabled +/// [`Metadata::is_span`]: crate::Metadata::is_span +/// [`enabled_event`]: crate::enabled_event +/// +#[macro_export] +macro_rules! enabled_span { + ($($rest:tt)*)=> ( + $crate::_enabled!(kind: $crate::metadata::Kind::SPAN.hint(), $($rest)*) + ) +} + +#[doc(hidden)] +#[macro_export] +macro_rules! _enabled { + (kind: $kind:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({ if $crate::level_enabled!($lvl) { use $crate::__macro_support::Callsite as _; static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! { @@ -896,7 +950,7 @@ macro_rules! enabled { ":", line!() ), - kind: $crate::metadata::Kind::HINT, + kind: $kind, target: $target, level: $lvl, fields: $($fields)* @@ -913,20 +967,22 @@ macro_rules! enabled { } }); // Just target and level - (target: $target:expr, $lvl:expr ) => ( - $crate::enabled!(target: $target, $lvl, { }) + (kind: $kind:expr, target: $target:expr, $lvl:expr ) => ( + $crate::_enabled!(kind: $kind, target: $target, $lvl, { }) ); // These two cases handle fields with no values - (target: $target:expr, $lvl:expr, $($field:tt)*) => ( - $crate::enabled!( + (kind: $kind:expr, target: $target:expr, $lvl:expr, $($field:tt)*) => ( + $crate::_enabled!( + kind: $kind, target: $target, $lvl, { $($field)*} ) ); - ($lvl:expr, $($field:tt)*) => ( - $crate::enabled!( + (kind: $kind:expr, $lvl:expr, $($field:tt)*) => ( + $crate::_enabled!( + kind: $kind, target: module_path!(), $lvl, { $($field)*} @@ -934,8 +990,8 @@ macro_rules! enabled { ); // Simplest `enabled!` case - ( $lvl:expr ) => ( - $crate::enabled!(target: module_path!(), $lvl, { }) + (kind: $kind:expr, $lvl:expr ) => ( + $crate::_enabled!(kind: $kind, target: module_path!(), $lvl, { }) ); } diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index 9840afd9e1..3d5959a28d 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -6,21 +6,29 @@ use tracing::Level; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn level_and_target() { - let (subscriber, handle) = subscriber::mock() + let subscriber = subscriber::mock() .with_filter(|meta| { if meta.target() == "debug_module" { meta.level() <= &Level::DEBUG + } else if meta.is_span() { + meta.level() <= &Level::TRACE + } else if meta.is_event() { + meta.level() <= &Level::DEBUG } else { meta.level() <= &Level::INFO } }) .done() - .run_with_handle(); + .run(); tracing::subscriber::set_global_default(subscriber).unwrap(); assert!(tracing::enabled!(target: "debug_module", Level::DEBUG)); assert!(tracing::enabled!(Level::ERROR)); assert!(!tracing::enabled!(Level::DEBUG)); - handle.assert_finished(); + + assert!(!tracing::enabled_event!(Level::TRACE)); + assert!(tracing::enabled_event!(Level::DEBUG)); + + assert!(tracing::enabled_span!(Level::TRACE)); } diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs index 0a32ebfc3f..47ffba9e38 100644 --- a/tracing/tests/macros.rs +++ b/tracing/tests/macros.rs @@ -1,7 +1,7 @@ #![deny(warnings)] use tracing::{ - callsite, debug, debug_span, enabled, error, error_span, event, info, info_span, span, trace, - trace_span, warn, warn_span, Level, + callsite, debug, debug_span, enabled, enabled_event, enabled_span, error, error_span, event, + info, info_span, span, trace, trace_span, warn, warn_span, Level, }; // Tests that macros work across various invocation syntax. @@ -346,6 +346,9 @@ fn enabled() { enabled!(Level::DEBUG); enabled!(target: "rando", Level::DEBUG); enabled!(target: "rando", Level::DEBUG, field); + + enabled_span!(target: "rando", Level::DEBUG, field); + enabled_event!(target: "rando", Level::DEBUG, field); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]