Struct actix_web_opentelemetry::RequestTracing

pub struct RequestTracing { /* fields omitted */ }

Request tracing middleware.

Example:

use actix_web::{App, HttpServer, web};
use actix_web_opentelemetry::RequestTracing;
use opentelemetry::api;

fn init_tracer() {
    opentelemetry::global::set_provider(api::NoopProvider {});
}

fn main() -> std::io::Result<()> {
    init_tracer();
    HttpServer::new(|| {
        App::new()
            .wrap(RequestTracing::new(false))
            .service(web::resource("/").to(|| "Hello world!"))
    })
    .bind("127.0.0.1:8080")?
    .run()
}

Methods

impl RequestTracing

pub fn new(extract_single_header: bool) -> Self

Configures a request tracing middleware transformer.

This middleware supports both version of B3 headers.

1. Single Header:

• X-B3: {trace_id}-{span_id}-{sampling_state}-{parent_span_id}

2. Multiple Headers:

• X-B3-TraceId: {trace_id}
• X-B3-ParentSpanId: {parent_span_id}
• X-B3-SpanId: {span_id}
• X-B3-Sampled: {sampling_state}
• X-B3-Flags: {debug_flag}

Trait Implementations

impl Debug for RequestTracing

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

Formats the value using the given formatter.

impl<S, B> Transform<S> for RequestTracing where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static, 

type Request = ServiceRequest

Requests handled by the service.

type Response = ServiceResponse<B>

Responses given by the service.

type Error = Error

Errors produced by the service.

type Transform = RequestTracingMiddleware<S, HttpB3Propagator>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a service.

type Future = FutureResult<Self::Transform, Self::InitError>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Service component, asynchronously

fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E> where
    F: Fn(Self::InitError) -> E, 

Map this service's factory error to a different error, returning a new transform service factory.

fn from_err<E>(self) -> TransformFromErr<Self, S, E> where
    E: From<Self::InitError>, 

Map this service's init error to any error implementing From for this services Error`.