Struct CallLogging 

pub struct CallLogging { /* private fields */ }

A Plugin that adds structured per-request logging to a Churust application.

CallLogging installs a single middleware in the Phase::Monitoring phase. For every request it records the HTTP method, request path, response status code, and elapsed wall-clock time in milliseconds, emitting them as a single tracing event.

Default log level

Unless overridden with CallLogging::level, events are emitted at Level::INFO.

Examples

Basic usage (default INFO level)

use churust_core::{Churust, Call, TestClient};
use churust_logging::CallLogging;

let app = Churust::server()
    .install(CallLogging::new())
    .routing(|r| {
        r.get("/ping", |_c: Call| async { "pong" });
    })
    .build();

let res = TestClient::new(app).get("/ping").send().await;
assert_eq!(res.status().as_u16(), 200);

Custom log level (DEBUG)

use churust_core::{Churust, Call, TestClient};
use churust_logging::CallLogging;
use tracing::Level;

let app = Churust::server()
    .install(CallLogging::new().level(Level::DEBUG))
    .routing(|r| {
        r.get("/", |_c: Call| async { "hi" });
    })
    .build();

let res = TestClient::new(app).get("/").send().await;
assert_eq!(res.status().as_u16(), 200);

Implementations

impl CallLogging

pub fn new() -> Self

Creates a new CallLogging plugin with the default log level (Level::INFO).

Use CallLogging::level on the returned value to select a different severity level before passing the plugin to AppBuilder::install.

Examples

use churust_logging::CallLogging;

let plugin = CallLogging::new();

pub fn level(self, level: Level) -> Self

Overrides the tracing level at which request events are emitted.

All five standard tracing levels are supported: Level::ERROR, Level::WARN, Level::INFO (default), Level::DEBUG, and Level::TRACE.

Choosing a lower level (e.g. DEBUG or TRACE) is useful in development where you want request logs without cluttering production output. Choosing a higher level (WARN or ERROR) lets you capture only unexpected or slow requests when combined with a filtered subscriber.

Arguments

• level — The tracing::Level to use for the emitted event.

Examples

use churust_logging::CallLogging;
use tracing::Level;

// Emit request logs at TRACE level (very verbose).
let plugin = CallLogging::new().level(Level::TRACE);

// Emit request logs at WARN level (production-quiet).
let plugin = CallLogging::new().level(Level::WARN);

Trait Implementations

impl Clone for CallLogging

fn clone(&self) -> CallLogging

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CallLogging

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

Formats the value using the given formatter.

impl Default for CallLogging

fn default() -> Self

Creates a CallLogging plugin with Level::INFO as the default log level.

This is equivalent to calling CallLogging::new().

impl Plugin for CallLogging

fn install(self: Box<Self>, app: &mut AppBuilder)

Install this plugin into the builder (register middleware, state, etc.). Consumes the boxed plugin.