OpenTelemetry SDK

https://docs.rs/opentelemetry_sdk/latest
Admin
Implements the SDK component of OpenTelemetry, providing functionalities for trace, metrics, and...
Tokens:1,217,046
Snippets:9,748
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Custom View

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

An example demonstrating how to create and use a custom `View` with the `SdkMeterProvider`.

```APIDOC
## Example Custom View

### Description
This example shows how to define a custom view function and use it to configure the `SdkMeterProvider`.

### Usage
```rust
use opentelemetry_sdk::metrics::{Instrument, SdkMeterProvider, Stream};

// Define a custom view function that returns streams for a given instrument.
let my_view = |i: &Instrument| {
  // Logic to determine if a Stream should be returned for the instrument.
  // For example, you might inspect the instrument's name or kind.
  // Return Some(Stream) if the instrument should be processed, or None to ignore it.
  None // Placeholder: replace with actual logic
};

// Build the SdkMeterProvider with the custom view.
let provider = SdkMeterProvider::builder().with_view(my_view).build();

// The provider can now be used to create instruments and collect metrics.

// Clean up the provider (in a real application, this would happen when the application shuts down).
# drop(provider);
```
```

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

### Basic Periodic Reader Setup

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/metrics/periodic_reader.rs.html?search=

Demonstrates the basic setup of a PeriodicReader with an InMemoryMetricExporter and SdkMeterProvider. This is useful for testing and in-memory metric collection.

```rust
let exporter = InMemoryMetricExporter::default();
let reader = PeriodicReader::builder(exporter.clone())
    .with_interval(interval)
    .build();

let meter_provider = SdkMeterProvider::builder().with_reader(reader).build();
let meter = meter_provider.meter("test");
```

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

### PeriodicReader Example

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/periodic_reader_with_async_runtime/struct.PeriodicReader.html?search=std%3A%3Avec

Example of how to set up and build a PeriodicReader with a push exporter and a selected runtime.

```APIDOC
## Example Usage

```rust
use opentelemetry_sdk::metrics::periodic_reader_with_async_runtime::PeriodicReader;

// Assume get_exporter() and get_runtime() are defined elsewhere
// and return a valid PushMetricExporter and a compatible Runtime respectively.
// let exporter = get_exporter(); 
// let runtime = get_runtime(); 

// let reader = PeriodicReader::builder(exporter, runtime).build();
```

### Description
This example demonstrates the basic instantiation of a `PeriodicReader` using its builder pattern. It requires a `PushMetricExporter` and a `Runtime` to be provided.
```

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

### Example Searches

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/sampler/jaeger_remote/sampling_strategy.rs.html?search=

Illustrative examples of search queries for OpenTelemetry SDK functionalities.

```text
Example searches:
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

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

### Basic Periodic Reader Setup

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

Demonstrates the basic setup of a PeriodicReader with an InMemoryMetricExporter and an observable gauge. This is useful for testing and collecting metrics in memory.

```rust
        let exporter = InMemoryMetricExporter::default();
        let reader = PeriodicReader::builder(exporter.clone())
            .with_interval(interval)
            .build();

        let meter_provider = SdkMeterProvider::builder().with_reader(reader).build();
        let meter = meter_provider.meter("test");
        let _gauge = meter
            .u64_observable_gauge("my_observable_gauge")
            .with_callback(|observer| {
                // using futures_executor::block_on intentionally and avoiding
                // any particular async runtime.
                let value = futures_executor::block_on(some_async_function());
                observer.observe(value, &[]);
            })
            .build();

        meter_provider.force_flush().expect("flush should succeed");
        let exported_metrics = exporter
            .get_finished_metrics()
            .expect("this should not fail");
        assert!(
            !exported_metrics.is_empty(),
            "Metrics should be available in exporter."
        );
```

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

### PeriodicReader Example

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/metrics/periodic_reader_with_async_runtime.rs.html?search=

Example demonstrating how to create and initialize a PeriodicReader with a custom exporter and runtime.

```APIDOC
## PeriodicReader Example

### Description

This example shows how to set up a `PeriodicReader` using a builder pattern, providing a push metric exporter and an async runtime.

### Usage

```no_run
use opentelemetry_sdk::metrics::periodic_reader_with_async_runtime::PeriodicReader;
# use opentelemetry_sdk::metrics::exporter::PushMetricExporter;
# use opentelemetry_sdk::runtime::Runtime;
# fn example<E, R>(get_exporter: impl Fn() -> E, get_runtime: impl Fn() -> R)
# where
#     E: PushMetricExporter,
#     R: Runtime,
# {

let exporter = get_exporter(); // e.g., setup an OTLP exporter
let runtime = get_runtime(); // e.g., opentelemetry_sdk::runtime::Tokio

let reader = PeriodicReader::builder(exporter, runtime).build();
# drop(reader);
# }
```
```

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

### Log Processor Test Setup

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/log_processor.rs.html?search=

Provides a basic setup for testing log processors, including mock implementations of `LogExporter` and `SdkLogRecord`.

```rust
use crate::logs::{LogBatch, LogExporter, SdkLogRecord};
use crate::Resource;
use crate::{
    error::OTelSdkResult,
    logs::{LogProcessor, SdkLoggerProvider},
};
use opentelemetry::logs::AnyValue;
use opentelemetry::logs::LogRecord as _;
```

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

### Example Usage

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/simple_log_processor.rs.html?search=u32+-%3E+bool

Demonstrates how to use `SimpleLogProcessor` with an `InMemoryLogExporter`.

```APIDOC
## Example Usage

### Using a SimpleLogProcessor

```rust
# #[cfg(feature = "testing")]
# {
use opentelemetry_sdk::logs::{SimpleLogProcessor, SdkLoggerProvider, LogExporter};
use opentelemetry::global;
use opentelemetry_sdk::logs::InMemoryLogExporter;

let exporter = InMemoryLogExporter::default(); // Replace with an actual exporter
let provider = SdkLoggerProvider::builder()
    .with_simple_exporter(exporter)
    .build();
# }
```
```

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

### Setup Tracer Provider with Sampler and Span Processor

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

Configures an SDK tracer provider with a specific sampler (AlwaysOn) and a span processor that uses an in-memory exporter. This setup is typical for testing tracing functionality.

```rust
use crate::trace::{InMemorySpanExporter, SimpleSpanProcessor};

let exporter = InMemorySpanExporter::default();
let tracer_provider = crate::trace::SdkTracerProvider::builder()
    .with_sampler(Sampler::AlwaysOn)
    .with_span_processor(SimpleSpanProcessor::new(exporter.clone()))
    .build();
let tracer = tracer_provider.tracer("test");
```

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

### Example Searches for Rust Functionality

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/tracer.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

These are example search queries demonstrating how to find specific Rust functionalities, such as vector operations, type conversions, and Option combinators.

```rust
std::vec
```

```rust
u32 -> bool
```

```rust
Option<T>, (T -> U) -> Option<U>
```

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

### Log Record Processing Example

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/log_processor.rs.html

Demonstrates how a log record is processed and its body is updated. This example shows a typical scenario within a log processor's implementation.

```rust
second_log.0.body.clone().unwrap()
                == AnyValue::String("Updated by FirstProcessor".into())
        );
    }
}
```

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

### Example Usage

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/in_memory_exporter/struct.InMemorySpanExporterBuilder.html

Demonstrates how to create and use an InMemorySpanExporter.

```APIDOC
## §Example
```
let exporter = InMemorySpanExporterBuilder::new().build();
```
```

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

### Tracer::build

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.Tracer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a Span from a configured SpanBuilder.

```APIDOC
## Tracer::build

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

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

### Parameters
* `builder`: `SpanBuilder` - The configured span builder.
```

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

### Basic SDK Trace Setup

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates initializing the OpenTelemetry SDK with a simple stdout exporter and creating spans. Ensure you have a compatible exporter like `opentelemetry_stdout::SpanExporter` available.

```rust
use opentelemetry::{global, trace::{Tracer, TracerProvider}};
use opentelemetry_sdk::trace::SdkTracerProvider;

fn main() {
    // Choose an exporter like `opentelemetry_stdout.SpanExporter`
    let exporter = new_exporter();

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

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

    // Shutdown trace pipeline
    provider.shutdown().expect("TracerProvider should shutdown successfully")
}
```

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

### Example: Get slice length

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=u32+-%3E+bool

Demonstrates how to get the number of events stored in SpanEvents using the `len` method, inherited from Deref<Target = [Event]>.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### SdkTracer::build

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SdkTracer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a Span using a pre-configured SpanBuilder.

```APIDOC
## SdkTracer::build

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

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

### Parameters
* `builder` (SpanBuilder): The configured span builder.

### Returns
Returns the created `Self::Span`.
```

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

### SdkTracer::start_with_context

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SdkTracer.html?search=u32+-%3E+bool

Starts a new Span with a given context.

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

Starts a new `Span` with a given context.
```

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

### Example: Get element or subslice by index

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=u32+-%3E+bool

Shows how to access individual events by position or retrieve subslices using ranges with the `get` method. Returns `None` for out-of-bounds indices.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### Basic SDK Setup and Tracing

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

Demonstrates how to set up the OpenTelemetry SDK with a simple exporter and create a tracer to instrument application logic. Ensure you have a compatible exporter like opentelemetry_stdout::SpanExporter.

```rust
use opentelemetry::{global, trace::{Tracer, TracerProvider}};
use opentelemetry_sdk::trace::SdkTracerProvider;

fn main() {
    // Choose an exporter like `opentelemetry_stdout::SpanExporter`
    let exporter = new_exporter();

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

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

    // Shutdown trace pipeline
    provider.shutdown().expect("TracerProvider should shutdown successfully")
}
```

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

### Get Gauge Start Time

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/data/struct.Gauge.html

Returns the optional SystemTime when the time series for this Gauge was initiated. This is useful for tracking the lifecycle of measurements.

```rust
pub fn start_time(&self) -> Option<SystemTime>
```

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

### Example: Configuring LoggerProvider with Resource

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.LoggerProviderBuilder.html?search=

Demonstrates how to build an SdkLoggerProvider with a custom Resource, including service name and deployment environment attributes. Uses Resource::builder() to preserve SDK defaults.

```rust
use opentelemetry_sdk::{Resource, logs::SdkLoggerProvider};
use opentelemetry::KeyValue;

let provider = SdkLoggerProvider::builder()
    .with_resource(
        Resource::builder()
            .with_service_name("my-service")
            .with_attributes([KeyValue::new("deployment.environment.name", "production")])
            .build(),
    )
    .build();
```

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

### Get ExponentialHistogram Start Time

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/data/struct.ExponentialHistogram.html

Retrieves the SystemTime when the time series associated with the ExponentialHistogram was initiated. This helps in understanding the duration of data collection.

```rust
pub fn start_time(&self) -> SystemTime
```

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

### Configure SdkMeterProvider and Record Metrics

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/index.html?search=u32+-%3E+bool

Demonstrates how to set up the SdkMeterProvider with a resource, create a meter, define a counter instrument, record measurements, and shut down the provider.

```rust
use opentelemetry::global;
use opentelemetry::KeyValue;
use opentelemetry_sdk::{metrics::SdkMeterProvider, Resource};

// Generate SDK configuration, resource, views, etc
let resource = Resource::builder().build(); // default attributes about the current process

// Create a meter provider with the desired config
let meter_provider = SdkMeterProvider::builder().with_resource(resource).build();
global::set_meter_provider(meter_provider.clone());

// Use the meter provider to create meter instances
let meter = global::meter("my_app");

// Create instruments scoped to the meter
let counter = meter
    .u64_counter("power_consumption")
    .with_unit("kWh")
    .build();

// use instruments to record measurements
counter.add(10, &[KeyValue::new("rate", "standard")]);

// shutdown the provider at the end of the application to ensure any metrics not yet
// exported are flushed.
meter_provider.shutdown().unwrap();

```

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

### unwrap_err_unchecked Example (Err)

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/error/type.OTelSdkResult.html?search=

Shows how to use `unwrap_err_unchecked` to get the Err value without a check. This is unsafe and should only be used when the value is guaranteed to be Err.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

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

### Initializing and Using TracerProvider

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/provider.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to initialize an SdkTracerProvider, set it as the global provider, create a Tracer, and then explicitly shut down the provider.

```APIDOC
```rust
use opentelemetry::global;
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry::trace::Tracer;

fn init_tracing() -> SdkTracerProvider {
    let provider = SdkTracerProvider::default();

    // Set the provider to be used globally
    let _ = global::set_tracer_provider(provider.clone());

    provider
}

fn main() {
    let provider = init_tracing();

    // create tracer..
    let tracer = global::tracer("example/client");

    // create span...
    let span = tracer
        .span_builder("test_span")
        .start(&tracer);

    // Explicitly shut down the provider
    provider.shutdown();
}
```
```

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

### unwrap_unchecked Example (Ok)

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/error/type.OTelSdkResult.html?search=

Shows how to use `unwrap_unchecked` to get the Ok value without a check. This is unsafe and should only be used when the value is guaranteed to be Ok.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

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

### Example: Get the last element

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=u32+-%3E+bool

Illustrates retrieving the last event from SpanEvents using the `last` method. Returns `None` if the event list is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

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

### Create and Record Measurements with Metrics

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

Shows how to obtain a meter, create a counter instrument, and record measurements with associated attributes. This example requires the 'metrics' feature to be enabled.

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

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

// create an instrument
let counter = meter.u64_counter("my_counter").build();

// record a measurement
counter.add(1, &[KeyValue::new("http.client_ip", "83.164.160.102")]);
# }

```

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

### Example: Get the first element

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=u32+-%3E+bool

Illustrates retrieving the first event from SpanEvents using the `first` method. Returns `None` if the event list is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

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

### Get ExponentialHistogram Temporality

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/data/struct.ExponentialHistogram.html

Returns the Temporality of the ExponentialHistogram, indicating whether the aggregation represents cumulative changes since a fixed start or changes from the last report time.

```rust
pub fn temporality(&self) -> Temporality
```

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

### Initialize and Use TracerProvider

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/provider.rs.html?search=std%3A%3Avec

Demonstrates how to initialize an SdkTracerProvider, set it as the global provider, create a tracer, and start a span. It also shows how to explicitly shut down the provider.

```rust
use opentelemetry::global;
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry::trace::Tracer;

fn init_tracing() -> SdkTracerProvider {
    let provider = SdkTracerProvider::default();

    // Set the provider to be used globally
    let _ = global::set_tracer_provider(provider.clone());

    provider
}

fn main() {
    let provider = init_tracing();

    // create tracer..
    let tracer = global::tracer("example/client");

    // create span...
    let span = tracer
        .span_builder("test_span")
        .start(&tracer);

    // Explicitly shut down the provider
    provider.shutdown();
}
```

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

### Example: Get the last N elements as an array

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=u32+-%3E+bool

Illustrates retrieving the last N events as a fixed-size array using `last_chunk`. Returns `None` if the slice is shorter than N.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

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

### Initialize OpenTelemetry SDK with a Tracer Provider

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

Demonstrates how to set up the OpenTelemetry SDK with a tracer provider and create a tracer. This example uses a simple stdout exporter and shows how to create and use spans. Ensure the 'trace' feature is enabled.

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

fn main() {
    // Choose an exporter like `opentelemetry_stdout::SpanExporter`
    # fn example<T: opentelemetry_sdk::trace::SpanExporter + 'static>(new_exporter: impl Fn() -> T) {
    let exporter = new_exporter();

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

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

    // Shutdown trace pipeline
    provider.shutdown().expect("TracerProvider should shutdown successfully")
    # }
}
# }

```

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

### Example: Get the first N elements as an array

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=u32+-%3E+bool

Demonstrates retrieving the first N events as a fixed-size array using `first_chunk`. Returns `None` if the slice is shorter than N.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

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

### Get Element Index by Pointer Offset

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=

Calculates the index of an element reference within a slice using pointer arithmetic. Returns `None` if the reference is not aligned to an element's start.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

```rust
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### Configure and Use Metrics SDK

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/index.html?search=

Demonstrates how to set up the OpenTelemetry metrics SDK, including resource configuration, meter provider creation, and instrument usage. Ensure the provider is shut down to flush remaining metrics.

```rust
use opentelemetry::global;
use opentelemetry::KeyValue;
use opentelemetry_sdk::{metrics::SdkMeterProvider, Resource};

// Generate SDK configuration, resource, views, etc
let resource = Resource::builder().build(); // default attributes about the current process

// Create a meter provider with the desired config
let meter_provider = SdkMeterProvider::builder().with_resource(resource).build();
global::set_meter_provider(meter_provider.clone());

// Use the meter provider to create meter instances
let meter = global::meter("my_app");

// Create instruments scoped to the meter
let counter = meter
    .u64_counter("power_consumption")
    .with_unit("kWh")
    .build();

// use instruments to record measurements
counter.add(10, &[KeyValue::new("rate", "standard")]);

// shutdown the provider at the end of the application to ensure any metrics not yet
// exported are flushed.
meter_provider.shutdown().unwrap();
```

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

### Iterate Subslices Backwards with `rsplit`

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanEvents.html?search=

Use `rsplit` to get an iterator over subslices separated by elements matching a predicate, starting from the end. The matched element is excluded. Handles leading/trailing matches by producing empty slices.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

```rust
let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);
```

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

### InMemorySpanExporterBuilder Example

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/in_memory_exporter/struct.InMemorySpanExporterBuilder.html?search=std%3A%3Avec

Example usage of InMemorySpanExporterBuilder to create an exporter.

```APIDOC
## §Example
```rust

let exporter = InMemorySpanExporterBuilder::new().build();
```
```

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

### InMemoryLogExporterBuilder Example

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/in_memory_exporter/struct.InMemoryLogExporterBuilder.html?search=u32+-%3E+bool

Example demonstrating how to create and use an InMemoryLogExporter.

```APIDOC
## Example Usage

```rust
// Create an InMemoryLogExporter
let exporter: InMemoryLogExporter = InMemoryLogExporterBuilder::default().build();

// Create a LoggerProvider and register the exporter
let logger_provider = SdkLoggerProvider::builder()
    .with_log_processor(BatchLogProcessor::builder(exporter.clone()).build())
    .build();

// Setup Log Appenders and emit logs. (Not shown here)
logger_provider.force_flush();

let emitted_logs = exporter.get_emitted_logs().unwrap();
for log in emitted_logs {
    println!("{:?}", log);
}
```
```

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

### Resource Initialization with Attributes

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/resource/mod.rs.html?search=

Demonstrates initializing a `Resource` with attributes, handling potential overwrites based on insertion order. The last attribute with a given key prevails.

```rust
#[rstest]
    #[case([KeyValue::new("a", ""), KeyValue::new("a", "final")], [(Key::new("a"), Value::from("final"))])]
    #[case([KeyValue::new("a", "final"), KeyValue::new("a", "")], [(Key::new("a"), Value::from(""))])]
    fn new_resource(
        #[case] given_attributes: [KeyValue; 2],
        #[case] expected_attrs: [(Key, Value); 1],
    ) {
        // Arrange
        let expected = HashMap::from_iter(expected_attrs.into_iter());

        // Act
        let resource = Resource::builder_empty()
            .with_attributes(given_attributes)
            .build();
        let resource_inner = Arc::try_unwrap(resource.inner).expect("Failed to unwrap Arc");

        // Assert
        assert_eq!(resource_inner.attrs, expected);
        assert_eq!(resource_inner.schema_url, None);
    }
```

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

### Configure SimpleLogProcessor with Resource

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/log_processor_with_async_runtime.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to set up a SimpleLogProcessor and associate a Resource with it when building the SdkLoggerProvider. This is useful for adding metadata to all logs processed.

```rust
resource: Arc::new(Mutex::new(None)) \
        };
        let processor = SimpleLogProcessor::new(exporter.clone());
        let _ = SdkLoggerProvider::builder()
            .with_log_processor(processor)
            .with_resource(
                Resource::builder_empty()
                    .with_attributes([
                        KeyValue::new("k1", "v1"),
                        KeyValue::new("k2", "v3"),
                        KeyValue::new("k3", "v3"),
                        KeyValue::new("k4", "v4"),
                        KeyValue::new("k5", "v5"),
                    ])
                    .build(),
            )
            .build();
        assert_eq!(exporter.get_resource().unwrap().into_iter().count(), 5);
```

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

### Configure OpenTelemetry SDK Metrics

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

Demonstrates how to set up the SDK MeterProvider with a resource, create meters and instruments, record measurements, and shut down the provider. This is useful for initializing the metrics collection in an application.

```rust
use opentelemetry::global;
use opentelemetry::KeyValue;
use opentelemetry_sdk::{metrics::SdkMeterProvider,
    Resource};

// Generate SDK configuration, resource, views, etc
let resource = Resource::builder().build(); // default attributes about the current process

// Create a meter provider with the desired config
let meter_provider = SdkMeterProvider::builder().with_resource(resource).build();
global::set_meter_provider(meter_provider.clone());

// Use the meter provider to create meter instances
let meter = global::meter("my_app");

// Create instruments scoped to the meter
let counter = meter
    .u64_counter("power_consumption")
    .with_unit("kWh")
    .build();

// use instruments to record measurements
counter.add(10, &[KeyValue::new("rate", "standard")]);

// shutdown the provider at the end of the application to ensure any metrics not yet
// exported are flushed.
meter_provider.shutdown().unwrap();
```

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

### Handle Span Start

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.BatchSpanProcessor.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Callback function for when a span starts. This implementation is a no-op.

```rust
fn on_start(&self, _span: &mut Span, _cx: &Context)
```

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

### build

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/provider.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Create a new SdkTracerProvider from the current configuration.

```APIDOC
## build

### Description
Create a new provider from this configuration.

### Method Signature
`pub fn build(self) -> SdkTracerProvider`

### Returns
An `SdkTracerProvider` instance configured with the specified options.
```

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

### Initialize and Use TracerProvider

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/provider.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize a default SdkTracerProvider, set it as the global provider, create a tracer, and then explicitly shut down the provider.

```rust
use opentelemetry::global;
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry::trace::Tracer;

fn init_tracing() -> SdkTracerProvider {
    let provider = SdkTracerProvider::default();

    // Set the provider to be used globally
    let _ = global::set_tracer_provider(provider.clone());

    provider
}

fn main() {
    let provider = init_tracing();

    // create tracer..
    let tracer = global::tracer("example/client");

    // create span...
    let span = tracer
        .span_builder("test_span")
        .start(&tracer);

    // Explicitly shut down the provider
    provider.shutdown();
}

```

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

### SdkMeterProvider Configuration and Usage

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/index.html

Demonstrates how to configure and use the SdkMeterProvider to create meters and instruments, and record measurements. It also shows how to shut down the provider.

```APIDOC
## SdkMeterProvider Configuration and Usage

### Description
This example shows how to set up the OpenTelemetry SDK's metrics component. It includes creating a resource, building an `SdkMeterProvider` with the resource, setting it as the global provider, creating a meter, defining a counter instrument, recording a measurement, and finally shutting down the provider to ensure all metrics are flushed.

### Method
N/A (SDK Usage)

### Endpoint
N/A (SDK Usage)

### Parameters
N/A (SDK Usage)

### Request Example
```rust
use opentelemetry::global;
use opentelemetry::KeyValue;
use opentelemetry_sdk::{metrics::SdkMeterProvider, Resource};

// Generate SDK configuration, resource, views, etc
let resource = Resource::builder().build(); // default attributes about the current process

// Create a meter provider with the desired config
let meter_provider = SdkMeterProvider::builder().with_resource(resource).build();
global::set_meter_provider(meter_provider.clone());

// Use the meter provider to create meter instances
let meter = global::meter("my_app");

// Create instruments scoped to the meter
let counter = meter
    .u64_counter("power_consumption")
    .with_unit("kWh")
    .build();

// use instruments to record measurements
counter.add(10, &[KeyValue::new("rate", "standard")]);

// shutdown the provider at the end of the application to ensure any metrics not yet
// exported are flushed.
meter_provider.shutdown().unwrap();
```

### Response
N/A (SDK Usage)
```

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

### Instrument Example Usage

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/struct.Instrument.html?search=u32+-%3E+bool

An example demonstrating how to use an Instrument reference to filter instruments for a view.

```APIDOC
## Example

```rust
use opentelemetry_sdk::metrics::{Instrument, Stream};

let my_view_change_cardinality = |i: &Instrument| {
    if i.name() == "my_second_histogram" {
        // Note: If Stream is invalid, `build()` will return an error. By
        // calling `.ok()`, any such error is ignored and treated as if the
        // view does not match the instrument. If this is not the desired
        // behavior, consider handling the error explicitly.
        Stream::builder().with_cardinality_limit(2).build().ok()
    } else {
        None
    }
};
```
```

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

### Configure Meter Provider with Multiple Resources

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/metrics/meter_provider.rs.html

Shows how to build an SdkMeterProvider and apply multiple resources. Resources are additive, and attributes/schema URLs from different resources are merged.

```rust
let builder = SdkMeterProvider::builder()
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key1", "value1")])
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key2", "value2")])
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_schema_url(vec![], "http://example.com")
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key3", "value3")])
                    .build(),
            );

        let resource = builder.resource.unwrap();

        assert_eq!(resource.get(&Key::from_static_str("key1")),
            Some(Value::from("value1"))
        );
        assert_eq!(resource.get(&Key::from_static_str("key2")),
            Some(Value::from("value2"))
        );
        assert_eq!(resource.get(&Key::from_static_str("key3")),
            Some(Value::from("value3")),
        );
        assert_eq!(resource.schema_url(), Some("http://example.com"));
```

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

### SdkTracer: Start a Span with Context

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SdkTracer.html

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

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

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

### Initialize and Use SdkMeterProvider

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/struct.SdkMeterProvider.html

Demonstrates how to initialize an SdkMeterProvider, set it as the global meter provider, record measurements, force flush telemetry, and shut down the provider with a timeout. This is useful for setting up metric collection and ensuring all data is sent before the application exits.

```rust
use opentelemetry::{global, Context};
use opentelemetry_sdk::metrics::SdkMeterProvider;

fn init_metrics() -> SdkMeterProvider {
    // Setup metric pipelines with readers + views, default has no
    // readers so nothing is exported.
    let provider = SdkMeterProvider::default();

    // Set provider to be used as global meter provider
    let _ = global::set_meter_provider(provider.clone());

    provider
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = init_metrics();

    // create instruments + record measurements

    // force all instruments to flush
    provider.force_flush()?;

    // record more measurements..

    // shutdown ensures any cleanup required by the provider is done,
    // and also invokes shutdown on the readers.
    provider.shutdown()?;

    Ok(())
}
```

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

### SdkTracer: Start a Span

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SdkTracer.html

Starts a new span with a given name. This is a fundamental operation for creating trace spans.

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

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

### Configure Logger Provider with Multiple Resources

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/logger_provider.rs.html

Demonstrates how to build an SdkLoggerProvider and add multiple resources using chained `with_resource` calls. Verifies that all attributes and schema URLs from the added resources are correctly aggregated.

```rust
    #[test]
    fn with_resource_multiple_calls_ensure_additive() {
        let builder = SdkLoggerProvider::builder()
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key1", "value1")])
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key2", "value2")])
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_schema_url(vec![], "http://example.com")
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key3", "value3")])
                    .build(),
            );

        let resource = builder.resource.unwrap();

        assert_eq!(
            resource.get(&Key::from_static_str("key1")),
            Some(Value::from("value1"))
        );
        assert_eq!(
            resource.get(&Key::from_static_str("key2")),
            Some(Value::from("value2"))
        );
        assert_eq!(
            resource.get(&Key::from_static_str("key3")),
            Some(Value::from("value3"))
        );
        assert_eq!(resource.schema_url(), Some("http://example.com"));
    }
```

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

### Create and Start a Span

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

Demonstrates creating a span builder and starting a span with a given name. This is a fundamental operation for tracing.

```rust
let span = tracer.span_builder("must_not_be_sampled").start(&tracer);
```

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

### SimpleSpanProcessor::on_start

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SimpleSpanProcessor.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Called when a Span is started. This method is called synchronously on the thread that started the span and should not block or throw exceptions.

```APIDOC
## SimpleSpanProcessor::on_start

### Description
Called when a `Span` is started. This method is invoked synchronously on the thread that initiated the span. It is crucial that this method does not block or raise exceptions to maintain performance.

### Method
`on_start(&self, _span: &Span, _cx: &Context)`

### Parameters
* `_span` (&Span): The span that is being started. This parameter is unused in this implementation.
* `_cx` (&Context): The context associated with the span. This parameter is unused in this implementation.
```

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

### Configure and Use OpenTelemetry Metrics SDK

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/index.html

Demonstrates how to set up the OpenTelemetry SDK metrics provider, create meters and instruments, record measurements, and shut down the provider. This is useful for integrating metrics collection into an application.

```rust
use opentelemetry::global;
use opentelemetry::KeyValue;
use opentelemetry_sdk::{metrics::SdkMeterProvider,
    Resource};

// Generate SDK configuration, resource, views, etc
let resource = Resource::builder().build(); // default attributes about the current process

// Create a meter provider with the desired config
let meter_provider = SdkMeterProvider::builder().with_resource(resource).build();
global::set_meter_provider(meter_provider.clone());

// Use the meter provider to create meter instances
let meter = global::meter("my_app");

// Create instruments scoped to the meter
let counter = meter
    .u64_counter("power_consumption")
    .with_unit("kWh")
    .build();

// use instruments to record measurements
counter.add(10, &[KeyValue::new("rate", "standard")]);

// shutdown the provider at the end of the application to ensure any metrics not yet
// exported are flushed.
meter_provider.shutdown().unwrap();

```

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

### Configuring MeterProvider with Resource

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/metrics/meter_provider.rs.html?search=

Demonstrates how to build a `SdkMeterProvider` and associate it with a custom `Resource`, including service name and specific attributes. This is useful for identifying the entity producing telemetry.

```rust
use opentelemetry_sdk::{Resource, metrics::SdkMeterProvider};
use opentelemetry::KeyValue;

let provider = SdkMeterProvider::builder()
    .with_resource(
        Resource::builder()
            .with_service_name("my-service")
            .with_attributes([KeyValue::new("deployment.environment.name", "production")])
            .build(),
    )
    .build();

```

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

### SimpleSpanProcessor::on_start

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SimpleSpanProcessor.html?search=std%3A%3Avec

Called when a Span is started. This method is called synchronously on the thread that started the span, therefore it should not block or throw exceptions.

```APIDOC
## SimpleSpanProcessor::on_start

### Description
`on_start` is called when a `Span` is started. This method is called synchronously on the thread that started the span, therefore it should not block or throw exceptions.

### Signature
`fn on_start(&self, _span: &mut Span, _cx: &Context)`
```

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

### SpanProcessor::on_start

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/span_processor_with_async_runtime/struct.BatchSpanProcessor.html?search=std%3A%3Avec

Called when a Span is started. This method is called synchronously on the thread that started the span, therefore it should not block or throw exceptions.

```APIDOC
## SpanProcessor::on_start

### Description
`on_start` is called when a `Span` is started. This method is called synchronously on the thread that started the span, therefore it should not block or throw exceptions.

### Signature
```rust
fn on_start(&self, _span: &mut Span, _cx: &Context)
```
```

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

### Example Search: Option<T>, (T -> U) -> Option<U>

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/metrics/mod.rs.html?search=

Demonstrates a search query for 'Option<T>, (T -> U) -> Option<U>'. This pattern is relevant for functional programming concepts involving optional values and transformations.

```rust
Option<T>, (T -> U) -> Option<U>
```

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

### SimpleLogProcessor Usage Example

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/simple_log_processor.rs.html?search=

Demonstrates how to create and use a SimpleLogProcessor with an InMemoryLogExporter.

```APIDOC
## Using a SimpleLogProcessor

```rust
# #[cfg(feature = "testing")]
# {
use opentelemetry_sdk::logs::{SimpleLogProcessor, SdkLoggerProvider, LogExporter};
use opentelemetry::global;
use opentelemetry_sdk::logs::InMemoryLogExporter;

let exporter = InMemoryLogExporter::default(); // Replace with an actual exporter
let provider = SdkLoggerProvider::builder()
    .with_simple_exporter(exporter)
    .build();
# }
```
```

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

### Get Type ID

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/data/enum.MetricData.html

Implements the Any trait, providing a `type_id` method to get the TypeId of the implementing type. Requires the type to be 'static.

```rust
fn type_id(&self) -> TypeId
where
    Self: 'static,
{
    // Implementation details
}
```

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

### Example Implementation of SpanProcessor

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/trait.SpanProcessor.html

This example demonstrates how to implement the `SpanProcessor` trait, specifically the `on_start` and `on_end` methods, to extract and utilize context information.

```APIDOC
```rust
impl SpanProcessor for MyProcessor {
    fn on_start(&self, span: &mut Span, cx: &Context) {
        // Extract baggage and store as span attribute
        if let Some(value) = cx.baggage().get("my-key") {
            span.set_attribute(KeyValue::new("my-key", value.to_string()));
        }
    }

    fn on_end(&self, span: SpanData) {
        // Access the attribute stored in on_start
        let my_value = span.attributes.iter()
            .find(|kv| kv.key.as_str() == "my-key");
    }
}
```
```

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

### BatchLogProcessor Configuration with Tokio Runtime

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/log_processor_with_async_runtime.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates building a BatchLogProcessor with the Tokio runtime and configuring it using environment variables. It shows how invalid configuration values fall back to defaults.

```rust
let mut env_vars = vec![
            (OTEL_BLRP_MAX_EXPORT_BATCH_SIZE, Some("500")),
            (OTEL_BLRP_SCHEDULE_DELAY, Some("I am not number")),
            (OTEL_BLRP_EXPORT_TIMEOUT, Some("2046")),
        ];
        temp_env::with_vars(env_vars.clone(), || {
            let builder =
                BatchLogProcessor::builder(InMemoryLogExporter::default(), runtime::Tokio);

            assert_eq!(builder.config.max_export_batch_size, 500);
            assert_eq!(
                builder.config.scheduled_delay,
                OTEL_BLRP_SCHEDULE_DELAY_DEFAULT
            );
            assert_eq!(
                builder.config.export_timeout,
                std::time::Duration::from_secs(2046)
            );
        });
```

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

### Configure SimpleLogProcessor with Resource

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/logs/log_processor_with_async_runtime.rs.html?search=std%3A%3Avec

Demonstrates setting up a SimpleLogProcessor with a logger provider and associating a resource with custom attributes. This is useful for defining metadata for logs emitted by this provider.

```rust
resource: Arc::new(Mutex::new(None))};
        let processor = SimpleLogProcessor::new(exporter.clone());
        let _ = SdkLoggerProvider::builder()
            .with_log_processor(processor)
            .with_resource(
                Resource::builder_empty()
                    .with_attributes([
                        KeyValue::new("k1", "v1"),
                        KeyValue::new("k2", "v3"),
                        KeyValue::new("k3", "v3"),
                        KeyValue::new("k4", "v4"),
                        KeyValue::new("k5", "v5"),
                    ])
                    .build(),
            )
            .build();
        assert_eq!(exporter.get_resource().unwrap().into_iter().count(), 5);
```

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

### Build Meter Provider with Multiple Resources

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

Shows how to build a MeterProvider by adding multiple resources, ensuring attributes and schema URLs are additive.

```rust
let builder = SdkMeterProvider::builder()
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key1", "value1")])
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key2", "value2")])
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_schema_url(vec![], "http://example.com")
                    .build(),
            )
            .with_resource(
                Resource::builder_empty()
                    .with_attributes(vec![KeyValue::new("key3", "value3")])
                    .build(),
            );

        let resource = builder.resource.unwrap();

        assert_eq!(
            resource.get(&Key::from_static_str("key1")),
            Some(Value::from("value1"))
        );
        assert_eq!(
            resource.get(&Key::from_static_str("key2")),
            Some(Value::from("value2"))
        );
        assert_eq!(
            resource.get(&Key::from_static_str("key3")),
            Some(Value::from("value3"))
        );
        assert_eq!(resource.schema_url(), Some("http://example.com"));
```

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

### Get Underlying Array with as_array

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/struct.SpanLinks.html?search=std%3A%3Avec

Attempts to get a reference to the underlying array if the specified size `N` matches the slice's length.

```rust
let slice = &[1, 2, 3];
let array_ref: Option<&[i32; 3]> = slice.as_array();
assert!(array_ref.is_some());

let short_slice = &[1, 2];
let array_ref_short: Option<&[i32; 3]> = short_slice.as_array();
assert!(array_ref_short.is_none());
```

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

### Start and End a Span

Source: https://docs.rs/opentelemetry_sdk/latest/src/opentelemetry_sdk/trace/mod.rs.html?search=

Demonstrates starting a span, adding attributes and events, setting its status to error, and ending it. Operations after ending the span have no effect.

```rust
        // Act
        let tracer = provider.tracer("test_tracer");
        let mut span = tracer.start("span_name");
        span.set_attribute(KeyValue::new("attribute1", "value1"));
        span.add_event("test-event".to_string(), vec![]);
        span.set_status(Status::error("cancelled"));
        span.end();

        // After span end, further operations should not have any effect
        span.update_name("span_name_updated");
```
Tokens:
Raw