Struct tracing_actix_web::TracingLogger

pub struct TracingLogger<RootSpan: RootSpanBuilder> { /* private fields */ }

TracingLogger is a middleware to capture structured diagnostic when processing an HTTP request. Check the crate-level documentation for an in-depth introduction.

TracingLogger is designed as a drop-in replacement of actix-web’s Logger.

Usage

Register TracingLogger as a middleware for your application using .wrap on App.
In this example we add a tracing::Subscriber to output structured logs to the console.

use actix_web::App;
use tracing::{Subscriber, subscriber::set_global_default};
use tracing_actix_web::TracingLogger;
use tracing_log::LogTracer;
use tracing_bunyan_formatter::{BunyanFormattingLayer, JsonStorageLayer};
use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry};

/// Compose multiple layers into a `tracing`'s subscriber.
pub fn get_subscriber(
    name: String,
    env_filter: String
) -> impl Subscriber + Send + Sync {
    let env_filter = EnvFilter::try_from_default_env()
        .unwrap_or(EnvFilter::new(env_filter));
    let formatting_layer = BunyanFormattingLayer::new(
        name.into(),
        std::io::stdout
    );
    Registry::default()
        .with(env_filter)
        .with(JsonStorageLayer)
        .with(formatting_layer)
}

/// Register a subscriber as global default to process span data.
///
/// It should only be called once!
pub fn init_subscriber(subscriber: impl Subscriber + Send + Sync) {
    LogTracer::init().expect("Failed to set logger");
    set_global_default(subscriber).expect("Failed to set subscriber");
}

fn main() {
    let subscriber = get_subscriber("app".into(), "info".into());
    init_subscriber(subscriber);

    let app = App::new().wrap(TracingLogger::default());
}

Like actix-web’s Logger, in order to use TracingLogger inside a Scope, Resource, or Condition, the Compat middleware must be used.

use actix_web::middleware::Compat;
use actix_web::{web, App};
use tracing_actix_web::TracingLogger;

let app = App::new()
    .service(
        web::scope("/some/route")
            .wrap(Compat::new(TracingLogger::default())),
    );

Implementations

impl<RootSpan: RootSpanBuilder> TracingLogger<RootSpan>

pub fn new() -> TracingLogger<RootSpan>

Trait Implementations

impl<RootSpan: RootSpanBuilder> Clone for TracingLogger<RootSpan>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for TracingLogger<DefaultRootSpanBuilder>

fn default() -> Self

Returns the “default value” for a type.

impl<S, B, RootSpan> Transform<S, ServiceRequest> for TracingLogger<RootSpan>

where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S::Future: 'static, B: MessageBody + 'static, RootSpan: RootSpanBuilder,

type Response = ServiceResponse<StreamSpan<B>>

Responses produced by the service.

type Error = Error

Errors produced by the service.

type Transform = TracingLoggerMiddleware<S, RootSpan>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = Ready<Result<<TracingLogger<RootSpan> as Transform<S, ServiceRequest>>::Transform, <TracingLogger<RootSpan> as Transform<S, ServiceRequest>>::InitError>>

The future response value.

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

Creates and returns a new Transform component, asynchronously