Struct storage_proofs::SP_LOG

pub struct SP_LOG { /* fields omitted */ }

Methods from Deref<Target = Logger>

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<Err = NeverStruct, Ok = ()> + 'static>> where
    D: SendRefUnwindSafeDrain + 'static + Clone, 

Create a copy with "erased" type

See into_erased

Trait Implementations

impl Deref for SP_LOG

type Target = Logger

The resulting type after dereferencing.

fn deref(&self) -> &Logger

Dereferences the value.

impl LazyStatic for SP_LOG

fn initialize(lazy: &Self)