Struct ntex::web::middleware::Logger

pub struct Logger { /* fields omitted */ }

Middleware for logging request and response info to the terminal.

Logger middleware uses standard log crate to log information. You should enable logger for ntex package to see access log. (env_logger or similar)

Usage

Create Logger middleware with the specified format. Default Logger could be created with default method, it uses the default format:

 %a "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T

use ntex::web::App;
use ntex::web::middleware::Logger;

fn main() {
    std::env::set_var("RUST_LOG", "ntex=info");
    env_logger::init();

    let app = App::new()
        .wrap(Logger::default())
        .wrap(Logger::new("%a %{User-Agent}i"));
}

Format

%% The percent sign

%a Remote IP-address (IP-address of proxy if using reverse proxy)

%t Time when the request was started to process (in rfc3339 format)

%r First line of request

%s Response status code

%b Size of response in bytes, including HTTP headers

%T Time taken to serve the request, in seconds with floating fraction in .06f format

%D Time taken to serve the request, in milliseconds

%U Request URL

%{FOO}i request.headers[‘FOO’]

%{FOO}o response.headers[‘FOO’]

%{FOO}e os.environ[‘FOO’]

Implementations

impl Logger

pub fn new(format: &str) -> Logger

Create Logger middleware with the specified format.

pub fn exclude<T: Into<String>>(self, path: T) -> Self

Ignore and do not log access info for specified path.

Trait Implementations

impl Default for Logger

fn default() -> Self

Create Logger middleware with format:

%a "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T

impl<S, Err> Transform<S> for Logger where
    S: Service<Request = WebRequest<Err>, Response = WebResponse>, 

type Request = WebRequest<Err>

Requests handled by the service.

type Response = WebResponse

Responses given by the service.

type Error = S::Error

Errors produced by the service.

type InitError = ()

Errors produced while building a transform service.

type Transform = LoggerMiddleware<S>

The TransformService value created by this factory

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

The future response value.

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

Creates and returns a new Transform component, asynchronously

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

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