implement Targets::enabled_for

tracing-subscriber/src/filter/directive.rs

@@ -5,7 +5,7 @@ use alloc::vec;
 use alloc::{string::String, vec::Vec};
 
 use core::{cmp::Ordering, fmt, iter::FromIterator, slice, str::FromStr};
-use tracing_core::Metadata;
+use tracing_core::{Level, Metadata};
 /// Indicates that a string could not be parsed as a filtering directive.
 #[derive(Debug)]
 pub struct ParseError {
@@ -38,6 +38,10 @@ pub(in crate::filter) trait Match {
     fn level(&self) -> &LevelFilter;
 }
 
+pub(in crate::filter) trait TargetMatch: Match {
+    fn cares_about_target(&self, to_check: &str) -> bool;
+}
+
 #[derive(Debug)]
 enum ParseErrorKind {
     #[cfg(feature = "std")]
@@ -80,6 +84,17 @@ impl<T: Match + Ord> DirectiveSet<T> {
         self.directives().filter(move |d| d.cares_about(metadata))
     }
 
+    pub(crate) fn directives_for_target<'a>(
+        &'a self,
+        target: &'a str,
+    ) -> impl Iterator<Item = &'a T> + 'a
+    where
+        T: TargetMatch,
+    {
+        self.directives()
+            .filter(move |d| d.cares_about_target(target))
+    }
+
     pub(crate) fn add(&mut self, directive: T) {
         // does this directive enable a more verbose level than the current
         // max? if so, update the max level.
@@ -142,6 +157,15 @@ impl DirectiveSet<StaticDirective> {
             None => false,
         }
     }
+
+    /// Same as `enabled` above, but short circuits to false if the
+    /// `Directive` has fields
+    pub(crate) fn enabled_for(&self, target: &'static str, level: &Level) -> bool {
+        match self.directives_for_target(target).next() {
+            Some(d) => d.level >= *level,
+            None => false,
+        }
+    }
 }
 
 // === impl StaticDirective ===
@@ -237,6 +261,24 @@ impl Match for StaticDirective {
     }
 }
 
+impl TargetMatch for StaticDirective {
+    fn cares_about_target(&self, to_check: &str) -> bool {
+        // Does this directive have a target filter, and does it match the
+        // metadata's target?
+        if let Some(ref target) = self.target {
+            if !to_check.starts_with(&target[..]) {
+                return false;
+            }
+        }
+
+        if !self.field_names.is_empty() {
+            return false;
+        }
+
+        true
+    }
+}
+
 impl Default for StaticDirective {
     fn default() -> Self {
         StaticDirective {

tracing-subscriber/src/filter/targets.rs

@@ -20,7 +20,7 @@ use core::{
     slice,
     str::FromStr,
 };
-use tracing_core::{Interest, Metadata, Subscriber};
+use tracing_core::{Interest, Level, Metadata, Subscriber};
 
 /// A filter that enables or disables spans and events based on their [target]
 /// and [level].
@@ -313,6 +313,36 @@ impl Targets {
             Interest::never()
         }
     }
+
+    /// Returns whether a [target]-[`Level`] pair would be enabled
+    /// for this `Targets`.
+    ///
+    /// You can use [`module_path!`] from `std` as the target
+    /// if you want to emulate the behavior of the
+    /// [`tracing::event!`] suite of macros.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::filter::{Targets, LevelFilter};
+    /// use tracing_core::Level;
+    ///
+    /// let filter = Targets::new()
+    ///     .with_target("my_crate", Level::INFO)
+    ///     .with_target("my_crate::interesting_module", Level::DEBUG);
+    ///
+    /// assert!(filter.enabled_for("my_crate", &Level::INFO));
+    /// assert!(!filter.enabled_for("my_crate::interesting_module", &Level::TRACE));
+    /// ```
+    ///
+    /// [target]: tracing_core::Metadata::target
+    /// [`tracing::event!`]: tracing::event!
+    /// [`module_path!`]: std::module_path!
+    pub fn enabled_for(&self, target: &'static str, level: &Level) -> bool {
+        // "Correct" to call because `Targets` only produces `StaticDirective`'s with NO
+        // fields
+        self.0.enabled_for(target, level)
+    }
 }
 
 impl<T, L> Extend<(T, L)> for Targets