brokkr-utils::logging Rust

Structs

`brokkr-utils::logging::BrokkrLogger`

pub

Custom logger for the Brokkr application

Functions

`brokkr-utils::logging::init`

pub

#![allow(unused)]
fn main() {
fn init (level : & str) -> Result < () , SetLoggerError >
}

Initializes the Brokkr logging system with the specified log level.

Sets up a custom logger that handles structured logging with timestamps, log levels, and module paths. Supports multiple output formats and concurrent logging from multiple threads.

Parameters:

Name	Type	Description
`level`	`-`	String representation of the log level (“debug”, “info”, “warn”, “error”)

Returns:

Result<(), Box<dyn Error>> - Success/failure of logger initialization

Examples:

use brokkr_utils::logging;

logging::init("debug")?;
log::info!("Logger initialized successfully");

Source

#![allow(unused)]
fn main() {
pub fn init(level: &str) -> Result<(), SetLoggerError> {
    init_with_format(level, "text")
}
}

`brokkr-utils::logging::init_with_format`

pub

#![allow(unused)]
fn main() {
fn init_with_format (level : & str , format : & str) -> Result < () , SetLoggerError >
}

Initializes the Brokkr logging system with the specified log level and format.

Parameters:

Name	Type	Description
`level`	`-`	String representation of the log level (“debug”, “info”, “warn”, “error”)
`format`	`-`	Log output format (“text” for human-readable, “json” for structured JSON)

Returns:

Result<(), SetLoggerError> - Success/failure of logger initialization

Source

#![allow(unused)]
fn main() {
pub fn init_with_format(level: &str, format: &str) -> Result<(), SetLoggerError> {
    let level_filter = str_to_level_filter(level);
    let use_json = format.eq_ignore_ascii_case("json");

    INIT.get_or_init(|| {
        log::set_logger(&LOGGER)
            .map(|()| log::set_max_level(LevelFilter::Trace))
            .expect("Failed to set logger");
    });

    JSON_FORMAT.store(use_json, Ordering::Relaxed);
    CURRENT_LEVEL.store(level_filter as usize, Ordering::Relaxed);
    log::set_max_level(level_filter);
    Ok(())
}
}

`brokkr-utils::logging::update_log_level`

pub

#![allow(unused)]
fn main() {
fn update_log_level (level : & str) -> Result < () , String >
}

Updates the current log level.

Parameters:

Name	Type	Description
`level`	`-`	A string slice that holds the new desired log level.

Returns:

Ok(()) if the log level was successfully updated. * Err(String) if there was an error updating the log level.

Examples:

use brokkr_logger;

    brokkr_logger::init("info").expect("Failed to initialize logger");
    info!("This will be logged");

    brokkr_logger::update_log_level("warn").expect("Failed to update log level");
    info!("This will not be logged");
    warn!("But this will be logged");

Source

#![allow(unused)]
fn main() {
pub fn update_log_level(level: &str) -> Result<(), String> {
    let new_level = str_to_level_filter(level);
    CURRENT_LEVEL.store(new_level as usize, Ordering::Relaxed);
    log::set_max_level(new_level);
    Ok(())
}
}

`brokkr-utils::logging::str_to_level_filter`

private

#![allow(unused)]
fn main() {
fn str_to_level_filter (level : & str) -> LevelFilter
}

Source

#![allow(unused)]
fn main() {
fn str_to_level_filter(level: &str) -> LevelFilter {
    match level.to_lowercase().as_str() {
        "off" => LevelFilter::Off,
        "error" => LevelFilter::Error,
        "warn" => LevelFilter::Warn,
        "info" => LevelFilter::Info,
        "debug" => LevelFilter::Debug,
        "trace" => LevelFilter::Trace,
        _ => LevelFilter::Info,
    }
}
}

`brokkr-utils::logging::level_filter_from_u8`

private

#![allow(unused)]
fn main() {
fn level_filter_from_u8 (v : u8) -> LevelFilter
}

Source

#![allow(unused)]
fn main() {
fn level_filter_from_u8(v: u8) -> LevelFilter {
    match v {
        0 => LevelFilter::Off,
        1 => LevelFilter::Error,
        2 => LevelFilter::Warn,
        3 => LevelFilter::Info,
        4 => LevelFilter::Debug,
        5 => LevelFilter::Trace,
        _ => LevelFilter::Off,
    }
}
}

Keyboard shortcuts

Brokkr