Struct LOGGER

pub struct LOGGER { /* private fields */ }

Methods from Deref<Target = Logger>

pub fn new<T>(&self, values: OwnedKV<T>) -> Logger<D>

where T: SendSyncRefUnwindSafeKV + 'static, D: Clone,

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 its 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

where D: SendRefUnwindSafeDrain + 'static + Clone,

Create a copy with “erased” type

See into_erased

Trait Implementations

impl Deref for LOGGER

type Target = Logger

The resulting type after dereferencing.

fn deref(&self) -> &Logger

Dereferences the value.

impl LazyStatic for LOGGER