implement enabled_span and enabled_event

Author: guswynn

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,29 +961,31 @@ 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)*}
         )
     );
 
     // Simplest `enabled!` case
-    ( $lvl:expr ) => (
-        $crate::enabled!(target: module_path!(), $lvl, { })
+    (kind: $kind:expr, $lvl:expr ) => (
+        $crate::_enabled!(kind: $kind, target: module_path!(), $lvl, { })
     );
 }
 

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));
 }

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)]