Struct tracing_opentelemetry::OpenTelemetryLayer

pub struct OpenTelemetryLayer<S, T: Tracer> { /* fields omitted */ }

OpenTelemetry layer for use in a project that uses tracing.

Methods

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

pub fn with_tracer(tracer: T) -> Self

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

use opentelemetry::{api::Provider, global, sdk};
use tracing_opentelemetry::OpenTelemetryLayer;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;

// Create a jaeger exporter for a `trace-demo` service.
let exporter = opentelemetry_jaeger::Exporter::builder()
    .with_agent_endpoint("127.0.0.1:6831".parse().unwrap())
    .with_process(opentelemetry_jaeger::Process {
        service_name: "trace_demo".to_string(),
        tags: Vec::new(),
    })
    .init().expect("Error initializing Jaeger exporter");

// Build a provider from the jaeger exporter that always samples.
let provider = sdk::Provider::builder()
    .with_simple_exporter(exporter)
    .with_config(sdk::Config {
        default_sampler: Box::new(sdk::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 otel_layer = OpenTelemetryLayer::with_tracer(tracer);

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

Trait Implementations

impl<S, T> Layer<S> for OpenTelemetryLayer<S, 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.

unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>

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