Struct LoggingMiddleware 

pub struct LoggingMiddleware { /* private fields */ }

Django-style request logging middleware with colored output

Outputs request logs in Django’s runserver format with latency: [DD/Mon/YYYY HH:MM:SS] "METHOD /path HTTP/1.1" STATUS SIZE LATENCYms

Status codes are color-coded:

• 2xx: Green (success)
• 3xx: Cyan (redirect)
• 4xx: Yellow (client error)
• 5xx: Red (server error)

Examples

use std::sync::Arc;
use reinhardt_middleware::LoggingMiddleware;
use reinhardt_http::{Handler, Middleware, Request, Response};
use hyper::{Method, Version, HeaderMap, StatusCode};
use bytes::Bytes;

struct TestHandler;

#[async_trait::async_trait]
impl Handler for TestHandler {
    async fn handle(&self, _request: Request) -> reinhardt_core::exception::Result<Response> {
        Ok(Response::new(StatusCode::OK).with_body(Bytes::from("OK")))
    }
}

let middleware = LoggingMiddleware::new();
let handler = Arc::new(TestHandler);
let request = Request::builder()
    .method(Method::GET)
    .uri("/api/users")
    .version(Version::HTTP_11)
    .headers(HeaderMap::new())
    .body(Bytes::new())
    .build()
    .unwrap();

let response = middleware.process(request, handler).await.unwrap();
assert_eq!(response.status, StatusCode::OK);
// Logs: [15/Dec/2024 10:30:45] "GET /api/users HTTP/1.1" 200 2 0ms

Implementations

impl LoggingMiddleware

pub fn new() -> Self

Create a new logging middleware with default configuration

pub fn with_config(config: LoggingConfig) -> Self

Create a logging middleware with custom configuration

pub fn production() -> Self

Create a production-ready logging middleware

Uses LoggingConfig::production() which disables raw value logging.

Trait Implementations

impl Default for LoggingMiddleware

fn default() -> Self

Returns the “default value” for a type.

impl Middleware for LoggingMiddleware

fn process<'life0, 'async_trait>( &'life0 self, request: Request, next: Arc<dyn Handler>, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes a request through this middleware.

fn should_continue(&self, _request: &Request) -> bool

Determines whether this middleware should be executed for the given request.