Struct tracing_opentelemetry::OpentelemetryLayer

pub struct OpentelemetryLayer<T: Tracer> { /* fields omitted */ }

OpenTelemetry layer for use in a project that uses tracing.

Methods

impl<T: Tracer + 'static> OpentelemetryLayer<T>

pub fn with_tracer(tracer: T) -> Self

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

use opentelemetry::{api::{Sampler, Key, Provider}, exporter::trace::jaeger, global, sdk};
use tracing_opentelemetry::OpentelemetryLayer;

// Create a jaeger exporter for a `trace-demo` service.
let exporter = jaeger::Exporter::builder()
    .with_collector_endpoint("127.0.0.1:6831".parse().unwrap())
    .with_process(jaeger::Process {
        service_name: "trace-demo",
        tags: Vec::new(),
    })
    .init();

// Build a provider from the jaeger exporter that always samples.
let provider = sdk::Provider::builder()
    .with_exporter(exporter)
    .with_config(sdk::Config {
        default_sampler: Sampler::Always,
        ..Default::default()
    })
    .build();

// Get a tracer from the provider for a component
let tracer = provider.get_tracer("component-name");

// Create a layer with the configured tracer
let _layer = OpentelemetryLayer::with_tracer(tracer);

Trait Implementations

impl<S, T> Layer<S> for OpentelemetryLayer<T> where
    S: Subscriber + for<'span> LookupSpan<'span>,
    T: Tracer + 'static, 

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

Creates an OpenTelemetry Span for the corresponding tracing Span. This will attempt to parse the parent context if possible from the given attributes.

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

Record values for the given span.

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

Record logs for the given event.

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

Mark the Span as ended when it is closed.

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_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_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_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>, 

Composes this layer around the given Layer, returning a Layered struct implementing Layer.

fn with_subscriber(self, inner: S) -> Layered<Self, S, S>

Composes this Layer with the given [Subscriber], returning a Layered struct that implements [Subscriber].