Struct Filtered

pub struct Filtered<L, F, S> { /* private fields */ }

A Layer that wraps an inner Layer and adds a Filter which controls what spans and events are enabled for that layer.

This is returned by the Layer::with_filter method. See the documentation on per-layer filtering for details.

Implementations

impl<L, F, S> Filtered<L, F, S>

pub fn new(layer: L, filter: F) -> Self

Wraps the provided Layer so that it is filtered by the given Filter.

This is equivalent to calling the Layer::with_filter method.

See the documentation on per-layer filtering for details.

pub fn filter(&self) -> &F

Borrows the Filter used by this layer.

pub fn filter_mut(&mut self) -> &mut F

Mutably borrows the Filter used by this layer.

When this layer can be mutably borrowed, this may be used to mutate the filter. Generally, this will primarily be used with the reload::Handle::modify method.

Examples

let filtered_layer = fmt::Layer::default().with_filter(filter::LevelFilter::WARN);
let (filtered_layer, reload_handle) = reload::Layer::new(filtered_layer);
info!("This will be ignored");
reload_handle.modify(|layer| *layer.filter_mut() = filter::LevelFilter::INFO);
info!("This will be logged");

pub fn inner(&self) -> &L

Borrows the inner Layer wrapped by this Filtered layer.

pub fn inner_mut(&mut self) -> &mut L

Mutably borrows the inner Layer wrapped by this Filtered layer.

This method is primarily expected to be used with the reload::Handle::modify method.

Examples

let filtered_layer = fmt::layer().with_writer(non_blocking(std::io::stderr())).with_filter(filter::LevelFilter::INFO);
let (filtered_layer, reload_handle) = reload::Layer::new(filtered_layer);
info!("This will be logged to stderr");
reload_handle.modify(|layer| *layer.inner_mut().writer_mut() = non_blocking(std::io::stdout()));
info!("This will be logged to stdout");

Trait Implementations

impl<L: Clone, F: Clone, S: Clone> Clone for Filtered<L, F, S>

fn clone(&self) -> Filtered<L, F, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, L, S> Debug for Filtered<F, L, S>

where F: Debug, L: Debug,

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

Formats the value using the given formatter.

impl<S, L, F> Layer<S> for Filtered<L, F, S>

where S: Subscriber + for<'span> LookupSpan<'span> + 'static, F: Filter<S> + 'static, L: Layer<S>,

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 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 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 on_new_span(&self, attrs: &Attributes<'_>, id: &Id, cx: 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<'_>, cx: 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, cx: 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<'_>, cx: Context<'_, S>) -> bool

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

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

Notifies this layer that an event has occurred.

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

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

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

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

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

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

fn on_id_change(&self, old: &Id, new: &Id, cx: 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.

fn boxed(self) -> Box<dyn Layer<S> + Send + Sync + 'static>

where Self: Sized + Layer<S> + Send + Sync + 'static, S: Subscriber,

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