Struct opentelemetry::sdk::trace::BatchSpanProcessor

pub struct BatchSpanProcessor { /* fields omitted */ }

This is supported on crate feature trace only.

A SpanProcessor that asynchronously buffers finished spans and reports them at a preconfigured interval.

Examples

This processor can be configured with an executor of your choice to batch and upload spans asynchronously when they end. If you have added a library like tokio or async-std, you can pass in their respective spawn and interval functions to have batching performed in those contexts.

use futures::{stream};
use opentelemetry::{trace as apitrace, sdk::trace as sdktrace, global, runtime};
use std::time::Duration;

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

    // Then build a batch processor. You can use whichever executor you have available, for
    // example if you are using `async-std` instead of `tokio` you can replace the spawn and
    // interval functions with `async_std::task::spawn` and `async_std::stream::interval`.
    let batch = sdktrace::BatchSpanProcessor::builder(exporter, runtime::Tokio)
        .with_max_queue_size(4096)
        .build();

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

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

Implementations

impl BatchSpanProcessor

pub fn builder<E, R>(exporter: E, runtime: R) -> BatchSpanProcessorBuilder<E, R> where
    E: SpanExporter,
    R: Runtime, 

Create a new batch processor builder

Trait Implementations

impl Debug for BatchSpanProcessor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl SpanProcessor for BatchSpanProcessor

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

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.

fn on_end(&self, span: SpanData)

on_end is called after a Span is ended (i.e., the end timestamp is already set). This method is called synchronously within the Span::end API, therefore it should not block or throw an exception.

fn force_flush(&self) -> TraceResult<()>

Force the spans lying in the cache to be exported.

fn shutdown(&mut self) -> TraceResult<()>

Shuts down the processor. Called when SDK is shut down. This is an opportunity for processors to do any cleanup required.