Struct libzetta::log::GlobalLogger

pub struct GlobalLogger { /* fields omitted */ }

Methods

impl GlobalLogger

pub fn get() -> &'static GlobalLogger

Get global logger. If you didn't call Logger::setup prior calling this then default logger created with StdLog as drain.

pub fn setup(root_logger: &SlogLogger) -> Result<(), GlobalLogger>

Set global logger. Optional. Can only called once. Returns Ok(()) if the cell was empty and Err(value) if it was full.

Methods from Deref<Target = SlogLogger>

pub fn new<T>(&self, values: OwnedKV<T>) -> Logger<D> where
    D: Clone,
    T: SendSyncRefUnwindSafeKV + 'static, 

Build a child logger

Child logger inherits all existing key-value pairs from its parent and supplements them with additional ones.

Use o! macro to build OwnedKV object.

Drain cloning (D : Clone requirement)

All children, their children and so on, form one tree sharing a common drain. This drain, will be Cloned when this method is called. That is why Clone must be implemented for D in Logger<D>::new.

For some Drain types Clone is cheap or even free (a no-op). This is the case for any Logger returned by Logger::root and it's children.

When using Logger::root_typed, it's possible that cloning might be expensive, or even impossible.

The reason why wrapping in an Arc is not done internally, and exposed to the user is performance. Calling Drain::log through an Arc is tiny bit slower than doing it directly.

#[macro_use]
extern crate slog;

fn main() {
    let root = slog::Logger::root(slog::Discard,
        o!("key1" => "value1", "key2" => "value2"));
    let _log = root.new(o!("key" => "value"));
}

pub fn log(&self, record: &Record)

Log one logging Record

Use specific logging functions instead. See log! macro documentation.

pub fn list(&self) -> &OwnedKVList

Get list of key-value pairs assigned to this Logger

pub fn to_erased(
    &self
) -> Logger<Arc<dyn SendSyncRefUnwindSafeDrain<Ok = (), Err = NeverStruct> + 'static>> where
    D: SendRefUnwindSafeDrain + 'static + Clone, 

Create a copy with "erased" type

See into_erased

Trait Implementations

impl Clone for GlobalLogger

fn clone(&self) -> GlobalLogger

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalLogger

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Deref for GlobalLogger

type Target = SlogLogger

The resulting type after dereferencing.

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

Dereferences the value.