Struct FilteredOpenTelemetryLayer 

pub struct FilteredOpenTelemetryLayer<S, T, F> { /* private fields */ }

A layer wrapping a OpenTelemetryLayer, discarding all events filtered out by a given [Filter]. This can be built by calling OpenTelemetryLayer::with_counting_event_filter.

Only events that are not filtered out will be saved as events on the span. All events, including those filtered out, will be counted and the total will be provided in the otel.tracing_event_count field of the exported span.

This is useful when there is large volume of logs outputted by the application and it would be too expensive to export all of them as span events, but it is still desirable to have information whether there is more information in logs for the given span.

Implementations

impl<S, T, F> FilteredOpenTelemetryLayer<S, T, F>

pub fn map_inner<Mapper, S2, T2>( self, mapper: Mapper, ) -> FilteredOpenTelemetryLayer<S2, T2, F>

where Mapper: FnOnce(OpenTelemetryLayer<S, T>) -> OpenTelemetryLayer<S2, T2>, F: Filter<S>,

pub fn with_counting_event_filter<F2>( self, filter: F2, ) -> FilteredOpenTelemetryLayer<S, T, F2>

where F2: Filter<S>,

Trait Implementations

impl<S, T, F> Layer<S> for FilteredOpenTelemetryLayer<S, T, F>

where S: Subscriber + for<'lookup> LookupSpan<'lookup>, OpenTelemetryLayer<S, T>: Layer<S>, F: Filter<S> + 'static,

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<'_>, ctx: 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, 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 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 on_register_dispatch(&self, subscriber: &Dispatch)

Performs late initialization when installing this layer as a Subscriber.

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

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

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>

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

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