Struct ErrorLayer 

pub struct ErrorLayer { /* private fields */ }

Captures tracing events as Sentry error events.

Using this layer alongside the legacy SentryLayer is unsupported. Use either the legacy layer or the individual layers, not both.

Implementations

impl ErrorLayer

pub fn new() -> Self

Creates a layer that captures tracing events as Sentry error events.

Most applications should start with LogLayer, and add this layer if ERROR events should also be captured as Sentry error events. Combine it with BreadcrumbLayer to attach the events leading up to each error.

Filtering

Configure a level filter to limit error-event volume. We recommend capturing only ERROR events, as shown below.

Do not use this layer without a filter. An unfiltered layer captures every tracing event, including DEBUG and TRACE, as a Sentry error event. This can quickly exhaust your Sentry error quota.

use sentry::integrations::tracing::ErrorLayer;
use tracing_subscriber::filter::LevelFilter;

tracing_subscriber::registry()
    .with(ErrorLayer::new().with_filter(LevelFilter::ERROR))
    .init();

// This will be captured ...
tracing::error!("ERROR event");

// ... but this will not be, due to LevelFilter::ERROR being set.
tracing::warn!("WARN event");

Event conversion

With the default converter:

• String, numeric, and boolean fields prefixed with tags. become Sentry tags, with the prefix removed.
• Other data fields are stored in the Rust Tracing Fields context on the Sentry error event.
• Record an error as &dyn std::error::Error to capture its exception type and source chain.

pub fn enable_span_attributes(self) -> Self

Include attributes of parent spans in error events.

We can only include spans captured by a super::SpanLayer on the same subscriber. So, this option only has any effect when the SpanLayer is installed.

Filtering

Parent-span attributes are included only when the span is accepted by both SpanLayer and ErrorLayer. A level filter such as LevelFilter::ERROR therefore omits attributes from less severe spans.

To include attributes from all spans captured by SpanLayer, we recommend accepting all spans in this layer’s filter, while filtering events to the desired level, like so:

use sentry::integrations::tracing::{ErrorLayer, SpanLayer};
use tracing_subscriber::filter::{filter_fn, LevelFilter, FilterExt as _};

tracing_subscriber::registry()
    .with(SpanLayer::new().with_filter(LevelFilter::INFO))
    .with(
        ErrorLayer::new()
            .enable_span_attributes()
            .with_filter(LevelFilter::ERROR.or(filter_fn(|m| m.is_span()))),
    )
    .init();

Including all spans in the error layer filter is safe, because this layer does not send any spans to Sentry.

Trait Implementations

impl Default for ErrorLayer

fn default() -> Self

Returns the “default value” for a type.

impl<S> Layer<S> for ErrorLayer

where S: Subscriber + for<'a> LookupSpan<'a>,

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

Notifies this layer that an event has occurred.

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<'_>, 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 event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, S>) -> bool

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

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 boxed(self) -> Box<dyn Layer<S> + Send + Sync>

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

Available on crate features alloc or std only.

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