Struct FilterFn

pub struct FilterFn<F = fn(_: &Metadata<'_>) -> bool> { /* private fields */ }

A filter implemented by a closure or function pointer that determines whether a given span or event is enabled, based on its Metadata.

This type can be used for both per-subscriber filtering (using its Filter implementation) and global filtering (using its Subscribe implementation).

See the documentation on filtering with subscribers for details.

Implementations

impl<F> FilterFn<F>

where F: Fn(&Metadata<'_>) -> bool,

pub fn new(enabled: F) -> Self

Constructs a FilterFn from a function or closure that returns true if a span or event should be enabled, based on its Metadata.

If determining whether a span or event should be enabled also requires information about the current span context, use DynFilterFn instead.

See the documentation on per-subscriber filtering for details on using Filters.

Examples

use tracing_subscriber::{
    subscribe::{Subscribe, CollectExt},
    filter::FilterFn,
    util::SubscriberInitExt,
};

let my_filter = FilterFn::new(|metadata| {
    // Only enable spans or events with the target "interesting_things"
    metadata.target() == "interesting_things"
});

let my_subscriber = tracing_subscriber::fmt::subscriber();

tracing_subscriber::registry()
    .with(my_subscriber.with_filter(my_filter))
    .init();

// This event will not be enabled.
tracing::warn!("something important but uninteresting happened!");

// This event will be enabled.
tracing::debug!(target: "interesting_things", "an interesting minor detail...");

pub fn with_max_level_hint(self, max_level_hint: impl Into<LevelFilter>) -> Self

Sets the highest verbosity Level the filter function will enable.

The value passed to this method will be returned by this FilterFn’s Filter::max_level_hint method.

If the provided function will not enable all levels, it is recommended to call this method to configure it with the most verbose level it will enable.

Examples

use tracing_subscriber::{
    subscribe::{Subscribe, CollectExt},
    filter::{filter_fn, LevelFilter},
    util::SubscriberInitExt,
};
use tracing_core::Level;

let my_filter = filter_fn(|metadata| {
    // Only enable spans or events with targets starting with `my_crate`
    // and levels at or below `INFO`.
    metadata.level() <= &Level::INFO && metadata.target().starts_with("my_crate")
})
    // Since the filter closure will only enable the `INFO` level and
    // below, set the max level hint
    .with_max_level_hint(LevelFilter::INFO);

let my_subscriber = tracing_subscriber::fmt::subscriber();

tracing_subscriber::registry()
    .with(my_subscriber.with_filter(my_filter))
    .init();

Trait Implementations

impl<F: Clone> Clone for FilterFn<F>

fn clone(&self) -> FilterFn<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F> Debug for FilterFn<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C, F> Filter<C> for FilterFn<F>

where F: Fn(&Metadata<'_>) -> bool,

Available on crate features registry and std only.

fn enabled(&self, metadata: &Metadata<'_>, _: &Context<'_, C>) -> bool

Returns true if this subscriber is interested in a span or event with the given Metadata in the current Context, similarly to Collect::enabled.

fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest

Returns an Interest indicating whether this subscriber will always, sometimes, or never be interested in the given Metadata.

fn max_level_hint(&self) -> Option<LevelFilter>

Returns an optional hint of the highest verbosity level that this Filter will enable.

fn event_enabled(&self, event: &Event<'_>, cx: &Context<'_, S>) -> bool

Called before the filtered subscribers’ on_event, to determine if on_event should be called.

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)

Notifies this filter that a new span was constructed with the given Attributes and Id.

fn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>)

Notifies this filter that a span with the given Id recorded the given values.

fn on_enter(&self, id: &Id, ctx: Context<'_, S>)

Notifies this filter that a span with the given ID was entered.

fn on_exit(&self, id: &Id, ctx: Context<'_, S>)

Notifies this filter that a span with the given ID was exited.

fn on_close(&self, id: Id, ctx: Context<'_, S>)

Notifies this filter that a span with the given ID has been closed.

impl<F> From<F> for FilterFn<F>

where F: Fn(&Metadata<'_>) -> bool,

fn from(enabled: F) -> Self

Converts to this type from the input type.

impl<C, F> Subscribe<C> for FilterFn<F>

where F: Fn(&Metadata<'_>) -> bool + 'static, C: Collect,

fn enabled(&self, metadata: &Metadata<'_>, _: Context<'_, C>) -> bool

Returns true if this subscriber is interested in a span or event with the given metadata in the current Context, similarly to Collect::enabled.

fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest

Registers a new callsite with this subscriber, returning whether or not the subscriber is interested in being notified about the callsite, similarly to Collect::register_callsite.

fn on_register_dispatch(&self, collector: &Dispatch)

Performs late initialization when installing this subscriber as a collector.

fn on_subscribe(&mut self, collector: &mut C)

Performs late initialization when attaching a subscriber to a collector.

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, C>)

Notifies this subscriber that a new span was constructed with the given Attributes and Id.

fn on_record(&self, _span: &Id, _values: &Record<'_>, _ctx: Context<'_, C>)

Notifies this subscriber that a span with the given Id recorded the given values.

fn on_follows_from(&self, _span: &Id, _follows: &Id, _ctx: Context<'_, C>)

Notifies this subscriber that a span with the ID span recorded that it follows from the span with the ID follows.

fn event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, C>) -> bool

Called before on_event, to determine if on_event should be called.

fn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, C>)

Notifies this subscriber that an event has occurred.

fn on_enter(&self, _id: &Id, _ctx: Context<'_, C>)

Notifies this subscriber that a span with the given ID was entered.

fn on_exit(&self, _id: &Id, _ctx: Context<'_, C>)

Notifies this subscriber that the span with the given ID was exited.

fn on_close(&self, _id: Id, _ctx: Context<'_, C>)

Notifies this subscriber that the span with the given ID has been closed.

fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, C>)

Notifies this subscriber that a span ID has been cloned, and that the subscriber returned a different ID.

fn and_then<S>(self, subscriber: S) -> Layered<S, Self, C>

where S: Subscribe<C>, Self: Sized,

Composes this subscriber around the given collector, returning a Layered struct implementing Subscribe.

fn with_collector(self, inner: C) -> Layered<Self, C>

where Self: Sized,

Composes this subscriber with the given collector, returning a Layered struct that implements Collect.

fn with_filter<F>(self, filter: F) -> Filtered<Self, F, C>

where Self: Sized, F: Filter<C>,

Available on crate features registry and std only.

Combines self with a Filter, returning a Filtered subscriber.

fn boxed(self) -> Box<dyn Subscribe<C> + Send + Sync + 'static>

where Self: Sized + Subscribe<C> + Send + Sync + 'static, C: Collect,

Available on crate features alloc or std only.

Erases the type of this subscriber, returning a Boxed dyn Subscribe trait object.