Struct env_logger::fmt::Formatter

pub struct Formatter { /* private fields */ }

A formatter to write logs into.

Formatter implements the standard Write trait for writing log records. It also supports terminal styling using ANSI escape codes.

Examples

Use the writeln macro to format a log record. An instance of a Formatter is passed to an env_logger format as buf:

use std::io::Write;

let mut builder = env_logger::Builder::new();

builder.format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()));

Implementations

impl Formatter

pub fn timestamp(&self) -> Timestamp

Available on crate feature humantime only.

Get a Timestamp for the current date and time in UTC.

Examples

Include the current timestamp with the log record:

use std::io::Write;

let mut builder = env_logger::Builder::new();

builder.format(|buf, record| {
    let ts = buf.timestamp();

    writeln!(buf, "{}: {}: {}", ts, record.level(), record.args())
});

Examples found in repository

examples/custom_format.rs (line 36)

    fn init_logger() {
        let env = Env::default()
            .filter("MY_LOG_LEVEL")
            .write_style("MY_LOG_STYLE");

        Builder::from_env(env)
            .format(|buf, record| {
                // We are reusing `anstyle` but there are `anstyle-*` crates to adapt it to your
                // preferred styling crate.
                let warn_style = buf.default_level_style(log::Level::Warn);
                let timestamp = buf.timestamp();

                writeln!(
                    buf,
                    "My formatted log ({timestamp}): {warn_style}{}{warn_style:#}",
                    record.args()
                )
            })
            .init();
    }

pub fn timestamp_seconds(&self) -> Timestamp

Available on crate feature humantime only.

Get a Timestamp for the current date and time in UTC with full second precision.

pub fn timestamp_millis(&self) -> Timestamp

Available on crate feature humantime only.

Get a Timestamp for the current date and time in UTC with millisecond precision.

pub fn timestamp_micros(&self) -> Timestamp

Available on crate feature humantime only.

Get a Timestamp for the current date and time in UTC with microsecond precision.

pub fn timestamp_nanos(&self) -> Timestamp

Available on crate feature humantime only.

Get a Timestamp for the current date and time in UTC with nanosecond precision.

impl Formatter

pub fn default_level_style(&self, level: Level) -> Style

Available on crate feature color only.

Get the default style::Style for the given level.

The style can be used to print other values besides the level.

See style for how to adapt it to the styling crate of your choice

Examples found in repository

examples/custom_format.rs (line 35)

    fn init_logger() {
        let env = Env::default()
            .filter("MY_LOG_LEVEL")
            .write_style("MY_LOG_STYLE");

        Builder::from_env(env)
            .format(|buf, record| {
                // We are reusing `anstyle` but there are `anstyle-*` crates to adapt it to your
                // preferred styling crate.
                let warn_style = buf.default_level_style(log::Level::Warn);
                let timestamp = buf.timestamp();

                writeln!(
                    buf,
                    "My formatted log ({timestamp}): {warn_style}{}{warn_style:#}",
                    record.args()
                )
            })
            .init();
    }

Trait Implementations

impl Debug for Formatter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Write for Formatter

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.