Struct Logger

pub struct Logger {
    pub formatter: Mutex<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

Using global logging:

use prettylogger::{debug, info, warn, err, fatal};

let mut message = "debug";
debug!("Hello, this is a {message} log!");

message = "info";
info!("Hello, this is an {message} log!");

message = "warning";
warn!("Hello, this is a {message}!");

message = "error";
err!("Hello, this is an {message}!");

message = "fatal error";
fatal!("Hello, this is a {message}!")

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.lock().unwrap().set_log_format("[ %d ] %m");

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

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

// Configure datetime format
logger.formatter.lock().unwrap().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.lock().unwrap().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.lock().unwrap().get_log_buffer();

Enabling file logging:

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

// Lock the file output and obtain a reference to it
let mut file_output = logger.output.file_output.lock().unwrap();

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

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

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

// Write to the log file buffer
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
file_output.flush();

Fields

formatter: Mutex<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(&self, message: &str)

Prints a debug message.

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

Prints an informational message.

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

Prints a warning.

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

Prints an error.

pub fn fatal(&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 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 PartialEq for Logger

fn eq(&self, other: &Self) -> 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 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.