Struct env_logger::Builder

pub struct Builder { /* private fields */ }

Builder acts as builder for initializing a Logger.

It can be used to customize the log format, change the environment variable used to provide the logging directives and also set the default log level filter.

Examples

use env_logger::Builder;
use log::{LevelFilter, error, info};

let mut builder = Builder::from_default_env();

builder
    .format(|buf, record| writeln!(buf, "{} - {}", record.level(), record.args()))
    .filter(None, LevelFilter::Info)
    .init();

error!("error message");
info!("info message");

Implementations

impl Builder

pub fn new() -> Builder

Initializes the log builder with defaults.

NOTE: This method won’t read from any environment variables. Use the filter and write_style methods to configure the builder or use from_env or from_default_env instead.

Examples

Create a new builder and configure filters and style:

use log::LevelFilter;
use env_logger::{Builder, WriteStyle};

let mut builder = Builder::new();

builder
    .filter(None, LevelFilter::Info)
    .write_style(WriteStyle::Always)
    .init();

pub fn from_env<'a, E>(env: E) -> Self

where E: Into<Env<'a>>,

Initializes the log builder from the environment.

The variables used to read configuration from can be tweaked before passing in.

Examples

Initialise a logger reading the log filter from an environment variable called MY_LOG:

use env_logger::Builder;

let mut builder = Builder::from_env("MY_LOG");
builder.init();

Initialise a logger using the MY_LOG variable for filtering and MY_LOG_STYLE for whether or not to write styles:

use env_logger::{Builder, Env};

let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");

let mut builder = Builder::from_env(env);
builder.init();

pub fn parse_env<'a, E>(&mut self, env: E) -> &mut Self

where E: Into<Env<'a>>,

Applies the configuration from the environment.

This function allows a builder to be configured with default parameters, to be then overridden by the environment.

Examples

Initialise a logger with filter level Off, then override the log filter from an environment variable called MY_LOG:

use log::LevelFilter;
use env_logger::Builder;

let mut builder = Builder::new();

builder.filter_level(LevelFilter::Off);
builder.parse_env("MY_LOG");
builder.init();

Initialise a logger with filter level Off, then use the MY_LOG variable to override filtering and MY_LOG_STYLE to override whether or not to write styles:

use log::LevelFilter;
use env_logger::{Builder, Env};

let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");

let mut builder = Builder::new();
builder.filter_level(LevelFilter::Off);
builder.parse_env(env);
builder.init();

pub fn from_default_env() -> Self

Initializes the log builder from the environment using default variable names.

This method is a convenient way to call from_env(Env::default()) without having to use the Env type explicitly. The builder will use the default environment variables.

Examples

Initialise a logger using the default environment variables:

use env_logger::Builder;

let mut builder = Builder::from_default_env();
builder.init();

pub fn parse_default_env(&mut self) -> &mut Self

Applies the configuration from the environment using default variable names.

This method is a convenient way to call parse_env(Env::default()) without having to use the Env type explicitly. The builder will use the default environment variables.

Examples

Initialise a logger with filter level Off, then configure it using the default environment variables:

use log::LevelFilter;
use env_logger::Builder;

let mut builder = Builder::new();
builder.filter_level(LevelFilter::Off);
builder.parse_default_env();
builder.init();

pub fn format<F>(&mut self, format: F) -> &mut Self

where F: Fn(&mut Formatter, &Record<'_>) -> Result<()> + Sync + Send + 'static,

Sets the format function for formatting the log output.

This function is called on each record logged and should format the log record and output it to the given Formatter.

The format function is expected to output the string directly to the Formatter so that implementations can use the std::fmt macros to format and output without intermediate heap allocations. The default env_logger formatter takes advantage of this.

Examples

Use a custom format to write only the log message:

use std::io::Write;
use env_logger::Builder;

let mut builder = Builder::new();

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

pub fn default_format(&mut self) -> &mut Self

Use the default format.

This method will clear any custom format set on the builder.

pub fn format_level(&mut self, write: bool) -> &mut Self

Whether or not to write the level in the default format.

pub fn format_module_path(&mut self, write: bool) -> &mut Self

Whether or not to write the module path in the default format.

pub fn format_target(&mut self, write: bool) -> &mut Self

Whether or not to write the target in the default format.

pub fn format_indent(&mut self, indent: Option<usize>) -> &mut Self

Configures the amount of spaces to use to indent multiline log records. A value of None disables any kind of indentation.

pub fn format_timestamp( &mut self, timestamp: Option<TimestampPrecision>, ) -> &mut Self

Configures if timestamp should be included and in what precision.

pub fn format_timestamp_secs(&mut self) -> &mut Self

Configures the timestamp to use second precision.

pub fn format_timestamp_millis(&mut self) -> &mut Self

Configures the timestamp to use millisecond precision.

pub fn format_timestamp_micros(&mut self) -> &mut Self

Configures the timestamp to use microsecond precision.

pub fn format_timestamp_nanos(&mut self) -> &mut Self

Configures the timestamp to use nanosecond precision.

pub fn format_suffix(&mut self, suffix: &'static str) -> &mut Self

Configures the end of line suffix.

pub fn filter_module(&mut self, module: &str, level: LevelFilter) -> &mut Self

Adds a directive to the filter for a specific module.

Examples

Only include messages for info and above for logs in path::to::module:

use env_logger::Builder;
use log::LevelFilter;

let mut builder = Builder::new();

builder.filter_module("path::to::module", LevelFilter::Info);

pub fn filter_level(&mut self, level: LevelFilter) -> &mut Self

Adds a directive to the filter for all modules.

Examples

Only include messages for info and above for logs globally:

use env_logger::Builder;
use log::LevelFilter;

let mut builder = Builder::new();

builder.filter_level(LevelFilter::Info);

pub fn filter(&mut self, module: Option<&str>, level: LevelFilter) -> &mut Self

Adds filters to the logger.

The given module (if any) will log at most the specified level provided. If no module is provided then the filter will apply to all log messages.

Examples

Only include messages for info and above for logs in path::to::module:

use env_logger::Builder;
use log::LevelFilter;

let mut builder = Builder::new();

builder.filter(Some("path::to::module"), LevelFilter::Info);

pub fn parse_filters(&mut self, filters: &str) -> &mut Self

Parses the directives string in the same form as the RUST_LOG environment variable.

See the module documentation for more details.

pub fn target(&mut self, target: Target) -> &mut Self

Sets the target for the log output.

Env logger can log to either stdout, stderr or a custom pipe. The default is stderr.

The custom pipe can be used to send the log messages to a custom sink (for example a file). Do note that direct writes to a file can become a bottleneck due to IO operation times.

Examples

Write log message to stdout:

use env_logger::{Builder, Target};

let mut builder = Builder::new();

builder.target(Target::Stdout);

pub fn write_style(&mut self, write_style: WriteStyle) -> &mut Self

Sets whether or not styles will be written.

This can be useful in environments that don’t support control characters for setting colors.

Examples

Never attempt to write styles:

use env_logger::{Builder, WriteStyle};

let mut builder = Builder::new();

builder.write_style(WriteStyle::Never);

pub fn parse_write_style(&mut self, write_style: &str) -> &mut Self

Parses whether or not to write styles in the same form as the RUST_LOG_STYLE environment variable.

See the module documentation for more details.

pub fn is_test(&mut self, is_test: bool) -> &mut Self

Sets whether or not the logger will be used in unit tests.

If is_test is true then the logger will allow the testing framework to capture log records rather than printing them to the terminal directly.

pub fn try_init(&mut self) -> Result<(), SetLoggerError>

Initializes the global logger with the built env logger.

This should be called early in the execution of a Rust program. Any log events that occur before initialization will be ignored.

Errors

This function will fail if it is called more than once, or if another library has already initialized a global logger.

pub fn init(&mut self)

Initializes the global logger with the built env logger.

This should be called early in the execution of a Rust program. Any log events that occur before initialization will be ignored.

Panics

This function will panic if it is called more than once, or if another library has already initialized a global logger.

pub fn build(&mut self) -> Logger

Build an env logger.

The returned logger implements the Log trait and can be installed manually or nested within another logger.

Trait Implementations

impl Debug for Builder

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

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.