Struct OpenTelemetryLayer

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

An OpenTelemetry propagation layer for use in a project that uses tracing.

Implementations

impl<S, T> OpenTelemetryLayer<S, T>

where S: Subscriber + for<'span> LookupSpan<'span>, T: Tracer + PreSampledTracer + 'static,

pub fn new(tracer: T) -> Self

Set the Tracer that this layer will use to produce and track OpenTelemetry Spans.

Examples

use tracing_opentelemetry::OpenTelemetryLayer;
use tracing_subscriber::layer::SubscriberExt;
use opentelemetry::trace::TracerProvider as _;
use tracing_subscriber::Registry;

// Create an OTLP pipeline exporter for a `trace_demo` service.

let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .build()
    .unwrap();

let tracer = opentelemetry_sdk::trace::TracerProvider::builder()
    .with_simple_exporter(otlp_exporter)
    .build()
    .tracer("trace_demo");

// Create a layer with the configured tracer
let otel_layer = OpenTelemetryLayer::new(tracer);

// Use the tracing subscriber `Registry`, or any other subscriber
// that impls `LookupSpan`
let subscriber = Registry::default().with(otel_layer);

pub fn with_tracer<Tracer>( self, tracer: Tracer, ) -> OpenTelemetryLayer<S, Tracer>

where Tracer: Tracer + PreSampledTracer + 'static,

Set the Tracer that this layer will use to produce and track OpenTelemetry Spans.

Examples

use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;
use opentelemetry::trace::TracerProvider;

// Create an OTLP pipeline exporter for a `trace_demo` service.

let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .build()
    .unwrap();

let tracer = opentelemetry_sdk::trace::TracerProvider::builder()
    .with_simple_exporter(otlp_exporter)
    .build()
    .tracer("trace_demo");

// Create a layer with the configured tracer
let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);

// Use the tracing subscriber `Registry`, or any other subscriber
// that impls `LookupSpan`
let subscriber = Registry::default().with(otel_layer);

pub fn with_error_fields_to_exceptions( self, error_fields_to_exceptions: bool, ) -> Self

Sets whether or not span and event metadata should include OpenTelemetry exception fields such as exception.message and exception.backtrace when an Error value is recorded. If multiple error values are recorded on the same span/event, only the most recently recorded error value will show up under these fields.

These attributes follow the OpenTelemetry semantic conventions for exceptions.

By default, these attributes are recorded. Note that this only works for (dyn Error + 'static). See Implementations on Foreign Types of tracing::Value or OpenTelemetryLayer::with_error_events_to_exceptions

pub fn with_error_events_to_status(self, error_events_to_status: bool) -> Self

Sets whether or not an event considered for exception mapping (see [OpenTelemetryLayer::with_error_recording]) should be propagated to the span status error description.

By default, these events do set the span status error description.

pub fn with_error_events_to_exceptions( self, error_events_to_exceptions: bool, ) -> Self

Sets whether or not a subset of events following the described schema are mapped to events following the OpenTelemetry semantic conventions for exceptions.

• Only events without a message field (unnamed events) and at least one field with the name error are considered for mapping.

By default, these events are mapped.

pub fn with_error_records_to_exceptions( self, error_records_to_exceptions: bool, ) -> Self

Sets whether or not reporting an Error value on an event will propagate the OpenTelemetry exception fields such as exception.message and exception.backtrace to the corresponding span. You do not need to enable with_exception_fields in order to enable this. If multiple error values are recorded on the same span/event, only the most recently recorded error value will show up under these fields.

These attributes follow the OpenTelemetry semantic conventions for exceptions.

By default, these attributes are propagated to the span. Note that this only works for (dyn Error + 'static). See Implementations on Foreign Types of tracing::Value or OpenTelemetryLayer::with_error_events_to_exceptions

pub fn with_location(self, location: bool) -> Self

Sets whether or not span and event metadata should include OpenTelemetry attributes with location information, such as the file, module and line number.

These attributes follow the OpenTelemetry semantic conventions for source locations.

By default, locations are enabled.

pub fn with_tracked_inactivity(self, tracked_inactivity: bool) -> Self

Sets whether or not spans metadata should include the busy time (total time for which it was entered), and idle time (total time the span existed but was not entered).

pub fn with_threads(self, threads: bool) -> Self

Sets whether or not spans record additional attributes for the thread name and thread ID of the thread they were created on, following the OpenTelemetry semantic conventions for threads.

By default, thread attributes are enabled.

pub fn with_level(self, level: bool) -> Self

Sets whether or not span metadata should include the tracing verbosity level information as a level field.

The level is always added to events, and based on OpenTelemetryLayer::with_error_events_to_status error-level events will mark the span status as an error.

By default, level information is disabled.

Trait Implementations

impl<S> Default for OpenTelemetryLayer<S, NoopTracer>

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

fn default() -> Self

Returns the “default value” for a type.

impl<S, T> Layer<S> for OpenTelemetryLayer<S, T>

where S: Subscriber + for<'span> LookupSpan<'span>, T: Tracer + PreSampledTracer + 'static,

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)

Creates an OpenTelemetry Span for the corresponding tracing Span.

fn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>)

Record OpenTelemetry attributes for the given values.

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

Records OpenTelemetry Event data on event.

Note: an ERROR-level event will also set the OpenTelemetry span status code to Error, signaling that an error has occurred.

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

Exports an OpenTelemetry Span on close.

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

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

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 with_filter<F>(self, filter: F) -> Filtered<Self, F, S>

where Self: Sized, F: Filter<S>,

Available on crate features registry and std only.

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,

Available on crate features alloc or std only.

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