Struct tracing_opentelemetry::OpenTelemetryLayer

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

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 opentelemetry::{api::Provider, 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::AlwaysOn),
        ..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::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 opentelemetry::{api::Provider, sdk};
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::AlwaysOn),
        ..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 = 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);

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 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_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_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 Unknown, signaling that an error has occurred.

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

Exports an OpenTelemetry Span on close.

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