Struct TracingLayer

pub struct TracingLayer;

Add tracing for every operation.

Examples

Basic Setup

let _ = Operator::new(services::Memory::default())?
    .layer(TracingLayer)
    .finish();
Ok(())

Real usage

use opentelemetry::trace::TracerProvider;
let tracer_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
    .with_simple_exporter(opentelemetry_otlp::SpanExporter::builder().with_tonic().build()?)
    .with_resource(Resource::builder().with_attributes(vec![
        KeyValue::new("service.name", "opendal_example"),
    ]).build())
    .build();
let tracer = tracer_provider.tracer("opendal_tracer");
let opentelemetry = tracing_opentelemetry::layer().with_tracer(tracer);

tracing_subscriber::registry()
    .with(EnvFilter::from_default_env())
    .with(opentelemetry)
    .try_init()?;

{
    let runtime = tokio::runtime::Runtime::new()?;
    runtime.block_on(async {
        let root = tracing::span!(tracing::Level::INFO, "app_start", work_units = 2);
        let _enter = root.enter();

        let _ = dotenvy::dotenv();
        let op = Operator::new(services::Memory::default())?
            .layer(TracingLayer)
            .finish();

        op.write("test", "0".repeat(16 * 1024 * 1024).into_bytes())
            .await?;
        op.stat("test").await?;
        op.read("test").await?;
        Ok::<(), opendal::Error>(())
    })?;
}

// Shut down the current tracer provider.
// This will invoke the shutdown method on all span processors.
// span processors should export remaining spans before return.
tracer_provider.shutdown()?;

Ok(())

Output

OpenDAL is using tracing for tracing internally.

To enable tracing output, please init one of the subscribers that tracing supports.

For example:

let my_subscriber = FooSubscriber::new();
tracing::subscriber::set_global_default(my_subscriber).expect("setting tracing default failed");

For real-world usage, please take a look at tracing-opentelemetry.

Trait Implementations

impl<A> Layer<A> for TracingLayer

where A: Access,

type LayeredAccess = TracingAccessor<A>

The layered accessor that returned by this layer.

fn layer(&self, inner: A) -> <TracingLayer as Layer<A>>::LayeredAccess

Intercept the operations on the underlying storage.