Struct session_log::Global

pub struct Global(/* private fields */);

The Global logger will share the same logger instance across the entire program that has the same name. This is useful when the logger is configured once and used in multiple places. The logger will be created with default configurations if it does not exist.

Implementations

impl Global

pub fn new(name: &str) -> Self

Get a logger with the given name. If the logger does not exist, a new logger will be created and registered with the given name & default configurations.

pub fn register<F: Formatter>(name: &str, config: Config) -> Self

Register a logger with the given name.

pub fn unregister(name: &str)

Unregister a logger with the given name. Logger will be dropped if no other reference exists.

pub fn session(name: &str, session: &str, silent: bool) -> Session

Create a session from the global logger without constructing a new logger first.

pub fn session_then<F, T>(&self, name: &str, silent: bool, callable: F) -> T

where F: FnOnce(Session) -> T,

Create a new session from the session and execute the callable with the session passed in.

This can be handy for isolating the environment of each callable while also providing a common logging interface for any callable that needs to be logged.

Methods from Deref<Target = Logger>

pub fn session(&self, name: &str, silent: bool) -> Session

Create a new session from the logger.

There are two types of session: silent & non-silent. Silent session will not print the header and footer of the session when no message is logged before the session is dropped. It’s useful session that may potentially not log anything. Non-silent session will always print the header and footer of the session.

Due to the uncertainty of if the session will log anything, the header will be deferred until the first log. If the session logged anything, it’ll act like a non-silent session.

pub fn session_then<F, T>(&self, name: &str, silent: bool, callable: F) -> T

where F: FnOnce(Session) -> T,

Create a new session from the session and execute the callable with the session passed in.

This can be handy for isolating the environment of each callable while also providing a common logging interface for any callable that needs to be logged.

Trait Implementations

impl Clone for Global

fn clone(&self) -> Global

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Deref for Global

type Target = Logger

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.