slog 0.5.0

Structured, composable logging for Rust

slog-rs - Structured, composable logging for Rust

Code snippet

fn main() {
    // Create a new group of loggers, sharing one drain.
    // Note `o!` macro for more natural `OwnedKeyValue` sequence building.
    let root = Logger::new_root(o!("version" => VERSION, "build-id" => "8dfljdf"));

    // Set drains to specify the output format and destination.

    // Build logging context as data becomes available.
    // Create child loggers from existing ones. Children clone `key: value`
    // pairs from their parents.
    let log =!("child" => 1));

    // Closures can be used for values that change at runtime.
    // Data captured by the closure needs to be `Send+Sync`.
    let counter = Arc::new(AtomicUsize::new(0));
    let log =!("counter" => {
        let counter = counter.clone();
        // Note the `move` to capture `counter`,
        // and unfortunate `|_ : &_|` that helps
        // current `rustc` limitations. In the future,
        // a `|_|` could work.
        move |_ : &_| { counter.load(SeqCst)}

    // Note `b!` macro for more natural `BorrowedKeyValue` sequence building."before-fetch-add", b!()); // counter == 0
    counter.fetch_add(1, SeqCst);"after-fetch-add", b!()); // counter == 1

    // Drains can be swapped atomically (race-free).
        // drains are composable
                // multiple outputs formats are supported

    // Closures can be used for lazy evaluation:
    // This `slow_fib` won't be evaluated, as the current drain discards
    // "trace" level logging records.
    log.debug("debug", b!("lazy-closure" => |_ : &_| slow_fib(40)));

    // Loggers are internally atomically reference counted so can be cloned,
    // passed between threads and stored without hassle.
    let join = thread::spawn({
        let log = log.clone();
        move || {
  "subthread", b!("stage" => "start"));
            thread::sleep(Duration::new(1, 0));
  "subthread", b!("stage" => "end"));


See examples/ for full code.


Structured, composable logging for Rust. Work in progress, but usable already.

Heavily inspired by log15 for Go, which I liked so much, that I want it in Rust too.

Read Documentation for details and features.

If you want to say hi, or need help use #dpc

To report a bug or ask for features use github issues.


  • easy to use
  • hierarchal loggers
  • lazily evaluated values
  • extensible: first-class custom implementations
  • drains & output formatting
    • filtering
    • multiple outputs
    • asynchronous IO writing
    • terminal output, with color support (slog-term crate)
    • Json (slog-json crate)
      • Bunyan (slog-bunyan crate)
    • more to come (syslog, network)

Building & running

If you need to install Rust (come on, you should have done that long time ago!), use rustup.

In your project

In Cargo.toml:

slog = "*"

In your

extern crate slog;