slog — Structured, composable logging for Rust

Getting started Introduction FAQ Crate list slog-rs - The Logging for Rust Introduction (please read) slog is an ecosystem of reusable components for

Information

Category: Rust / Logging
Watchers: 17
Star: 1.5k
Fork: 92
Last update: Dec 7, 2023

Resource links

https://github.com/slog-rs/slog

README
Issues 48

Getting started Introduction FAQ
Crate list

slog-rs - The Logging for Rust

Introduction (please read)

slog is an ecosystem of reusable components for structured, extensible, composable and contextual logging for Rust.

The ambition is to be The Logging Library for Rust. slog should accommodate a variety of logging features and requirements. If there is a feature that you need and standard log crate is missing, slog should have it.

This power comes with a little steeper learning curve, so if you experience any problems, please join slog-rs gitter channel to get up to speed. If you'd like to take a quick, convenient route, consider using sloggers wrapper library.

While the code is reliable, the documentation sometimes could use an improvement. Please report all issues and ideas.

Features & technical documentation

Most of the interesting documentation is auto-generated and hosted on https://docs.rs.

Go to docs.rs/slog to read about features and APIs (examples included).

Note: slog is just a core, and the actual functionality is inside many feature crates. To name a few:

slog-term for terminal output
slog-async for asynchronous logging
slog-json for logging JSON
slog-syslog for logging to syslog
sloggers for convenience methods (note: 3rd-party library)

There are many more slog feature crates. Search for more slog features on crates.io. It is easy to write and publish new ones. Look through all the existing crates using slog for examples and ideas.

Terminal output example

slog-term is only one of many slog features - useful showcase, multi-platform, and featuring eg. automatic TTY detection and colors.

See following screenshot: same output in both compact and full output mode.

Using & help

Please use slog-rs gitter channel to ask for help or discuss slog features.

See examples/features.rs for full quick code example overview.

Read Documentation for details and features.

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

Slog community

Slog related crates are hosted under slog github organization.

Dawid Ciężarkiewicz is the original author and current maintainer of slog and therefore self-appointed benevolent dictator over the project. When working on slog Dawid follows and expects everyone to follow his Code of Conduct.

Any particular repositories under slog ecosystem might be created, controlled, maintained by other entities with various levels of autonomy. Lets work together toward a common goal in a respectful and welcoming atmosphere!

Verification Recommendation

To help with the maintaince, the ownership of this crate is potentially shared between multiple developers. It is recommended to always use cargo-crev to verify the trustworthiness of each of your dependencies, including this one.

48 Open More issues

Closed

TAG-based filtering between components

Trying to figure out how to have a main logger that is passed down into components that based on their configuration set a LevelFilter. I can't get the drain from the drain from main log for LevelFilter::new and I don't want a new logger but the previous logger copied (but it doesn't take LevelFilter as Drain, only root does) ...

feature question

opened Nov 26, 2016 by przygienda 29

Closed

Add extra timestamp format options

Add option to use the UTC time zone
Add option to change the timestamp format string
Fix clippy warnings

opened Sep 21, 2016 by alex-gulyas 20

Closed

Optimize performance

https://github.com/dpc/slog-rs/wiki/Bench-log

Ideas:

[x] &'a str in RecordInfo`
[x] static dispatch - 39e6b5e
[x] measure perf of closure-values
[x] stdlog not to allocate String
[x] Arc chaining instead of copying in Logger hierarchies?
[x] closure-values not to allocate anything - implement SerializeKey for Fn(&RecordInfo, mut io::Writer) ? so the value can output itself without returning?
[x] use the same feature that standard log uses to remove logging statesments at compile time. Now that macros are being used, this should work smoothly.

enhancement

opened Jul 20, 2016 by dpc 18

Closed

Log capturing in unit tests

When writing unit tests, cargo captures output to stdout by default.

#[test]
fn print() {
    println!("Logging with println!");
}

This will not print the text to the terminal, unless cargo test is started with the -- --nocapture argument.

However, with slog this does not seem to work:

// main.rs

fn main() {
    println!("Hello, world!");
}

#[cfg(test)]
mod tests {
    use slog::{Drain, o, info};

    #[test]
    fn print() {
        println!("Logging with println!");
    }

    #[test]
    fn log_to_stdout() {
        let decorator = slog_term::TermDecorator::new().stdout().build();
        let drain = slog_term::CompactFormat::new(decorator).build();
        let log = slog::Logger::root(std::sync::Mutex::new(drain).fuse(), o!());
        info!(log, "Logging to stdout");
    }

    #[test]
    fn log_to_stderr() {
        let decorator = slog_term::TermDecorator::new().stderr().build();
        let drain = slog_term::CompactFormat::new(decorator).build();
        let log = slog::Logger::root(std::sync::Mutex::new(drain).fuse(), o!());
        info!(log, "Logging to stderr");
    }
}

Running this with cargo test will print:

$ cargo test -- --test-threads=1
    Finished test [unoptimized + debuginfo] target(s) in 0.02s
     Running target/debug/deps/asdf-5593e16ab0d57485

running 3 tests
test tests::log_to_stderr ... Feb 17 17:33:41.976 INFO Logging to stderr
ok
test tests::log_to_stdout ... Feb 17 17:33:41.977 INFO Logging to stdout
ok
test tests::print ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Neither stdout nor stderr logs are captured.

I realize that this is probably due to some pecularity in how cargo handles capturing, but is there some kind of drain that logs in a cargo log capturing compatible way (possibly using println) that can be used in tests?

opened Feb 17, 2020 by dbrgn 14

Closed

Completion doesn't work for Logger and other types in intellij-rust

I'm using IntelliJ Rust as an IDE and use slog. With IntelliJ Rust, completion usually works nicely for crates that I'm using.

The problem is that with slog, it doesn't work at all, e.g. for Logger. I can jump to the type using Navigate > Class..., and it will find it in the _logger.rs file of slog. But completion doesn't work and neither does jumping to the definition from a usage of Logger.

I'm pretty sure the reason for that is the use of the include! macro to include _logger.rs and co from lib.rs. I don't know if racer has the same problem.

Have you considered using normal mod logger and pub use logger::{a, b}? I know it's more to type, but maybe it's worth it to make completion work? It also has the advantage of making the whole API surface visible in one file.

I can also file an issue with IntelliJ Rust, but I wanted to file it here first because this is the only crates that I've encountered that uses this unusual way to define its API.

opened Feb 9, 2017 by robinst 14

Closed

Minimum rust version bump in minor version release is a breaking change

This commit bumps the minimum version from 1.15.0 to 1.26.1 which is a breaking change and it breaks builds for us which depend on 1.22.0 rust version.

One solution i to wrap the u128 support in an optional feature gate.

opened Sep 29, 2018 by Dylan-DPC 13

Open

env_logger cannot be used as root logger because it is not unwind safe

use slog::Drain;

fn main() {
    let drain = slog::Discard;
    let drain = slog_envlogger::LogBuilder::new(drain).build();
    // Does not help:
    // let drain = drain.fuse();
    let logger = slog::Logger::root(drain, slog::o!());
}

error[E0277]: the type std::cell::UnsafeCell<std::option::Option<std::boxed::Box<std::cell::RefCell<regex::exec::ProgramCacheInner>>>> may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary --> src/main.rs:8:18 | 8 | let logger = slog::Logger::root(drain, slog::o!()); | ^^^^^^^^^^^^^^^^^^ std::cell::UnsafeCell<std::option::Option<std::boxed::Box<std::cell::RefCell<regex::exec::ProgramCacheInner>>>> may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary | ::: /.cargo/registry/src/github.com-1ecc6299db9ec823/slog-2.5.2/src/lib.rs:1120:38 | 1120 | T: SendSyncRefUnwindSafeKV + 'static, | ------- required by this bound in slog::Logger::<D>::root | = help: within slog_envlogger::EnvLogger<slog::Discard>, the trait std::panic::RefUnwindSafe is not implemented for std::cell::UnsafeCell<std::option::Option<std::boxed::Box<std::cell::RefCell<regex::exec::ProgramCacheInner>>>> = note: required because it appears within the type thread_local::cached::CachedThreadLocal<std::cell::RefCell<regex::exec::ProgramCacheInner>> = note: required because it appears within the type regex::cache::imp::Cached<std::cell::RefCell<regex::exec::ProgramCacheInner>> = note: required because it appears within the type regex::exec::Exec = note: required because it appears within the type regex::re_unicode::Regex = note: required because it appears within the type slog_envlogger::filter::Filter = note: required because it appears within the type std::option::Option<slog_envlogger::filter::Filter> = note: required because it appears within the type slog_envlogger::EnvLogger<slog::Discard> = note: required because of the requirements on the impl of slog::SendSyncRefUnwindSafeDrain for slog_envlogger::EnvLogger<slog::Discard>

I find this surprising. In one of the examples https://github.com/slog-rs/envlogger/blob/v2.2.0/examples/proper.rs the workaround seems to be that env_logger is wrapped in the async logger.

opened Jun 8, 2020 by e00E 4

Open

Record does not contain file location and module for log messages from isahc crate, but works with env_logger

When using isahc https://crates.io/crates/isahc log records are missing location information when logging them through slog. The information exists when logging through env_logger https://crates.io/crates/env_logger .

Cargo.toml:

[package]
name = "temp"
version = "0.1.0"
edition = "2018"

[dependencies]
env_logger = "0.7.1"
isahc = "0.9.3"
log = "0.4.8"
slog = "2.5.2"
slog-scope = "4.3.0"
slog-stdlog = "4.0.0"

main.rs:

pub struct CustomFormatter;
impl slog::Drain for CustomFormatter {
    type Ok = ();
    type Err = ();
    fn log(
        &self,
        record: &slog::Record,
        _values: &slog::OwnedKVList,
    ) -> std::result::Result<Self::Ok, Self::Err> {
        println!(
            "{} {} {} {}: {}",
            record.level(),
            record.module(),
            record.file(),
            record.line(),
            record.msg()
        );
        Ok(())
    }
}

fn env_logger_format(
    formatter: &mut env_logger::fmt::Formatter,
    record: &log::Record,
) -> std::io::Result<()> {
    use std::io::Write as _;
    writeln!(
        formatter,
        "{} {} {} {}: {}",
        record.level(),
        record.module_path().unwrap(),
        record.file().unwrap(),
        record.line().unwrap(),
        record.args()
    )
    .unwrap();
    Ok(())
}

fn setup_env_logger() {
    env_logger::Builder::new()
        .filter_level(log::LevelFilter::Trace)
        .format(env_logger_format)
        .init();
}

fn setup_slog_logger() -> slog_scope::GlobalLoggerGuard {
    use slog::Drain as _;
    let logger = slog::Logger::root(CustomFormatter {}.fuse(), slog::o!());
    let guard = slog_scope::set_global_logger(logger);
    slog_stdlog::init().unwrap();
    guard
}

fn main() {
    // setup_env_logger();
    let _guard = setup_slog_logger();
    log::info!("start");
    isahc::HttpClient::new().unwrap();
    log::info!("end");
}

cargo run:

INFO temp src/main.rs 32: start
INFO <unknown> <unknown> 505: new
INFO <unknown> <unknown> 505: -> new
INFO <unknown> <unknown> 372: build
...

Change which logger is enabled:

    setup_env_logger();
    // let _guard = setup_slog_logger();

cargo run:

INFO temp src/main.rs 58: start
INFO isahc::client /home/u/.cargo/registry/src/github.com-1ecc6299db9ec823/isahc-0.9.3/src/client.rs 505: new
INFO isahc::client /home/u/.cargo/registry/src/github.com-1ecc6299db9ec823/isahc-0.9.3/src/client.rs 505: -> new
INFO isahc::client /home/u/.cargo/registry/src/github.com-1ecc6299db9ec823/isahc-0.9.3/src/client.rs 372: build
...

I am not sure which crate is at fault but slog is most likely as it works with env_logger.

opened May 25, 2020 by e00E 2

Open

Update slog-syslog depdencies

The syslog dependency is outdated and there is a new version.

opened Apr 25, 2020 by omarabid 3

Open

memory leak in slog_scope

Running valgrind on a program I have, I obtain a lot of these:

==4175714== 16 bytes in 1 blocks are possibly lost in loss record 24 of 103
==4175714==    at 0x4C29DAF: malloc (vg_replace_malloc.c:309)
==4175714==    by 0x1198DEB: alloc::alloc::alloc (alloc.rs:81)
==4175714==    by 0x1198D5B: alloc::alloc::exchange_malloc (alloc.rs:203)
==4175714==    by 0x119783C: alloc::sync::Arc<T>::new (sync.rs:302)
==4175714==    by 0x11960B6: slog::OwnedKVList::root (lib.rs:3426)
==4175714==    by 0x119618E: slog::Logger<D>::root (lib.rs:1125)
==4175714==    by 0x119433E: __static_ref_initialize (lib.rs:110)
==4175714==    by 0x119433E: core::ops::function::FnOnce::call_once (function.rs:232)
==4175714==    by 0x119271A: lazy_static::lazy::Lazy<T>::get::{{closure}} (inline_lazy.rs:31)
==4175714==    by 0x1198737: std::sync::once::Once::call_once::{{closure}} (once.rs:264)
==4175714==    by 0x1799E70: std::sync::once::Once::call_inner (once.rs:417)
==4175714==    by 0x11986B2: std::sync::once::Once::call_once (once.rs:264)                                                                                              ==4175714==    by 0x119BAA8: get<arc_swap::ArcSwapAny<alloc::sync::Arc<slog::Logger<alloc::sync::Arc<SendSyncRefUnwindSafeDrain>>>, arc_swap::gen_lock::Global>,fn() -> a
rc_swap::ArcSwapAny<alloc::sync::Arc<slog::Logger<alloc::sync::Arc<SendSyncRefUnwindSafeDrain>>>, arc_swap::gen_lock::Global>> (inline_lazy.rs:30)
==4175714==    by 0x119BAA8: __stability (<::lazy_static::__lazy_static_internal macros>:16)
==4175714==    by 0x119BAA8: <slog_scope::GLOBAL_LOGGER as core::ops::deref::Deref>::deref (<::lazy_static::__lazy_static_internal macros>:18)

way to repro:

git clone --depth 1 https://github.com/libra/libra.git
cd libra/testsuite/libra-fuzzer
mkdir -p fuzz/corpus/addmission_control
echo "CswBKskB0njtjZhgowd2SjEB3IHegKQ9IUQRjELOcD0Xov3K9CE2F6aKwZmkBwMAAAAZAAAAtlYH3Ag+23KMY6B1tqBHEbBAUaxMScfWwZcOhVJS1/oSHKpxHc03UIdPSvkksDFODSAAAADGx885lPdOFj7vzuiGRP/v4VeM/Vq8GhWEXEPzFwaT8kAAAAB2ovix102nyik07zRXRqYO6/hovSjhn+p2MEyxnWD4hB6CAgHZH3x5JJ1zOjQUt+3Dd5vGHuoE6U7Ft7tBpXsF" | base64 -D > fuzz/corpus/admission_control/0705ebd76487a545fbde086c56f678bc996db1c3
cargo build --bin investigate
valgrind --leak-check=full ../../target/debug/investigate  -i fuzz/corpus/admission_control/0705ebd76487a545fbde086c56f678bc996db1c3

opened Feb 14, 2020 by mimoo 1

Open

Deadlock in slog-rs when logging a structure which logs in Debug / Display

I've noted this on the slog gitter, but raising an issue here to track the problem.

If you log (using error!, info!, warn! or debug!) when implementing Debug or Display, then when you log the structure (with info!(logger, "Logging: {:?}", struct); ) then slog may deadlock.

There's a full stack at: https://gist.github.com/richardwhiuk/c53a19c4b92d6e33dab17c615f1b3001

but the key parts are:

#5  _$LT$std..sync..mutex..Mutex$LT$D$GT$$u20$as$u20$slog..Drain$GT$::log::h1a8c2cc72bb29644 (self=0x564d8943dcc0, record=0x7ff4454ce598, logger_values=0x564d8943de70)
    at /opt/rust/registry/src/crates-27bb2a0041c1489d/slog-2.5.2/src/lib.rs:2035
#6  0x0000564d86e3eed5 in _$LT$slog..Fuse$LT$D$GT$$u20$as$u20$slog..Drain$GT$::log::he38f0b0d96904e9b (self=0x80, record=0x0, logger_values=0x7ff44769610d <__lll_lock_wait+29>)
    at /opt/rust/registry/src/crates-27bb2a0041c1489d/slog-2.5.2/src/lib.rs:1912

which attempts to grab the lock and:

#24 _$LT$slog_json..SerdeSerializer$LT$S$GT$$u20$as$u20$slog..Serializer$GT$::emit_arguments::_$u7b$$u7b$closure$u7d$$u7d$::h52bb2c0438e0f6aa (buf=0x7ff4454d14f0)
    at /opt/rust/registry/src/crates-27bb2a0041c1489d/slog-json-2.3.0/lib.rs:147

where slog-json calls into a user specified Debug function.

opened Feb 12, 2020 by richardwhiuk 1

Open

Request for convenience function

Might be nice to have something like:

use slog_scope::*;
new_scope!("key" => "value", || {
  info!("hi");
});

that is shorthand for:

use slog_scope::*;
with_logger(|logger| {
  scope(logger.new(o!("key" => "value")), || {
    info!("hi")
  });
});

opened Jan 15, 2020 by aklitzke 1

slog-scope - Logging scopes for slog-rs

vue-composable - Vue composition-api composable components. i18n, validation, pagination, fetch, etc. +30 variable composable functions.

Truly highly composable logging utility

jl — JSON Logs, a development tool for working with structured JSON logging.

ulog - Structured and context based logging for golang

Structured Logging, Tracing, and Observability with Logback

Structured+contextual logging experiments in Ruby

A lite go logging component

emit - A structured logger in the style of Serilog

:green_book: Simple, configurable and scalable Structured Logging for Go.

Blazing fast, structured, leveled logging in Go.

Simple Logging Facade for Java

A flexible logging library for use in Ruby programs based on the design of Java's log4j library.

JustLog brings logging on iOS to the next level. It supports console, file and remote Logstash logging via TCP socket with no effort. Support for logz.io available.

Reckless logging. Low-latency, high-throughput, asynchronous logging library for C++.

MongoDB Python logging handler, Centralized logging made simple using MongoDB.

log — Logging implementation for Rust

Training neural models with structured signals.

Structured, composable logging for Go

trace is a wrapper for net/trace that extends it by logging trace/event information to a structured log and providing metrics (counts, errors, histograms of durations) to Prometheus. De-clutter your functions by combining all the things you need to do in one place.

Share this repo

Related Repos

Logging

787

A nginx log explorer

Rhit reads your nginx log files in their standard location(even gzipped), does some analysis and tells you about it in pretty tables in your console, storing and polluting nothing.

Logging

Log call tree summaries after each request for rust programs instrumented with `tracing`.

Log "request x-rays" for rust programs instrumented with tracing. This includes aggregated wall/own times as frequently found in flame graphs in a human-friendly text format.

Logging

A simple middleware for tide using the tracing crate for logging.

Logging

4.4k

tracing — An application level tracing framework for async-aware structured logging, error...

tracing Application-level tracing for Rust. Website | Chat | Documentation (master branch) Overview tracing is a framework for instrumenting Rust prog

Logging

866

log4rs — highly configurable logging framework modeled after Java's Logback and log4j libr...

log4rs log4rs is a highly configurable logging framework modeled after Java's Logback and log4j libraries. Warning If you are using the file rotation

Logging

1.5k

slog — Structured, composable logging for Rust

Getting started Introduction FAQ Crate list slog-rs - The Logging for Rust Introduction (please read) slog is an ecosystem of reusable components for

Logging

1.9k

log — Logging implementation for Rust

log A Rust library providing a lightweight logging facade. log documentation A logging facade provides a single logging API that abstracts over the ac

Logging

452

pretty-env-logger — A pretty, easy-to-use logger for Rust.

pretty-env-logger A simple logger built on top of env_logger. It is configured via an environment variable and writes to standard error with nice colo