Struct tracing_subscriber::filter::DynFilterFn

pub struct DynFilterFn<S, F = fn(_: &Metadata<'_>, _: &Context<'_, S>) -> bool, R = fn(_: &'static Metadata<'static>) -> Interest> { /* private fields */ }

A filter implemented by a closure or function pointer that determines whether a given span or event is enabled dynamically, potentially based on the current span context.

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

See the documentation on filtering with layers for details.

Implementations

impl<S, F> DynFilterFn<S, F>

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

pub fn new(enabled: F) -> Self

Constructs a Filter from a function or closure that returns true if a span or event should be enabled in the current span context.

Unlike FilterFn, a DynFilterFn is constructed from a closure or function pointer that takes both the Metadata for a span or event and the current Context. This means that a DynFilterFn can choose whether to enable spans or events based on information about the current span (or its parents).

If this is not necessary, use FilterFn instead.

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

Examples

use tracing_subscriber::{
    layer::{Layer, SubscriberExt},
    filter::DynFilterFn,
    util::SubscriberInitExt,
};

// Only enable spans or events within a span named "interesting_span".
let my_filter = DynFilterFn::new(|metadata, cx| {
    // If this *is* "interesting_span", make sure to enable it.
    if metadata.is_span() && metadata.name() == "interesting_span" {
        return true;
    }

    // Otherwise, are we in an interesting span?
    if let Some(current_span) = cx.lookup_current() {
        return current_span.name() == "interesting_span";
    }

    false
});

let my_layer = tracing_subscriber::fmt::layer();

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

// This event will not be enabled.
tracing::info!("something happened");

tracing::info_span!("interesting_span").in_scope(|| {
    // This event will be enabled.
    tracing::debug!("something else happened");
});

impl<S, F, R> DynFilterFn<S, F, R>

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

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 DynFilterFn’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::{
    layer::{Layer, SubscriberExt},
    filter::{DynFilterFn, LevelFilter},
    util::SubscriberInitExt,
};
use tracing_core::Level;

// Only enable spans or events with levels at or below `INFO`, if
// we are inside a span called "interesting_span".
let my_filter = DynFilterFn::new(|metadata, cx| {
    // If the level is greater than INFO, disable it.
    if metadata.level() > &Level::INFO {
        return false;
    }

    // If any span in the current scope is named "interesting_span",
    // enable this span or event.
    for span in cx.lookup_current().iter().flat_map(|span| span.scope()) {
        if span.name() == "interesting_span" {
            return true;
         }
    }

    // Otherwise, disable it.
    false
})
    // 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_layer = tracing_subscriber::fmt::layer();

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

pub fn with_callsite_filter<R2>( self, callsite_enabled: R2, ) -> DynFilterFn<S, F, R2>

where R2: Fn(&'static Metadata<'static>) -> Interest,

Adds a function for filtering callsites to this filter.

When this filter’s Filter::callsite_enabled method is called, the provided function will be used rather than the default.

By default, DynFilterFn assumes that, because the filter may depend dynamically on the current span context, its result should never be cached. However, some filtering strategies may require dynamic information from the current span context in some cases, but are able to make static filtering decisions from Metadata alone in others.

For example, consider the filter given in the example for DynFilterFn::new. That filter enables all spans named “interesting_span”, and any events and spans that occur inside of an interesting span. Since the span’s name is part of its static Metadata, the “interesting_span” can be enabled in callsite_enabled:

use tracing_subscriber::{
    layer::{Layer, SubscriberExt},
    filter::DynFilterFn,
    util::SubscriberInitExt,
};
use tracing_core::subscriber::Interest;

// Only enable spans or events within a span named "interesting_span".
let my_filter = DynFilterFn::new(|metadata, cx| {
    // If this *is* "interesting_span", make sure to enable it.
    if metadata.is_span() && metadata.name() == "interesting_span" {
        return true;
    }

    // Otherwise, are we in an interesting span?
    if let Some(current_span) = cx.lookup_current() {
        return current_span.name() == "interesting_span";
    }

    false
}).with_callsite_filter(|metadata| {
    // If this is an "interesting_span", we know we will always
    // enable it.
    if metadata.is_span() && metadata.name() == "interesting_span" {
        return Interest::always();
    }

    // Otherwise, it depends on whether or not we're in an interesting
    // span. You'll have to ask us again for each span/event!
    Interest::sometimes()
});

let my_layer = tracing_subscriber::fmt::layer();

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

Trait Implementations

impl<S, F, R> Clone for DynFilterFn<S, F, R>

where F: Clone, R: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, F, R> Debug for DynFilterFn<S, F, R>

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

Formats the value using the given formatter.

impl<S, F, R> Filter<S> for DynFilterFn<S, F, R>

where F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool, R: Fn(&'static Metadata<'static>) -> Interest,

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

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

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

Returns an Interest indicating whether this layer 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 [Layer]'s [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, S> From<F> for DynFilterFn<S, F>

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

fn from(f: F) -> Self

Converts to this type from the input type.

impl<S, F, R> Layer<S> for DynFilterFn<S, F, R>

where F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool + 'static, R: Fn(&'static Metadata<'static>) -> Interest + 'static, S: Subscriber,

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

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

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

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

fn on_register_dispatch(&self, subscriber: &Dispatch)

Performs late initialization when installing this layer as a Subscriber.

fn on_layer(&mut self, subscriber: &mut S)

Performs late initialization when attaching a Layer to a Subscriber.

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

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

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

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

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

Notifies this layer 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<'_, S>) -> bool

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

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

Notifies this layer that an event has occurred.

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

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

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

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

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

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

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

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

fn and_then<L>(self, layer: L) -> Layered<L, Self, S>

where L: Layer<S>, Self: Sized,

Composes this layer around the given Layer, returning a Layered struct implementing Layer.

fn with_subscriber(self, inner: S) -> Layered<Self, S>

where Self: Sized,

Composes this Layer with the given Subscriber, returning a Layered struct that implements Subscriber.

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

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

Combines self with a Filter, returning a Filtered layer.