Struct afire::extension::Logger

pub struct Logger { /* private fields */ }

Log requests to the console or a file.

Implementations

impl Logger

pub fn new() -> Logger

Make a new logger

The default settings are as follows

• Log Level: Level::Info

• File: None

• Console: true

Example

// Import Lib
use afire::extension::logger::{Logger, Level};

// Create a new logger
let logger = Logger::new();

Examples found in repository

examples/basic/logging.rs (line 34)

    fn exec(&self) {
        // Create a new Server instance on localhost port 8080
        let mut server = Server::<()>::new("localhost", 8080);

        // Define a handler for GET "/"
        server.route(Method::GET, "/", |_req| {
            Response::new()
                .text("Hello World!\nThis request has been logged!")
                .content(Content::TXT)
        });

        // Make a logger and attach it to the server

        // By default Log Level is INFO, File is None and Console is true
        // This could be condensed to `Logger::new().attach(&mut server);` as it uses al default values
        Logger::new()
            // The level of logging this can be Debug or Info
            // Debug will give a lot more information about the request
            .level(Level::Info)
            // This will have Logger make use of the RealIp extention,
            // which will allow logging the correct IP when using a reverse proxy.
            .real_ip(HeaderType::XForwardedFor)
            // The file argument tells the logger if it should save to a file
            // Only one file can be defined per logger
            // With logging to file it will write to the file on every request... (for now)
            .file("example.log")
            .unwrap()
            // Tells the Logger it should log to the console as well
            .console(true)
            // This must be put at the end of your Logger Construction
            // It adds the Logger to your Server as Middleware
            .attach(&mut server);

        // Now if you goto http://localhost:8080/ you should see the log message in console.

        // Start the server
        // This will block the current thread
        server.start().unwrap();
    }

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

Set the log Level of a logger

Example

// Import Lib
use afire::extension::logger::{Logger, Level};

// Create a new logger
let logger = Logger::new()
    .level(Level::Debug);

Examples found in repository

examples/basic/logging.rs (line 37)

    fn exec(&self) {
        // Create a new Server instance on localhost port 8080
        let mut server = Server::<()>::new("localhost", 8080);

        // Define a handler for GET "/"
        server.route(Method::GET, "/", |_req| {
            Response::new()
                .text("Hello World!\nThis request has been logged!")
                .content(Content::TXT)
        });

        // Make a logger and attach it to the server

        // By default Log Level is INFO, File is None and Console is true
        // This could be condensed to `Logger::new().attach(&mut server);` as it uses al default values
        Logger::new()
            // The level of logging this can be Debug or Info
            // Debug will give a lot more information about the request
            .level(Level::Info)
            // This will have Logger make use of the RealIp extention,
            // which will allow logging the correct IP when using a reverse proxy.
            .real_ip(HeaderType::XForwardedFor)
            // The file argument tells the logger if it should save to a file
            // Only one file can be defined per logger
            // With logging to file it will write to the file on every request... (for now)
            .file("example.log")
            .unwrap()
            // Tells the Logger it should log to the console as well
            .console(true)
            // This must be put at the end of your Logger Construction
            // It adds the Logger to your Server as Middleware
            .attach(&mut server);

        // Now if you goto http://localhost:8080/ you should see the log message in console.

        // Start the server
        // This will block the current thread
        server.start().unwrap();
    }

pub fn real_ip(self, real_ip: HeaderType) -> Self

Uses the crate::extension::RealIp extension for log IPs. You will need to supply the header that will contain the IP address, for example the X-Forwarded-For header (HeaderType::XForwardedFor)

Warning: Make sure your reverse proxy is overwriting the specified header on the incoming requests so clients cant spoof their original Ips.

Examples found in repository

examples/basic/logging.rs (line 40)

    fn exec(&self) {
        // Create a new Server instance on localhost port 8080
        let mut server = Server::<()>::new("localhost", 8080);

        // Define a handler for GET "/"
        server.route(Method::GET, "/", |_req| {
            Response::new()
                .text("Hello World!\nThis request has been logged!")
                .content(Content::TXT)
        });

        // Make a logger and attach it to the server

        // By default Log Level is INFO, File is None and Console is true
        // This could be condensed to `Logger::new().attach(&mut server);` as it uses al default values
        Logger::new()
            // The level of logging this can be Debug or Info
            // Debug will give a lot more information about the request
            .level(Level::Info)
            // This will have Logger make use of the RealIp extention,
            // which will allow logging the correct IP when using a reverse proxy.
            .real_ip(HeaderType::XForwardedFor)
            // The file argument tells the logger if it should save to a file
            // Only one file can be defined per logger
            // With logging to file it will write to the file on every request... (for now)
            .file("example.log")
            .unwrap()
            // Tells the Logger it should log to the console as well
            .console(true)
            // This must be put at the end of your Logger Construction
            // It adds the Logger to your Server as Middleware
            .attach(&mut server);

        // Now if you goto http://localhost:8080/ you should see the log message in console.

        // Start the server
        // This will block the current thread
        server.start().unwrap();
    }

pub fn file(self, file: impl AsRef<Path>) -> Result<Self>

Set the log file of a logger

Example

// Import Lib
use afire::extension::logger::{Logger, Level};

// Create a new logger and enable logging to file
let logger = Logger::new()
    .file("nose.txt");

Examples found in repository

examples/basic/logging.rs (line 44)

    fn exec(&self) {
        // Create a new Server instance on localhost port 8080
        let mut server = Server::<()>::new("localhost", 8080);

        // Define a handler for GET "/"
        server.route(Method::GET, "/", |_req| {
            Response::new()
                .text("Hello World!\nThis request has been logged!")
                .content(Content::TXT)
        });

        // Make a logger and attach it to the server

        // By default Log Level is INFO, File is None and Console is true
        // This could be condensed to `Logger::new().attach(&mut server);` as it uses al default values
        Logger::new()
            // The level of logging this can be Debug or Info
            // Debug will give a lot more information about the request
            .level(Level::Info)
            // This will have Logger make use of the RealIp extention,
            // which will allow logging the correct IP when using a reverse proxy.
            .real_ip(HeaderType::XForwardedFor)
            // The file argument tells the logger if it should save to a file
            // Only one file can be defined per logger
            // With logging to file it will write to the file on every request... (for now)
            .file("example.log")
            .unwrap()
            // Tells the Logger it should log to the console as well
            .console(true)
            // This must be put at the end of your Logger Construction
            // It adds the Logger to your Server as Middleware
            .attach(&mut server);

        // Now if you goto http://localhost:8080/ you should see the log message in console.

        // Start the server
        // This will block the current thread
        server.start().unwrap();
    }

pub fn console(self, console: bool) -> Self

Enable writing events to stdout

Example

// Import Lib
use afire::extension::logger::{Logger, Level};

// Create a new logger and enable console
let logger = Logger::new()
    .console(true );

Examples found in repository

examples/basic/logging.rs (line 47)

    fn exec(&self) {
        // Create a new Server instance on localhost port 8080
        let mut server = Server::<()>::new("localhost", 8080);

        // Define a handler for GET "/"
        server.route(Method::GET, "/", |_req| {
            Response::new()
                .text("Hello World!\nThis request has been logged!")
                .content(Content::TXT)
        });

        // Make a logger and attach it to the server

        // By default Log Level is INFO, File is None and Console is true
        // This could be condensed to `Logger::new().attach(&mut server);` as it uses al default values
        Logger::new()
            // The level of logging this can be Debug or Info
            // Debug will give a lot more information about the request
            .level(Level::Info)
            // This will have Logger make use of the RealIp extention,
            // which will allow logging the correct IP when using a reverse proxy.
            .real_ip(HeaderType::XForwardedFor)
            // The file argument tells the logger if it should save to a file
            // Only one file can be defined per logger
            // With logging to file it will write to the file on every request... (for now)
            .file("example.log")
            .unwrap()
            // Tells the Logger it should log to the console as well
            .console(true)
            // This must be put at the end of your Logger Construction
            // It adds the Logger to your Server as Middleware
            .attach(&mut server);

        // Now if you goto http://localhost:8080/ you should see the log message in console.

        // Start the server
        // This will block the current thread
        server.start().unwrap();
    }

Trait Implementations

impl Debug for Logger

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

Formats the value using the given formatter.

impl Default for Logger

fn default() -> Logger

Returns the “default value” for a type.

impl Middleware for Logger

fn end(&self, req: &Request, _res: &Response)

Middleware ot run after the response has been handled

fn pre_raw(&self, req: &mut Result<Request>) -> MiddleResult

Middleware to run before routes. Because this is the raw version of Middleware::pre, it is passed a Result. The default implementation calls Middleware::pre if the Result is Ok.

fn pre(&self, _req: &mut Request) -> MiddleResult

Middleware to run Before Routes

fn post_raw( &self, req: Result<Rc<Request>>, res: &mut Result<Response> ) -> MiddleResult

Middleware to run after routes. Because this is the raw version of Middleware::post, it is passed a Result. The default implementation calls Middleware::post if the Result is Ok.

fn post(&self, _req: &Request, _res: &mut Response) -> MiddleResult

Middleware to run After Routes

fn end_raw(&self, req: &Result<Request>, res: &Result<Response>)

Middleware to run after the response has been handled. Because this is the raw version of Middleware::end, it is passed a Result. The default implementation calls Middleware::end if the Result is Ok.

fn attach<State>(self, server: &mut Server<State>)where Self: 'static + Send + Sync + Sized, State: 'static + Send + Sync,

Attach Middleware to a Server. If you want to get a reference to the server’s state in your middleware state, you should override this method.