Struct ConfigBuilder 

#[non_exhaustive]
pub struct ConfigBuilder(/* private fields */);

Implementations

impl ConfigBuilder

pub fn new() -> ConfigBuilder

Create a new default ConfigBuilder

Examples found in repository

examples/custom_colors.rs (line 8)

fn main() {
    let config = ConfigBuilder::new()
        .set_level_color(Level::Error, Some(Color::Magenta))
        .set_level_color(Level::Trace, Some(Color::Green))
        .build();

    TermLogger::init(
        LevelFilter::Trace,
        config,
        TerminalMode::Stdout,
        ColorChoice::Auto,
    )
    .unwrap();
    error!("Magenta error");
    warn!("Yellow warning");
    info!("Blue info");
    debug!("Cyan debug");
    trace!("Green trace");
}

examples/rgb_colors.rs (line 8)

fn main() {
    let config = ConfigBuilder::new()
        .set_level_color(Level::Error, Some(Color::Rgb(191, 0, 0)))
        .set_level_color(Level::Warn, Some(Color::Rgb(255, 127, 0)))
        .set_level_color(Level::Info, Some(Color::Rgb(192, 192, 0)))
        .set_level_color(Level::Debug, Some(Color::Rgb(63, 127, 0)))
        .set_level_color(Level::Trace, Some(Color::Rgb(127, 127, 255)))
        .build();

    TermLogger::init(
        LevelFilter::Trace,
        config,
        TerminalMode::Stdout,
        ColorChoice::Auto,
    )
    .unwrap();
    error!("Red error");
    warn!("Orange warning");
    info!("Yellow info");
    debug!("Dark green debug");
    trace!("Light blue trace");
}

pub fn set_line_ending(&mut self, line_ending: LineEnding) -> &mut ConfigBuilder

Set a custom line ending

pub fn set_max_level(&mut self, level: LevelFilter) -> &mut ConfigBuilder

Set at which level and above (more verbose) the level itself shall be logged (default is Error)

pub fn set_time_level(&mut self, time: LevelFilter) -> &mut ConfigBuilder

Set at which level and above (more verbose) the current time shall be logged (default is Error)

pub fn set_thread_level(&mut self, thread: LevelFilter) -> &mut ConfigBuilder

Set at which level and above (more verbose) the thread id shall be logged. (default is Debug)

pub fn set_target_level(&mut self, target: LevelFilter) -> &mut ConfigBuilder

Set at which level and above (more verbose) the target shall be logged. (default is Debug)

pub fn set_target_padding( &mut self, padding: TargetPadding, ) -> &mut ConfigBuilder

Set how the thread should be padded

pub fn set_location_level( &mut self, location: LevelFilter, ) -> &mut ConfigBuilder

Set at which level and above (more verbose) a source code reference shall be logged (default is Trace)

pub fn set_module_level(&mut self, module: LevelFilter) -> &mut ConfigBuilder

Set at which level and above (more verbose) a module shall be logged (default is Off)

pub fn set_level_padding(&mut self, padding: LevelPadding) -> &mut ConfigBuilder

Set how the levels should be padded, when logging (default is Off)

pub fn set_thread_padding( &mut self, padding: ThreadPadding, ) -> &mut ConfigBuilder

Set how the thread should be padded

pub fn set_thread_mode(&mut self, mode: ThreadLogMode) -> &mut ConfigBuilder

Set the mode for logging the thread

pub fn set_level_color( &mut self, level: Level, color: Option<Color>, ) -> &mut ConfigBuilder

Set the color used for printing the level (if the logger supports it), or None to use the default foreground color

Examples found in repository

examples/custom_colors.rs (line 9)

fn main() {
    let config = ConfigBuilder::new()
        .set_level_color(Level::Error, Some(Color::Magenta))
        .set_level_color(Level::Trace, Some(Color::Green))
        .build();

    TermLogger::init(
        LevelFilter::Trace,
        config,
        TerminalMode::Stdout,
        ColorChoice::Auto,
    )
    .unwrap();
    error!("Magenta error");
    warn!("Yellow warning");
    info!("Blue info");
    debug!("Cyan debug");
    trace!("Green trace");
}

examples/rgb_colors.rs (line 9)

fn main() {
    let config = ConfigBuilder::new()
        .set_level_color(Level::Error, Some(Color::Rgb(191, 0, 0)))
        .set_level_color(Level::Warn, Some(Color::Rgb(255, 127, 0)))
        .set_level_color(Level::Info, Some(Color::Rgb(192, 192, 0)))
        .set_level_color(Level::Debug, Some(Color::Rgb(63, 127, 0)))
        .set_level_color(Level::Trace, Some(Color::Rgb(127, 127, 255)))
        .build();

    TermLogger::init(
        LevelFilter::Trace,
        config,
        TerminalMode::Stdout,
        ColorChoice::Auto,
    )
    .unwrap();
    error!("Red error");
    warn!("Orange warning");
    info!("Yellow info");
    debug!("Dark green debug");
    trace!("Light blue trace");
}

pub fn set_time_format_custom( &mut self, time_format: &'static [FormatItem<'static>], ) -> &mut ConfigBuilder

Sets the time format to a custom representation.

The easiest way to satisfy the static lifetime of the argument is to directly use the re-exported time::macros::format_description macro.

Note: The default time format is [hour]:[minute]:[second].

The syntax for the format_description macro can be found in the time crate book.

Usage

let config = ConfigBuilder::new()
    .set_time_format_custom(format_description!("[hour]:[minute]:[second].[subsecond]"))
    .build();

pub fn set_time_format_rfc2822(&mut self) -> &mut ConfigBuilder

Set time format string to use rfc2822.

pub fn set_time_format_rfc3339(&mut self) -> &mut ConfigBuilder

Set time format string to use rfc3339.

pub fn set_time_offset(&mut self, offset: UtcOffset) -> &mut ConfigBuilder

Set offset used for logging time (default is UTC)

pub fn set_time_offset_to_local( &mut self, ) -> Result<&mut ConfigBuilder, &mut ConfigBuilder>

Sets the offset used to the current local time offset (overriding values previously set by ConfigBuilder::set_time_offset).

This function may fail if the offset cannot be determined soundly. This may be the case, when the program is multi-threaded by the time of calling this function. One can opt-out of this behavior by setting RUSTFLAGS="--cfg unsound_local_offset". Doing so is not recommended, completely untested and may cause unexpected segfaults.

pub fn add_filter_allow_str( &mut self, filter_allow: &'static str, ) -> &mut ConfigBuilder

Add allowed target filters. If any are specified, only records from targets matching one of these entries will be printed

For example, add_filter_allow_str("tokio::uds") would allow only logging from the tokio crates uds module.

pub fn add_filter_allow(&mut self, filter_allow: String) -> &mut ConfigBuilder

Add allowed target filters. If any are specified, only records from targets matching one of these entries will be printed

For example, add_filter_allow(format!("{}::{}","tokio", "uds")) would allow only logging from the tokio crates uds module.

pub fn clear_filter_allow(&mut self) -> &mut ConfigBuilder

Clear allowed target filters. If none are specified, nothing is filtered out

pub fn add_filter_ignore_str( &mut self, filter_ignore: &'static str, ) -> &mut ConfigBuilder

Add denied target filters. If any are specified, records from targets matching one of these entries will be ignored

For example, add_filter_ignore_str("tokio::uds") would deny logging from the tokio crates uds module.

pub fn add_filter_ignore(&mut self, filter_ignore: String) -> &mut ConfigBuilder

Add denied target filters. If any are specified, records from targets matching one of these entries will be ignored

For example, add_filter_ignore(format!("{}::{}","tokio", "uds")) would deny logging from the tokio crates uds module.

pub fn clear_filter_ignore(&mut self) -> &mut ConfigBuilder

Clear ignore target filters. If none are specified, nothing is filtered

pub fn build(&mut self) -> Config

Build new Config

Examples found in repository

examples/custom_colors.rs (line 11)

fn main() {
    let config = ConfigBuilder::new()
        .set_level_color(Level::Error, Some(Color::Magenta))
        .set_level_color(Level::Trace, Some(Color::Green))
        .build();

    TermLogger::init(
        LevelFilter::Trace,
        config,
        TerminalMode::Stdout,
        ColorChoice::Auto,
    )
    .unwrap();
    error!("Magenta error");
    warn!("Yellow warning");
    info!("Blue info");
    debug!("Cyan debug");
    trace!("Green trace");
}

examples/rgb_colors.rs (line 14)

fn main() {
    let config = ConfigBuilder::new()
        .set_level_color(Level::Error, Some(Color::Rgb(191, 0, 0)))
        .set_level_color(Level::Warn, Some(Color::Rgb(255, 127, 0)))
        .set_level_color(Level::Info, Some(Color::Rgb(192, 192, 0)))
        .set_level_color(Level::Debug, Some(Color::Rgb(63, 127, 0)))
        .set_level_color(Level::Trace, Some(Color::Rgb(127, 127, 255)))
        .build();

    TermLogger::init(
        LevelFilter::Trace,
        config,
        TerminalMode::Stdout,
        ColorChoice::Auto,
    )
    .unwrap();
    error!("Red error");
    warn!("Orange warning");
    info!("Yellow info");
    debug!("Dark green debug");
    trace!("Light blue trace");
}

Trait Implementations

impl Clone for ConfigBuilder

fn clone(&self) -> ConfigBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConfigBuilder

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

Formats the value using the given formatter.

impl Default for ConfigBuilder

fn default() -> Self

Returns the “default value” for a type.