Struct slog_async::AsyncCore

pub struct AsyncCore { /* fields omitted */ }

Core of Async drain

See Async for documentation.

Wrapping AsyncCore allows implementing custom overflow (and other errors) handling strategy.

Note: On drop AsyncCore waits for it's worker-thread to finish (after handling all previous Records sent to it). If you can't tolerate the delay, make sure you drop it eg. in another thread.

Methods

impl AsyncCore

fn new<D: Drain<Err=Never, Ok=()> + Send + 'static>(drain: D) -> Self

New AsyncCore with default parameters

fn custom<D: Drain<Err=Never, Ok=()> + Send + 'static>(drain: D)
                                                       -> AsyncBuilder<D, Self>

Build AsyncCore drain with custom parameters

Trait Implementations

impl<D, T> From<AsyncBuilder<D, T>> for AsyncCore where D: Drain<Err=Never, Ok=()> + Send + 'static,
        T: Send + 'static

fn from(from: AsyncBuilder<D, T>) -> AsyncCore

Performs the conversion.

impl Drain for AsyncCore

type Ok = ()

Type returned by this drain

type Err = AsyncError

Type of potential errors that can be returned by this Drain

fn log(&self, record: &Record, logger_values: &OwnedKVList) -> AsyncResult<()>

Handle one logging statement (Record)

fn map<F, R>(self, f: F) -> R where F: FnOnce(Self) -> R

Pass Drain through a closure, eg. to wrap into another Drain.

fn filter<F>(self, f: F) -> Filter<Self, F> where F: Fn(&Record) -> bool + 'static + Send + Sync

Filter logging records passed to Drain

fn filter_level(self, level: Level) -> LevelFilter<Self>

Filter logging records passed to Drain (by level)

fn map_err<F, E>(self, f: F) -> MapError<Self, E> where F: 'static + Sync + Send + Fn(Self::Err) -> E

Map logging errors returned by this drain

fn ignore_res(self) -> IgnoreResult<Self>

Ignore results returned by this drain

impl Drop for AsyncCore

fn drop(&mut self)

A method called when the value goes out of scope.