Struct tracing_subscriber::fmt::SubscriberBuilder

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

Configures and constructs Subscribers.

Implementations

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>

Finish the builder, returning a new FmtSubscriber.

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

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)

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>

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>

Do not emit timestamps with log messages.

pub fn with_span_events(self, kind: FmtSpan) -> Self

Configures how synthesized events are emitted at points in the span lifecycle.

The following options are available:

• FmtSpan::NONE: No events will be synthesized when spans are created, entered, exited, or closed. Data from spans will still be included as the context for formatted events. This is the default.
• FmtSpan::NEW: An event will be synthesized when spans are created.
• FmtSpan::ENTER: An event will be synthesized when spans are entered.
• FmtSpan::EXIT: An event will be synthesized when spans are exited.
• FmtSpan::CLOSE: An event will be synthesized when a span closes. If timestamps are enabled for this formatter, the generated event will contain fields with the span’s busy time (the total time for which it was entered) and idle time (the total time that the span existed but was not entered).
• FmtSpan::ACTIVE: An event will be synthesized when spans are entered or exited.
• FmtSpan::FULL: Events will be synthesized whenever a span is created, entered, exited, or closed. If timestamps are enabled, the close event will contain the span’s busy and idle time, as described above.

The options can be enabled in any combination. For instance, the following will synthesize events whenever spans are created and closed:

use tracing_subscriber::fmt::format::FmtSpan;
use tracing_subscriber::fmt;

let subscriber = fmt()
    .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
    .finish();

Note that the generated events will only be part of the log output by this formatter; they will not be recorded by other Subscribers or by Layers added to this subscriber.

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

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

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

Sets whether or not an event’s level is displayed.

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

Sets whether or not the name of the current thread is displayed when formatting events

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

Sets whether or not the thread ID of the current thread is displayed when formatting events

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

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

See format::Compact.

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, 

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

For example:

use tracing_subscriber::fmt::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 = tracing_subscriber::fmt()
    .fmt_fields(formatter)
    .finish();

pub fn with_max_level(
    self,
    filter: impl Into<LevelFilter>
) -> SubscriberBuilder<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::fmt;
use tracing::Level;

fmt()
    .with_max_level(Level::DEBUG)
    .init();

This subscriber won’t record any spans or events!

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

let subscriber = fmt()
    .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, 

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

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.

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, 

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

Examples

Using stderr rather than stdout:

use tracing_subscriber::fmt;
use std::io;

fmt()
    .with_writer(io::stderr)
    .init();

pub fn with_test_writer(self) -> SubscriberBuilder<N, E, F, TestWriter>

Configures the subscriber to support libtest’s output capturing when used in unit tests.

See TestWriter for additional details.

Examples

Using TestWriter to let cargo test capture test output. Note that we do not install it globally as it may cause conflicts.

use tracing_subscriber::fmt;
use tracing::subscriber;

subscriber::set_default(
    fmt()
        .with_test_writer()
        .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.

impl<N, E, F, W> From<SubscriberBuilder<N, E, F, W>> for Dispatch 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, 

fn from(builder: SubscriberBuilder<N, E, F, W>) -> Dispatch

Performs the conversion.