Struct LogLayer 

pub struct LogLayer { /* private fields */ }

Available on crate feature logs only.

Captures tracing events as Sentry logs.

Captures all event levels unless a filter is configured; see LogLayer::new for the recommended level filter.

Logs are sent by default, unless disabled.

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

Implementations

impl LogLayer

pub fn new() -> Self

Creates a layer that captures Sentry logs from tracing events.

Filtering

Without a filter, this layer captures logs at every level. Configure a level filter to limit log volume. We recommend capturing logs at the INFO level, and more severe.

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

tracing_subscriber::registry()
    .with(LogLayer::new().with_filter(LevelFilter::INFO))
    .init();

// This will be captured ...
tracing::info!("INFO log");

// ... but this will not be, due to LevelFilter::INFO being set.
tracing::debug!("DEBUG log");

pub fn enable_span_attributes(self) -> Self

Include attributes of parent spans in logs.

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 LogLayer.

If LogLayer uses a stricter level filter, attributes from less severe spans are omitted. For example, this captures logs at WARN and more severe levels while allowing attributes from INFO parent spans to appear on those logs:

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

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

No filter adjustment is needed when both layers use the same level filter, such as the INFO level recommended for most applications.

Trait Implementations

impl Default for LogLayer

fn default() -> Self

Returns the “default value” for a type.

impl<S> Layer<S> for LogLayer

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.