Struct Dtrace 

pub struct Dtrace<D> { /* private fields */ }

A slog::Drain that forwards all log messages to DTrace.

Implementations

impl Dtrace<Discard>

pub fn new() -> (Self, ProbeRegistration)

Create a new DTrace logger, emitting messages only to DTrace.

This method will create a Dtrace drain that sends messages only to DTrace. If you wish to emit messages to another location as well, you can use with_drain or call slog::Duplicate.

Note that it’s possible for probe registration to fail. The result of registering is returned as the second tuple element. It may be inspected so that callers can decide how to handle failure. See ProbeRegistration for more information.

Trait Implementations

impl<D: Debug> Debug for Dtrace<D>

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

Formats the value using the given formatter.

impl<D> Drain for Dtrace<D>

where D: Drain<Ok = (), Err = Never>,

type Ok = ()

Type returned by this drain

type Err = Infallible

Type of potential errors that can be returned by this Drain

fn log( &self, record: &Record<'_>, values: &OwnedKVList, ) -> Result<Self::Ok, Self::Err>

Handle one logging statement (Record)

fn flush(&self) -> Result<(), FlushError>

Flush all pending log records, blocking until completion.

fn is_enabled(&self, level: Level) -> bool

Avoid: Check if messages at the specified log level are maybe enabled for this logger.

fn is_critical_enabled(&self) -> bool

Avoid: See is_enabled

fn is_error_enabled(&self) -> bool

Avoid: See is_enabled

fn is_warning_enabled(&self) -> bool

Avoid: See is_enabled

fn is_info_enabled(&self) -> bool

Avoid: See is_enabled

fn is_debug_enabled(&self) -> bool

Avoid: See is_enabled

fn is_trace_enabled(&self) -> bool

Avoid: See is_enabled

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

where Self: Sized, 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 Self: Sized, F: FilterFn,

Filter logging records passed to Drain

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

where Self: Sized,

Filter logging records passed to Drain (by level)

fn map_err<F, E>(self, f: F) -> MapError<Self, E>

where Self: Sized, F: MapErrFn<Self::Err, E>,

Map logging errors returned by this drain

fn ignore_res(self) -> IgnoreResult<Self>

where Self: Sized,

Ignore results returned by this drain

fn fuse(self) -> Fuse<Self>

where Self::Err: Debug, Self: Sized,

Make Self panic when returning any errors