OpenTelemetry

https://docs.rs/opentelemetry/latest/
Admin
OpenTelemetry is a Rust crate that implements the OpenTelemetry API for distributed tracing,...
Tokens:246,601
Snippets:2,262
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Getting Started with Traces in Rust

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/lib.rs.html

Demonstrates how to get a tracer, start a new span, set attributes, and end the span to export trace data. Ensure the 'trace' feature is enabled.

```rust
# #[cfg(feature = "trace")]
# {
use opentelemetry::{global, trace::{Span, Tracer}, KeyValue};

// get a tracer from a provider
let tracer = global::tracer("my_service");

// start a new span
let mut span = tracer.start("my_span");

// set some attributes
span.set_attribute(KeyValue::new("http.client_ip", "83.164.160.102"));

// perform some more work...

// end or drop the span to export
span.end();
# }

```

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

### Application Code Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/mod.rs.html

Demonstrates how to initialize a TracerProvider and get a named tracer instance in application code.

```APIDOC
## Application Code Example

### Description
In application code, you typically initialize a `TracerProvider` once at application startup and then retrieve named `Tracer` instances as needed.

### Code
```rust
use opentelemetry::trace::{Tracer, noop::NoopTracerProvider};
use opentelemetry::global;

fn init_tracer() {
    // Swap this no-op provider for your tracing service of choice (jaeger, zipkin, etc)
    let provider = NoopTracerProvider::new();

    // Configure the global `TracerProvider` singleton when your app starts
    // (there is a no-op default if this is not set by your application)
    let _ = global::set_tracer_provider(provider);
}

fn do_something_tracked() {
    // Then you can get a named tracer instance anywhere in your codebase.
    let tracer = global::tracer("my-component");

    tracer.in_span("doing_work", |cx| {
        // Traced app logic here...
    });
}

// in main or other app start
init_tracer();
do_something_tracked();
```
```

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

### Library Code Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/mod.rs.html

Shows how a library can use the global TracerProvider to get a tracer and create spans.

```APIDOC
## Library Code Example

### Description
In library code, you access the globally configured `TracerProvider` to obtain a `Tracer` specific to your library's instrumentation scope.

### Code
```rust
use opentelemetry::{global, trace::{Span, Tracer, TracerProvider}};
use opentelemetry::InstrumentationScope;
use std::sync::Arc;

fn my_library_function() {
    // Use the global tracer provider to get access to the user-specified
    // tracer configuration
    let tracer_provider = global::tracer_provider();

    // Get a tracer for this library
    let scope = InstrumentationScope::builder("my_name")
        .with_version(env!("CARGO_PKG_VERSION"))
        .with_schema_url("https://opentelemetry.io/schemas/1.17.0")
        .build();

    let tracer = tracer_provider.tracer_with_scope(scope);

    // Create spans
    let mut span = tracer.start("doing_work");

    // Do work...

    // End the span
    span.end();
}
```
```

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

### Initialize Global Tracer Provider (Application)

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/index.html

Applications configure their tracer by installing a trace pipeline or calling `set_tracer_provider`. This example shows how to set a custom provider, defaulting to a no-op provider if not explicitly set.

```rust
use opentelemetry::trace::{Tracer, noop::NoopTracerProvider};
use opentelemetry::global;

fn init_tracer() {
    // Swap this no-op provider for your tracing service of choice (jaeger, zipkin, etc)
    let provider = NoopTracerProvider::new();

    // Configure the global `TracerProvider` singleton when your app starts
    // (there is a no-op default if this is not set by your application)
    let _ = global::set_tracer_provider(provider);
}

fn do_something_tracked() {
    // Then you can get a named tracer instance anywhere in your codebase.
    let tracer = global::tracer("my-component");

    tracer.in_span("doing_work", |cx| {
        // Traced app logic here...
    });
}

// in main or other app start
init_tracer();
do_something_tracked();
```

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

### Get Tracer and Create Spans (Library Code)

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/index.html

In library code, use the global tracer provider to get a tracer for your library. Create spans using `start` and end them with `span.end()`.

```rust
use opentelemetry::{global, trace::{Span, Tracer, TracerProvider}};
use opentelemetry::InstrumentationScope;
use std::sync::Arc;

fn my_library_function() {
    // Use the global tracer provider to get access to the user-specified
    // tracer configuration
    let tracer_provider = global::tracer_provider();

    // Get a tracer for this library
    let scope = InstrumentationScope::builder("my_name")
        .with_version(env!("CARGO_PKG_VERSION"))
        .with_schema_url("https://opentelemetry.io/schemas/1.17.0")
        .build();

    let tracer = tracer_provider.tracer_with_scope(scope);

    // Create spans
    let mut span = tracer.start("doing_work");

    // Do work...

    // End the span
    span.end();
}
```

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

### Example Usage of OpenTelemetry Metrics API in Rust

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

Demonstrates how to get a meter, create a counter and an observable counter, and record measurements with attributes. Ensure the 'metrics' feature flag is enabled.

```rust
use opentelemetry::{global, KeyValue};

// Get a meter from a provider.
let meter = global::meter("my_service");

// Create an instrument (in this case, a Counter).
let counter = meter.u64_counter("request.count").build();

// Record a measurement by passing the value and a set of attributes.
counter.add(1, &[KeyValue::new("http.client_ip", "83.164.160.102")]);

// Create an ObservableCounter and register a callback that reports the measurement.
let _observable_counter = meter
.u64_observable_counter("bytes_received")
.with_callback(|observer| {
    observer.observe(
        100,
        &[
            KeyValue::new("protocol", "udp"),
        ],
    )
})
.build();
```

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

### Get Tracer Instance in Library

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/index.html

Libraries can use the global tracer without explicit setup, as end-users are responsible for configuring the global tracer provider. This example demonstrates obtaining a named tracer with version and schema URL.

```rust
use std::sync::Arc;
use opentelemetry::trace::Tracer;
use opentelemetry::global;
use opentelemetry::InstrumentationScope;

pub fn my_traced_library_function() {
    // End users of your library will configure their global tracer provider
    // so you can use the global tracer without any setup

    let scope = InstrumentationScope::builder("my_library-name")
        .with_version(env!("CARGO_PKG_VERSION"))
        .with_schema_url("https://opentelemetry.io/schemas/1.17.0")
        .build();

    let tracer = global::tracer_with_scope(scope);

    tracer.in_span("doing_library_work", |cx| {
        // Traced library logic here...
    });
}
```

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

### Start Span with Tracer

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Builds and starts a span using the provided tracer and the current context. This is a convenience method for starting a span with implicit parent context.

```rust
pub fn start<T: Tracer>(self, tracer: &T) -> T::Span {
        Context::map_current(|cx| tracer.build_with_context(self, cx))
    }
```

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

### i64 Gauge Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates recording a value for an i64 Gauge with attributes.

```rust
let gauge = meter.i64_gauge("my_gauge").build();
gauge.record(
-10,
&[
    KeyValue::new("mykey1", "myvalue1"),
    KeyValue::new("mykey2", "myvalue2"),
],
);
```

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

### f64 Gauge Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates recording a value for an f64 Gauge with attributes.

```rust
let gauge = meter.f64_gauge("my_gauge").build();
gauge.record(
12.5,
&[
    KeyValue::new("mykey1", "myvalue1"),
    KeyValue::new("mykey2", "myvalue2"),
],
);
```

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

### u64 Gauge Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates recording a value for a u64 Gauge with attributes.

```rust
let gauge = meter.u64_gauge("my_gauge").build();
gauge.record(
101,
&[
    KeyValue::new("mykey1", "myvalue1"),
    KeyValue::new("mykey2", "myvalue2"),
],
);
```

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

### Start Span with Default Context

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Starts a new span using the tracer's `start` method. This method implicitly uses the current thread's context to determine the parent span. If no active span is found in the current context, the new span becomes a root span.

```rust
fn start<T>(&self, name: T) -> Self::Span
where
    T: Into<Cow<'static, str>>,
{
    Context::map_current(|cx| self.start_with_context(name, cx))
}
```

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

### Start and End a Span in Rust

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

Demonstrates how to obtain a tracer, start a new span, set attributes, and end the span. Ensure the 'opentelemetry' crate is added as a dependency.

```rust
use opentelemetry::{global, trace::{Span, Tracer}, KeyValue};

// get a tracer from a provider
let tracer = global::tracer("my_service");

// start a new span
let mut span = tracer.start("my_span");

// set some attributes
span.set_attribute(KeyValue::new("http.client_ip", "83.164.160.102"));

// perform some more work...

// end or drop the span to export
span.end();
```

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

### Start a span from a SpanBuilder

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/struct.BoxedTracer.html

Creates and starts a span using a pre-configured SpanBuilder. This method allows for more complex span configurations.

```rust
fn build(&self, builder: SpanBuilder) -> Self::Span
```

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

### f64 Histogram Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates recording a value for an f64 Histogram with attributes.

```rust
let f64_histogram = meter.f64_histogram("my_f64_histogram").build();
f64_histogram.record(
    10.5,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);
```

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

### i64 UpDownCounter Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates how to create and add values to an i64 UpDownCounter with attributes.

```rust
let updown_i64_counter = meter.i64_up_down_counter("my_updown_i64_counter").build();
updown_i64_counter.add(
    -10,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);
```

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

### Initialize Tracer Provider in Application

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/mod.rs.html

Configure the global `TracerProvider` singleton when your application starts. Swap the `NoopTracerProvider` for your desired tracing service implementation.

```rust
use opentelemetry::trace::{Tracer, noop::NoopTracerProvider};
use opentelemetry::global;

fn init_tracer() {
    // Swap this no-op provider for your tracing service of choice (jaeger, zipkin, etc)
    let provider = NoopTracerProvider::new();

    // Configure the global `TracerProvider` singleton when your app starts
    // (there is a no-op default if this is not set by your application)
    let _ = global::set_tracer_provider(provider);
}

fn do_something_tracked() {
    // Then you can get a named tracer instance anywhere in your codebase.
    let tracer = global::tracer("my-component");

    tracer.in_span("doing_work", |cx| {
        // Traced app logic here...
    });
}

// in main or other app start
init_tracer();
do_something_tracked();

```

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

### u64 Histogram Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates recording a value for a u64 Histogram with attributes.

```rust
let u64_histogram = meter.u64_histogram("my_u64_histogram").build();
u64_histogram.record(
    12,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);
```

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

### Build Tracer and Create Spans Manually

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Demonstrates how to get a tracer and manually create parent and child spans, managing their context and lifecycle.

```rust
use opentelemetry::{global, trace::{Span, Tracer}, Context};

let tracer = global::tracer("my-component");

let parent = tracer.start("foo");
let parent_cx = Context::current_with_span(parent);
let mut child = tracer.start_with_context("bar", &parent_cx);

// ...

child.end(); // explicitly end
drop(parent_cx) // or implicitly end on drop
```

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

### i64 Observable Gauge Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Shows how to create an observable i64 Gauge with a callback to observe values and attributes.

```rust
let _observable_i64_gauge = meter
    .i64_observable_gauge("my_i64_gauge")
    .with_description("An observable gauge set to 1")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            1,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();
```

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

### SpanBuilder Usage Examples

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/struct.SpanBuilder.html

Demonstrates how to use SpanBuilder to create and configure spans, either directly or using the builder pattern.

```APIDOC
## SpanBuilder

`SpanBuilder` allows span attributes to be configured before the span has started.

```rust
use opentelemetry::{
    global,
    trace::{TracerProvider, SpanBuilder, SpanKind, Tracer},
};

let tracer = global::tracer("example-tracer");

// The builder can be used to create a span directly with the tracer
let _span = tracer.build(SpanBuilder {
    name: "example-span-name".into(),
    span_kind: Some(SpanKind::Server),
    ..Default::default()
});

// Or used with builder pattern
let _span = tracer
    .span_builder("example-span-name")
    .with_kind(SpanKind::Server)
    .start(&tracer);
```
```

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

### Start Span with SpanBuilder and Context

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Starts a new span as a child of a provided parent context, configuring it with a SpanBuilder and executing a closure within its active context.

```rust
fn in_span_with_builder_and_context<T, F>(
        &self,
        builder: SpanBuilder,
        parent_cx: &Context,
        f: F,
    ) -> T
    where
        F: FnOnce(Context) -> T,
        Self::Span: Send + Sync + 'static,
    {
        let span = self.build_with_context(builder, parent_cx);
        let cx = parent_cx.with_span(span);
        let _guard = cx.clone().attach();
        f(cx)
    }
```

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

### Setup Function for Tests

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/propagation/composite.rs.html

Initializes a default context and enriches it with a test span and baggage for use in propagator tests.

```rust
fn setup() -> Context {
    let mut cx = Context::default();
    cx = cx.with_span(TestSpan(SpanContext::new(
        TraceId::from(1),
        SpanId::from(11),
        TraceFlags::default(),
        true,
        TraceState::default(),
    )));
    // setup for baggage propagator
    cx.with_baggage(vec![KeyValue::new("baggagekey", "value")])
}
```

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

### Build Span from Builder

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Starts a span using a pre-configured SpanBuilder and the current context. This method is a convenient way to start a span with custom attributes.

```rust
fn build(&self, builder: SpanBuilder) -> Self::Span {
    Context::map_current(|cx| self.build_with_context(builder, cx))
}
```

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

### Start Span with Tracer and Explicit Context

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Builds and starts a span using the provided tracer and an explicit parent context. Use this when you need to control the parent span explicitly.

```rust
pub fn start_with_context<T: Tracer>(self, tracer: &T, parent_cx: &Context) -> T::Span {
        tracer.build_with_context(self, parent_cx)
    }
```

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

### f64 UpDownCounter Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Demonstrates how to create and add values to an f64 UpDownCounter with attributes.

```rust
let updown_f64_counter = meter.f64_up_down_counter("my_updown_f64_counter").build();
updown_f64_counter.add(
    -10.67,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);
```

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

### Start and Use an Active Span

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/context.rs.html

Demonstrates how to start an active span within a component and access it in nested function calls. Ensure the global tracer is initialized before use.

```rust
/// fn my_function() {
///     // start an active span in one function
///     global::tracer("my-component").in_span("span-name", |_cx| {
///         // anything happening in functions we call can still access the active span...
///         my_other_function();
///     })
/// }
/// 
/// fn my_other_function() {
///     // call methods on the current span from
///     get_active_span(|span| {
///         span.add_event("An event!", vec![KeyValue::new("happened", true)]);
///     })
/// }
```

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

### Example: in_span_with_builder_and_context Usage

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Demonstrates how to create a child span with explicit parent context and span configuration using `in_span_with_builder_and_context`.

```rust
fn my_function() {
    let tracer = global::tracer("my-component");

    // Create a parent context
    let parent = tracer.start("parent-span");
    let parent_cx = Context::current_with_span(parent);

    // start an active span with explicit parent context and span configuration
    tracer.in_span_with_builder_and_context(
        tracer.span_builder("child-span")
            .with_kind(SpanKind::Client)
            .with_attributes(vec![KeyValue::new("key", "value")]),
        &parent_cx,
        |_cx| {
            // child span is active here with configured attributes
        }
    )
}
```

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

### f64 Observable Gauge Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Shows how to create an observable f64 Gauge with a callback to observe values and attributes.

```rust
let _observable_f64_gauge = meter
    .f64_observable_gauge("my_f64_gauge")
    .with_description("An observable gauge set to 1.0")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            1.0,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();
```

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

### u64 Observable Gauge Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Shows how to create an observable u64 Gauge with a callback to observe values and attributes.

```rust
let _observable_u64_gauge = meter
    .u64_observable_gauge("my_u64_gauge")
    .with_description("An observable gauge set to 1")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            1,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();
```

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

### Build Span

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Starts a new span using a configured SpanBuilder and the current context.

```APIDOC
## build

### Description
Starts a [`Span`] from a [`SpanBuilder`] using the current context.

### Method Signature
`fn build(&self, builder: SpanBuilder) -> Self::Span`

### Parameters
- `builder` (SpanBuilder): The configured SpanBuilder to create the span from.
```

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

### i64 Observable UpDownCounter Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Shows how to create an observable i64 UpDownCounter with a callback to observe values and attributes.

```rust
let _observable_updown_i64_counter = meter
    .i64_observable_up_down_counter("my_observable_i64_updown_counter")
    .with_description("My observable updown counter example")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            100,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();
```

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

### f64 Observable UpDownCounter Example

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/meter.rs.html

Shows how to create an observable f64 UpDownCounter with a callback to observe values and attributes.

```rust
let _observable_updown_f64_counter = meter
    .f64_observable_up_down_counter("my_observable_f64_updown_counter")
    .with_description("My observable updown counter example")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            100.0,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();
```

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

### Create and Use a Counter Instrument (Metrics)

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/index.html

Applications and libraries can obtain a meter from the global meter provider to create instruments. This example shows creating and using a `u64_counter` and recording measurements with attributes.

```rust
use opentelemetry::metrics::{Meter};
use opentelemetry::{global, KeyValue};

   fn do_something_instrumented() {
    let meter = global::meter("my-component");
    // It is recommended to reuse the same counter instance for the
    // lifetime of the application
    let counter = meter.u64_counter("my_counter").build();

    // record measurements
    counter.add(1, &[KeyValue::new("mykey", "myvalue")]);
    }
}
```

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

### Creating Loggers with LoggerProvider

Source: https://docs.rs/opentelemetry/latest/opentelemetry/logs/trait.LoggerProvider.html

Demonstrates how to obtain a Logger instance using the LoggerProvider trait. Shows creation of both application-level loggers and library-level loggers with detailed instrumentation scope information.

```rust
use opentelemetry::InstrumentationScope;
use opentelemetry::logs::LoggerProvider;
use opentelemetry_sdk::logs::SdkLoggerProvider;

let provider = SdkLoggerProvider::builder().build();

// logger used in applications/binaries
let logger = provider.logger("my_app");

// logger used in libraries/crates that optionally includes version and schema url
let scope = InstrumentationScope::builder(env!("CARGO_PKG_NAME"))
    .with_version(env!("CARGO_PKG_VERSION"))
    .with_schema_url("https://opentelemetry.io/schemas/1.0.0")
    .build();

let logger = provider.logger_with_scope(scope);
```

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

### Start Span with Name for NoopTracer

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/noop/struct.NoopTracer.html

Starts a new `Span` with a given name. This is a no-op operation.

```rust
fn start<T>(&self, name: T) -> Self::Span
where T: Into<Cow<'static, str>>
```

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

### Get TypeId of a Type

Source: https://docs.rs/opentelemetry/latest/opentelemetry/baggage/struct.KeyValueMetadata.html

Gets the `TypeId` of `self`. This is a fundamental operation for dynamic type checking and downcasting.

```rust
fn type_id(&self) -> TypeId
```

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

### Context Management and Usage

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/context.rs.html

Demonstrates how to create, manage, and retrieve values from the execution-scoped context.

```APIDOC
## Context API

### Description

The `Context` type represents an immutable, execution-scoped collection of values. It is used to propagate execution-scoped values across API boundaries and between logically associated execution units.

### Methods

- `Context::new()`: Creates an empty `Context`.
- `Context::current()`: Returns an immutable snapshot of the current thread's context.
- `Context::with_value(value)`: Creates a new context with the given value added.
- `Context::attach()`: Attaches the current context to the thread, returning a `ContextGuard`.

### Examples

```rust
use opentelemetry::Context;

// Application-specific `a` and `b` values
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
#[derive(Debug, PartialEq)]
struct ValueB(u64);

// Create a new context and add a value
let ctx_with_a = Context::new().with_value(ValueA("a"));

// Attach the context to the current thread
let _guard = ctx_with_a.attach();

// Get the current context and retrieve values
let current = Context::current();
assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(current.get::<ValueB>(), None);

// Create a new context based on the current one and add another value
let ctx_with_b = Context::current_with_value(ValueB(42));
let _inner_guard = ctx_with_b.attach();

// Both values are now available
let inner_current = Context::current();
assert_eq!(inner_current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(inner_current.get::<ValueB>(), Some(&ValueB(42)));

// When the inner guard is dropped, the context reverts to the outer one
// (This happens automatically when `_inner_guard` goes out of scope)
let outer_current = Context::current();
assert_eq!(outer_current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(outer_current.get::<ValueB>(), None);
```

### Behavior During Context Drop

When `Context::current()` is called from within a `Drop` implementation that is triggered by a `ContextGuard` being dropped (e.g., when a `Span` is dropped as part of context cleanup), this function returns whatever context happens to be current after the guard is popped, not the context being dropped. This is important because contexts can be activated in any order and are detached in LIFO order.
```

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

### Start Span with Name and Context for NoopTracer

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/noop/struct.NoopTracer.html

Starts a new `Span` with a given name and a specific `Context`. This is a no-op operation.

```rust
fn start_with_context<T>(&self, name: T, parent_cx: &Context) -> Self::Span
where T: Into<Cow<'static, str>>
```

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

### Context Management

Source: https://docs.rs/opentelemetry/latest/opentelemetry/context/struct.Context.html

Demonstrates how to manage the current execution context, including setting and retrieving values, and nesting contexts.

```APIDOC
## Context Management

### Description
Manages the current execution context, allowing for the storage and retrieval of key-value pairs. Contexts are immutable, and operations that modify them create new contexts. The current context can be attached to a thread and restored by dropping the returned guard.

### Methods

- `Context::new()`: Creates a new, empty context.
- `Context::current()`: Retrieves the current context associated with the execution unit.
- `Context::current_with_value(value)`: Creates a new context with the given value attached to the current context.
- `context.with_value(value)`: Creates a new context with the given value added to the existing context.
- `context.attach()`: Attaches the context to the current execution unit, returning a `ContextGuard`.
- `context.get::<T>()`: Retrieves a value of type `T` from the context, if it exists.

### Example
```rust
use opentelemetry::Context;

// Application-specific `a` and `b` values
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
#[derive(Debug, PartialEq)]
struct ValueB(u64);

let _outer_guard = Context::new().with_value(ValueA("a")).attach();

// Only value a has been set
let current = Context::current();
assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(current.get::<ValueB>(), None);

{
    let _inner_guard = Context::current_with_value(ValueB(42)).attach();
    // Both values are set in inner context
    let current = Context::current();
    assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
    assert_eq!(current.get::<ValueB>(), Some(&ValueB(42)));
}

// Resets to only the `a` value when inner guard is dropped
let current = Context::current();
assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(current.get::<ValueB>(), None);
```
```

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

### Start a new span with a given context

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/struct.BoxedTracer.html

Starts a new span with a specified name and associates it with a given parent context.

```rust
fn start_with_context<T>(&self, name: T, parent_cx: &Context) -> Self::Span
where T: Into<Cow<'static, str>>,
```

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

### Test HashMap Extractor Get

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/propagation/mod.rs.html

Verifies the case-insensitive extraction of a value from a HashMap using the Extractor trait's get method.

```rust
#[test]
fn hash_map_get() {
    let mut carrier = HashMap::new();
    carrier.set("headerName", "value".to_string());

    assert_eq!(
        Extractor::get(&carrier, "HEADERNAME"),
        Some("value"),
        "case insensitive extraction"
    );
}
```

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

### Create a new Key

Source: https://docs.rs/opentelemetry/latest/opentelemetry/struct.Key.html

Demonstrates creating a new Key from a static string, an owned String, and an Arc<str>. Ensure the appropriate types are used for key creation.

```rust
use opentelemetry::Key;
use std::sync::Arc;

let key1 = Key::new("my_static_str");
let key2 = Key::new(String::from("my_owned_string"));
let key3 = Key::new(Arc::from("my_ref_counted_str"));
```

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

### Start a new Span with a given context

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Starts a new Span with a given context. If this context contains a span, the newly created span will be a child of that span.

```APIDOC
## start_with_context<T>(&self, name: T, parent_cx: &Context) -> Self::Span
where T: Into<Cow<'static, str>>,

### Description
Starts a new `Span` with a given context. If this context contains a span, the newly created span will be a child of that span. Each span has zero or one parent span and zero or more child spans, which represent causally related operations. A tree of related spans comprises a trace. A span is said to be a root span if it does not have a parent. Each trace includes a single root span, which is the shared ancestor of all other spans in the trace.
```

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

### Building Async Instruments with Macros

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/metrics/instruments/mod.rs.html

The `build_async_instrument!` macro simplifies the creation of specific async instrument types. Call the `build()` method on the configured builder to finalize instrument creation. Invalid configurations result in a no-op instrument and logged errors.

```rust
macro_rules! build_async_instrument {
    ($name:ident, $inst:ty, $measurement:ty) => {
        impl<'a> AsyncInstrumentBuilder<'a, $inst, $measurement> {
            #[doc = concat!("Validates the instrument configuration and creates a new `",  stringify!($inst), "`.")]
            /// In case of invalid configuration, a no-op instrument is returned
            /// and an error is logged using internal logging.
            pub fn build(self) -> $inst {
                self.instrument_provider.$name(self)
            }
        }
    };
}

build_async_instrument!(u64_observable_counter, ObservableCounter<u64>, u64);
build_async_instrument!(f64_observable_counter, ObservableCounter<f64>, f64);
build_async_instrument!(u64_observable_gauge, ObservableGauge<u64>, u64);
build_async_instrument!(f64_observable_gauge, ObservableGauge<f64>, f64);
build_async_instrument!(i64_observable_gauge, ObservableGauge<i64>, i64);
build_async_instrument!(
    i64_observable_up_down_counter,
    ObservableUpDownCounter<i64>,
    i64
);
build_async_instrument!(
    f64_observable_up_down_counter,
    ObservableUpDownCounter<f64>,
    f64
);
```

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

### Start Span with Context

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Starts a new span with a given name and parent context. This is useful for creating child spans explicitly linked to a parent trace.

```APIDOC
## start_with_context

### Description
Starts a new span with a given name and parent context.

### Method Signature
`fn start_with_context<T>(&self, name: T, parent_cx: &Context) -> Self::Span`

### Parameters
- `name` (T): The name of the span. Can be any type that can be converted into a static string.
- `parent_cx` (&Context): The parent context to which this span will be linked.
```

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

### Get a named Meter

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/fn.meter.html

Use this function to get a `Meter` instance from the global `MeterProvider`. This is a shortcut for `global::meter_provider().meter(name)`. Ensure the `metrics` feature is enabled.

```rust
pub fn meter(name: &'static str) -> Meter
```

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

### Start a new span

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Starts a new span. The currently active span is set as the parent by default. Spans form a tree of causally related operations, constituting a trace.

```rust
use opentelemetry::global;

let tracer = global::tracer("my-component");
let span = tracer.start("span-name");
// use span...
```

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

### from_raw_in

Source: https://docs.rs/opentelemetry/latest/opentelemetry/metrics/type.Callback.html

Constructs a Box<T, A> from a raw pointer and a given allocator. This is a nightly-only experimental API and requires `allocator_api` feature.

```APIDOC
## pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>

### Description
Constructs a box from a raw pointer in the given allocator. After calling this function, the raw pointer is owned by the resulting `Box`. Specifically, the `Box` destructor will call the destructor of `T` and free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by `Box`.

### Method
`from_raw_in`

### Parameters
#### Path Parameters
- **raw** (*`*mut T`*) - Required - A mutable raw pointer to the memory block.
- **alloc** (*A*) - Required - The allocator to be used for the Box.

### Safety
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer. The raw pointer must point to a block of memory allocated by `alloc`. The safety conditions are described in the memory layout section. Note that the considerations for unsafe code apply to all `Box<T, A>` values.

### Request Example
```rust
#![feature(allocator_api)]

use std::alloc.System;

let x = Box::new_in(5, System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

```rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
```
```

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

### Get Tracer and Create Spans in Library

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/mod.rs.html

In library code, use the global tracer provider to get a tracer with specific instrumentation scope details. Create and end spans manually.

```rust
use opentelemetry::{global, trace::{Span, Tracer, TracerProvider}};
use opentelemetry::InstrumentationScope;
use std::sync::Arc;

fn my_library_function() {
    // Use the global tracer provider to get access to the user-specified
    // tracer configuration
    let tracer_provider = global::tracer_provider();

    // Get a tracer for this library
    let scope = InstrumentationScope::builder("my_name")
        .with_version(env!("CARGO_PKG_VERSION"))
        .with_schema_url("https://opentelemetry.io/schemas/1.17.0")
        .build();

    let tracer = tracer_provider.tracer_with_scope(scope);

    // Create spans
    let mut span = tracer.start("doing_work");

    // Do work...

    // End the span
    span.end();
}

```

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

### Create and Use f64 Counter

Source: https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Meter.html

Demonstrates how to create and use an f64 Counter instrument. This instrument is suitable for recording floating-point increments.

```rust
// f64 Counter
let f64_counter = meter.f64_counter("my_f64_counter").build();
f64_counter.add(
    3.15,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);
```

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

### Any::type_id

Source: https://docs.rs/opentelemetry/latest/opentelemetry/baggage/struct.Iter.html

Gets the TypeId of an object.

```APIDOC
## Any::type_id

### Description
Gets the `TypeId` of `self`.

### Method
`type_id(&self) -> TypeId`
```

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

### Start a new Span

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Starts a new Span. By default, the currently active Span is set as the new Span's parent. Each trace includes a single root span, which is the shared ancestor of all other spans in the trace.

```APIDOC
## start<T>(&self, name: T) -> Self::Span
where T: Into<Cow<'static, str>>,

### Description
Starts a new `Span`. By default the currently active `Span` is set as the new `Span`’s parent. Each span has zero or one parent span and zero or more child spans, which represent causally related operations. A tree of related spans comprises a trace. A span is said to be a root span if it does not have a parent. Each trace includes a single root span, which is the shared ancestor of all other spans in the trace.
```

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

### Start a new span with explicit parent context

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Starts a new span with a specified parent context. If the context contains a span, the new span becomes its child. This is useful for establishing explicit causal relationships between spans.

```rust
use opentelemetry::global;
use opentelemetry::trace::Context;

let tracer = global::tracer("my-component");
let parent_cx = Context::new(); // Assume parent_cx is obtained elsewhere
let span = tracer.start_with_context("span-name", &parent_cx);
// use span...
```

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

### Execute closure with SpanBuilder and active span

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Builds and starts a new span from a SpanBuilder, sets it as the active span, executes a closure, and then ends the span. This method is useful for starting spans with custom configurations within a managed context.

```rust
use opentelemetry::{global, trace::{Span, SpanKind, Tracer}, KeyValue};

fn my_function() {
    let tracer = global::tracer("my-component");

    // start an active span with span configuration
    tracer.in_span_with_builder(
        tracer.span_builder("span-name")
            .with_kind(SpanKind::Client)
            .with_attributes(vec![KeyValue::new("key", "value")])
            ,
        |_cx| {
            // span is active here with configured attributes
        }
    )
}
```

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

### Build a Span from a SpanBuilder

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Start a Span from a SpanBuilder.

```APIDOC
## build(&self, builder: SpanBuilder) -> Self::Span

### Description
Start a `Span` from a `SpanBuilder`.
```

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

### Create and Use u64 Counter

Source: https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Meter.html

Demonstrates how to create and use a u64 Counter instrument. This instrument is suitable for recording non-negative increments.

```rust
let meter = global::meter("my-meter");

// Synchronous Instruments

// u64 Counter
let u64_counter = meter.u64_counter("my_u64_counter").build();
u64_counter.add(
    10,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);
```

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

### Start Span with Explicit Context

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Starts a new span and associates it with a provided `Context`. If the given context contains an active span, the new span will be created as a child of that span. This allows for explicit control over span relationships, especially in concurrent or asynchronous scenarios.

```rust
fn start_with_context<T>(&self, name: T, cx: &Context) -> Self::Span
where
    T: Into<Cow<'static, str>>;
```

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

### take

Source: https://docs.rs/opentelemetry/latest/opentelemetry/metrics/type.Callback.html

Creates an iterator that yields the first `n` elements.

```APIDOC
## take(self, n: usize) -> Take<Self>
where Self: Sized

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Method
`take`

### Parameters
- `n`: The maximum number of elements to yield.

### Returns
A `Take` iterator.
```

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

### NoopTracer::build

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/noop/struct.NoopTracer.html

Starts a span from a SpanBuilder. This is a no-op operation.

```APIDOC
## `NoopTracer::build()`

### Description

Starts a `Span` from a `SpanBuilder`. This is a no-op operation.

### Parameters

- `builder`: `SpanBuilder` - The span builder.

### Returns

- `Self::Span` - A no-op span.
```

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

### SpanBuilder Initialization and Usage

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/trace/tracer.rs.html

Shows how to initialize a `SpanBuilder` directly or using a builder pattern to configure span properties like name, kind, and attributes before starting a span.

```rust
let tracer = global::tracer("example-tracer");

// The builder can be used to create a span directly with the tracer
let _span = tracer.build(SpanBuilder {
    name: "example-span-name".into(),
    span_kind: Some(SpanKind::Server),
    ..Default::default()
});

// Or used with builder pattern
let _span = tracer
    .span_builder("example-span-name")
    .with_kind(SpanKind::Server)
    .start(&tracer);
```

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

### Get SpanContext

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/struct.SpanRef.html

Retrieves a reference to the SpanContext associated with this span.

```rust
pub fn span_context(&self) -> &SpanContext
```

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

### Execute closure within an active span

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/trait.Tracer.html

Starts a new span and executes the given closure with reference to the context in which the span is active. This method starts a new span and sets it as the active span for the given function. It then executes the body and ends the span before returning the execution result.

```APIDOC
## in_span<T, F, N>(&self, name: N, f: F) -> T
where F: FnOnce(Context) -> T, N: Into<Cow<'static, str>>, Self::Span: Send + Sync + 'static,

### Description
Start a new span and execute the given closure with reference to the context in which the span is active. This method starts a new span and sets it as the active span for the given function. It then executes the body. It ends the span before returning the execution result.

##### §Examples
```
use opentelemetry::{global, trace::{Span, Tracer, get_active_span}, KeyValue};

fn my_function() {
    // start an active span in one function
    global::tracer("my-component").in_span("span-name", |_cx| {
        // anything happening in functions we call can still access the active span...
        my_other_function();
    })
}

fn my_other_function() {
    // call methods on the current span from
    get_active_span(|span| {
        span.add_event("An event!".to_string(), vec![KeyValue::new("happened", true)]);
    })
}
```
```

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

### Set Global Meter Provider

Source: https://docs.rs/opentelemetry/latest/opentelemetry/global/fn.set_meter_provider.html

Sets the given `MeterProvider` instance as the current global meter provider. Libraries should NOT call this function. It is intended for applications/executables. This function should be called before getting `Meter` instances via `meter()` or `meter_with_scope()`. Otherwise, you could get no-op `Meter` instances.

```rust
pub fn set_meter_provider<P>(new_provider: P)
where
    P: MeterProvider + Send + Sync + 'static,

```

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

### Create a Key from different string types

Source: https://docs.rs/opentelemetry/latest/src/opentelemetry/common.rs.html

Demonstrates creating a `Key` from a static string slice, an owned `String`, and an `Arc<str>`. The `Key::new` function handles the conversion.

```rust
use opentelemetry::Key;
use std::sync::Arc;

let key1 = Key::new("my_static_str");
let key2 = Key::new(String::from("my_owned_string"));
let key3 = Key::new(Arc::from("my_ref_counted_str"));

```

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

### Create and Use Current Context

Source: https://docs.rs/opentelemetry/latest/opentelemetry/context/struct.Context.html

Demonstrates how to create a new context, attach a value, and then assert its presence in a function called from the attached context. This is useful for setting up context for operations.

```rust
use opentelemetry::Context;

#[derive(Debug, PartialEq)]
struct ValueA(&'static str);

fn do_work() {
    assert_eq!(Context::current().get(), Some(&ValueA("a")));
}

let _guard = Context::new().with_value(ValueA("a")).attach();
do_work()
```

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

### Default TraceState

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/struct.TraceState.html

Provides a way to get the default value for TraceState.

```APIDOC
## fn default() -> TraceState

### Description
Returns the “default value” for a type.

### Method
default
```

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

### NoopTracer::start

Source: https://docs.rs/opentelemetry/latest/opentelemetry/trace/noop/struct.NoopTracer.html

Starts a new span with the given name. This is a no-op operation.

```APIDOC
## `NoopTracer::start()`

### Description

Starts a new `Span` with the given name. This is a no-op operation.

### Parameters

- `name`: `T` where `T: Into<Cow<'static, str>>` - The name of the span.

### Returns

- `Self::Span` - A no-op span.
```

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

### Clone Box<T, A> Example

Source: https://docs.rs/opentelemetry/latest/opentelemetry/metrics/type.Callback.html

Demonstrates how to clone a Box<T, A> instance. The cloned instance contains a copy of the original data, but they are distinct objects in memory.

```rust
let x = Box::new(5);
let y = x.clone();

// The value is the same
assert_eq!(x, y);

// But they are unique objects
assert_ne!(&*x as *const i32, &*y as *const i32);
```

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

### Create a new NoopLoggerProvider

Source: https://docs.rs/opentelemetry/latest/opentelemetry/logs/struct.NoopLoggerProvider.html

Instantiates a new `NoopLoggerProvider`. This is a no-op implementation, meaning it does not perform any actual logging operations.

```rust
pub fn new() -> Self
```
Tokens:
Raw