Struct Logger

pub struct Logger { /* private fields */ }

The Logger struct used to print logs.

Example

// Create a `Logger` with default configuration:
let mut logger = Logger::default();
logger.debug("debug message");
logger.info("info message");
logger.warning("warning message");
logger.error("error message");
logger.fatal("fatal error message");

Implementations

impl Logger

pub fn set_verbosity<I: Into<Verbosity>>(&mut self, verbosity: I)

Sets logger verbosity.

Example

logger.set_verbosity(Verbosity::Quiet);

pub fn toggle_log_filtering<I: Into<bool>>(&mut self, enabled: I)

Toggles log filtering.

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

pub fn toggle_log_header_color<I: Into<bool>>(&mut self, enabled: I)

Toggles colored log headers.

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

pub fn set_debug_color<I: Into<Color>>(&mut self, color: I)

Sets debug log header color.

pub fn set_info_color<I: Into<Color>>(&mut self, color: I)

Sets info log header color.

pub fn set_warning_color<I: Into<Color>>(&mut self, color: I)

Sets warning header color.

pub fn set_error_color<I: Into<Color>>(&mut self, color: I)

Sets error header color.

pub fn set_fatal_color<I: Into<Color>>(&mut self, color: I)

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<(), Error>

Sets the log format.

There are several placeholders in a log format string:

• %c: Ascending log count starting at 1.
• %d: The timestamp.
• %h: The header indicating the log type (e.g., debug, error, etc.)
• %m: The log message (this placeholder is mandatory, you will get an error if you don’t include this in your log format).

You can have multiple placeholders of the same type in a format string.

Example

l.set_log_format("<l> <h>%h</h> <m>%m</m> </l>");
l.error("lorem ipsum");

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.

Check out the File logging documentation.

Example

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

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

Toggles file logging.

Before enabling file logging, ensure that the log file path is set. This is because this 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.

Example

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

pub fn set_max_log_buffer_size<I: Into<u32>>(&mut self, size: I)

Sets the maximum allowed size for the log buffer.

When the buffer exceeds its max size, it gets flushed automatically to the log file. When 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.

Example

let mut logger = Logger::default();
logger.set_log_file_path(path);
logger.toggle_file_logging(true);

// Make `Logger` flush the log buffer every 16 logs:
logger.set_max_log_buffer_size(16 as u32);

let mut i = 0;
loop {
    logger.info("Yay!");
    i += 1;
    if i >= 16 {
        break;
    }
}
// Here the buffer gets flushed, after sixteenth iteration.

pub fn toggle_log_file_lock<I: Into<bool>>(&mut self, enabled: I)

Log file lock can be used to prevent race conditions when there are multiple threads accessing the log file at the same time.

WARNING: leaving this option on for a long period of time will

cause high memory usage!

• 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<I: Into<OnDropPolicy>>(&mut self, policy: I)

Sets Logger’s on drop log file policy.

Example

logger.set_on_drop_file_policy(OnDropPolicy::IgnoreLogFileLock);

pub fn toggle_console_output<I: Into<bool>>(&mut self, enabled: I)

Toggles printing logs to stdout.

• true: Logs will be printed in your terminal’s stdout.
• false: No log output in your terminal.

pub fn toggle_custom_log_buffer<I: Into<bool>>(&mut self, enabled: I)

Toggles the usage of a custom log buffer.

• true: Logs will be stored in a buffer inside Logger and can be cloned using the clone_log_buffer() method. Be aware that this will lead to high memory usage if turned on for a log period of time.
• false: Logs will not be stored in a log buffer.

pub fn clear_log_buffer(&mut self)

Clears the custom log buffer.

impl Logger

pub fn from_template_str(template: &str) -> Result<Logger, Error>

Creates a Logger instance from a JSON template as string.

Example

let pretty_json = serde_json::to_string_pretty(&Logger::default())
    .expect("Failed to serialize logger!");
let raw_json = serde_json::to_string(&Logger::default())
    .expect("Failed to serialize logger!");
assert_eq!(Logger::default(), Logger::from_template_str(&pretty_json)
    .expect("Failed to deserialize logger!"));
assert_eq!(Logger::default(), Logger::from_template_str(&raw_json)
    .expect("Failed to deserialize logger!"));

pub fn from_template(path: &str) -> Result<Logger, Error>

Creates a Logger instance from a template file.

Automatically expands environment variables.

Example

let mut logger = Logger::from_template(path);

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

Saves a Logger to template file.

Automatically expands environment variables.

Example

let mut logger = Logger::default();
logger.save_template(path);

impl Logger

pub fn log_buffer(&self) -> &Vec<LogStruct>

Returns a reference to the custom log buffer.

pub fn log_count(&self) -> &u128

Returns the number of logs printed since the struct was instantiated.

impl Logger

pub fn print_log(&mut self, log: &LogStruct)

Used to print a log from a LogStruct.

Example:

logger.print_log(&LogStruct::error("&%$#@!"));

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

Returns a log entry from a LogStruct based on current Logger configuration.

Example:

let log_string = logger.format_log(&LogStruct::error("ZXJyb3IK"));

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

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

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 to stdout.

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

Prints a debug message to stdout, bypasses filtering.

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

Prints an informational message to stdout.

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

Prints an informational message to stdout, bypasses filtering.

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

Prints a warning to stdout.

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

Prints a warning to stdout, bypasses filtering.

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

Prints an error to stderr.

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

Prints a fatal error to stderr.

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() -> Self

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