Struct slog_extlog::stats::StatisticsLogger

pub struct StatisticsLogger<T: StatisticsLogFormatter> { /* fields omitted */ }

A logger with statistics tracking.

This should only be created through the new method.

Methods

impl<T> StatisticsLogger<T> where
    T: StatisticsLogFormatter + Send + Sync + 'static, 

pub fn new(logger: Logger, cfg: StatsConfig<T>) -> StatisticsLogger<T>

Create a child logger with stats tracking support.

The StatsConfig must contain the definitions necessary to generate metrics from logs.

pub fn with_params<P>(&self, params: OwnedKV<P>) -> Self where
    P: SendSyncRefUnwindSafeKV + 'static, 

Build a child logger with new parameters.

This is essentially a wrapper around slog::Logger::new().

pub fn update_stats(&self, log: &StatTrigger)

Update the statistics for the current log.

pub fn set_slog_logger(&mut self, logger: Logger)

Modify the logger field without changing the stats tracker

Important traits for Vec<u8>

impl Write for Vec<u8>

pub fn get_stats(&self) -> Vec<StatSnapshot>

Retrieve the current values of all stats tracked by this logger.

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

Create a copy with "erased" type

See into_erased

Trait Implementations

impl<T: Debug + StatisticsLogFormatter> Debug for StatisticsLogger<T>

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

Formats the value using the given formatter.

impl<T: StatisticsLogFormatter> Clone for StatisticsLogger<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: StatisticsLogFormatter> Deref for StatisticsLogger<T>

type Target = Logger

The resulting type after dereferencing.

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

Dereferences the value.