Macro astral::thirdparty::slog::log

macro_rules! log {
    (
2 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr ) => { ... };
    (
2 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , ) => { ... };
    (
2 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr ; ) => { ... };
    (
2 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ ( $ args : tt ) * ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ k : ident = $ v : expr ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ k : ident = $ v : expr ; ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ k : ident = $ v : expr , ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ k : ident = $ v : expr ; $ ( $ args : tt
) * ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ k : ident = $ v : expr , $ ( $ args : tt
) * ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , ; $ ( $ args : tt ) * ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr ; $ ( $ args : tt ) * ) => { ... };
    (
1 @ { $ ( $ fmt : tt ) * } , { $ ( $ kv : tt ) * } , $ l : expr , $ lvl : expr
, $ tag : expr , $ msg_fmt : expr , $ f : tt $ ( $ args : tt ) * ) => { ... };
    (
$ l : expr , $ lvl : expr , $ tag : expr , $ ( $ args : tt ) * ) => { ... };
}

Log message a logging record

Use wrappers error!, warn! etc. instead

The max_level_* and release_max_level* cargo features can be used to statically disable logging at various levels. See slog notable details

Use version with longer name if you want to prevent clash with legacy log crate macro names.

Supported invocations

Simple

#[macro_use]
extern crate slog;

fn main() {
    let drain = slog::Discard;
    let root = slog::Logger::root(
        drain,
        o!("key1" => "value1", "key2" => "value2")
    );
    info!(root, "test info log"; "log-key" => true);
}

Note that "key" => value part is optional:

#[macro_use]
extern crate slog;

fn main() {
    let drain = slog::Discard;
    let root = slog::Logger::root(
        drain, o!("key1" => "value1", "key2" => "value2")
    );
    info!(root, "test info log");
}

Formatting support:

#[macro_use]
extern crate slog;

fn main() {
    let drain = slog::Discard;
    let root = slog::Logger::root(drain,
        o!("key1" => "value1", "key2" => "value2")
    );
    info!(root, "formatted {num_entries} entries of {}", "something", num_entries = 2; "log-key" => true);
}

Note:

• ; is used to separate message arguments and key value pairs.
• message behaves like format!/format_args!
• Named arguments to messages will be added to key-value pairs as well!

"key" => value part is optional:

#[macro_use]
extern crate slog;

fn main() {
    let drain = slog::Discard;
    let root = slog::Logger::root(
        drain, o!("key1" => "value1", "key2" => "value2")
    );
    info!(root, "formatted: {}", 1);
}

Use formatting support wisely. Prefer named arguments, so the associated data is not "lost" by becoming an untyped string in the message.

Tags

All above versions can be supplemented with a tag - string literal prefixed with #.

#[macro_use]
extern crate slog;

fn main() {
    let drain = slog::Discard;
    let root = slog::Logger::root(drain,
        o!("key1" => "value1", "key2" => "value2")
    );
    let ops = 3;
    info!(
        root,
        #"performance-metric", "thread speed"; "ops_per_sec" => ops
    );
}

See Record::tag() for more information about tags.

Own implementations of KV and Value

List of key value pairs is a comma separated list of key-values. Typically, a designed syntax is used in form of k => v where k can be any type that implements Value type.

It's possible to directly specify type that implements KV trait without => syntax.

#[macro_use]
extern crate slog;

use slog::*;

fn main() {
    struct MyKV;
    struct MyV;

    impl KV for MyKV {
       fn serialize(&self,
                    _record: &Record,
                    serializer: &mut Serializer)
                   -> Result {
           serializer.emit_u32("MyK", 16)
       }
    }

    impl Value for MyV {
       fn serialize(&self,
                    _record: &Record,
                    key : Key,
                    serializer: &mut Serializer)
                   -> Result {
           serializer.emit_u32("MyKV", 16)
       }
    }

    let drain = slog::Discard;

    let root = slog::Logger::root(drain, o!(MyKV));

    info!(
        root,
        "testing MyV"; "MyV" => MyV
    );
}

fmt::Display and fmt::Debug values

Value of any type that implements std::fmt::Display can be prefixed with % in k => v expression to use it's text representation returned by format_args!("{}", v). This is especially useful for errors. Not that this does not allocate any String since it operates on fmt::Arguments.

Similarly to use std::fmt::Debug value can be prefixed with ?.

#[macro_use]
extern crate slog;
use std::fmt::Write;

fn main() {
    let drain = slog::Discard;
    let log  = slog::Logger::root(drain, o!());

    let mut output = String::new();

    if let Err(e) = write!(&mut output, "write to string") {
        error!(log, "write failed"; "err" => %e);
    }
}