Struct fxa_email_service::logging::MozlogLogger

pub struct MozlogLogger(pub Logger);

Mozlog-compatible logger type.

Methods

impl MozlogLogger

pub fn new(settings: &Settings) -> Self

Construct a logger.

pub fn with_request(request: &Request) -> Result<MozlogLogger, Error>

Log a rocket request.

pub fn with_app_error(     logger: &MozlogLogger,     error: &AppError ) -> Result<MozlogLogger, Error>

Log an application error.

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

Create a copy with "erased" type

See into_erased

Trait Implementations

impl Deref for MozlogLogger

type Target = Logger

The resulting type after dereferencing.

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

Dereferences the value.