Function afire::trace::set_log_level

pub fn set_log_level(level: Level)

Sets the global afire log level. Setting to Level::Off will disable all logging.

Examples found in repository

examples/middle_bench.rs (line 24)

fn main() {
    set_log_level(Level::Debug);
    let mut server = Server::<()>::new([127, 0, 0, 1], 8080);
    server.route(Method::ANY, "**", |_req| Response::new());

    Middleware1.attach(&mut server);
    Middleware2.attach(&mut server);
    Middleware3.attach(&mut server);
    Middleware4.attach(&mut server);
    Middleware5.attach(&mut server);

    server.start().unwrap();
}

examples/basic/trace.rs (line 44)

    fn exec(&self) {
        // Set the log level to Trace (shows some helpful information during startup)
        // The default is Level::Error
        set_log_level(Level::Trace);
        trace!(Level::Trace, "Setting log level to Trace");
        trace!(Level::Error, "Example error message");

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

        server.route(Method::GET, "/", |req| {
            // The default log level is Level::Trace so this will be logged
            trace!("Request from {}", req.address.ip());
            Response::new()
        });

        server.start().unwrap();
    }

examples/basic/main.rs (line 28)

fn main() {
    set_log_level(Level::Trace);
    let examples: Vec<Box<dyn Example>> = vec![
        Box::new(basic::Basic),
        Box::new(serve_file::ServeFile),
        Box::new(routing::Routing),
        Box::new(data::Data),
        Box::new(path_prams::PathParam),
        Box::new(header::Header),
        Box::new(state::State),
        Box::new(cookie::Cookie),
        Box::new(error_handling::ErrorHandling),
        Box::new(serve_static::ServeStatic),
        Box::new(middleware::MiddlewareExample),
        Box::new(logging::Logging),
        Box::new(rate_limit::RateLimit),
        Box::new(threading::Threading),
        Box::new(trace::Trace),
    ];

    if let Some(run_arg) = env::args().nth(1) {
        let example = examples.iter().find(|x| x.name() == run_arg);
        if example.is_none() {
            return println!("[*] Invalid example name");
        }

        return example.unwrap().exec();
    };

    for (i, item) in examples.iter().enumerate() {
        println!(
            "[{: >w$}] {}",
            i,
            item.name(),
            w = place_count(examples.len() - 1)
        );
    }

    let run_index = input("\n[*] Index ❯ ").unwrap();
    let run_index = match run_index.parse::<usize>() {
        Ok(i) => i,
        Err(_) => return println!("[*] Das not a number..."),
    };

    if run_index >= examples.len() {
        return println!("[*] Invalid Id");
    }

    println!("[*] Starting `{}`\n", examples[run_index].name());
    examples[run_index].exec();
}

examples/application_quote_book.rs (line 35)

fn main() {
    set_log_level(Level::Trace);
    let app = App::new(PathBuf::from("quotes.txt"));
    app.load();

    let mut server = Server::new(Ipv4Addr::LOCALHOST, 8080).state(app);

    // Route to serve the homepage (page that has add quote form)
    server.route(Method::GET, "/", |_| {
        Response::new()
            .text(String::new() + HEADER + HOME)
            .content(Content::HTML)
    });

    // Route to handle creating new quotes.
    // After successful creation the user will be redirected to the new quotes page.
    server.stateful_route(Method::POST, "/api/new", |app, req| {
        let form = Query::from_body(&String::from_utf8_lossy(&req.body));
        let name =
            url::decode(form.get("author").expect("No author supplied")).expect("Invalid author");
        let body =
            url::decode(form.get("quote").expect("No quote supplied")).expect("Invalid quote");

        let quote = Quote {
            name,
            value: body,
            date: now(),
        };
        let mut quotes = app.quotes.write().unwrap();
        let id = quotes.len();
        quotes.insert(id.to_string(), quote);
        drop(quotes);
        trace!(Level::Trace, "Added new quote #{id}");

        app.save();
        Response::new()
            .status(Status::SeeOther)
            .header(HeaderType::Location, format!("/quote/{id}"))
            .text("Redirecting to quote page.")
    });

    server.stateful_route(Method::GET, "/quote/{id}", |app, req| {
        let id = req.param("id").unwrap();
        if id == "undefined" {
            return Response::new();
        }

        let id = id.parse::<usize>().expect("ID is not a valid integer");
        let quotes = app.quotes.read().unwrap();
        if id >= quotes.len() {
            return Response::new()
                .status(Status::NotFound)
                .text(format!("No quote with the id {id} was found."));
        }

        let quote = quotes.get(&id.to_string()).unwrap();
        Response::new().content(Content::HTML).text(
            String::new()
                + HEADER
                + &QUOTE
                    .replace("{QUOTE}", &quote.value)
                    .replace("{AUTHOR}", &quote.name)
                    .replace("{TIME}", &imp_date(quote.date)),
        )
    });

    server.stateful_route(Method::GET, "/quotes", |app, _req| {
        let mut out = String::from(HEADER);
        out.push_str("<ul>");
        for i in app.quotes.read().unwrap().iter() {
            out.push_str(&format!(
                "<li><a href=\"/quote/{}\">\"{}\" - {}</a></li>\n",
                i.0, i.1.name, i.1.value
            ));
        }

        Response::new().text(out + "</ul>").content(Content::HTML)
    });

    // Note: In a production application you may want to multithread the server with the Server::start_threaded method.
    server.start().unwrap();
}