OpenTelemetry SDK

https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/
Admin
OpenTelemetry SDK is a Rust implementation of the OpenTelemetry SDK component that provides trace,...
Tokens:44,532
Snippets:576
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize SimpleLogProcessor

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.SimpleLogProcessor.html

Example showing how to configure an SdkLoggerProvider with a SimpleLogProcessor.

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

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

### Slice get method example

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

Example usage of the get method on a slice.

```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));
```

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

### Slice first method example

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

Example usage of the first method on a slice.

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

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

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

### Using a BatchLogProcessor

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.BatchLogProcessor.html

Example demonstrating how to configure and initialize a BatchLogProcessor with a custom batch configuration and attach it to an SdkLoggerProvider.

```rust
use opentelemetry_sdk::logs::{BatchLogProcessor, BatchConfigBuilder, SdkLoggerProvider};
use opentelemetry::global;
use std::time::Duration;
use opentelemetry_sdk::logs::InMemoryLogExporter;

let exporter = InMemoryLogExporter::default(); // Replace with an actual exporter
let processor = BatchLogProcessor::builder(exporter)
    .with_batch_config(
        BatchConfigBuilder::default()
            .with_max_queue_size(2048)
            .with_max_export_batch_size(512)
            .with_scheduled_delay(Duration::from_secs(5))
            .build(),
    )
    .build();

let provider = SdkLoggerProvider::builder()
    .with_log_processor(processor)
    .build();
```

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

### Slice last method example

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

Example usage of the last method on a slice.

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

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

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

### Slice first_chunk method example

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

Example usage of the first_chunk method on a slice.

```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>());
```

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

### Slice split_first method example

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

Example usage of the split_first method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

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

### Slice is_empty method example

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

Example usage of the is_empty method on a slice.

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

let b: &[i32] = &[];
assert!(b.is_empty());
```

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

### Slice split_first_chunk method example

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

Example usage of the split_first_chunk method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

assert_eq!(None, x.split_first_chunk::<4>());
```

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

### Slice split_last_chunk method example

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

Example usage of the split_last_chunk method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());
```

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

### Slice last_chunk method example

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

Example usage of the last_chunk method on a slice.

```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>());
```

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

### Slice len method example

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

Example usage of the len method on a slice.

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

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

### Slice split_last method example

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

Example usage of the split_last method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

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

### FromIterator Implementation for Result

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

Examples demonstrating how FromIterator collects Results, stopping at the first Err encountered.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

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

### Customize Metrics with Views

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

Views allow for renaming, transforming, or limiting the cardinality of metrics without changing instrument definitions. These examples demonstrate renaming, cardinality limits, and handling stream build errors.

```rust
let view_rename = |i: &Instrument| {
    if i.name() == "my_counter" {
        Some(Stream::builder().with_name("my_counter_renamed").build().expect("Stream should be valid"))
    } else {
        None
    }
};
builder.with_view(view_rename);
```

```rust
let view_change_cardinality = |i: &Instrument| {
    if i.name() == "my_counter" {
        Some(
            Stream::builder()
                .with_cardinality_limit(100).build().expect("Stream should be valid"),
        )
    } else {
        None
    }
};
builder.with_view(view_change_cardinality);
```

```rust
let my_view_change_cardinality = |i: &Instrument| {
    if i.name() == "my_second_histogram" {
        // Note: If Stream is invalid, build() will return `Error` variant.
        // 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(0).build().ok()
    } else {
        None
    }
};
builder.with_view(my_view_change_cardinality);
```

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

### Check if a slice starts with a prefix

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

Verifies if a slice begins with a specific sequence of elements.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

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

### Iterate over slice elements

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

The iter method provides an iterator over all items in the slice from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### Reverse split a slice

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

Splits a slice into subslices starting from the end based on a predicate.

```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);
```

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

### Split slice into fixed-size arrays from the end

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

Uses as_rchunks to split a slice into arrays of size N starting from the end. Panics if N is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

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

### Iterate over chunks from the end

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

Uses rchunks to iterate over non-overlapping chunks of a specific size starting from the end. Panics if chunk_size is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

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

### Reverse split a slice into at most n items

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

Splits a slice into a maximum of n items starting from the end based on a predicate.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

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

### Initialize and manage SdkMeterProvider

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

Demonstrates setting up a provider, registering it globally, and performing manual flush and shutdown operations.

```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(())
}
```

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

### Configure and use SdkMeterProvider

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

Demonstrates initializing a meter provider with a resource, creating a meter, defining a counter instrument, and recording measurements.

```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();
```

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

### Initialize a Trace Pipeline

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

Demonstrates how to configure an SdkTracerProvider with a simple exporter and execute a span. Ensure an appropriate exporter is provided to the builder.

```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")
}
```

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

### Initialize and use InMemoryMetricExporter

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

Demonstrates creating an exporter, registering it with a MeterProvider, recording a metric, and retrieving the results.

```rust
// Create an InMemoryMetricExporter
 let exporter = InMemoryMetricExporter::default();

 // Create a MeterProvider and register the exporter
 let meter_provider = metrics::SdkMeterProvider::builder()
     .with_reader(PeriodicReader::builder(exporter.clone()).build())
     .build();

 // Create and record metrics using the MeterProvider
 let meter = meter_provider.meter("example");
 let counter = meter.u64_counter("my_counter").build();
 counter.add(1, &[KeyValue::new("key", "value")]);

 meter_provider.force_flush().unwrap();

 // Retrieve the finished metrics from the exporter
 let finished_metrics = exporter.get_finished_metrics().unwrap();

 // Print the finished metrics
for resource_metrics in finished_metrics {
     println!("{:?}", resource_metrics);
 }
```

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

### build

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

Constructs a new SdkMeterProvider with the current configuration.

```APIDOC
## pub fn build(self) -> SdkMeterProvider

### Description
Consumes the builder and constructs a new `SdkMeterProvider` instance using the configured resources, readers, and views.
```

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

### Create metrics instruments and record measurements

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

Initializes a meter from the global provider, builds a counter instrument, and records a measurement with associated attributes.

```rust
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")]);
```

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

### Configure BatchSpanProcessor with Tokio

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

Demonstrates initializing a BatchSpanProcessor with the Tokio runtime and a NoopSpanExporter.

```rust
use opentelemetry::global;
use opentelemetry_sdk::{runtime, testing::trace::NoopSpanExporter, trace};
use opentelemetry_sdk::trace::BatchConfigBuilder;
use std::time::Duration;
use opentelemetry_sdk::trace::span_processor_with_async_runtime::BatchSpanProcessor;

#[tokio::main]
async fn main() {
    // Configure your preferred exporter
    let exporter = NoopSpanExporter::new();

    // Create a batch span processor using an exporter and a runtime
    let batch = BatchSpanProcessor::builder(exporter, runtime::Tokio)
        .with_batch_config(BatchConfigBuilder::default().with_max_queue_size(4096).build())
        .build();

    // Then use the `with_batch_exporter` method to have the provider export spans in batches.
    let provider = trace::SdkTracerProvider::builder()
        .with_span_processor(batch)
        .build();

    let _ = global::set_tracer_provider(provider);
}
```

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

### Create and use an InMemoryLogExporter

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/in_memory_exporter/struct.InMemoryLogExporterBuilder.html

Demonstrates initializing an exporter, registering it with a LoggerProvider, and retrieving emitted logs for verification.

```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);
   }
```

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

### Initialize PeriodicReader

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

Demonstrates how to build a PeriodicReader instance using a push exporter and an async runtime.

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

let exporter = get_exporter(); // set up a push exporter like OTLP
let runtime = get_runtime(); // select runtime: e.g. opentelemetry_sdk:runtime::Tokio

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

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

### build

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

Create a new provider from this configuration.

```APIDOC
## pub fn build(self) -> SdkTracerProvider

### Description
Create a new SdkTracerProvider instance from the current configuration.
```

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

### Associate a resource with the provider

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

Shows how to configure a Resource with custom attributes and service names before building the provider.

```rust
use opentelemetry_sdk::{Resource, trace::SdkTracerProvider};
use opentelemetry::KeyValue;

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

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

### build

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

Builds a BatchSpanProcessor instance from the current configuration.

```APIDOC
## pub fn build(self) -> BatchSpanProcessor<R>

### Description
Consumes the builder and returns a configured BatchSpanProcessor instance.
```

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

### build

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/log_processor_with_async_runtime/struct.BatchLogProcessorBuilder.html

Constructs the BatchLogProcessor instance.

```APIDOC
## pub fn build(self) -> BatchLogProcessor<R>

### Description
Finalizes the configuration and builds the BatchLogProcessor instance.
```

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

### Configure a dynamic sampler

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

Demonstrates how to provide a custom or boxed sampler to the builder using the with_sampler method.

```rust
use opentelemetry_sdk::trace::{Sampler, ShouldSample};

fn should_return_dynamic_sampler() -> Box<dyn ShouldSample + 'static> {
    Box::new(opentelemetry_sdk::trace::Sampler::AlwaysOn)
}

opentelemetry_sdk::trace::SdkTracerProvider::builder()
    // You can pass already boxed sampler if you need to configure your sampler in a simple fashion
    // This can be useful if you create your own sampler that implements `ShouldSample`
    .with_sampler(should_return_dynamic_sampler())
    // Or you can pass exact instance if you do not have complex configuration
    .with_sampler(Sampler::AlwaysOff);
```

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

### Configure LoggerProvider with Resource

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

Demonstrates how to associate a custom Resource with an SdkLoggerProvider using the builder.

```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();
```

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

### SimpleSpanProcessor::new

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

Creates a new instance of SimpleSpanProcessor using the provided exporter.

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

### Description
Creates a new SimpleSpanProcessor using the provided exporter.

### Parameters
- **exporter** (T: SpanExporter) - Required - The exporter instance used to export spans.
```

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

### Create a Stream using StreamBuilder

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

Demonstrates the fluent builder pattern to configure and instantiate a new Stream object.

```rust
use opentelemetry_sdk::metrics::Stream;

let stream = Stream::builder()
    .with_name("my_stream")
    .with_description("A custom stream")
    .with_unit("ms")
    .with_cardinality_limit(100)
    .build()
    .unwrap();
```

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

### ManualReaderBuilder::new

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

Creates a new instance of the ManualReaderBuilder.

```APIDOC
## pub fn new() -> Self

### Description
Initializes a new manual builder configuration for a ManualReader.

### Signature
`pub fn new() -> Self`
```

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

### ManualReaderBuilder::build

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

Constructs the ManualReader instance.

```APIDOC
## pub fn build(self) -> ManualReader

### Description
Creates a new ManualReader instance based on the current configuration.

### Returns
- **ManualReader** - The configured reader instance.
```

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

### SimpleLogProcessor::new

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.SimpleLogProcessor.html

Creates a new instance of SimpleLogProcessor using the provided log exporter.

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

### Description
Creates a new instance of `SimpleLogProcessor` that exports log records synchronously using the provided `LogExporter`.

### Parameters
- **exporter** (T: LogExporter) - Required - The exporter implementation used to export log records.
```

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

### Initialize ManualReader

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

Create a new instance of ManualReader using the builder pattern.

```rust
use opentelemetry_sdk::metrics::ManualReader;

// can specify additional reader configuration
let reader = ManualReader::builder().build();
```

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

### TraceContextPropagator::new

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/propagation/struct.TraceContextPropagator.html

Creates a new instance of the TraceContextPropagator.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new TraceContextPropagator instance.
```

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

### BatchSpanProcessor::new

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

Creates a new instance of BatchSpanProcessor with a specified exporter and configuration.

```APIDOC
## pub fn new<E>(exporter: E, config: BatchConfig) -> Self

### Description
Creates a new instance of `BatchSpanProcessor` using the provided span exporter and batch configuration.

### Parameters
- **exporter** (E) - Required - An implementation of `SpanExporter` that is `Send` and `'static`.
- **config** (BatchConfig) - Required - The configuration settings for batching.
```

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

### Create BatchLogProcessor Builder

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/log_processor_with_async_runtime/struct.BatchLogProcessor.html

Creates a new builder for the batch log processor.

```rust
pub fn builder<E>(exporter: E, runtime: R) -> BatchLogProcessorBuilder<E, R>
where E: LogExporter, 
      runtime: R
```

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

### ManualReader::builder()

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

Creates a new builder instance to configure a ManualReader.

```APIDOC
## pub fn builder() -> ManualReaderBuilder

### Description
Returns a builder instance used to configure the ManualReader.

### Signature
`pub fn builder() -> ManualReaderBuilder`
```

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

### Calculate Product of Result Items

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

Demonstrates using the product method on an iterator of Results, which short-circuits on the first Err encountered.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

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

### build

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

Creates a PeriodicReader instance using the configured settings.

```APIDOC
## pub fn build(self) -> PeriodicReader<E>

### Description
Finalizes the configuration and constructs a new PeriodicReader instance.
```

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

### meter(name: &'static str) -> Meter

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

Returns a new Meter with the provided name and default configuration.

```APIDOC
### Method
meter(name: &'static str) -> Meter

### Description
Returns a new Meter with the provided name and default configuration.

### Parameters
- **name** (&'static str) - Required - The name of the meter to create.
```

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

### with_sampler

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

Specify the sampler to be used.

```APIDOC
## pub fn with_sampler(self, sampler: impl Into<Box<dyn ShouldSample>>) -> Self

### Description
Specify the sampler to be used for sampling decisions.
```

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

### Initialize InMemorySpanExporter

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

Create a new builder instance and build the exporter.

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

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

### Force flush spans with SdkTracerProvider

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

Demonstrates initializing a global tracer provider and manually triggering a flush of all pending spans.

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

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

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

    provider
}

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

    // create spans..

    // force all spans to flush
    if let Err(err) = provider.force_flush() {
        // .. handle flush error
    }

    // create more spans..

    // dropping provider ensures all remaining spans are exported
    drop(provider);
}
```

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

### Create an InMemoryMetricExporter

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

Initialize a new exporter using the builder pattern.

```rust
let exporter = InMemoryMetricExporterBuilder::new().build();
```

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

### tracer(name: impl Into<Cow<'static, str>>)

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

Creates a new tracer with the specified name.

```APIDOC
## fn tracer(&self, name: impl Into<Cow<'static, str>>) -> Self::Tracer

### Description
Returns a new tracer with the given name.

### Parameters
- **name** (impl Into<Cow<'static, str>>) - Required - The name of the tracer to create.
```

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

### with_resource

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

Associates a Resource with a SdkTracerProvider.

```APIDOC
## pub fn with_resource(self, resource: Resource) -> Self

### Description
Associates a Resource with a SdkTracerProvider. This Resource represents the entity producing telemetry and is associated with all Tracers the SdkTracerProvider will create. Calls to this method are additive.
```

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

### Default::default()

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

Creates a new BatchConfigBuilder instance initialized with default values, which are automatically overridden by specific environment variables if present.

```APIDOC
## fn default()

### Description
Creates a new `BatchConfigBuilder` initialized with default batch config values as per the OpenTelemetry specifications. The values are overridden by environment variables if set.

### Supported Environment Variables
- `OTEL_BSP_MAX_QUEUE_SIZE`
- `OTEL_BSP_SCHEDULE_DELAY`
- `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
- `OTEL_BSP_EXPORT_TIMEOUT`
- `OTEL_BSP_MAX_CONCURRENT_EXPORTS`

### Note
Programmatic configuration overrides any value set via the environment variable.
```

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

### SdkLoggerProvider::builder

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.SdkLoggerProvider.html

Creates a new LoggerProvider builder to configure the provider.

```APIDOC
## pub fn builder() -> LoggerProviderBuilder

### Description
Create a new `LoggerProvider` builder.
```

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

### with_batch_config

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/log_processor_with_async_runtime/struct.BatchLogProcessorBuilder.html

Sets the configuration for the batch log processor.

```APIDOC
## pub fn with_batch_config(self, config: BatchConfig) -> Self

### Description
Sets the BatchConfig for the BatchLogProcessorBuilder instance.

### Parameters
- **config** (BatchConfig) - Required - The configuration settings for batch processing.
```

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

### LogBatch Constructor

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.LogBatch.html

Creates a new instance of LogBatch. Note that this is not a public function and should not be used directly.

```rust
pub fn new( data: &'a [(&'a SdkLogRecord, &'a InstrumentationScope)], ) -> LogBatch<'a>
```

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

### InMemorySpanExporterBuilder::new

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

Creates a new instance of the InMemorySpanExporterBuilder.

```APIDOC
### pub fn new() -> Self

Creates a new instance of the `InMemorySpanExporterBuilder`.
```

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

### BatchConfigBuilder Methods

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.BatchConfigBuilder.html

Methods available on the BatchConfigBuilder for configuring log batch processing parameters.

```APIDOC
## pub fn with_max_queue_size(self, max_queue_size: usize) -> Self

Sets the maximum queue size to buffer logs for delayed processing. If the queue is full, logs are dropped. Default is 2048.

## pub fn with_scheduled_delay(self, scheduled_delay: Duration) -> Self

Sets the delay interval between two consecutive processing of batches. Default is 1000 milliseconds.

## pub fn with_max_export_timeout(self, max_export_timeout: Duration) -> Self

Sets the maximum duration to export a batch of data. Default is 30000 milliseconds. Requires `experimental_logs_batch_log_processor_with_async_runtime` feature.

## pub fn with_max_export_batch_size(self, max_export_batch_size: usize) -> Self

Sets the maximum number of logs to process in a single batch. Default is 512.

## pub fn build(self) -> BatchConfig

Builds a `BatchConfig` instance, ensuring that `max_export_batch_size` is less than or equal to `max_queue_size`.
```

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

### SdkTracerProvider::builder

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

Creates a new builder instance for configuring an SdkTracerProvider.

```APIDOC
## pub fn builder() -> TracerProviderBuilder

### Description
Creates a new `SdkTracerProvider` builder to configure and initialize a tracer provider.
```

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

### InMemoryLogExporterBuilder::new

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/in_memory_exporter/struct.InMemoryLogExporterBuilder.html

Creates a new instance of the InMemoryLogExporterBuilder.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new instance of `InMemoryLogExporterBuilder`.

### Signature
`pub fn new() -> Self`
```

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

### BaggagePropagator::new

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/propagation/struct.BaggagePropagator.html

Constructs a new instance of the BaggagePropagator.

```APIDOC
### pub fn new() -> Self

Constructs a new baggage propagator.
```

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

### Using Result::and

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

Demonstrates chaining two Result values where the second is returned if the first is Ok.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

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

### Associate a Resource with a MeterProvider

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

Use with_resource to define the entity producing telemetry. Calls are additive, merging the provided resource with any previously set resources.

```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();
```

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

### BatchConfigBuilder Methods

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

Methods available on the BatchConfigBuilder to configure span batching behavior.

```APIDOC
## pub fn with_max_queue_size(self, max_queue_size: usize) -> Self

### Description
Sets the maximum queue size to buffer spans for delayed processing. If the queue is full, spans are dropped. The default value is 2048.

### Parameters
- **max_queue_size** (usize) - Required - The maximum number of spans to buffer.

## pub fn with_max_export_batch_size(self, max_export_batch_size: usize) -> Self

### Description
Sets the maximum number of spans to process in a single batch. The default value is 512.

### Parameters
- **max_export_batch_size** (usize) - Required - The maximum number of spans per batch.

## pub fn with_max_concurrent_exports(self, max_concurrent_exports: usize) -> Self

### Description
Sets the maximum number of concurrent export tasks. This is only honored by the async-runtime BatchSpanProcessor.

### Parameters
- **max_concurrent_exports** (usize) - Required - The maximum number of concurrent exports.

## pub fn with_scheduled_delay(self, scheduled_delay: Duration) -> Self

### Description
Sets the delay interval between consecutive processing of batches. The default value is 5000 milliseconds.

### Parameters
- **scheduled_delay** (Duration) - Required - The duration between batch processing cycles.

## pub fn with_max_export_timeout(self, max_export_timeout: Duration) -> Self

### Description
Sets the maximum duration allowed to export a batch of data. The default value is 30000 milliseconds.

### Parameters
- **max_export_timeout** (Duration) - Required - The maximum timeout duration.

## pub fn build(self) -> BatchConfig

### Description
Builds a BatchConfig instance, ensuring that max_export_batch_size is less than or equal to max_queue_size.
```

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

### SdkLoggerProvider::logger

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.SdkLoggerProvider.html

Returns a new logger with the specified name.

```APIDOC
## fn logger(&self, name: impl Into<Cow<'static, str>>) -> Self::Logger

### Description
Returns a new logger with the given name.
```

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

### BatchSpanProcessor::builder

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

Returns a builder for configuring a BatchSpanProcessor.

```APIDOC
## pub fn builder<E>(exporter: E) -> BatchSpanProcessorBuilder<E>

### Description
Returns a builder instance to configure and create a `BatchSpanProcessor`.
```

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

### with_view

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

Adds a view to the MeterProvider to customize how metrics are aggregated, renamed, or transformed.

```APIDOC
## pub fn with_view<T>(self, view: T) -> Self

### Description
Adds a view to the `MeterProvider`. Views allow customization of metric aggregation, renaming, or transformation before export without modifying instrument definitions. The view is a function or closure matching `Fn(&Instrument) -> Option<Stream> + Send + Sync + 'static`.

### Parameters
- **view** (T) - Required - A function or closure that defines how to transform instruments into streams.
```

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

### Runtime::spawn

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/runtime/struct.Tokio.html

Spawns a new task or thread to execute the provided future.

```APIDOC
## fn spawn<F>(&self, future: F)

### Description
Spawn a new task or thread, which executes the given future.

### Parameters
- **future** (F) - The future to execute, must implement Future<Output = ()> + Send + 'static.
```

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

### Check Result Success with Predicate using is_ok_and

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

Verifies if a Result is Ok and matches a specific predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

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

### SdkMeterProvider::builder

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

Returns a default MeterProviderBuilder for configuring the provider.

```APIDOC
## pub fn builder() -> MeterProviderBuilder

### Description
Returns a default MeterProviderBuilder to configure and create a new SdkMeterProvider instance.
```

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

### ResourceBuilder Methods

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/resource/struct.ResourceBuilder.html

Methods available on the ResourceBuilder for configuring and building a Resource.

```APIDOC
## ResourceBuilder Methods

### with_detector(detector: Box<dyn ResourceDetector>) -> Self
Adds a single ResourceDetector to the builder.

### with_detectors(detectors: &[Box<dyn ResourceDetector>]) -> Self
Adds multiple ResourceDetectors to the builder.

### with_attribute(kv: KeyValue) -> Self
Adds a single KeyValue attribute to the resource.

### with_attributes<T: IntoIterator<Item = KeyValue>>(kvs: T) -> Self
Adds multiple KeyValue attributes to the resource.

### with_service_name(name: impl Into<Value>) -> Self
Adds the 'service.name' resource attribute.

### with_schema_url<KV, S>(attributes: KV, schema_url: S) -> Self
Merges the provided schema_url with the current state of the Resource being built.

### build() -> Resource
Consumes the builder and returns the configured Resource.
```

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

### with_simple_exporter

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

Adds a SimpleSpanProcessor with the configured exporter to the pipeline.

```APIDOC
## pub fn with_simple_exporter<T: SpanExporter + 'static>(self, exporter: T) -> Self

### Description
Adds a SimpleSpanProcessor with the configured exporter to the pipeline. Processors are invoked in the order they are added.

### Arguments
- **exporter** (T) - The exporter to be used by the SimpleSpanProcessor.
```

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

### Convert Result to Reference with as_ref

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

Creates a new Result containing references to the original values.

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

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Using Result::or

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

Returns the provided result if the current result is Err, otherwise returns the current Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));

let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));
```

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

### with_batch_config

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

Sets the BatchConfig for the BatchSpanProcessorBuilder.

```APIDOC
## pub fn with_batch_config(self, config: BatchConfig) -> Self

### Description
Sets the BatchConfig for the BatchSpanProcessorBuilder instance.

### Parameters
- **config** (BatchConfig) - Required - The configuration object defining batching behavior.
```

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

### with_endpoint

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

Sets the remote server endpoint for sampling strategies. Defaults to http://localhost:5778/sampling.

```APIDOC
### pub fn with_endpoint<Str: Into<String>>(self, endpoint: Str) -> Self

Sets the URL of the remote Jaeger sampling server.
```

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

### Logical And Chaining

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

Returns the provided result if the current result is Ok, otherwise returns the Err.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));

let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
```

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

### build

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

Constructs the JaegerRemoteSampler instance based on the configured parameters.

```APIDOC
### pub fn build(self) -> Result<Sampler, JaegerRemoteSamplerBuildError>

Finalizes the configuration and returns a Sampler. Returns an error if the endpoint or service name is empty.
```

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

### Use InMemorySpanExporter in a TracerProvider

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

Demonstrates configuring an SdkTracerProvider with an InMemorySpanExporter to capture spans during application execution.

```rust

    let exporter = InMemorySpanExporterBuilder::new().build();
    let provider = SdkTracerProvider::builder()
        .with_span_processor(BatchSpanProcessor::builder(exporter.clone()).build())
        .build();

    global::set_tracer_provider(provider.clone());

    let tracer = global::tracer("example/in_memory_exporter");
    let span = tracer
        .span_builder("say hello")
        .with_kind(SpanKind::Server)
        .start(&tracer);

    let cx = Context::current_with_span(span);
    cx.span().add_event("handling this...", Vec::new());
    cx.span().end();

    if let Err(e) = provider.force_flush() {
        println!("{:?}", e)
    }
    let spans = exporter.get_finished_spans().unwrap();
    for span in spans {
        println!("{:?}", span)
    }
```

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

### Resource::builder

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/resource/struct.Resource.html

Creates a ResourceBuilder initialized with default detectors including SdkProvidedResourceDetector, TelemetryResourceDetector, and EnvResourceDetector.

```APIDOC
## pub fn builder() -> ResourceBuilder

### Description
Creates a ResourceBuilder that allows you to configure multiple aspects of the Resource. This builder includes default ResourceDetectors.
```

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

### Unwrap or Default Value

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

Returns the Ok value or the default value for the type if the result is an Err.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

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

### SdkLoggerProvider Definition

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.SdkLoggerProvider.html

The structure definition for SdkLoggerProvider.

```rust
pub struct SdkLoggerProvider { /* private fields */ }
```

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

### with_resource

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

Associates a Resource with the MeterProvider. This resource represents the entity producing telemetry and is associated with all meters created by the provider.

```APIDOC
## pub fn with_resource(self, resource: Resource) -> Self

### Description
Associates a `Resource` with a `MeterProvider`. This resource represents the entity producing telemetry and is associated with all meters the provider will create. Calls are additive, merging the provided resource with any previously set resources.

### Parameters
- **resource** (Resource) - Required - The resource to associate with the provider.
```

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

### jaeger_remote

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/trace/enum.Sampler.html

Creates a builder for a Jaeger remote sampler, allowing for dynamic sampling decisions based on remote configuration.

```APIDOC
## fn jaeger_remote

### Description
Creates a jaeger remote sampler builder. This function is available only when the `jaeger_remote_sampler` crate feature is enabled.

### Parameters
- **runtime** (RuntimeChannel) - Required - A runtime to run the HTTP client.
- **http_client** (HttpClient) - Required - An HTTP client to query the sampling endpoint.
- **default_sampler** (ShouldSample) - Required - A default sampler to make a sampling decision when the remote is unavailable or before the SDK receives the first response from remote.
- **service_name** (Into<String>) - Required - The name of the service, required to query the sampling endpoint.
```

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

### unwrap_or

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

Returns the contained Ok value or a provided default value.

```APIDOC
## pub fn unwrap_or(self, default: T) -> T

### Description
Returns the contained `Ok` value or a provided default. Arguments passed to `unwrap_or` are eagerly evaluated.

### Requirements
- Available on crate feature `metrics` only.
```

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

### new_test_exporter

Source: https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/testing/trace/fn.new_test_exporter.html

Creates a new test exporter for OpenTelemetry tracing, returning the exporter and channels to receive span data and signals.

```APIDOC
## Function: new_test_exporter

### Description
Creates a new test exporter for OpenTelemetry tracing. This function is available only when the `testing` crate feature is enabled.

### Signature
`pub fn new_test_exporter() -> (TestSpanExporter, UnboundedReceiver<SpanData>, UnboundedReceiver<()>)`

### Returns
- **TestSpanExporter**: The exporter instance used for testing.
- **UnboundedReceiver<SpanData>**: A receiver channel for span data.
- **UnboundedReceiver<()>**: A receiver channel for signals.
```

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

### StreamBuilder Methods

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

Methods available on the StreamBuilder to configure and construct a Stream instance.

```APIDOC
## StreamBuilder Methods

### with_name(name: impl Into<Cow<'static, str>>) -> Self
Sets the stream name. If not set, the name provided during instrument creation is used.

### with_description(description: impl Into<Cow<'static, str>>) -> Self
Sets the stream description. If not set, the description provided during instrument creation is used.

### with_unit(unit: impl Into<Cow<'static, str>>) -> Self
Sets the stream unit. If not set, the unit provided during instrument creation is used.

### with_aggregation(aggregation: Aggregation) -> Self
Sets the stream aggregation. If not set, the default aggregation based on the instrument kind is used.

### with_cardinality_limit(limit: usize) -> Self
Sets the stream cardinality limit. If not set, the default limit of 2000 is used.

### build() -> Result<Stream, Box<dyn Error>>
Builds a new Stream instance using the current configuration. Returns a Result containing the Stream or an error if the build fails.
```

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

### Using Result::unwrap_or

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

Returns the contained Ok value or a provided default value.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

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

### Config Struct Definition

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

The definition of the Config struct, which requires the 'trace' crate feature.

```rust
#[non_exhaustive]
pub struct Config {
    pub sampler: Box<dyn ShouldSample>,
    pub id_generator: Box<dyn IdGenerator>,
    pub span_limits: SpanLimits,
    pub resource: Cow<'static, Resource>,
}
```
Tokens:
Raw