Struct Logger

pub struct Logger { /* private fields */ }

A logger struct used for printing logs.

You can create a Logger instance with the default configuration using:

let l = Logger::default();

Alternatively, initialize a Logger instance from a JSON template file:

Logger::from_template("/path/to/file.json");

Once you have a Logger instance, you can start printing logs:

l.debug("debug message");
l.info("info message");
l.warning("warning message");
l.error("error message");
l.fatal("fatal error message");

Implementations

impl Logger

pub fn default() -> Self

Returns a Logger instance with default configuration applied.

pub fn format_log(&self, log: &LogStruct) -> String

Returns a log entry out of a LogStruct based on current Logger configuration.

pub fn flush(&mut self) -> Result<(), String>

Flushes log buffer (if file logging is enabled and log file lock disabled, it writes the log buffer to a file) and then clears the log buffer.

Returns an error when there is an issue writing to a file or log file lock is enabled.

pub fn debug(&mut self, message: &str)

Prints a debug message.

pub fn debug_no_filtering(&mut self, message: &str)

Prints a debug message, bypasses filtering.

pub fn info(&mut self, message: &str)

Prints info message.

pub fn info_no_filtering(&mut self, message: &str)

Prints info message, bypasses filtering.

pub fn warning(&mut self, message: &str)

Prints a warning.

pub fn warning_no_filtering(&mut self, message: &str)

Prints a warning, bypasses filtering.

pub fn error(&mut self, message: &str)

Prints an error (errors cannot be suppressed).

pub fn fatal(&mut self, message: &str)

Prints a fatal error (errors cannot be suppressed).

impl Logger

pub fn set_verbosity(&mut self, verbosity: &Verbosity)

Sets logger verbosity.

• All -> Don’t filter any logs
• Standard -> Just filter debug logs
• Quiet -> Only let warnings and errors to be displayed
• ErrorsOnly -> I’m not gonna explain this one

pub fn toggle_log_filtering(&mut self, enabled: &bool)

Toggles log filtering.

• true -> logs will get filtered based on verbosity
• false -> log filtering will be disabled globally

pub fn toggle_log_header_color(&mut self, enabled: &bool)

Toggles colored log headers.

• true -> Log headers will have colors
• false -> No colors :(

pub fn set_debug_color(&mut self, color: &Color)

Sets debug log header color.

pub fn set_info_color(&mut self, color: &Color)

Sets info log header color.

pub fn set_warning_color(&mut self, color: &Color)

Sets warning header color.

pub fn set_error_color(&mut self, color: &Color)

Sets error header color.

pub fn set_fatal_color(&mut self, color: &Color)

Sets fatal error header color.

pub fn set_debug_header(&mut self, header: &str)

Sets debug log header format.

pub fn set_info_header(&mut self, header: &str)

Sets info log header format.

pub fn set_warning_header(&mut self, header: &str)

Sets warning header format.

pub fn set_error_header(&mut self, header: &str)

Sets error header format.

pub fn set_fatal_header(&mut self, header: &str)

Sets fatal error header format.

pub fn set_datetime_format(&mut self, format: &str)

Sets datetime format.

pub fn set_log_format(&mut self, format: &str) -> Result<(), &'static str>

Sets the log format.

There are three placeholders in a log format string (you can place multiple placeholders of the same type in a format string):

• %m -> The log message (this placeholder is mandatory, you format will get rejected if it doesn’t contain this placeholder)
• %h -> The log type header (debug, error, etc.)
• %d -> The datetime

Set an XML-like log format;

l.set_log_format("<l> <h>%h</h> <m>%m</m> </l>");
l.error("A nice debug log!");

Returns an error when the %m placeholder is missing.

pub fn set_log_file_path(&mut self, path: &str) -> Result<(), Error>

Sets log file path.

Returns an error if the path is inaccessible.

Make sure to actually enable file logging:

// Set the log file path first:
logger.set_log_file_path("/path/to/file.log");
// Then enable file logging:
logger.toggle_file_logging(true);

pub fn toggle_file_logging(&mut self, enabled: &bool) -> Result<(), Error>

Toggles file logging.

Before enabling file logging, ensure that the log file path is set. This is because the method checks if the log file is writable. If the log file path is not set, or the file is not writable, enabling file logging will result in an error.

Enabling file logging:

// Set the log file path first:
logger.set_log_file_path("/path/to/file.log");
// Then enable file logging:
logger.toggle_file_logging(true);

pub fn set_max_log_buffer_size(&mut self, size: &usize)

Sets the maximum size of the log buffer.

This method sets the maximum allowed size for the log buffer. When the buffer exceeds this size, it will be automatically flushed to the log file. If the buffer size is set to 0, automatic flushing is disabled, and the buffer can only be flushed manually.

If a log file lock is active, the log buffer will not be flushed automatically, regardless of the size limit.

Setting a custom log buffer size:

let mut logger = Logger::default();
logger.set_log_file_path("/path/to/file.log");
logger.toggle_file_logging(true);

// This will force `Logger` to flush the log buffer every 16 logs:
logger.set_max_log_buffer_size(&16);

let mut i = 0;
loop {
    logger.info("Yay!");
    i += 1;
    if i >= 16 {
        break;
    }
}

pub fn toggle_log_file_lock(&mut self, enabled: &bool)

Log file lock can be used to prevent race conditions when there is one thread reading from the log file and another thread writing to the log file.

WARNING: LEAVING THIS OPTION ON FOR A LONG PERIOD OF TIME CAN CAUSE

HIGH MEMORY USAGE AND STUTTERING!

true -> When log file lock is enabled, logger won’t flush into the log file. Instead, it will wait until the lock is disabled. You will not loose any logs, they will be stored in the log buffer even when it exceeds its size limit. false -> Logger will write to the log file normally.

pub fn set_on_drop_file_policy(&mut self, policy: &OnDropPolicy)

Sets Logger’s on drop log file policy.

logger.set_on_drop_file_policy(&OnDropPolicy::IgnoreLogFileLock);

impl Logger

pub fn from_template(path: &str) -> Logger

Creates a Logger instance from a template file.

Logger templates documentation

Deserializing Logger from a json file:

let mut logger = Logger::from_template("/path/to/template.json");

pub fn save_template(&self, path: &str)

Saves a Logger to template file.

Logger templates documentation

Serializing Logger into a json file

let mut logger = Logger::default(); // Create a default `Logger`
logger.save_template("/path/to/template.json");

Trait Implementations

impl Clone for Logger

fn clone(&self) -> Logger

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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<'de> Deserialize<'de> for Logger

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drop for Logger

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for Logger

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Logger

fn cmp(&self, other: &Logger) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Logger

fn eq(&self, other: &Logger) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Logger

fn partial_cmp(&self, other: &Logger) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Logger

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Logger

impl StructuralPartialEq for Logger