36 releases (21 stable)

new 2.4.1 Jul 11, 2019
2.4.0 Apr 14, 2018
2.3.0 Nov 11, 2017
2.0.4 Jul 31, 2017
0.6.0 Jul 19, 2016

#7 in Debugging

Download history 6029/week @ 2019-03-28 7443/week @ 2019-04-04 7740/week @ 2019-04-11 5889/week @ 2019-04-18 6058/week @ 2019-04-25 5265/week @ 2019-05-02 6693/week @ 2019-05-09 8451/week @ 2019-05-16 10502/week @ 2019-05-23 7949/week @ 2019-05-30 5949/week @ 2019-06-06 11313/week @ 2019-06-13 12694/week @ 2019-06-20 10613/week @ 2019-06-27 9855/week @ 2019-07-04

35,865 downloads per month
Used in 144 crates (106 directly)

MPL-2.0/MIT/Apache-2.0

40KB
1K SLoC

slog-rs logo
Travis CI Build Status slog-term on crates.io slog-rs Gitter Chat

slog-term - Terminal output drain for slog-rs

For more information, help, to report issues etc. see slog-rs.


lib.rs:

slog-rs's Drain for terminal output

This crate implements output formatting targeting logging to terminal/console/shell or similar text-based IO.

Warning: slog-term (like slog-rs itself) is fast, modular and extensible. It comes with a price: a lot of details (that you don't care about right now and think they are stupid, until you actually do and then you are happy that someone thought of them for you) are being taken into consideration. Anyway, if you just want to get a logging to terminal working with slog, consider using a wrapper crate like sloggers instead.

Note: A lot of users gets bitten by the fact that slog::Logger::root(...) requires a drain that is safe to send and share across threads (Send+Sync). With shared resource like terminal or a file to which you log, a synchronization needs to be taken care of. If you get compilation errors around Sync or Send you are doing something wrong around it.

Using Decorator open trait, user can implement outputting using different colors, terminal types and so on.

Synchronization via PlainSyncDecorator

This logger works by synchronizing on the IO directly in PlainSyncDecorator. The formatting itself is thread-safe.

#[macro_use]
extern crate slog;
extern crate slog_term;

use slog::*;

fn main() {
    let plain = slog_term::PlainSyncDecorator::new(std::io::stdout());
    let logger = Logger::root(
        slog_term::FullFormat::new(plain)
        .build().fuse(), o!()
    );

    info!(logger, "Logging ready!");
}

Synchronization via slog_async

This drain puts logging into a separate thread via slog_async::Async: formatting and writing to terminal is happening in a one dedicated thread, so no further synchronization is required.

#[macro_use]
extern crate slog;
extern crate slog_term;
extern crate slog_async;

use slog::Drain;

fn main() {
    let decorator = slog_term::TermDecorator::new().build();
    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
    let drain = slog_async::Async::new(drain).build().fuse();

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

    info!(log, "Logging ready!");
}

Synchronization via Mutex

This drain synchronizes by wrapping everything in a big mutex (yes, Mutex<Drain> implements a Drain trait). This is kind of slow, but in scripting languages like Ruby or Python pretty much the whole code is running in a one huge mutex and noone seems to mind, so I'm sure you're going to get away with this. Personally, I am a bit sad, that I've spent so much effort to give you tools to make your code as efficient as possible, and you choose this. ಠ_ಠ . But I'm here to serve, not to tell you what to do.

#[macro_use]
extern crate slog;
extern crate slog_term;

use slog::Drain;

fn main() {
    let decorator = slog_term::TermDecorator::new().build();
    let drain = slog_term::CompactFormat::new(decorator).build();
    let drain = std::sync::Mutex::new(drain).fuse();

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

    info!(log, "Logging ready!");
}

Dependencies

~2MB
~25K SLoC