Struct TelemetryHandles 

pub struct TelemetryHandles {
    pub tracer_provider: SdkTracerProvider,
    pub meter_provider: Option<SdkMeterProvider>,
    pub logger_provider: Option<SdkLoggerProvider>,
    pub profiling_handle: Option<ProfilingHandle>,
    /* private fields */
}

Handles returned by init_telemetry or TelemetryBuilder::init.

Keep alive for the duration of the process. Call shutdown before exiting to flush pending spans, metrics, and logs.

When dropped, shutdown is attempted with a bounded timeout (default: 5 s). If the timeout expires a warning is logged but the process continues normally.

Example

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let handles = otel_bootstrap::init_telemetry("my-service")?;

    // run your application here …

    handles.shutdown()?;
    Ok(())
}

Fields

tracer_provider: SdkTracerProvider

meter_provider: Option<SdkMeterProvider>

logger_provider: Option<SdkLoggerProvider>

profiling_handle: Option<ProfilingHandle>

Implementations

impl TelemetryHandles

pub fn shutdown(&self) -> Result<(), Box<dyn Error>>

Flush pending data and shut down all providers.

Must be called before the tokio runtime shuts down so the batch exporter can send remaining spans over gRPC. Safe to call multiple times — subsequent calls are no-ops.

Best-effort. A provider that cannot flush — collector unreachable, export deadline exceeded — is logged at warn and shutdown continues to the next one. Failing to deliver telemetry is not a failure of the program that produced it, and a service must be able to exit cleanly when its collector is down. This mirrors what Drop has always done; the two paths previously disagreed, and shutdown() propagating was the odd one out.

The Result is retained for API compatibility and so a genuinely fallible step could be surfaced later; today every provider error is absorbed.

Historically this returned Ok for metrics purely because nothing registered instruments, so there was never anything to export. Once real instruments exist, an unreachable collector turns every shutdown into a 5-second timeout and an error — which is exactly the situation this must not turn into a failure.

Example

let handles = otel_bootstrap::init_telemetry("my-service").unwrap();
// … application logic …
handles.shutdown().expect("telemetry shutdown failed");

Trait Implementations

impl Drop for TelemetryHandles

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.