Struct tracing_subscriber::fmt::Builder

pub struct Builder<N = NewRecorder, E = Format<Full>, F = Identity, 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<Subscriber<N, E, W>> + 'static, 

pub fn finish(self) -> Layered<F, Subscriber<N, E, 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, Filter, W> where
    Subscriber<N, E, W>: Subscriber + 'static, 

pub fn with_filter_reloading(
    self
) -> Builder<N, E, Layer<Filter, Subscriber<N, E, W>>, W>

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

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

pub fn reload_handle(&self) -> Handle<Filter, Subscriber<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_filter(self, filter: impl Into<Filter>) -> Builder<N, E, Filter, W> where
    Subscriber<N, E, W>: Subscriber + 'static, 

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

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<N: Default, E: Default, F: Default, W: Default> Default for Builder<N, E, F, W>

fn default() -> Builder<N, E, F, W>

Returns the "default value" for a type.

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.