Tracing OpenTelemetry

https://docs.rs/tracing-opentelemetry/latest/
Admin
Tracing OpenTelemetry is a Rust crate that connects spans from the tracing framework to...
Tokens:65,639
Snippets:487
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Execute with Started Context

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Ensures the span context is started before executing a closure with the active context.

```rust
fn with_started_cx<U>(&self, otel_data: &mut OtelData, f: &dyn Fn(&OtelContext) -> U) -> U {
        self.start_cx(otel_data);
        match &otel_data.state {
            OtelDataState::Context { current_cx, .. } => prevent_reentrant_call(|| f(current_cx)),
            _ => panic!("OtelDataState should be a Context after starting it; this is a bug!"),
        }
    }
```

--------------------------------

### Start OTel Span Context

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Transitions the span state from a builder to an active context, disabling reentrancy during the process.

```rust
fn start_cx(&self, otel_data: &mut OtelData) {
        if let OtelDataState::Context { .. } = &otel_data.state {
            // If the context is already started, we do nothing.
        } else if let OtelDataState::Builder {
            builder,
            parent_cx,
            status,
        } = take(&mut otel_data.state)
        {
            // We purposefully disable all tracing inside this call. Whoever called this is holding
            // a lock on `OtelData` and this is not reentrant.
            let current_cx = prevent_reentrant_call(|| {
                let mut span = builder.start_with_context(&self.tracer, &parent_cx);
                span.set_status(status);
                parent_cx.with_span(span)
            });

            otel_data.state = OtelDataState::Context { current_cx };
        }
    }
```

--------------------------------

### Handle New Span Creation

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Initializes an OpenTelemetry span when a new tracing span is created, including timing and attribute setup.

```rust
fn on_new_span(&self, attrs: &Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
        let span = ctx.span(id).expect("Span not found, this is a bug");
        let mut extensions = span.extensions_mut();

        if self.tracked_inactivity && extensions.get_mut::<Timings>().is_none() {
            extensions.insert(Timings::new());
        }

        let parent_cx = self.parent_context(attrs, &ctx);
        let mut builder = self
            .tracer
            .span_builder(attrs.metadata().name())
            .with_start_time(crate::time::now());

        let builder_attrs = builder.attributes.get_or_insert(Vec::with_capacity(
            attrs.fields().len() + self.extra_span_attrs(),
        ));

        if self.location {
```

--------------------------------

### Initialize OpenTelemetryLayer with a tracer

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/struct.OpenTelemetryLayer.html

Demonstrates creating an OTLP exporter and initializing the OpenTelemetryLayer using the new constructor.

```rust
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::SdkTracerProvider::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);
```

--------------------------------

### set_parent

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/span_ext.rs.html?search=

Sets the parent context for the current tracing span. This must be called before the span is started.

```APIDOC
## fn set_parent(&self, cx: Context) -> Result<(), SetParentError>

### Description
Sets the parent OpenTelemetry context for the span. If the span has already been started or the OpenTelemetry layer is not found, an error is returned.

### Parameters
- **cx** (Context) - The OpenTelemetry context to set as the parent.

### Returns
- **Result<(), SetParentError>** - Returns Ok(()) on success, or a SetParentError if the operation fails.
```

--------------------------------

### Initialize OpenTelemetryLayer with a Tracer

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Demonstrates creating an OpenTelemetryLayer using the constructor and attaching it to a tracing Registry.

```rust
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::SdkTracerProvider::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);
# drop(subscriber);
```

--------------------------------

### Initialize MetricsLayer

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

Shows how to instantiate the MetricsLayer and add it to a tracing subscriber.

```rust
use tracing_opentelemetry::MetricsLayer;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;
# use opentelemetry_sdk::metrics::SdkMeterProvider;

// Constructing a MeterProvider is out-of-scope for the docs here, but there
// are examples in the opentelemetry repository. See:
// https://github.com/open-telemetry/opentelemetry-rust/blob/dfeac078ff7853e7dc814778524b93470dfa5c9c/examples/metrics-basic/src/main.rs#L7
# let meter_provider: SdkMeterProvider = unimplemented!();

let opentelemetry_metrics =  MetricsLayer::new(meter_provider);
let subscriber = Registry::default().with(opentelemetry_metrics);
tracing::subscriber::set_global_default(subscriber).unwrap();
```

--------------------------------

### OpenTelemetrySpanExt::set_parent

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/span_ext.rs.html?search=std%3A%3Avec

Sets the parent OpenTelemetry context for a tracing span. This must be called before the span is started.

```APIDOC
## fn set_parent(&self, cx: Context) -> Result<(), SetParentError>

### Description
Sets the parent OpenTelemetry context for the current tracing span. If the span has already been started or the OpenTelemetry layer is not found, an error is returned.

### Parameters
- **cx** (Context) - The OpenTelemetry context to set as the parent.

### Returns
- **Result<(), SetParentError>** - Returns Ok(()) on success, or a SetParentError variant (LayerNotFound, AlreadyStarted, SpanDisabled) on failure.
```

--------------------------------

### Publish Metrics via Events

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

Demonstrates how to emit different types of metrics using tracing events with specific prefixes.

```rust
# use tracing::info;
info!(monotonic_counter.foo = 1);
info!(monotonic_counter.bar = 1.1);

info!(counter.baz = 1);
info!(counter.baz = -1);
info!(counter.xyz = 1.1);

info!(histogram.qux = 1);
info!(histogram.abc = -1);
info!(histogram.def = 1.1);

info!(gauge.foo = 1);
info!(gauge.bar = 1.1);
```

--------------------------------

### Configure OpenTelemetryLayer with with_tracer

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/struct.OpenTelemetryLayer.html

Demonstrates configuring the tracer for an OpenTelemetryLayer using the with_tracer builder method.

```rust
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::SdkTracerProvider::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);
```

--------------------------------

### Initialize OpenTelemetry tracing pipeline

Source: https://docs.rs/tracing-opentelemetry/latest/index.html

Configures an OpenTelemetry tracer provider with a simple stdout exporter and integrates it into a tracing subscriber registry.

```rust
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry::trace::{Tracer, TracerProvider as _};
use tracing::{error, span};
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;

// Create a new OpenTelemetry trace pipeline that prints to stdout
let provider = SdkTracerProvider::builder()
    .with_simple_exporter(opentelemetry_stdout::SpanExporter::default())
    .build();
let tracer = provider.tracer("readme_example");

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

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

// Trace executed code
tracing::subscriber::with_default(subscriber, || {
    // Spans will be sent to the configured OpenTelemetry exporter
    let root = span!(tracing::Level::TRACE, "app_start", work_units = 2);
    let _enter = root.enter();

    error!("This event will be logged in the root span.");
});
```

--------------------------------

### Publishing Metrics via tracing::info!

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

How to emit metrics using tracing events with specific prefixes.

```APIDOC
## Publishing Metrics

### Description
Metrics are published by adding key-value pairs to `tracing::Event` macros (like `info!`) using specific prefixes to define the metric type.

### Metric Prefixes
- `monotonic_counter.`: Non-negative increasing counters.
- `counter.`: Counters that can increase or decrease.
- `histogram.`: Statistical distribution of values.
- `gauge.`: Instantaneous values.

### Example
```rust
use tracing::info;

// Monotonic counter
info!(monotonic_counter.foo = 1);

// Counter
info!(counter.baz = 1);

// Histogram
info!(histogram.qux = 1);

// Gauge
info!(gauge.foo = 1);

// With Attributes
info!(monotonic_counter.foo = 1, bar = "baz", qux = 2);
```
```

--------------------------------

### Initialize OpenTelemetry Layer

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Configures a tracing subscriber with the OpenTelemetry layer using the default no-op tracer.

```rust
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;

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

--------------------------------

### Configure OpenTelemetry Layer Options

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=

Methods to toggle metadata inclusion for locations, inactivity tracking, thread info, levels, targets, and context activation.

```rust
pub fn with_location(self, location: bool) -> Self {
        Self { location, ..self }
    }
```

```rust
pub fn with_tracked_inactivity(self, tracked_inactivity: bool) -> Self {
        Self {
            tracked_inactivity,
            ..self
        }
    }
```

```rust
pub fn with_threads(self, threads: bool) -> Self {
        Self {
            with_threads: threads,
            ..self
        }
    }
```

```rust
pub fn with_level(self, level: bool) -> Self {
        Self {
            with_level: level,
            ..self
        }
    }
```

```rust
pub fn with_target(self, target: bool) -> Self {
        Self {
            with_target: target,
            ..self
        }
    }
```

```rust
pub fn with_context_activation(self, context_activation: bool) -> Self {
        Self {
            context_activation,
            ..self
        }
    }
```

--------------------------------

### OpenTelemetryLayer::new

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/struct.OpenTelemetryLayer.html

Creates a new OpenTelemetryLayer instance with the specified tracer.

```APIDOC
## pub fn new(tracer: T) -> Self

### Description
Creates a new OpenTelemetryLayer that uses the provided tracer to produce and track OpenTelemetry spans.

### Parameters
- **tracer** (T) - Required - The tracer implementation to use for span tracking.
```

--------------------------------

### Configuration Methods

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/struct.OpenTelemetryLayer.html?search=

Methods to configure span and event metadata attributes and context behavior.

```APIDOC
## with_location(location: bool) -> Self
Sets whether span and event metadata include OpenTelemetry attributes for file, module, and line number. Enabled by default.

## with_tracked_inactivity(tracked_inactivity: bool) -> Self
Sets whether span metadata includes busy and idle time tracking. Enabled by default.

## with_threads(threads: bool) -> Self
Sets whether spans record thread name and thread ID attributes. Enabled by default.

## with_level(level: bool) -> Self
Sets whether span metadata includes the tracing verbosity level. Disabled by default.

## with_target(target: bool) -> Self
Sets whether span metadata includes the tracing target attribute. Enabled by default.

## with_context_activation(context_activation: bool) -> Self
Sets whether an OpenTelemetry Context is activated on span entry. Enabled by default.
```

--------------------------------

### Establish Follows-From Relationship

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Demonstrates how to link spans using the 'follows_from' relationship with optional context activation.

```rust
    #[test]
    fn follows_from_adds_link_with_context_activation() {
        follows_from_adds_link_impl(true);
    }

    #[test]
    fn follows_from_adds_link_no_context_activation() {
        follows_from_adds_link_impl(false);
    }

    fn follows_from_adds_link_impl(context_activation: bool) {
        use crate::OpenTelemetrySpanExt;
        let mut tracer = TestTracer::default();
        let subscriber = tracing_subscriber::registry().with(
            layer()
                .with_tracer(tracer.clone())
                .with_context_activation(context_activation),
        );

        let span1_id = tracing::subscriber::with_default(subscriber, || {
            let span2 = tracing::debug_span!("span2");
            let span1 = tracing::debug_span!("span1");

            // Ensure that span2 is started
            let _ = span2.context();

            // Establish follows_from relationship
            span2.follows_from(&span1);

            // Enter span2 to ensure it's exported
            let _guard = span2.enter();

            // Get span ID for later verification
            span1.context().span().span_context().span_id()
        });

        let spans = tracer.spans();
```

--------------------------------

### Constructing an OpenTelemetry layer

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/fn.layer.html

Initializes a tracing subscriber with the OpenTelemetry layer. Requires a subscriber that implements LookupSpan, such as the Registry.

```rust
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;

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

--------------------------------

### Configure Event Filtering and Counting

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=

Demonstrates how to apply event filters to a tracing layer and verify the count of recorded events on a span.

```rust
    #[test]
    #[cfg(not(__reentrant_tracing_test))] // The counts would be wrong
    fn event_filter_count() {
        let mut tracer = TestTracer::default();
        let subscriber = tracing_subscriber::registry().with(
            layer()
                .with_tracer(tracer.clone())
                .with_counting_event_filter(LevelFilter::INFO)
                .with_filter(LevelFilter::DEBUG),
        );

        tracing::subscriber::with_default(subscriber, || {
            tracing::debug_span!("test span").in_scope(|| {
                tracing::event!(tracing::Level::TRACE, "1");
                tracing::event!(tracing::Level::DEBUG, "2");
                tracing::event!(tracing::Level::INFO, "3");
                tracing::event!(tracing::Level::WARN, "4");
                tracing::event!(tracing::Level::ERROR, "5");
            });
        });

        let events = tracer.with_data(|data| data.events.clone());

        let mut iter = events.iter();

        assert_eq!(iter.next().unwrap().name, "3");
        assert_eq!(iter.next().unwrap().name, "4");
        assert_eq!(iter.next().unwrap().name, "5");
        assert!(iter.next().is_none());

        let spans = tracer.spans();
        assert_eq!(spans.len(), 1);

        let Value::I64(event_count) = spans
            .first()
            .unwrap()
            .attributes
            .iter()
            .find(|key_value| key_value.key.as_str() == SPAN_EVENT_COUNT_FIELD)
            .unwrap()
            .value
        else {
            panic!("Unexpected type of `{SPAN_EVENT_COUNT_FIELD}`.");
        };
        // We've sent 5 events out of which 1 was filtered out by an actual filter and another by
        // our event filter.
        assert_eq!(event_count, 4);
    }
```

--------------------------------

### Record Span Attributes and Initialize OtelData

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Extracts metadata and thread information to populate span attributes, then initializes the OpenTelemetry span builder and stores it in span extensions.

```rust
let meta = attrs.metadata();

            if let Some(filename) = meta.file() {
                builder_attrs.push(KeyValue::new("code.file.path", filename));
            }

            if let Some(module) = meta.module_path() {
                builder_attrs.push(KeyValue::new("code.module.name", module));
            }

            if let Some(line) = meta.line() {
                builder_attrs.push(KeyValue::new("code.line.number", line as i64));
            }
        }

        if self.with_threads {
            THREAD_ID.with(|id| builder_attrs.push(KeyValue::new("thread.id", *id as i64)));
            if let Some(name) = std::thread::current().name() {
                // TODO(eliza): it's a bummer that we have to allocate here, but
                // we can't easily get the string as a `static`. it would be
                // nice if `opentelemetry` could also take `Arc<str>`s as
                // `String` values...
                builder_attrs.push(KeyValue::new("thread.name", name.to_string()));
            }
        }

        if self.with_level {
            builder_attrs.push(KeyValue::new("level", attrs.metadata().level().as_str()));
        }
        if self.with_target {
            builder_attrs.push(KeyValue::new("target", attrs.metadata().target()));
        }

        let mut updates = SpanBuilderUpdates::default();
        attrs.record(&mut SpanAttributeVisitor {
            span_builder_updates: &mut updates,
            sem_conv_config: self.sem_conv_config,
        });

        let mut status = Status::Unset;
        updates.update(&mut builder, &mut status);
        extensions.insert(OtelDataLock::new(OtelData {
            state: OtelDataState::Builder {
                builder,
                parent_cx,
                status,
            },
            end_time: None,
        }));
    }
```

--------------------------------

### Retrieve and Activate OpenTelemetry Context

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=u32+-%3E+bool

Retrieves the OtelData, activates the context using the layer, and then applies the provided callback.

```rust
fn get_activated_context(
    dispatch: &tracing::Dispatch,
    id: &span::Id,
    f: &mut dyn FnMut(&mut OtelData),
) {
    let layer = dispatch
        .downcast_ref::<OpenTelemetryLayer<S, T>>()
        .expect("layer should downcast to expected type; this is a bug!");

    let subscriber = dispatch
        .downcast_ref::<S>()
        .expect("subscriber should downcast to expected type; this is a bug!");

    let span = subscriber
        .span(id)
        .expect("registry should have a span for the current ID");

    let otel_data = span.extensions().get::<OtelDataLock>().cloned();

    if let Some(otel_data) = otel_data {
        let mut otel_data = otel_data.lock();
        // Activate the context
        layer.start_cx(&mut otel_data);
        f(&mut otel_data);
    }
}
```

--------------------------------

### Integer Handling and Casting

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

Illustrates how the subscriber handles integer types and potential overflow when casting u64 to i64.

```rust
# use tracing::info;
// The subscriber receives an i64
info!(counter.baz = 1);

// The subscriber receives an i64
info!(counter.baz = -1);

// The subscriber receives a u64, but casts it to i64 internally
info!(counter.baz = 1_u64);

// The subscriber receives a u64, but cannot cast it to i64 because of
// overflow. An error is printed to stderr, and the metric is dropped.
info!(counter.baz = (i64::MAX as u64) + 1)
```

--------------------------------

### OpenTelemetryLayer::with_tracer

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/struct.OpenTelemetryLayer.html

Configures the tracer for an existing OpenTelemetryLayer instance.

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

### Description
Sets or updates the tracer used by the layer to produce and track OpenTelemetry spans.

### Parameters
- **tracer** (Tracer) - Required - The new tracer implementation to use.
```

--------------------------------

### Test Tracer Infrastructure

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A mock tracer implementation using InMemorySpanExporter to capture and inspect spans during tests.

```rust
#[derive(Debug, Clone)]
struct TestTracer {
    tracer: opentelemetry_sdk::trace::Tracer,
    exporter: opentelemetry_sdk::trace::InMemorySpanExporter,
}

impl TestTracer {
    fn spans(&mut self) -> Vec<opentelemetry_sdk::trace::SpanData> {
        self.exporter
            .force_flush()
            .expect("problems flushing spans");
        self.exporter
            .get_finished_spans()
            .expect("problems recording spans")
    }

    fn with_data<T>(&mut self, f: impl FnOnce(&opentelemetry_sdk::trace::SpanData) -> T) -> T {
        let spans = self.spans();
        f(spans.first().expect("no spans recorded"))
    }

    fn attributes(&mut self) -> HashMap<String, Value> {
        self.with_data(|data| {
            data.attributes
                .iter()
                .map(|kv| (kv.key.to_string(), kv.value.clone()))
                .collect()
        })
    }
}

impl Default for TestTracer {
    fn default() -> Self {
        let exporter = opentelemetry_sdk::trace::InMemorySpanExporter::default();
        let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
            .with_simple_exporter(exporter.clone())
            .build();
        let tracer = provider.tracer("test-tracer");
        Self { tracer, exporter }
    }
}

impl opentelemetry::trace::Tracer for TestTracer {
    type Span = opentelemetry_sdk::trace::Span;

    fn build_with_context(&self, builder: SpanBuilder, parent_cx: &OtelContext) -> Self::Span {
        self.tracer.build_with_context(builder, parent_cx)
    }
}
```

--------------------------------

### Implement Platform-Specific Time Utilities

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/lib.rs.html?search=std%3A%3Avec

Provides a consistent interface for retrieving the current system time across different platforms, including WASM.

```rust
pub(crate) mod time {
    use std::time::SystemTime;

    #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
    pub(crate) fn now() -> SystemTime {
        SystemTime::now()
    }

    #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
    pub(crate) fn now() -> SystemTime {
        SystemTime::UNIX_EPOCH + std::time::Duration::from_millis(js_sys::Date::now() as u64)
    }
}
```

--------------------------------

### Configure Tracer for OpenTelemetryLayer

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=

Sets the tracer instance for the layer, requiring the tracer to be 'static and its span to be Send + Sync.

```rust
pub fn with_tracer<Tracer>(self, tracer: Tracer) -> OpenTelemetryLayer<S, Tracer>
    where
        Tracer: otel::Tracer + 'static,
        Tracer::Span: Send + Sync,
    {
        OpenTelemetryLayer {
            tracer,
            location: self.location,
            tracked_inactivity: self.tracked_inactivity,
            with_threads: self.with_threads,
            with_level: self.with_level,
            with_target: self.with_target,
            context_activation: self.context_activation,
            sem_conv_config: self.sem_conv_config,
            with_context: WithContext {
                with_context: OpenTelemetryLayer::<S, Tracer>::get_context,
                with_activated_context: OpenTelemetryLayer::<S, Tracer>::get_activated_context,
                with_activated_otel_context:
                    OpenTelemetryLayer::<S, Tracer>::get_activated_otel_context,
            },
            _registry: self._registry,
        }
    }
```

--------------------------------

### MetricsLayer::new

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

Creates a new instance of MetricsLayer, which integrates with an OpenTelemetry MeterProvider to process metrics.

```APIDOC
## MetricsLayer::new

### Description
Creates a new instance of MetricsLayer. This layer filters tracing events and records them as metrics using the provided MeterProvider.

### Signature
`pub fn new<M>(meter_provider: M) -> MetricsLayer<S, M> where M: MeterProvider`

### Parameters
- **meter_provider** (M) - Required - An implementation of the OpenTelemetry MeterProvider trait used to create the meter for instrumenting events.
```

--------------------------------

### Define MetricsLayer and Constructor

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

Defines the MetricsLayer structure and provides a constructor to initialize it with a MeterProvider.

```rust
#[cfg_attr(docsrs, doc(cfg(feature = "metrics")))]
pub struct MetricsLayer<S, M> {
    inner: Filtered<InstrumentLayer, MetricsFilter, S>,
    // We need to hold onto this so that the `InstrumentLayer` can use the created `Meter`.
    _meter_provider: M,
}

impl<S, M> MetricsLayer<S, M>
where
    S: Subscriber + for<'span> LookupSpan<'span>,
{
    /// Create a new instance of MetricsLayer.
    pub fn new(meter_provider: M) -> MetricsLayer<S, M>
    where
        M: MeterProvider,
    {
        let meter = meter_provider.meter_with_scope(
            InstrumentationScope::builder(INSTRUMENTATION_LIBRARY_NAME)
                .with_version(CARGO_PKG_VERSION)
                .build(),
        );

        let layer = InstrumentLayer {
            meter,
            instruments: Default::default(),
        };

        MetricsLayer {
            inner: layer.with_filter(MetricsFilter),
            _meter_provider: meter_provider,
        }
    }
}
```

--------------------------------

### Publishing Metrics via Tracing Events

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html

Describes how to emit metrics by using specific prefixes in tracing events.

```APIDOC
## Publishing Metrics

### Description
Metrics are published by adding key-value pairs to `tracing::Event` macros using specific prefixes to define the metric type.

### Supported Prefixes
- **monotonic_counter.**: For non-negative values that only increase.
- **counter.**: For values that can increase or decrease.
- **histogram.**: For statistically meaningful arbitrary values.
- **gauge.**: For instantaneous values.

### Example
```rust
use tracing::info;

// Counter example
info!(counter.baz = 1);

// Histogram example
info!(histogram.qux = 1);

// Adding attributes
info!(monotonic_counter.foo = 1, bar = "baz", qux = 2);
```
```

--------------------------------

### TestTracer Implementation

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

A mock tracer implementation using an InMemorySpanExporter for testing span recording and attribute verification.

```rust
#[derive(Debug, Clone)]
    struct TestTracer {
        tracer: opentelemetry_sdk::trace::Tracer,
        exporter: opentelemetry_sdk::trace::InMemorySpanExporter,
    }

    impl TestTracer {
        fn spans(&mut self) -> Vec<opentelemetry_sdk::trace::SpanData> {
            self.exporter
                .force_flush()
                .expect("problems flushing spans");
            self.exporter
                .get_finished_spans()
                .expect("problems recording spans")
        }

        fn with_data<T>(&mut self, f: impl FnOnce(&opentelemetry_sdk::trace::SpanData) -> T) -> T {
            let spans = self.spans();
            f(spans.first().expect("no spans recorded"))
        }

        fn attributes(&mut self) -> HashMap<String, Value> {
            self.with_data(|data| {
                data.attributes
                    .iter()
                    .map(|kv| (kv.key.to_string(), kv.value.clone()))
                    .collect()
            })
        }
    }

    impl Default for TestTracer {
        fn default() -> Self {
            let exporter = opentelemetry_sdk::trace::InMemorySpanExporter::default();
            let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
                .with_simple_exporter(exporter.clone())
                .build();
            let tracer = provider.tracer("test-tracer");
            Self { tracer, exporter }
        }
    }

    impl opentelemetry::trace::Tracer for TestTracer {
        type Span = opentelemetry_sdk::trace::Span;

        fn build_with_context(&self, builder: SpanBuilder, parent_cx: &OtelContext) -> Self::Span {
            self.tracer.build_with_context(builder, parent_cx)
        }
    }
```

--------------------------------

### Configure Parent Context for Spans

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Shows how to manually set a parent context for tracing spans using `set_parent`.

```rust
#[test]
    fn parent_context() {
        let mut tracer = TestTracer::default();
        let subscriber = tracing_subscriber::registry().with(layer().with_tracer(tracer.clone()));

        tracing::subscriber::with_default(subscriber, || {
            let root = trace_span!("root");

            let child1 = trace_span!("child-1");
            let root_context = root.context(); // SpanData (None)
            let _ = child1.set_parent(root_context); // Clone context, but SpanData(None)

            let _enter_root = root.enter();
            drop(_enter_root);

            let child2 = trace_span!("child-2");
            let _ = child2.set_parent(root.context());
        });

        // Let's check the spans
        let spans = tracer.spans();
        let parent = spans.iter().find(|span| span.name == "root").unwrap();
        let child1 = spans.iter().find(|span| span.name == "child-1").unwrap();
```

--------------------------------

### Publishing Metrics via tracing::Event

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

How to emit metrics using tracing macros by prefixing field names.

```APIDOC
## Publishing Metrics

### Description
To publish a metric, include a field in a `tracing` event (e.g., `info!`, `debug!`) with one of the following prefixes:

- `monotonic_counter.`: Non-negative increasing counters.
- `counter.`: Counters that can increase or decrease.
- `histogram.`: Statistical distribution values.
- `gauge.`: Instantaneous values.

### Example
```rust
use tracing::info;

// Monotonic counter
info!(monotonic_counter.foo = 1);

// Counter
info!(counter.baz = 1);

// Histogram
info!(histogram.qux = 1);

// Gauge
info!(gauge.foo = 1);

// With attributes
info!(monotonic_counter.foo = 1, bar = "baz", qux = 2);
```
```

--------------------------------

### Verify Dynamic Span Names

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A test case demonstrating how to set dynamic span names using the otel.name attribute.

```rust
#[test]
fn dynamic_span_names() {
    let dynamic_name = "GET http://example.com".to_string();
    let mut tracer = TestTracer::default();
    let subscriber = tracing_subscriber::registry().with(layer().with_tracer(tracer.clone()));

    tracing::subscriber::with_default(subscriber, || {
        tracing::debug_span!("static_name", otel.name = dynamic_name.as_str());
    });
```

--------------------------------

### OpenTelemetryLayer Configuration Methods

Source: https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/struct.OpenTelemetryLayer.html

Methods used to configure the behavior and metadata inclusion of the OpenTelemetryLayer.

```APIDOC
## Configuration Methods

### with_location(location: bool) -> Self
Sets whether span and event metadata include OpenTelemetry attributes for file, module, and line number. Enabled by default.

### with_tracked_inactivity(tracked_inactivity: bool) -> Self
Sets whether span metadata includes busy and idle time tracking. Enabled by default.

### with_threads(threads: bool) -> Self
Sets whether spans record thread name and ID attributes. Enabled by default.

### with_level(level: bool) -> Self
Sets whether span metadata includes the tracing verbosity level. Disabled by default.

### with_target(target: bool) -> Self
Sets whether span metadata includes the tracing target attribute. Enabled by default.

### with_context_activation(context_activation: bool) -> Self
Sets whether an OpenTelemetry Context is activated on span entry. Enabled by default.

### with_counting_event_filter<F: Filter<S>>(filter: F) -> FilteredOpenTelemetryLayer<S, T, F>
Adds a filter for events that counts all events processed by the layer.
```

--------------------------------

### Manage OpenTelemetry Context in Tracing Spans

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=u32+-%3E+bool

Demonstrates attaching context values, verifying retrieval, and ensuring context is not propagated when activation is disabled.

```rust
OtelContext::attach(OtelContext::current_with_value(ValueB("inner")));
assert!(OtelContext::current().get::<ValueA>().is_none());
assert_eq!(OtelContext::current().get(), Some(&ValueB("inner")));

let child = span!(tracing::Level::TRACE, "tokio-tracing-span-child");

// Drop the guard to ensure the context is reverted
drop(_inner_guard);
assert!(OtelContext::current().get::<ValueA>().is_none());
assert!(OtelContext::current().get::<ValueB>().is_none());

// Enter the child span - with context activation disabled,
// the context should NOT be propagated
let _enter_child = child.enter();
assert!(OtelContext::current().get::<ValueA>().is_none());
assert!(OtelContext::current().get::<ValueB>().is_none());
});

// Verify spans were still created and exported
let spans = tracer.spans();
assert_eq!(spans.len(), 2);
assert!(spans
    .iter()
    .any(|span| span.name == "tokio-tracing-span-parent"));
assert!(spans
    .iter()
    .any(|span| span.name == "tokio-tracing-span-child"));
}
```

--------------------------------

### Propagate Context and Verify Span Hierarchy

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Demonstrates attaching values to the OpenTelemetry context and verifying that span parent-child relationships are correctly established across tracing and OpenTelemetry spans.

```rust
assert_eq!(OtelContext::current().get(), Some(&ValueA("outer")));
            let root = span!(tracing::Level::TRACE, "tokio-tracing-span-parent");
            // Drop the guard to ensure the context is cleared
            drop(_outer_guard);
            assert!(OtelContext::current().get::<ValueA>().is_none());
            // Enter the root span, the context should be propagated
            let _enter_root = root.enter();
            assert_eq!(OtelContext::current().get(), Some(&ValueA("outer")));
            // Add another value to the current OpenTelemetry context for the bridge to propagate
            let _inner_guard =
                OtelContext::attach(OtelContext::current_with_value(ValueB("inner")));
            assert_eq!(OtelContext::current().get(), Some(&ValueA("outer")));
            assert_eq!(OtelContext::current().get(), Some(&ValueB("inner")));
            let child = span!(tracing::Level::TRACE, "tokio-tracing-span-child");
            // Drop the guard to ensure the context is reverted
            drop(_inner_guard);
            assert_eq!(OtelContext::current().get(), Some(&ValueA("outer")));
            assert!(OtelContext::current().get::<ValueB>().is_none());
            // Enter the child span, the context should be propagated
            let _enter_child = child.enter();
            assert_eq!(OtelContext::current().get(), Some(&ValueA("outer")));
            assert_eq!(OtelContext::current().get(), Some(&ValueB("inner")));
            // Create an OpenTelemetry span using the OpenTelemetry notion of current
            // span to see check that it is a child of the tokio child span
            let span = tracer
                .tracer
                .span_builder("otel-tracing-span")
                .start(&tracer);
            let _otel_guard = OtelContext::attach(OtelContext::current_with_span(span));
            let child2 = span!(tracing::Level::TRACE, "tokio-tracing-span-child2");
            drop(_otel_guard);
            // Drop the child span, the context should be reverted
            drop(_enter_child);
            assert_eq!(OtelContext::current().get(), Some(&ValueA("outer")));
            assert!(OtelContext::current().get::<ValueB>().is_none());
            // Drop the root span, the context should be reverted
            drop(_enter_root);
            assert!(OtelContext::current().get::<ValueA>().is_none());
            assert!(OtelContext::current().get::<ValueB>().is_none());
            let _ = child2.enter();
        });

        // Let's check the spans
        let spans = tracer.spans();
        let parent = spans
            .iter()
            .find(|span| span.name == "tokio-tracing-span-parent")
            .unwrap();
        let child = spans
            .iter()
            .find(|span| span.name == "tokio-tracing-span-child")
            .unwrap();
        let child2 = spans
            .iter()
            .find(|span| span.name == "tokio-tracing-span-child2")
            .unwrap();
        let otel = spans
            .iter()
            .find(|span| span.name == "otel-tracing-span")
            .unwrap();
        // The tokio parent span should be a root span
        assert_eq!(parent.parent_span_id, otel::SpanId::INVALID);
        // The first tokio child span should have the tokio parent span as parent
        assert_eq!(child.parent_span_id, parent.span_context.span_id());
        // The otel span should have the first tokio child span as parent
        assert_eq!(otel.parent_span_id, child.span_context.span_id());
        // The second tokio child span should have the otel span as parent
        assert_eq!(child2.parent_span_id, otel.span_context.span_id());
    }
```

--------------------------------

### Configure Exception Mapping Methods

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=

Methods to toggle the mapping of error fields, events, and records to OpenTelemetry exception semantic conventions.

```rust
pub fn with_error_fields_to_exceptions(self, error_fields_to_exceptions: bool) -> Self {
        Self {
            sem_conv_config: SemConvConfig {
                error_fields_to_exceptions,
                ..self.sem_conv_config
            },
            ..self
        }
    }
```

```rust
pub fn with_error_events_to_status(self, error_events_to_status: bool) -> Self {
        Self {
            sem_conv_config: SemConvConfig {
                error_events_to_status,
                ..self.sem_conv_config
            },
            ..self
        }
    }
```

```rust
pub fn with_error_events_to_exceptions(self, error_events_to_exceptions: bool) -> Self {
        Self {
            sem_conv_config: SemConvConfig {
                error_events_to_exceptions,
                ..self.sem_conv_config
            },
            ..self
        }
    }
```

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

--------------------------------

### WithContext Struct Methods

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Methods for accessing and activating OpenTelemetry span contexts associated with a tracing span ID.

```rust
impl WithContext {
    ///
    /// Return the OtelData associated with the given spanId.
    ///
    pub(crate) fn with_context(
        &self,
        dispatch: &tracing::Dispatch,
        id: &span::Id,
        mut f: impl FnMut(&mut OtelData),
    ) {
        (self.with_context)(dispatch, id, &mut f)
    }

    ///
    /// If the span associated with the given SpanId has not yet been
    /// built, build it, consuming the span ID.
    ///
    /// Optionally performs additional operations on the OtelData after building.
    ///
    pub(crate) fn with_activated_context(
        &self,
        dispatch: &tracing::Dispatch,
        id: &span::Id,
        mut f: impl FnMut(&mut OtelData),
    ) {
        (self.with_activated_context)(dispatch, id, &mut f)
    }

    ///
    /// Ensures the given SpanId has been activated - that is, created in the OTel side of things,
    /// and had its SpanBuilder consumed - and then provides access to the OtelData associated with it.
    ///
    #[allow(clippy::type_complexity)]
    pub(crate) fn with_activated_otel_context(
        &self,
        dispatch: &tracing::Dispatch,
        id: &span::Id,
        mut f: impl FnMut(&OtelContext),
    ) {
        (self.with_activated_otel_context)(dispatch, id, &mut f)
    }
}
```

--------------------------------

### Handle Follows-From Relationship

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=std%3A%3Avec

Establishes a link between the current span and a 'follows-from' span, ensuring thread safety by managing lock order.

```rust
fn on_follows_from(&self, id: &Id, follows: &Id, ctx: Context<S>) {
        let span = ctx.span(id).expect("Span not found, this is a bug");
        let otel_data = span.extensions().get::<OtelDataLock>().cloned();
        let Some(data) = otel_data else {
            return; // The span must already have been closed by us
        };

        // The follows span may be filtered away (or closed), from this layer,
        // in which case we just drop the data, as opposed to panicking. This
        // uses the same reasoning as `parent_context` above.
        if let Some(follows_span) = ctx.span(follows) {
            let follows_extensions = follows_span.extensions();
            let follows_otel_data = follows_extensions.get::<OtelDataLock>();
            let Some(follows_data) = follows_otel_data else {
                return; // The span must already have been closed by us
            };

            let follows_data = follows_data.clone();
            let mut follows_locked = follows_data.lock();
            // We drop the extensions lock only after locking the inside. This is because we want to
            // hinder potential `close` on the follows span. If we hold one or the other lock, the
            // close implementation cannot progress to remove the span.
            drop(follows_extensions);

            let follows_context =
                self.with_started_cx(&mut follows_locked, &|cx| cx.span().span_context().clone());
            match &mut data.lock().state {
                OtelDataState::Builder { builder, .. } => {
                    if let Some(ref mut links) = builder.links {
                        links.push(otel::Link::with_context(follows_context));
                    } else {
                        builder.links = Some(vec![otel::Link::with_context(follows_context)]);
                    }
                }
                OtelDataState::Context { current_cx, .. } => {
                    prevent_reentrant_call(|| current_cx.span().add_link(follows_context, vec![]));
                }
            }
        }
    }
```

--------------------------------

### Adding Attributes to Metrics

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/metrics.rs.html?search=

Shows how to attach key-value attributes to a metric event.

```rust
# use tracing::info;
// adds attributes bar="baz" and qux=2 to the `foo` counter.
info!(monotonic_counter.foo = 1, bar = "baz", qux = 2);
```

--------------------------------

### Configure Context Activation

Source: https://docs.rs/tracing-opentelemetry/latest/src/tracing_opentelemetry/layer.rs.html?search=u32+-%3E+bool

Enables or disables the activation of an OpenTelemetry Context upon span entry.

```rust
pub fn with_context_activation(self, context_activation: bool) -> Self {
        Self {
            context_activation,
            ..self
        }
    }
```
Tokens:
Raw