Struct tracing_subscriber::filter::DynFilterFn
source · [−]pub struct DynFilterFn<S, F = fn(_: &Metadata<'_>, _: &Context<'_, S>) -> bool, R = fn(_: &'static Metadata<'static>) -> Interest> { /* private fields */ }
Expand description
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
sourceimpl<S, F> DynFilterFn<S, F> where
F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
impl<S, F> DynFilterFn<S, F> where
F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
sourcepub fn new(enabled: F) -> Self
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
Filter
s.
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");
});
sourceimpl<S, F, R> DynFilterFn<S, F, R> where
F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
impl<S, F, R> DynFilterFn<S, F, R> where
F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
sourcepub fn with_max_level_hint(self, max_level_hint: impl Into<LevelFilter>) -> Self
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();
sourcepub fn with_callsite_filter<R2>(
self,
callsite_enabled: R2
) -> DynFilterFn<S, F, R2> where
R2: Fn(&'static Metadata<'static>) -> Interest,
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
sourceimpl<S, F, R> Clone for DynFilterFn<S, F, R> where
F: Clone,
R: Clone,
impl<S, F, R> Clone for DynFilterFn<S, F, R> where
F: Clone,
R: Clone,
sourceimpl<S, F, R> Debug for DynFilterFn<S, F, R>
impl<S, F, R> Debug for DynFilterFn<S, F, R>
sourceimpl<S, F, R> Filter<S> for DynFilterFn<S, F, R> where
F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
R: Fn(&'static Metadata<'static>) -> Interest,
impl<S, F, R> Filter<S> for DynFilterFn<S, F, R> where
F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
R: Fn(&'static Metadata<'static>) -> Interest,
sourcefn enabled(&self, metadata: &Metadata<'_>, cx: &Context<'_, S>) -> bool
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
. Read more
sourcefn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest
fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest
sourcefn max_level_hint(&self) -> Option<LevelFilter>
fn max_level_hint(&self) -> Option<LevelFilter>
Returns an optional hint of the highest verbosity level that
this Filter
will enable. Read more
sourcefn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
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
. Read more
sourcefn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>)
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
. Read more
sourcefn on_enter(&self, id: &Id, ctx: Context<'_, S>)
fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
Notifies this filter that a span with the given ID was entered. Read more
sourceimpl<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,
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,
sourcefn enabled(&self, metadata: &Metadata<'_>, cx: Context<'_, S>) -> bool
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
. Read more
sourcefn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
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
. Read more
sourcefn on_layer(&mut self, subscriber: &mut S)
fn on_layer(&mut self, subscriber: &mut S)
Performs late initialization when attaching a Layer
to a
Subscriber
. Read more
sourcefn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
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
. Read more
sourcefn on_record(&self, _span: &Id, _values: &Record<'_>, _ctx: Context<'_, S>)
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
. Read more
sourcefn on_follows_from(&self, _span: &Id, _follows: &Id, _ctx: Context<'_, S>)
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
. Read more
sourcefn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, S>)
fn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, S>)
Notifies this layer that an event has occurred.
sourcefn on_enter(&self, _id: &Id, _ctx: Context<'_, S>)
fn on_enter(&self, _id: &Id, _ctx: Context<'_, S>)
Notifies this layer that a span with the given ID was entered.
sourcefn on_exit(&self, _id: &Id, _ctx: Context<'_, S>)
fn on_exit(&self, _id: &Id, _ctx: Context<'_, S>)
Notifies this layer that the span with the given ID was exited.
sourcefn on_close(&self, _id: Id, _ctx: Context<'_, S>)
fn on_close(&self, _id: Id, _ctx: Context<'_, S>)
Notifies this layer that the span with the given ID has been closed.
sourcefn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, S>)
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. Read more
sourcefn and_then<L>(self, layer: L) -> Layered<L, Self, S> where
L: Layer<S>,
Self: Sized,
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
. Read more
sourcefn with_subscriber(self, inner: S) -> Layered<Self, S> where
Self: Sized,
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
. Read more
sourcefn with_filter<F>(self, filter: F) -> Filtered<Self, F, S> where
Self: Sized,
F: Filter<S>,
fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S> where
Self: Sized,
F: Filter<S>,
Auto Trait Implementations
impl<S, F, R> RefUnwindSafe for DynFilterFn<S, F, R> where
F: RefUnwindSafe,
R: RefUnwindSafe,
impl<S, F, R> Send for DynFilterFn<S, F, R> where
F: Send,
R: Send,
impl<S, F, R> Sync for DynFilterFn<S, F, R> where
F: Sync,
R: Sync,
impl<S, F, R> Unpin for DynFilterFn<S, F, R> where
F: Unpin,
R: Unpin,
impl<S, F, R> UnwindSafe for DynFilterFn<S, F, R> where
F: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more