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};
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, tokio::spawn, tokio::time::delay_for, tokio::time::interval)
        .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_batch_exporter(batch)
        .build();

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

Implementations

impl BatchSpanProcessor

pub fn builder<E, S, SH, SO, I, IO, D, DS>(
    exporter: E,
    spawn: S,
    delay: D,
    interval: I
) -> BatchSpanProcessorBuilder<E, S, I, D> where
    E: SpanExporter,
    S: Fn(BoxFuture<'static, ()>) -> SH,
    SH: Future<Output = SO> + Send + Sync + 'static,
    I: Fn(Duration) -> IO,
    D: Fn(Duration) -> DS + Send + Sync + 'static,
    DS: Future<Output = ()> + 'static + Send + Sync, 

Create a new batch processor builder

pub fn from_env<E, S, SH, SO, I, IO, D, DS>(
    exporter: E,
    spawn: S,
    interval: I,
    delay: D
) -> BatchSpanProcessorBuilder<E, S, I, D> where
    E: SpanExporter,
    S: Fn(BoxFuture<'static, ()>) -> SH,
    SH: Future<Output = SO> + Send + Sync + 'static,
    I: Fn(Duration) -> IO,
    D: Fn(Duration) -> DS + Send + Sync + 'static,
    DS: Future<Output = ()> + 'static + Send + Sync, 

Create a new batch processor builder and set the config value based on environment variables.

If the value in environment variables is illegal, will fall back to use default value.

Note that export batch size should be less than or equals to max queue size. If export batch size is larger than max queue size, we will lower to be the same as max queue size

Trait Implementations

impl Debug for BatchSpanProcessor

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

Formats the value using the given formatter.

impl SpanProcessor for BatchSpanProcessor

pub 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.

pub 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.

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

Force the spans lying in the cache to be exported.

pub 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.