Crate slog_term

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!");
}

Structs

CompactFormat	Compact terminal-output formatting Drain
CompactFormatBuilder	Streamer builder
FullFormat	Terminal-output formatting Drain
FullFormatBuilder	Streamer builder
PlainDecorator	Plain (no-op) Decorator implementation
PlainRecordDecorator	Record decorator used by PlainDecorator
PlainSyncDecorator	PlainSync Decorator implementation
PlainSyncRecordDecorator	RecordDecorator used by PlainSyncDecorator
TermDecorator	Decorator implemented using term crate
TermDecoratorBuilder	TermDecorator builder
TermRecordDecorator	Record decorator used by TermDecorator
TestStdoutWriter	Replacement for std::io::stdout() for when output capturing by rust’s test harness is required.

Traits

Decorator	Output decorator
RecordDecorator	Per-record decorator
ThreadSafeTimestampFn	Threadsafe timestamp formatting function type

Functions

term_compact	Create a CompactFormat drain with default settings
term_full	Create a FullFormat drain with default settings
timestamp_local	Default local timezone timestamp function
timestamp_utc	Default UTC timestamp function