From ef715b9a4e8b187addd0f01bf9bd6c9513b0b55d Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Thu, 3 Feb 2022 15:48:11 -0800 Subject: [PATCH 1/9] implement `enabled_span` and `enabled_event` --- tracing/src/macros.rs | 76 ++++++++++++++++++++++++++++++++++------ tracing/tests/enabled.rs | 15 ++++++-- tracing/tests/macros.rs | 7 ++-- 3 files changed, 83 insertions(+), 15 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index eb80bf0592..daf34af1f3 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -878,9 +878,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! { @@ -890,7 +944,7 @@ macro_rules! enabled { ":", line!() ), - kind: $crate::metadata::Kind::HINT, + kind: $kind, target: $target, level: $lvl, fields: $($fields)* @@ -907,20 +961,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)*} @@ -928,8 +984,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 59c9c1106e..e8e76a8d8a 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -10,21 +10,30 @@ use tracing::Level; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn level_and_target() { - let (collector, handle) = collector::mock() + let collector = collector::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::collect::set_global_default(collector).unwrap(); assert!(tracing::enabled!(target: "debug_module", Level::DEBUG)); assert!(tracing::enabled!(Level::ERROR)); assert!(!tracing::enabled!(Level::DEBUG)); - handle.assert_finished(); + + // Ensure that the `_event` and `_span` alternatives work corretly + 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)] From 04075d52176ffbec4e2183a3d75e1ee5e295f102 Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Fri, 4 Feb 2022 09:57:57 -0800 Subject: [PATCH 2/9] enabled_event -> event_enable --- tracing/src/macros.rs | 18 +++++++++--------- tracing/tests/enabled.rs | 6 +++--- tracing/tests/macros.rs | 8 ++++---- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index daf34af1f3..2a7c02e4d9 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -882,15 +882,15 @@ macro_rules! event { /// /// `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 +/// use [`event_enabled`] or [`span_enabled`] 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 +/// [`event_enabled`]: crate::event_enabled +/// [`span_enabled`]: crate::span_enabled /// #[macro_export] macro_rules! enabled { @@ -902,14 +902,14 @@ macro_rules! enabled { /// The same as [`enabled`], but queries subscribers with `Metadata` where /// [`Metadata::is_event`] returns true. /// -/// See also [`enabled_span`]. +/// See also [`span_enabled`]. /// /// [`enabled`]: crate::enabled /// [`Metadata::is_event`]: crate::Metadata::is_event -/// [`enabled_span`]: crate::enabled_span +/// [`span_enabled`]: crate::span_enabled /// #[macro_export] -macro_rules! enabled_event { +macro_rules! event_enabled { ($($rest:tt)*)=> ( $crate::_enabled!(kind: $crate::metadata::Kind::EVENT.hint(), $($rest)*) ) @@ -918,14 +918,14 @@ macro_rules! enabled_event { /// The same as [`enabled`], but queries subscribers with `Metadata` where /// [`Metadata::is_span`] returns true. /// -/// See also [`enabled_event`]. +/// See also [`event_enabled`]. /// /// [`enabled`]: crate::enabled /// [`Metadata::is_span`]: crate::Metadata::is_span -/// [`enabled_event`]: crate::enabled_event +/// [`event_enabled`]: crate::event_enabled /// #[macro_export] -macro_rules! enabled_span { +macro_rules! span_enabled { ($($rest:tt)*)=> ( $crate::_enabled!(kind: $crate::metadata::Kind::SPAN.hint(), $($rest)*) ) diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index e8e76a8d8a..c2eafb1b02 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -32,8 +32,8 @@ fn level_and_target() { assert!(!tracing::enabled!(Level::DEBUG)); // Ensure that the `_event` and `_span` alternatives work corretly - assert!(!tracing::enabled_event!(Level::TRACE)); - assert!(tracing::enabled_event!(Level::DEBUG)); + assert!(!tracing::event_enabled!(Level::TRACE)); + assert!(tracing::event_enabled!(Level::DEBUG)); - assert!(tracing::enabled_span!(Level::TRACE)); + assert!(tracing::span_enabled!(Level::TRACE)); } diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs index 47ffba9e38..b51bc05292 100644 --- a/tracing/tests/macros.rs +++ b/tracing/tests/macros.rs @@ -1,7 +1,7 @@ #![deny(warnings)] use tracing::{ - callsite, debug, debug_span, enabled, enabled_event, enabled_span, error, error_span, event, - info, info_span, span, trace, trace_span, warn, warn_span, Level, + callsite, debug, debug_span, enabled, error, error_span, event, event_enabled, info, info_span, + span, span_enabled, trace, trace_span, warn, warn_span, Level, }; // Tests that macros work across various invocation syntax. @@ -347,8 +347,8 @@ fn enabled() { 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); + span_enabled!(target: "rando", Level::DEBUG, field); + event_enabled!(target: "rando", Level::DEBUG, field); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] From 8f5a94e006d80d756a55e8c76c4d8ce1af82f460 Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Fri, 4 Feb 2022 10:05:53 -0800 Subject: [PATCH 3/9] improve {event,span}_enabled docs --- tracing/src/macros.rs | 46 +++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 15 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index 2a7c02e4d9..36ea1e5abd 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -882,15 +882,15 @@ macro_rules! event { /// /// `enabled!` queries subscribers with [`Metadata`] where /// [`is_event`] and [`is_span`] both return `false`. Alternatively, -/// use [`event_enabled`] or [`span_enabled`] to ensure one of these +/// use [`event_enabled!`] or [`span_enabled!`] to ensure one of these /// returns true. /// /// /// [`Metadata`]: crate::Metadata /// [`is_event`]: crate::Metadata::is_event /// [`is_span`]: crate::Metadata::is_span -/// [`event_enabled`]: crate::event_enabled -/// [`span_enabled`]: crate::span_enabled +/// [`event_enabled!`]: crate::event_enabled +/// [`span_enabled!`]: crate::span_enabled /// #[macro_export] macro_rules! enabled { @@ -899,14 +899,22 @@ macro_rules! enabled { ) } -/// The same as [`enabled`], but queries subscribers with `Metadata` where -/// [`Metadata::is_event`] returns true. +/// The same as [`enabled!`], but queries subscribers specifically for an event, +/// whereas [`enabled!`] queries for an event _or_ span. /// -/// See also [`span_enabled`]. +/// See also [`span_enabled!`]. /// -/// [`enabled`]: crate::enabled -/// [`Metadata::is_event`]: crate::Metadata::is_event -/// [`span_enabled`]: crate::span_enabled +/// # Examples +/// +/// ```rust +/// # use tracing::{event_enabled, Level}; +/// if event_enabled!(target: "my_crate", Level::DEBUG) { +/// // some expensive work... +/// } +/// ``` +/// +/// [`enabled!`]: crate::enabled +/// [`span_enabled!`]: crate::span_enabled /// #[macro_export] macro_rules! event_enabled { @@ -915,14 +923,22 @@ macro_rules! event_enabled { ) } -/// The same as [`enabled`], but queries subscribers with `Metadata` where -/// [`Metadata::is_span`] returns true. +/// The same as [`enabled!`], but queries subscribers specifically for an span, +/// whereas [`enabled!`] queries for an event _or_ span. /// -/// See also [`event_enabled`]. +/// See also [`event_enabled!`]. +/// +/// # Examples +/// +/// ```rust +/// # use tracing::{span_enabled, Level}; +/// if span_enabled!(target: "my_crate", Level::DEBUG) { +/// // some expensive work... +/// } +/// ``` /// -/// [`enabled`]: crate::enabled -/// [`Metadata::is_span`]: crate::Metadata::is_span -/// [`event_enabled`]: crate::event_enabled +/// [`enabled!`]: crate::enabled +/// [`event_enabled!`]: crate::event_enabled /// #[macro_export] macro_rules! span_enabled { From 8716d981cf0e5373f67cedfab5bab27635fe5f6f Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Fri, 4 Feb 2022 11:01:56 -0800 Subject: [PATCH 4/9] cleanup rustdoc links for enabled --- tracing/src/macros.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index 36ea1e5abd..441b8595b6 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -889,8 +889,6 @@ macro_rules! event { /// [`Metadata`]: crate::Metadata /// [`is_event`]: crate::Metadata::is_event /// [`is_span`]: crate::Metadata::is_span -/// [`event_enabled!`]: crate::event_enabled -/// [`span_enabled!`]: crate::span_enabled /// #[macro_export] macro_rules! enabled { @@ -913,9 +911,6 @@ macro_rules! enabled { /// } /// ``` /// -/// [`enabled!`]: crate::enabled -/// [`span_enabled!`]: crate::span_enabled -/// #[macro_export] macro_rules! event_enabled { ($($rest:tt)*)=> ( @@ -937,9 +932,6 @@ macro_rules! event_enabled { /// } /// ``` /// -/// [`enabled!`]: crate::enabled -/// [`event_enabled!`]: crate::event_enabled -/// #[macro_export] macro_rules! span_enabled { ($($rest:tt)*)=> ( From 497f318bfa3a266b3b15bb1705ff41f509402e87 Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Fri, 4 Feb 2022 11:20:37 -0800 Subject: [PATCH 5/9] switch macro impl to all being enabled --- tracing/src/macros.rs | 127 +++++++++++++++++++++++----------------- tracing/tests/macros.rs | 4 ++ 2 files changed, 77 insertions(+), 54 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index 441b8595b6..fa6c3db4e7 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -801,6 +801,48 @@ macro_rules! event { ); } +/// The same as [`enabled!`], but queries subscribers specifically for an event, +/// whereas [`enabled!`] queries for an event _or_ span. +/// +/// See also [`span_enabled!`]. +/// +/// # Examples +/// +/// ```rust +/// # use tracing::{event_enabled, Level}; +/// if event_enabled!(target: "my_crate", Level::DEBUG) { +/// // some expensive work... +/// } +/// ``` +/// +#[macro_export] +macro_rules! event_enabled { + ($($rest:tt)*)=> ( + $crate::enabled!(kind: $crate::metadata::Kind::EVENT.hint(), $($rest)*) + ) +} + +/// The same as [`enabled!`], but queries subscribers specifically for an span, +/// whereas [`enabled!`] queries for an event _or_ span. +/// +/// See also [`event_enabled!`]. +/// +/// # Examples +/// +/// ```rust +/// # use tracing::{span_enabled, Level}; +/// if span_enabled!(target: "my_crate", Level::DEBUG) { +/// // some expensive work... +/// } +/// ``` +/// +#[macro_export] +macro_rules! span_enabled { + ($($rest:tt)*)=> ( + $crate::enabled!(kind: $crate::metadata::Kind::SPAN.hint(), $($rest)*) + ) +} + /// Checks whether a span or event is [enabled] based on the provided [metadata]. /// /// [enabled]: crate::Collect::enabled @@ -892,56 +934,6 @@ macro_rules! event { /// #[macro_export] macro_rules! enabled { - ($($rest:tt)*)=> ( - $crate::_enabled!(kind: { $crate::metadata::Kind::HINT }, $($rest)*) - ) -} - -/// The same as [`enabled!`], but queries subscribers specifically for an event, -/// whereas [`enabled!`] queries for an event _or_ span. -/// -/// See also [`span_enabled!`]. -/// -/// # Examples -/// -/// ```rust -/// # use tracing::{event_enabled, Level}; -/// if event_enabled!(target: "my_crate", Level::DEBUG) { -/// // some expensive work... -/// } -/// ``` -/// -#[macro_export] -macro_rules! event_enabled { - ($($rest:tt)*)=> ( - $crate::_enabled!(kind: $crate::metadata::Kind::EVENT.hint(), $($rest)*) - ) -} - -/// The same as [`enabled!`], but queries subscribers specifically for an span, -/// whereas [`enabled!`] queries for an event _or_ span. -/// -/// See also [`event_enabled!`]. -/// -/// # Examples -/// -/// ```rust -/// # use tracing::{span_enabled, Level}; -/// if span_enabled!(target: "my_crate", Level::DEBUG) { -/// // some expensive work... -/// } -/// ``` -/// -#[macro_export] -macro_rules! span_enabled { - ($($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 _; @@ -970,20 +962,33 @@ macro_rules! _enabled { }); // Just target and level (kind: $kind:expr, target: $target:expr, $lvl:expr ) => ( - $crate::_enabled!(kind: $kind, target: $target, $lvl, { }) + $crate::enabled!(kind: $kind, target: $target, $lvl, { }) + ); + (target: $target:expr, $lvl:expr ) => ( + $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: $target, $lvl, { }) ); // These two cases handle fields with no values (kind: $kind:expr, target: $target:expr, $lvl:expr, $($field:tt)*) => ( - $crate::_enabled!( + $crate::enabled!( kind: $kind, target: $target, $lvl, { $($field)*} ) ); + (target: $target:expr, $lvl:expr, $($field:tt)*) => ( + $crate::enabled!( + kind: $crate::metadata::Kind::HINT, + target: $target, + $lvl, + { $($field)*} + ) + ); + + // Level and field case (kind: $kind:expr, $lvl:expr, $($field:tt)*) => ( - $crate::_enabled!( + $crate::enabled!( kind: $kind, target: module_path!(), $lvl, @@ -991,9 +996,23 @@ macro_rules! _enabled { ) ); + // Simplest `enabled!` case // Simplest `enabled!` case (kind: $kind:expr, $lvl:expr ) => ( - $crate::_enabled!(kind: $kind, target: module_path!(), $lvl, { }) + $crate::enabled!(kind: $kind, target: module_path!(), $lvl, { }) + ); + ($lvl:expr ) => ( + $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: module_path!(), $lvl, { }) + ); + + // Fallthrough from above + ($lvl:expr, $($field:tt)*) => ( + $crate::enabled!( + kind: $crate::metadata::Kind::HINT, + target: module_path!(), + $lvl, + { $($field)*} + ) ); } diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs index b51bc05292..2013c9c011 100644 --- a/tracing/tests/macros.rs +++ b/tracing/tests/macros.rs @@ -349,6 +349,10 @@ fn enabled() { span_enabled!(target: "rando", Level::DEBUG, field); event_enabled!(target: "rando", Level::DEBUG, field); + + // other cases + span_enabled!(Level::DEBUG); + span_enabled!(Level::DEBUG, foo, bar.baz, quux,); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] From 43d54b509bcbd6ef247ae6a12303fe60cc1fb1dc Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Tue, 8 Feb 2022 14:34:42 -0800 Subject: [PATCH 6/9] docs and tests --- tracing/src/macros.rs | 23 +++++++++++-------- tracing/tests/enabled.rs | 10 -------- tracing/tests/macros.rs | 29 +++++++++++++++++++---- tracing/tests/specific_enabled.rs | 38 +++++++++++++++++++++++++++++++ 4 files changed, 77 insertions(+), 23 deletions(-) create mode 100644 tracing/tests/specific_enabled.rs diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index fa6c3db4e7..80c1843cab 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -801,9 +801,12 @@ macro_rules! event { ); } -/// The same as [`enabled!`], but queries subscribers specifically for an event, -/// whereas [`enabled!`] queries for an event _or_ span. +/// Tests whether an event with the specified level and target would be enabled. /// +/// This is similar to [`enabled!`], but queries the current collector specifically for +/// an event, whereas [`enabled!`] queries for an event _or_ span. +/// +/// See the documentation for [`enabled!]` for more details on using this macro. /// See also [`span_enabled!`]. /// /// # Examples @@ -822,10 +825,13 @@ macro_rules! event_enabled { ) } -/// The same as [`enabled!`], but queries subscribers specifically for an span, -/// whereas [`enabled!`] queries for an event _or_ span. +/// Tests whether a span with the specified level and target would be enabled. +/// +/// This is similar to [`enabled!`], but queries the current collector specifically for +/// an event, whereas [`enabled!`] queries for an event _or_ span. /// -/// See also [`event_enabled!`]. +/// See the documentation for [`enabled!]` for more details on using this macro. +/// See also [`span_enabled!`]. /// /// # Examples /// @@ -968,7 +974,7 @@ macro_rules! enabled { $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: $target, $lvl, { }) ); - // These two cases handle fields with no values + // These four cases handle fields with no values (kind: $kind:expr, target: $target:expr, $lvl:expr, $($field:tt)*) => ( $crate::enabled!( kind: $kind, @@ -997,11 +1003,10 @@ macro_rules! enabled { ); // Simplest `enabled!` case - // Simplest `enabled!` case - (kind: $kind:expr, $lvl:expr ) => ( + (kind: $kind:expr, $lvl:expr) => ( $crate::enabled!(kind: $kind, target: module_path!(), $lvl, { }) ); - ($lvl:expr ) => ( + ($lvl:expr) => ( $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: module_path!(), $lvl, { }) ); diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index c2eafb1b02..3dca448fe0 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -14,10 +14,6 @@ fn level_and_target() { .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 } @@ -30,10 +26,4 @@ fn level_and_target() { assert!(tracing::enabled!(target: "debug_module", Level::DEBUG)); assert!(tracing::enabled!(Level::ERROR)); assert!(!tracing::enabled!(Level::DEBUG)); - - // Ensure that the `_event` and `_span` alternatives work corretly - assert!(!tracing::event_enabled!(Level::TRACE)); - assert!(tracing::event_enabled!(Level::DEBUG)); - - assert!(tracing::span_enabled!(Level::TRACE)); } diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs index 2013c9c011..a9679a3e94 100644 --- a/tracing/tests/macros.rs +++ b/tracing/tests/macros.rs @@ -346,13 +346,34 @@ fn enabled() { enabled!(Level::DEBUG); enabled!(target: "rando", Level::DEBUG); enabled!(target: "rando", Level::DEBUG, field); +} - span_enabled!(target: "rando", Level::DEBUG, field); - event_enabled!(target: "rando", Level::DEBUG, field); +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] +#[test] +fn span_enabled() { + span_enabled!(Level::DEBUG, foo, bar.baz, quux,); + span_enabled!(Level::DEBUG, message); + span_enabled!(Level::INFO, foo, bar.baz, quux, message,); + span_enabled!(Level::INFO, foo, bar., message,); + span_enabled!(Level::DEBUG, foo); - // other cases span_enabled!(Level::DEBUG); - span_enabled!(Level::DEBUG, foo, bar.baz, quux,); + span_enabled!(target: "rando", Level::DEBUG); + span_enabled!(target: "rando", Level::DEBUG, field); +} + +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] +#[test] +fn event_enabled() { + event_enabled!(Level::DEBUG, foo, bar.baz, quux,); + event_enabled!(Level::DEBUG, message); + event_enabled!(Level::INFO, foo, bar.baz, quux, message,); + event_enabled!(Level::INFO, foo, bar., message,); + event_enabled!(Level::DEBUG, foo); + + event_enabled!(Level::DEBUG); + event_enabled!(target: "rando", Level::DEBUG); + event_enabled!(target: "rando", Level::DEBUG, field); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] diff --git a/tracing/tests/specific_enabled.rs b/tracing/tests/specific_enabled.rs new file mode 100644 index 0000000000..9617d5db12 --- /dev/null +++ b/tracing/tests/specific_enabled.rs @@ -0,0 +1,38 @@ +// liballoc is required because the test subscriber cannot be constructed +// statically +#![cfg(feature = "alloc")] + +mod support; + +use self::support::*; +use tracing::Level; + +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] +#[test] +fn span_and_event() { + let collector = collector::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(); + + tracing::collect::set_global_default(collector).unwrap(); + + // Ensure that the `_event` and `_span` alternatives work corretly + assert!(!tracing::event_enabled!(Level::TRACE)); + assert!(tracing::event_enabled!(Level::DEBUG)); + assert!(tracing::span_enabled!(Level::TRACE)); + + // target variants + assert!(tracing::span_enabled!(target: "debug_module", Level::DEBUG)); + assert!(tracing::event_enabled!(target: "debug_module", Level::DEBUG)); +} From 704ecf7392d858899261773533a47767ef7e3a49 Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Tue, 8 Feb 2022 14:38:03 -0800 Subject: [PATCH 7/9] more doc tests --- tracing/src/macros.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index 80c1843cab..2d04d39322 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -816,6 +816,14 @@ macro_rules! event { /// if event_enabled!(target: "my_crate", Level::DEBUG) { /// // some expensive work... /// } +/// // simpler +/// if event_enabled!(Level::DEBUG) { +/// // some expensive work... +/// } +/// // with fields +/// if event_enabled!(Level::DEBUG, foo_field) { +/// // some expensive work... +/// } /// ``` /// #[macro_export] @@ -840,6 +848,14 @@ macro_rules! event_enabled { /// if span_enabled!(target: "my_crate", Level::DEBUG) { /// // some expensive work... /// } +/// // simpler +/// if span_enabled!(Level::DEBUG) { +/// // some expensive work... +/// } +/// // with fields +/// if span_enabled!(Level::DEBUG, foo_field) { +/// // some expensive work... +/// } /// ``` /// #[macro_export] From 1b0d66e872a2c7f70297e34ce1c232c3bed91629 Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Tue, 8 Feb 2022 14:41:38 -0800 Subject: [PATCH 8/9] cleanup .hint usage --- tracing/src/macros.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index 2d04d39322..aa6930943d 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -829,7 +829,7 @@ macro_rules! event { #[macro_export] macro_rules! event_enabled { ($($rest:tt)*)=> ( - $crate::enabled!(kind: $crate::metadata::Kind::EVENT.hint(), $($rest)*) + $crate::enabled!(kind: $crate::metadata::Kind::EVENT, $($rest)*) ) } @@ -861,7 +861,7 @@ macro_rules! event_enabled { #[macro_export] macro_rules! span_enabled { ($($rest:tt)*)=> ( - $crate::enabled!(kind: $crate::metadata::Kind::SPAN.hint(), $($rest)*) + $crate::enabled!(kind: $crate::metadata::Kind::SPAN, $($rest)*) ) } @@ -966,7 +966,7 @@ macro_rules! enabled { ":", line!() ), - kind: $kind, + kind: $kind.hint(), target: $target, level: $lvl, fields: $($fields)* From 1d3e8db1a8d796ef1a8436aeb811a7d36ae20dc0 Mon Sep 17 00:00:00 2001 From: Gus Wynn Date: Wed, 9 Feb 2022 14:16:14 -0800 Subject: [PATCH 9/9] merge tests with set_default --- tracing/tests/enabled.rs | 32 +++++++++++++++++++++++++- tracing/tests/specific_enabled.rs | 38 ------------------------------- 2 files changed, 31 insertions(+), 39 deletions(-) delete mode 100644 tracing/tests/specific_enabled.rs diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index 3dca448fe0..fbf6b3f487 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -21,9 +21,39 @@ fn level_and_target() { .done() .run(); - tracing::collect::set_global_default(collector).unwrap(); + let _guard = tracing::collect::set_default(collector); assert!(tracing::enabled!(target: "debug_module", Level::DEBUG)); assert!(tracing::enabled!(Level::ERROR)); assert!(!tracing::enabled!(Level::DEBUG)); } + +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] +#[test] +fn span_and_event() { + let collector = collector::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(); + + let _guard = tracing::collect::set_default(collector); + + // Ensure that the `_event` and `_span` alternatives work corretly + assert!(!tracing::event_enabled!(Level::TRACE)); + assert!(tracing::event_enabled!(Level::DEBUG)); + assert!(tracing::span_enabled!(Level::TRACE)); + + // target variants + assert!(tracing::span_enabled!(target: "debug_module", Level::DEBUG)); + assert!(tracing::event_enabled!(target: "debug_module", Level::DEBUG)); +} diff --git a/tracing/tests/specific_enabled.rs b/tracing/tests/specific_enabled.rs deleted file mode 100644 index 9617d5db12..0000000000 --- a/tracing/tests/specific_enabled.rs +++ /dev/null @@ -1,38 +0,0 @@ -// liballoc is required because the test subscriber cannot be constructed -// statically -#![cfg(feature = "alloc")] - -mod support; - -use self::support::*; -use tracing::Level; - -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] -#[test] -fn span_and_event() { - let collector = collector::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(); - - tracing::collect::set_global_default(collector).unwrap(); - - // Ensure that the `_event` and `_span` alternatives work corretly - assert!(!tracing::event_enabled!(Level::TRACE)); - assert!(tracing::event_enabled!(Level::DEBUG)); - assert!(tracing::span_enabled!(Level::TRACE)); - - // target variants - assert!(tracing::span_enabled!(target: "debug_module", Level::DEBUG)); - assert!(tracing::event_enabled!(target: "debug_module", Level::DEBUG)); -}