Struct IndicatifLayer 

pub struct IndicatifLayer<S, F = DefaultFields> { /* private fields */ }

The layer that handles creating and managing indicatif progress bars for active spans. This layer must be registered with your tracing subscriber to have any effect.

This layer performs no filtering on which spans to show progress bars for. It is expected one attaches filters to this layer to control which spans actually have progress bars generated for them. See filter::IndicatifFilter for a rudimentary filter.

Progress bars will be started the very first time a span is entered or when one of its child spans is entered for the first time, and will finish when the span is closed (including all child spans having closed).

Progress bars are emitted to stderr.

Under the hood, this just uses indicatif’s MultiProgress struct to manage individual ProgressBar instances per span.

Implementations

impl<S> IndicatifLayer<S>

where S: Subscriber + for<'a> LookupSpan<'a>,

pub fn new() -> IndicatifLayer<S>

Spawns a progress bar for every tracing span that is received by this layer.

The default settings for this layer are 7 progress bars maximum and progress bars in the style of:

⠄ do_work{val=0}
⠄ do_work{val=1}
⠄ do_work{val=2}
  ↳ ⠴ do_sub_work{val=2}
  ↳ ⠴ do_sub_work{val=2}
⠄ do_work{val=3}
⠄ do_work{val=4}
...and 5 more not shown above.

impl<S, F> IndicatifLayer<S, F>

where S: Subscriber + for<'a> LookupSpan<'a>,

pub fn get_fmt_writer(&self) -> IndicatifWriter

👎Deprecated since 0.2.3:

use get_stderr_writer() instead

pub fn get_stderr_writer(&self) -> IndicatifWriter

Returns the a writer for std::io::Stderr that ensures its output will not be clobbered by active progress bars.

Instead of eprintln!(...) prefer writeln!(indicatif_layer.get_stderr_writer(), ...) instead to ensure your output is not clobbered by active progress bars.

If one wishes tracing logs to be output to stderr, this should be passed into fmt::Layer::with_writer.

pub fn get_stdout_writer(&self) -> IndicatifWriter<Stdout>

Returns the a writer for std::io::Stdout that ensures its output will not be clobbered by active progress bars.

Instead of println!(...) prefer writeln!(indicatif_layer.get_stdout_writer(), ...) instead to ensure your output is not clobbered by active progress bars.

If one wishes tracing logs to be output to stdout, this should be passed into fmt::Layer::with_writer.

pub fn with_span_field_formatter<F2>( self, formatter: F2, ) -> IndicatifLayer<S, F2>

where F2: for<'writer> FormatFields<'writer> + 'static,

Set the formatter for span fields, the result of which will be available as the progress bar template key span_fields.

The default is the DefaultFields formatter.

pub fn with_progress_style(self, style: ProgressStyle) -> IndicatifLayer<S, F>

Override the style used for displayed progress bars.

Two additional keys are available for the progress bar template:

• span_fields - the formatted string of this span’s fields
• span_name - the name of the span
• span_child_prefix - a prefix that increase in size according to the number of parents the span has.

The default template is {span_child_prefix}{spinner} {span_name}{{{span_fields}}}.

pub fn with_span_child_prefix_indent( self, indent: &'static str, ) -> IndicatifLayer<S, F>

Set the indent used to mark the “level” of a given child span’s progress bar.

For example, if the given span is two levels deep (iow has two parent spans with progress bars), and this is “ “, the {span_child_prefix} key for this span’s progress bar will be prefixed with “ “.

pub fn with_span_child_prefix_symbol( self, symbol: &'static str, ) -> IndicatifLayer<S, F>

Set the symbol used to denote this is a progress bar from a child span.

This is ultimately concatenated with the child prefix indent to make the span_child_prefix progress bar key.

pub fn with_max_progress_bars( self, max_progress_bars: u64, footer_style: Option<ProgressStyle>, ) -> IndicatifLayer<S, F>

Set the maximum number of progress bars that will be displayed, and the possible footer “progress bar” that displays when there are more progress bars than can be displayed.

footer_style dictates the appearance of the footer, and the footer will only appear if there are more progress bars than can be displayed. If it is None, no footer will be displayed. footer_style has the following keys available to it:

• pending_progress_bars - the number of progress bars waiting to be shown

pub fn with_tick_settings( self, tick_settings: TickSettings, ) -> IndicatifLayer<S, F>

Configures how often progress bars are recalcuated and redrawn to the terminal.

Trait Implementations

impl<S> Default for IndicatifLayer<S>

where S: Subscriber + for<'a> LookupSpan<'a>,

fn default() -> IndicatifLayer<S>

Returns the “default value” for a type.

impl<S, F> Layer<S> for IndicatifLayer<S, F>

where S: Subscriber + for<'a> LookupSpan<'a>, F: for<'writer> FormatFields<'writer> + 'static,

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)

Notifies this layer that a new span was constructed with the given Attributes and Id.

fn on_enter(&self, id: &Id, ctx: Context<'_, S>)

Notifies this layer that a span with the given ID was entered.

fn on_close(&self, id: Id, ctx: Context<'_, S>)

Notifies this layer that the span with the given ID has been closed.

fn on_register_dispatch(&self, subscriber: &Dispatch)

Performs late initialization when installing this layer as a Subscriber.

fn on_layer(&mut self, subscriber: &mut S)

Performs late initialization when attaching a Layer to a Subscriber.

fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest

Registers a new callsite with this layer, returning whether or not the layer is interested in being notified about the callsite, similarly to Subscriber::register_callsite.

fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool

Returns true if this layer is interested in a span or event with the given metadata in the current Context, similarly to Subscriber::enabled.

fn on_record(&self, _span: &Id, _values: &Record<'_>, _ctx: Context<'_, S>)

Notifies this layer that a span with the given Id recorded the given values.

fn on_follows_from(&self, _span: &Id, _follows: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span with the ID span recorded that it follows from the span with the ID follows.

fn event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, S>) -> bool

Called before on_event, to determine if on_event should be called.

fn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, S>)

Notifies this layer that an event has occurred.

fn on_exit(&self, _id: &Id, _ctx: Context<'_, S>)

Notifies this layer that the span with the given ID was exited.

fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span ID has been cloned, and that the subscriber returned a different ID.

fn and_then<L>(self, layer: L) -> Layered<L, Self, S>

where L: Layer<S>, Self: Sized,

Composes this layer around the given Layer, returning a Layered struct implementing Layer.

fn with_subscriber(self, inner: S) -> Layered<Self, S>

where Self: Sized,

Composes this Layer with the given Subscriber, returning a Layered struct that implements Subscriber.

fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>

where Self: Sized, F: Filter<S>,

Combines self with a Filter, returning a Filtered layer.

fn boxed(self) -> Box<dyn Layer<S> + Sync + Send>

where Self: Sized + Layer<S> + Send + Sync + 'static, S: Subscriber,

Erases the type of this Layer, returning a Boxed dyn Layer trait object.