Struct Slogger

pub struct Slogger { /* private fields */ }

Implementations

impl Slogger

pub fn new_terminal_logger() -> Self

pub fn new_bunyan_logger(name: &'static str) -> Self

pub fn from_logger(logger: Logger) -> Self

pub fn get(&self) -> &Logger

pub fn get_for_request(&self, request: &Request<'_>) -> Logger

pub fn get_for_response( &self, request: &Request<'_>, response: &Response<'_>, ) -> Logger

pub fn on_request( self, handler: impl for<'r> Fn(Arc<Logger>, &'r mut Request<'_>) -> Pin<Box<dyn Future<Output = Option<Arc<Logger>>> + Send + 'r>> + Send + Sync + 'static, ) -> Self

pub fn on_response( self, handler: impl for<'r> Fn(Arc<Logger>, &'r Request<'_>, &'r mut Response<'_>) -> Pin<Box<dyn Future<Output = Option<Arc<Logger>>> + Send + 'r>> + Send + Sync + 'static, ) -> Self

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 Clone for Slogger

fn clone(&self) -> Slogger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for Slogger

type Target = Logger

The resulting type after dereferencing.

fn deref(&self) -> &Logger

Dereferences the value.

impl Fairing for Slogger

fn info(&self) -> Info

Returns an Info structure containing the name and Kind of this fairing. The name can be any arbitrary string. Kind must be an ord set of Kind variants.

fn on_ignite<'life0, 'async_trait>( &'life0 self, rocket: Rocket<Build>, ) -> Pin<Box<dyn Future<Output = Result<Rocket<Build>, Rocket<Build>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The ignite callback. Returns Ok if ignition should proceed and Err if ignition and launch should be aborted.

fn on_liftoff<'life0, 'life1, 'async_trait>( &'life0 self, rocket: &'life1 Rocket<Orbit>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The liftoff callback.

fn on_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, request: &'life1 mut Request<'life2>, _: &'life3 mut Data<'life4>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

The request callback.

fn on_response<'r, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request: &'r Request<'life1>, response: &'life2 mut Response<'r>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The response callback.

fn on_shutdown<'life0, 'life1, 'async_trait>( &'life0 self, _rocket: &'life1 Rocket<Orbit>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

The shutdown callback.

impl From<&Logger> for Slogger

fn from(logger: &Logger) -> Self

Converts to this type from the input type.

impl From<Logger> for Slogger

fn from(logger: Logger) -> Self

Converts to this type from the input type.

impl<'r> FromRequest<'r> for Slogger

type Error = ()

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>( request: &'r Request<'life0>, ) -> Pin<Box<dyn Future<Output = Outcome<Slogger, ()>> + Send + 'async_trait>>

where 'r: 'async_trait, 'life0: 'async_trait,

Derives an instance of Self from the incoming request metadata.