Struct Logger

pub struct Logger {
    pub formatter: LogFormatter,
    pub output: LogOutput,
    /* private fields */
}

Logger capable of filtering logs, formatting them and distributing them to various streams.

The Logger struct is modular and itself only filters the logs, relying on LogFormatter and LogOutput for log formatting and outputting.

Additionally, Logger includes a template system with built-in methods and constructors for easy JSON serialization and deserialization.

Examples

Creating a Logger struct and printing out some logs:

// Create a `Logger` instance with default configuration
let mut logger = Logger::default();

// Print log messages
logger.debug("debug message");
logger.info("info message");
logger.warning("warning message");
logger.error("error message");
logger.fatal("fatal error message");

Configuring the formatter of a Logger:

// Create a `Logger` instance with default configuration
let mut logger = Logger::default();

// Set a simple log format
logger.formatter.set_log_format("[ %d ] %m");

// Change debug log header color
logger.formatter.set_debug_color(Color::Red);

// Set a fatal log header
logger.formatter.set_fatal_header("--FATAL--");

// Configure datetime format
logger.formatter.set_datetime_format("%H:%M");

Enabling log buffering:

// Create a `Logger` instance with default configuration
let mut logger = Logger::default();

// Enable log buffering
logger.output.buffer_output.enable();

// Write to the log buffer 128 times
for i in 0..128 {
    logger.error(&format!("Error number {}", i));
}

// Get a reference to the log buffer
let buffer = logger.output.buffer_output.get_log_buffer();

Enabling file logging:

// Create a `Logger` instance with default configuration
let mut logger = Logger::default();

// Required by `FileStream` for parsing logs
let mut formatter = LogFormatter::default();

// Set the log file path **first**
logger.output.file_output.set_log_file_path(&path)
    .expect("Failed to set the log file path!");

// Enable the output
logger.output.file_output.enable().
    expect("Failed to enable the output!");

// Write to the log file buffer
logger.output.file_output.out(&LogStruct::debug("Hello from file!"),
    &mut formatter).expect("Failed to write to the buffer!");

// Flush the logs from the buffer to the log file
logger.output.file_output.flush();

Fields

formatter: LogFormatter

output: LogOutput

Implementations

impl Logger

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

Creates a Logger instance from a JSON template as string.

Examples

Deserializing Logger from a JSON string:

let pretty_json = serde_json::to_string_pretty(&Logger::default())
    .expect("Failed to serialize logger!");

let mut logger = Logger::from_template_str(&pretty_json)
    .expect("Failed to deserialize logger!");

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

Creates a Logger instance from a template file.

Examples

Deserializing Logger from a JSON file:

let mut logger = Logger::from_template(path)
    .expect("Failed to deserialize logger!");

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

Saves a Logger instance to template file.

Examples

Serializing a Logger instance to a file:

let mut logger = Logger::default();
logger.save_template(path);
    .expect("Failed to deserialize logger!"), Logger::default());

impl Logger

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

Prints a debug message.

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

Prints an informational message.

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

Prints a warning.

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

Prints an error.

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

Prints a fatal error.

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

Sets Logger verbosity.

Examples

Setting Logger verbosity:

logger.set_verbosity(Verbosity::Quiet);

pub fn enable_log_filtering(&mut self)

Enables log filtering.

pub fn disable_log_filtering(&mut self)

Disables log filtering.

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