Struct ConsoleSink 

pub struct ConsoleSink<F: Formatter, W: Write = BufWriter<Stdout>> { /* private fields */ }

Writes formatted records to a Write destination.

Composes a Formatter with a buffered writer. The writer plus a reusable scratch String live behind a Mutex because Sink::write_record takes &self; in practice the lock is uncontended — sinks are usually invoked only from the backend worker thread.

The writer type W defaults to BufWriter<Stdout>, which is what ConsoleSink::new produces. Use ConsoleSink::with_writer to supply an alternative destination (e.g. a Vec<u8> in tests).

Implementations

impl<F: Formatter> ConsoleSink<F>

pub fn new(formatter: F, level: LogLevel) -> ConsoleSink<F, BufWriter<Stdout>>

Constructs a ConsoleSink writing to a fresh BufWriter<Stdout>.

Examples found in repository

examples/core_concepts.rs (lines 16-19)

fn main() -> Result<(), Box<dyn Error>> {
    // ANCHOR: backend
    let _guard = start(BackendOptions::default())?;
    // ANCHOR_END: backend

    // ANCHOR: sink
    let sink: Arc<dyn insomnilog::Sink> = Arc::new(ConsoleSink::new(
        PatternFormatter::default(),
        LogLevel::Trace,
    ));
    register_sink("console", Arc::clone(&sink))?;
    // ANCHOR_END: sink

    // ANCHOR: logger
    let logger = create_logger("app", vec![Arc::clone(&sink)], LogLevel::Info)?;

    log_info!(logger, "server started on port {}", 8080_u16);
    // ANCHOR_END: logger

    Ok(())
}

examples/preallocating.rs (lines 13-16)

fn main() -> Result<(), Box<dyn Error>> {
    let _guard = start(BackendOptions::default())?;

    let sink: Arc<dyn insomnilog::Sink> = Arc::new(ConsoleSink::new(
        PatternFormatter::default(),
        LogLevel::Info,
    ));
    let logger = create_logger("app", vec![sink], LogLevel::Info)?;

    // ANCHOR: main_thread
    // Allocate the queue for the main thread before entering the hot path.
    preallocate_thread();
    // ANCHOR_END: main_thread

    log_info!(logger, "main thread ready");

    // ANCHOR: worker_thread
    let worker_logger = Arc::clone(&logger);
    thread::spawn(move || {
        // Allocate the queue for this thread before any log call.
        preallocate_thread();

        log_info!(worker_logger, "worker thread ready");
    })
    .join()
    .unwrap();
    // ANCHOR_END: worker_thread

    Ok(())
}

examples/formatter.rs (lines 43-46)

fn log_example(
    name: &str,
    pattern: &str,
    expected: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let console = Arc::new(ConsoleSink::new(
        PatternFormatter::new(pattern)?,
        LogLevel::Trace,
    ));
    let capture = Arc::new(ConsoleSink::with_writer(
        PatternFormatter::new(pattern)?,
        LogLevel::Trace,
        Vec::<u8>::new(),
    ));
    let logger = create_logger(
        name,
        vec![
            console as Arc<dyn Sink>,
            Arc::clone(&capture) as Arc<dyn Sink>,
        ],
        LogLevel::Trace,
    )?;

    // ANCHOR: message
    log_info!(
        logger,
        "The Answer to the Ultimate Question of Life, the Universe, and Everything.: {}",
        42_u16
    );
    log_warn!(logger, "...What{}", "?");
    // ANCHOR_END: message

    if !expected.is_empty() {
        let ready = spin_until(
            || capture.captured_output().len() >= expected.len(),
            Duration::from_millis(100),
        );
        assert!(
            ready,
            "capture sink did not receive all records within 100 ms"
        );
        let actual =
            String::from_utf8(capture.captured_output()).expect("sink output is valid UTF-8");
        assert_eq!(normalize(&actual), normalize(expected));
    }
    Ok(())
}

#[expect(
    clippy::literal_string_with_formatting_args,
    reason = "{secs}, {millis:03} etc. are PatternFormatter placeholders, not Rust format args"
)]
fn main() -> Result<(), Box<dyn Error>> {
    let _guard = start(BackendOptions::default())?;

    // ANCHOR: definition
    let fmt = PatternFormatter::new("{level:7} {message}")?;
    let sink = Arc::new(ConsoleSink::new(fmt, LogLevel::Trace));
    // ANCHOR_END: definition

    let _ = sink;

    // ANCHOR: minimal
    let pattern = "{level:7} {message}";
    let expected = concat!(
        "INFO    The Answer to the Ultimate Question of Life, the Universe, and Everything.: 42\n",
        "WARNING ...What?\n",
    );
    // ANCHOR_END: minimal
    log_example("minimal", pattern, expected)?;

    // ANCHOR: structured
    let pattern = "[{secs}.{millis:03}] {level:<8} {logger:<12} {message}";
    let expected = concat!(
        "[1779463945.562] INFO     Example 1    The Answer to the Ultimate Question of Life, the Universe, and Everything.: 42\n",
        "[1779463945.562] WARNING  Example 1    ...What?\n",
    );
    // ANCHOR_END: structured
    log_example("Example 1", pattern, expected)?;

    // ANCHOR: module
    let pattern = "{level} [{module}] {file}:{line} {message}";
    let expected = concat!(
        "INFO [formatter] examples/examples/formatter.rs:54 The Answer to the Ultimate Question of Life, the Universe, and Everything.: 42\n",
        "WARNING [formatter] examples/examples/formatter.rs:59 ...What?\n",
    );
    // ANCHOR_END: module
    log_example("Example 2", pattern, expected)?;

    // ANCHOR: centered
    let pattern = "{message:-^40}";
    let expected = concat!(
        "The Answer to the Ultimate Question of Life, the Universe, and Everything.: 42\n",
        "----------------...What?----------------\n",
    );
    // ANCHOR_END: centered
    log_example("Example 3", pattern, expected)?;

    Ok(())
}

examples/quick_start.rs (lines 18-21)

fn main() -> Result<(), Box<dyn Error>> {
    // 1. Start the backend worker thread. The returned guard keeps it alive;
    // dropping it drains all buffered records and joins the thread.
    let _guard = insomnilog::start(insomnilog::BackendOptions::default())?;

    // 2. Create a sink — decides where and how records are written. The built-in
    // `ConsoleSink` formats records as human-readable lines and writes them to
    // stdout.
    let sink = Arc::new(ConsoleSink::new(
        PatternFormatter::default(),
        LogLevel::Trace,
    ));

    // 3. Create a logger — the handle you pass to every log macro. It holds a
    // level filter and the list of sinks that receive its records.
    let logger = insomnilog::create_logger("app", vec![sink], LogLevel::Trace)?;

    // Optional: Eagerly allocate this thread's queue so the first log call is
    // allocation-free. Omit it and allocation happens on first use.
    preallocate_thread();

    // 4. Start logging
    // The macros accept a format string and zero or more typed arguments, similar to
    // `println!`
    log_info!(logger, "application started");
    log_debug!(logger, "config loaded from {}", "/etc/app/config.toml");
    log_warn!(logger, "disk usage at {}%", 87.5_f64);
    log_error!(logger, "connection lost to {}", "db-primary");

    // _guard drops here → backend drains and exits cleanly.
    Ok(())
}

impl<F: Formatter, W: Write> ConsoleSink<F, W>

pub const fn with_writer(formatter: F, level: LogLevel, writer: W) -> Self

Constructs a ConsoleSink writing to the given writer.

Prefer ConsoleSink::new for production use. This constructor exists mainly to allow tests to capture output without touching stdout.

Examples found in repository

examples/formatter.rs (lines 47-51)

fn log_example(
    name: &str,
    pattern: &str,
    expected: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let console = Arc::new(ConsoleSink::new(
        PatternFormatter::new(pattern)?,
        LogLevel::Trace,
    ));
    let capture = Arc::new(ConsoleSink::with_writer(
        PatternFormatter::new(pattern)?,
        LogLevel::Trace,
        Vec::<u8>::new(),
    ));
    let logger = create_logger(
        name,
        vec![
            console as Arc<dyn Sink>,
            Arc::clone(&capture) as Arc<dyn Sink>,
        ],
        LogLevel::Trace,
    )?;

    // ANCHOR: message
    log_info!(
        logger,
        "The Answer to the Ultimate Question of Life, the Universe, and Everything.: {}",
        42_u16
    );
    log_warn!(logger, "...What{}", "?");
    // ANCHOR_END: message

    if !expected.is_empty() {
        let ready = spin_until(
            || capture.captured_output().len() >= expected.len(),
            Duration::from_millis(100),
        );
        assert!(
            ready,
            "capture sink did not receive all records within 100 ms"
        );
        let actual =
            String::from_utf8(capture.captured_output()).expect("sink output is valid UTF-8");
        assert_eq!(normalize(&actual), normalize(expected));
    }
    Ok(())
}

impl<F: Formatter> ConsoleSink<F, Vec<u8>>

pub fn captured_output(&self) -> Vec<u8>

Returns a copy of the bytes written to the sink so far.

Examples found in repository

examples/formatter.rs (line 72)

fn log_example(
    name: &str,
    pattern: &str,
    expected: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let console = Arc::new(ConsoleSink::new(
        PatternFormatter::new(pattern)?,
        LogLevel::Trace,
    ));
    let capture = Arc::new(ConsoleSink::with_writer(
        PatternFormatter::new(pattern)?,
        LogLevel::Trace,
        Vec::<u8>::new(),
    ));
    let logger = create_logger(
        name,
        vec![
            console as Arc<dyn Sink>,
            Arc::clone(&capture) as Arc<dyn Sink>,
        ],
        LogLevel::Trace,
    )?;

    // ANCHOR: message
    log_info!(
        logger,
        "The Answer to the Ultimate Question of Life, the Universe, and Everything.: {}",
        42_u16
    );
    log_warn!(logger, "...What{}", "?");
    // ANCHOR_END: message

    if !expected.is_empty() {
        let ready = spin_until(
            || capture.captured_output().len() >= expected.len(),
            Duration::from_millis(100),
        );
        assert!(
            ready,
            "capture sink did not receive all records within 100 ms"
        );
        let actual =
            String::from_utf8(capture.captured_output()).expect("sink output is valid UTF-8");
        assert_eq!(normalize(&actual), normalize(expected));
    }
    Ok(())
}

Trait Implementations

impl<F: Formatter, W: Write + Send> Sink for ConsoleSink<F, W>

fn write_record(&self, record: &LogRecord) -> Result<(), SinkError>

Processes a log record. Called by the backend worker once per record, after the worker confirms self.level() <= record.level.

fn flush(&self) -> Result<(), SinkError>

Flushes any buffered output. Called by the worker after each batch of records and at shutdown.

fn level(&self) -> LogLevel

Returns the sink’s filter level. Fixed at construction.