implement enabled!

tracing-core/src/metadata.rs

@@ -373,6 +373,7 @@ impl<'a> fmt::Debug for Metadata<'a> {
 enum KindInner {
     Event,
     Span,
+    Hint,
 }
 
 impl Kind {
@@ -382,6 +383,11 @@ impl Kind {
     /// `Span` callsite
     pub const SPAN: Kind = Kind(KindInner::Span);
 
+    /// `enabled!` callsite. [`Collect`][`crate::collect::Collect`]s can assume
+    /// this `Kind` means they will never recieve a
+    /// full event with this [`Metadata`].
+    pub const HINT: Kind = Kind(KindInner::Hint);
+
     /// Return true if the callsite kind is `Span`
     pub fn is_span(&self) -> bool {
         matches!(self, Kind(KindInner::Span))
@@ -391,6 +397,11 @@ impl Kind {
     pub fn is_event(&self) -> bool {
         matches!(self, Kind(KindInner::Event))
     }
+
+    /// Return true if the callsite kind is `Hint`
+    pub fn is_hint(&self) -> bool {
+        matches!(self, Kind(KindInner::Hint))
+    }
 }
 
 // ===== impl Level =====

tracing/src/macros.rs

@@ -783,6 +783,97 @@ macro_rules! event {
     );
 }
 
+/// Check's whether an equivalent `event!` invocation would result in an enabled
+/// event.
+///
+/// If you are using this macro to guard a log line that requires expensive computation, it can
+/// result in false-negative's, if the default collector has filters based on line numbers or field
+/// names.
+///
+/// This macro operates similarly to [`event!`], with some extensions:
+/// - Allows passing just a level.
+/// - Allows passing just a level and a target.
+///
+/// See [the top-level documentation][lib] for details on the syntax accepted by
+/// this macro.
+///
+/// [lib]: crate#using-the-macros
+/// [`event!`]: event!
+///
+/// # Examples
+///
+/// ```rust
+/// use tracing::{enabled, Level};
+///
+/// # fn main() {
+/// #   if enabled!(Level::DEBUG, "Debug loggin") {
+/// #       // Do something expensive
+/// #   }
+/// # }
+/// ```
+///
+#[macro_export]
+macro_rules! enabled {
+    (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! {
+                name: concat!(
+                    "enabled ",
+                    file!(),
+                    ":",
+                    line!()
+                ),
+                kind: $crate::metadata::Kind::EVENT,
+                target: $target,
+                level: $lvl,
+                fields: $($fields)*
+            };
+            let interest = CALLSITE.interest();
+            if !interest.is_never() && CALLSITE.is_enabled(interest)  {
+                let meta = CALLSITE.metadata();
+                $crate::dispatch::get_default(|current| current.enabled(meta))
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    });
+    // Just target and level
+    (target: $target:expr, $lvl:expr ) => (
+        $crate::enabled!(target: $target, $lvl, { })
+    );
+
+    // These two cases handle fields with no values
+    (target: $target:expr, $lvl:expr, $($k:ident).+) => (
+        $crate::enabled!(target: $target, $lvl, $($k).+,)
+    );
+    (target: $target:expr, $lvl:expr, $($k:ident).+, $($field:tt)*) => (
+        $crate::enabled!(
+            target: $target,
+            $lvl,
+            { $($k).+, $($field)*}
+        )
+    );
+
+    ($lvl:expr, $($k:ident).+, $($field:tt)*) => (
+        $crate::enabled!(
+            target: module_path!(),
+            $lvl,
+            { $($k).+, $($field)*}
+        )
+    );
+    ($lvl:expr, $($k:ident).+) => (
+        $crate::enabled!($lvl, $($k).+,)
+    );
+
+    // Simplest `enabled!` case
+    ( $lvl:expr ) => (
+        $crate::enabled!(target: module_path!(), $lvl, { })
+    );
+}
+
 /// Constructs an event at the trace level.
 ///
 /// This functions similarly to the [`event!`] macro. See [the top-level

tracing/tests/enabled.rs

@@ -0,0 +1,30 @@
+// 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 level_and_target() {
+    let (collector, handle) = collector::mock()
+        .with_filter(|meta| {
+            if meta.target() == "debug_module" {
+                meta.level() <= &Level::DEBUG
+            } else {
+                meta.level() <= &Level::INFO
+            }
+        })
+        .done()
+        .run_with_handle();
+
+    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();
+}

tracing/tests/macros.rs

@@ -1,6 +1,6 @@
 #![deny(warnings)]
 use tracing::{
-    callsite, debug, debug_span, error, error_span, event, info, info_span, span, trace,
+    callsite, debug, debug_span, enabled, error, error_span, event, info, info_span, span, trace,
     trace_span, warn, warn_span, Level,
 };
 
@@ -334,6 +334,19 @@ fn event() {
     event!(Level::DEBUG, foo);
 }
 
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn enabled() {
+    enabled!(Level::DEBUG, foo, bar.baz, quux,);
+    enabled!(Level::DEBUG, message);
+    enabled!(Level::INFO, foo, bar.baz, quux, messaged,);
+    enabled!(Level::DEBUG, foo);
+
+    enabled!(Level::DEBUG);
+    enabled!(target: "rando", Level::DEBUG);
+    enabled!(target: "rando", Level::DEBUG, field);
+}
+
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
 #[test]
 fn locals_with_message() {