[−][src]Module opentelemetry::sdk::trace::span_processor
Span Processor
Span processor is an interface which allows hooks for span start and end
method invocations. Span processors are invoked only when is_recording
is true
.
Built-in span processors are responsible for batching and conversion of
spans to exportable representation and passing batches to exporters.
Span processors can be registered directly on SDK Provider
and they are
invoked in the same order as they were registered.
All Tracer
instances created by a Provider
share the same span
processors. Changes to this collection reflect in all Tracer
instances.
The following diagram shows SpanProcessor
's relationship to other
components in the SDK:
+-----+--------------+ +-------------------------+ +-------------------+
| | | | | | |
| | | | BatchExporterProcessor | | SpanExporter |
| | +---> SimpleExporterProcessor +---> (JaegerExporter) |
| | | | | | |
| SDK | Span.start() | +-------------------------+ +-------------------+
| | Span.end() |
| | | +---------------------+
| | | | |
| | +---> ZPagesProcessor |
| | | | |
+-----+--------------+ +---------------------+
Examples
Exporting spans with a simple exporter:
Note that the simple processor exports synchronously every time a span is ended. If you find this limiting, consider the batch processor instead.
use opentelemetry::{api, sdk, global}; // Configure your preferred exporter let exporter = api::NoopSpanExporter {}; // Then use the `with_simple_exporter` method to have the provider export when spans finish. let provider = sdk::Provider::builder() .with_simple_exporter(exporter) .build(); global::set_provider(provider);
Exporting spans asynchronously in batches:
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::{api, sdk, global}; use std::time::Duration; #[tokio::main] async fn main() { // Configure your preferred exporter let exporter = api::NoopSpanExporter {}; // 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 = sdk::BatchSpanProcessor::builder(exporter, tokio::spawn, 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 = sdk::Provider::builder() .with_batch_exporter(batch) .build(); global::set_provider(provider); }
Structs
BatchConfig | Batch span processor configuration |
BatchSpanProcessor | A |
BatchSpanProcessorBuilder | A builder for creating |
BatchSpanProcessorWorker | A worker process that batches and processes spans as they are reported. |
SimpleSpanProcessor | A |