Struct tracing_subscriber::fmt::SubscriberBuilder

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

This is supported on feature="fmt" only.

Configures and constructs Subscribers.

Methods

impl<N, E, F, W> SubscriberBuilder<N, E, F, W> where
    N: for<'writer> FormatFields<'writer> + 'static,
    E: FormatEvent<Registry, N> + 'static,
    W: MakeWriter + 'static,
    F: Layer<Formatter<N, E, W>> + Send + Sync + 'static,
    Layer<Registry, N, E, W>: Layer<Registry> + Send + Sync + 'static, 

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

This is supported on feature="fmt" only.

Finish the builder, returning a new FmtSubscriber.

pub fn try_init(self) -> Result<(), Box<dyn Error + Send + Sync + 'static>>

This is supported on feature="fmt" only.

Install this Subscriber as the global default if one is not already set.

If the tracing-log feature is enabled, this will also install the LogTracer to convert Log records into tracing Events.

Errors

Returns an Error if the initialization was unsuccessful, likely because a global subscriber was already installed by another call to try_init.

pub fn init(self)

This is supported on feature="fmt" only.

Install this Subscriber as the global default.

If the tracing-log feature is enabled, this will also install the LogTracer to convert Log records into tracing Events.

Panics

Panics if the initialization was unsuccessful, likely because a global subscriber was already installed by another call to try_init.

impl<N, L, T, F, W> SubscriberBuilder<N, Format<L, T>, F, W> where
    N: for<'writer> FormatFields<'writer> + 'static, 

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

This is supported on feature="fmt" only.

Use the given timer for log message timestamps.

See time for the provided timer implementations.

Note that using the chrono feature flag enables the additional time formatters ChronoUtc and ChronoLocal.

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

This is supported on feature="fmt" only.

Do not emit timestamps with log messages.

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

This is supported on feature="fmt" and feature="ansi" only.

Enable ANSI encoding for formatted events.

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

This is supported on feature="fmt" only.

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

pub fn compact(self) -> SubscriberBuilder<N, Format<Compact, T>, F, W> where
    N: for<'writer> FormatFields<'writer> + 'static, 

This is supported on feature="fmt" only.

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

See format::Compact.

pub fn json(self) -> SubscriberBuilder<JsonFields, Format<Json, T>, F, W> where
    N: for<'writer> FormatFields<'writer> + 'static, 

This is supported on feature="fmt" and feature="json" only.

Sets the subscriber being built to use a JSON formatter.

See format::Json

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

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

This is supported on feature="fmt" and feature="env-filter" only.

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

impl<N, E, W> SubscriberBuilder<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>>

This is supported on feature="fmt" and feature="env-filter" only.

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

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

pub fn fmt_fields<N2>(self, fmt_fields: N2) -> SubscriberBuilder<N2, E, F, W> where
    N2: for<'writer> FormatFields<'writer> + 'static, 

This is supported on feature="fmt" only.

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

For example:

use tracing_subscriber::fmt::{Subscriber, format};
use tracing_subscriber::prelude::*;

let formatter =
    // Construct a custom formatter for `Debug` fields
    format::debug_fn(|writer, field, value| write!(writer, "{}: {:?}", field, value))
        // Use the `tracing_subscriber::MakeFmtExt` trait to wrap the
        // formatter so that a delimiter is added between fields.
        .delimited(", ");

let subscriber = Subscriber::builder()
    .fmt_fields(formatter)
    .finish();

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

This is supported on feature="fmt" and feature="env-filter" only.

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_max_level(
    self,
    filter: impl Into<LevelFilter>
) -> SubscriberBuilder<N, E, LevelFilter, W>

This is supported on feature="fmt" only.

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 event_format<E2>(self, fmt_event: E2) -> SubscriberBuilder<N, E2, F, W> where
    E2: FormatEvent<Registry, N> + 'static,
    N: for<'writer> FormatFields<'writer> + 'static,
    W: MakeWriter + 'static, 

This is supported on feature="fmt" only.

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

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

Deprecated since 0.2.0:

this no longer does anything

This is supported on feature="fmt" only.

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

pub fn on_event<E2>(self, fmt_event: E2) -> SubscriberBuilder<N, E2, F, W> where
    E2: FormatEvent<Registry, N> + 'static,
    N: for<'writer> FormatFields<'writer> + 'static,
    W: MakeWriter + 'static, 

Deprecated since 0.2.0:

renamed to event_format.

This is supported on feature="fmt" only.

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

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

This is supported on feature="fmt" only.

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<N: Debug, E: Debug, F: Debug, W: Debug> Debug for SubscriberBuilder<N, E, F, W>

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

Formats the value using the given formatter.

impl Default for SubscriberBuilder

fn default() -> Self

Returns the "default value" for a type.