Struct tracing_subscriber::fmt::Builder

pub struct Builder<N = NewRecorder, E = Format<Full>, F = LevelFilter, W = fn() -> Stdout> { /* fields omitted */ }

Configures and constructs Subscribers.

Methods

impl<N, E, F, W> Builder<N, E, F, W> where
    N: for<'a> NewVisitor<'a> + 'static,
    E: FormatEvent<N> + 'static,
    W: MakeWriter + 'static,
    F: Layer<Formatter<N, E, W>> + 'static, 

pub fn finish(self) -> Subscriber<N, E, F, W>

Finish the builder, returning a new FmtSubscriber.

impl<N, L, T, F, W> Builder<N, Format<L, T>, F, W> where
    N: for<'a> NewVisitor<'a> + 'static, 

pub fn with_timer<T2>(self, timer: T2) -> Builder<N, Format<L, T2>, F, W>

Use the given timer for log message timestamps.

pub fn without_time(self) -> Builder<N, Format<L, ()>, F, W>

Do not emit timestamps with log messages.

pub fn with_ansi(self, ansi: bool) -> Builder<N, Format<L, T>, F, W>

Enable ANSI encoding for formatted events.

pub fn with_target(self, display_target: bool) -> Builder<N, Format<L, T>, F, W>

Sets whether or not an event's target is displayed.

impl<N, E, W> Builder<N, E, EnvFilter, W> where
    Formatter<N, E, W>: Subscriber + 'static, 

pub fn with_filter_reloading(
    self
) -> Builder<N, E, Layer<EnvFilter, Formatter<N, E, W>>, W>

Configures the subscriber being built to allow filter reloading at runtime.

impl<N, E, W> Builder<N, E, Layer<EnvFilter, Formatter<N, E, W>>, W> where
    Formatter<N, E, W>: Subscriber + 'static, 

pub fn reload_handle(&self) -> Handle<EnvFilter, Formatter<N, E, W>>

Returns a Handle that may be used to reload the constructed subscriber's filter.

impl<N, E, F, W> Builder<N, E, F, W>

pub fn with_visitor<N2>(self, new_visitor: N2) -> Builder<N2, E, F, W> where
    N2: for<'a> NewVisitor<'a> + 'static, 

Sets the Visitor that the subscriber being built will use to record fields.

pub fn with_env_filter(
    self,
    filter: impl Into<EnvFilter>
) -> Builder<N, E, EnvFilter, W> where
    Formatter<N, E, W>: Subscriber + 'static, 

Sets the EnvFilter that the subscriber will use to determine if a span or event is enabled.

Note that this method requires the "env-filter" feature flag to be enabled.

If a filter was previously set, or a maximum level was set by the with_max_level method, that value is replaced by the new filter.

Examples

Setting a filter based on the value of the RUST_LOG environment variable:

use tracing_subscriber::{FmtSubscriber, EnvFilter};

let subscriber = FmtSubscriber::builder()
    .with_env_filter(EnvFilter::from_default_env())
    .finish();

Setting a filter based on a pre-set filter directive string:

use tracing_subscriber::FmtSubscriber;

let subscriber = FmtSubscriber::builder()
    .with_env_filter("my_crate=info,my_crate::my_mod=debug,[my_span]=trace")
    .finish();

Adding additional directives to a filter constructed from an env var:

use tracing_subscriber::{
    FmtSubscriber,
    filter::{EnvFilter, LevelFilter},
};

let filter = EnvFilter::try_from_env("MY_CUSTOM_FILTER_ENV_VAR")?
    // Set the base level when not matched by other directives to WARN.
    .add_directive(LevelFilter::WARN.into())
    // Set the max level for `my_crate::my_mod` to DEBUG, overriding
    // any directives parsed from the env variable.
    .add_directive("my_crate::my_mod=debug".parse()?);

let subscriber = FmtSubscriber::builder()
    .with_env_filter(filter)
    .finish();

pub fn with_filter(
    self,
    filter: impl Into<EnvFilter>
) -> Builder<N, E, EnvFilter, W> where
    Formatter<N, E, W>: Subscriber + 'static, 

Deprecated since 0.1.2:

renamed to with_env_filter

Sets the EnvFilter that the subscriber will use to determine if a span or event is enabled.

Note: this method was renamed to with_env_filter in version 0.1.2. This method just wraps a call to with_env_filter, and will be removed in version 0.2.

pub fn with_max_level(
    self,
    filter: impl Into<LevelFilter>
) -> Builder<N, E, LevelFilter, W>

Sets the maximum verbosity level that will be enabled by the subscriber.

If the max level has already been set, or a EnvFilter was added by with_filter, this replaces that configuration with the new maximum level.

Examples

Enable up to the DEBUG verbosity level:

use tracing_subscriber::FmtSubscriber;
use tracing::Level;

let subscriber = FmtSubscriber::builder()
    .with_max_level(Level::DEBUG)
    .finish();

This subscriber won't record any spans or events!

use tracing_subscriber::{
    FmtSubscriber,
    filter::LevelFilter,
};

let subscriber = FmtSubscriber::builder()
    .with_max_level(LevelFilter::OFF)
    .finish();

pub fn compact(self) -> Builder<N, Format<Compact>, F, W> where
    N: for<'a> NewVisitor<'a> + 'static, 

Sets the subscriber being built to use a less verbose formatter.

See format::Compact.

pub fn on_event<E2>(self, fmt_event: E2) -> Builder<N, E2, F, W> where
    E2: FormatEvent<N> + 'static, 

Sets the function that the subscriber being built should use to format events that occur.

pub fn inherit_fields(self, inherit_fields: bool) -> Self

Sets whether or not spans inherit their parents' field values (disabled by default).

impl<N, E, F, W> Builder<N, E, F, W>

pub fn with_writer<W2>(self, make_writer: W2) -> Builder<N, E, F, W2> where
    W2: MakeWriter + 'static, 

Sets the MakeWriter that the subscriber being built will use to write events.

Examples

Using stderr rather than stdout:

use std::io;

let subscriber = tracing_subscriber::fmt::Subscriber::builder()
    .with_writer(io::stderr)
    .finish();

Trait Implementations

impl Default for Builder

fn default() -> Self

Returns the "default value" for a type.

impl<N: Debug, E: Debug, F: Debug, W: Debug> Debug for Builder<N, E, F, W>

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

Formats the value using the given formatter.