Struct ProgressLogger 

pub struct ProgressLogger { /* private fields */ }

An implementation of ProgressLog with output generated using the log crate at a configurable level (default: info).

Instances can be created by using fluent setters, or by using the progress_logger macro.

You can clone a logger to create a new one with the same setup but with all the counters reset and the expected number of updates cleared. This behavior is useful when you want to configure a logger and then use its configuration for other loggers.

Examples

A typical call sequence to a progress logger is as follows:

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = ProgressLogger::default();
pl.item_name("pumpkin");
pl.start("Smashing pumpkins...");
for _ in 0..100 {
   // do something on each pumpkin
   pl.update();
}
pl.done();

The progress_logger macro will create the progress logger for you and set its log_target to std::module_path!(), which is usually what you want. You can also call any setter with a key-value syntax:

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = progress_logger![item_name="pumpkin"];
pl.start("Smashing pumpkins...");
for _ in 0..100 {
   // do something on each pumpkin
   pl.update();
}
pl.done();

A progress logger can also be used as a handy timer:

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = progress_logger![item_name="pumpkin"];
pl.start("Smashing pumpkins...");
for _ in 0..100 {
   // do something on each pumpkin
}
pl.done_with_count(100);

This progress logger will display information about memory usage:

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = progress_logger![display_memory=true];

Implementations

impl ProgressLogger

pub const LIGHT_UPDATE_MASK: usize

Calls to light_update will cause a call to Instant::now only if the current count is a multiple of this mask plus one.

Trait Implementations

impl Clone for ProgressLogger

fn clone(&self) -> Self

Clones the logger, returning a logger with the same setup but with all the counters reset and the expected number of updates cleared.

The expected number of updates is cleared, as in stop, because it rarely carries over to another activity; if needed, it can be set again with expected_updates. Note that this behavior extends to ProgressLog::concurrent and ConcurrentProgressLog::dup, which clone the underlying logger.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ProgressLogger

fn default() -> Self

Creates a default ProgressLogger with a log interval of 10 seconds and item name set to “item”.

impl Display for ProgressLogger

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

Formats the value using the given formatter.

impl ProgressLog for ProgressLogger

fn light_update(&mut self)

Increases the count and, once every LIGHT_UPDATE_MASK + 1 calls, checks whether it is time to log.

type Concurrent = ConcurrentWrapper

The type returned by concurrent.

fn log(&mut self, now: Instant)

Forces a log of self assuming now is the current time.

fn log_if(&mut self, now: Instant)

Logs self if it is time to log.

fn add_to_count(&mut self, count: usize)

Adds a value to the counter.

fn display_memory(&mut self, display_memory: bool) -> &mut Self

Sets the display of memory information.

fn item_name(&mut self, item_name: impl AsRef<str>) -> &mut Self

Sets the name of an item.

fn log_interval(&mut self, log_interval: Duration) -> &mut Self

Sets the log interval.

fn expected_updates( &mut self, expected_updates: impl Into<Option<usize>>, ) -> &mut Self

Sets the expected number of updates.

fn time_unit(&mut self, time_unit: impl Into<Option<TimeUnit>>) -> &mut Self

Sets the time unit to use for speed.

fn local_speed(&mut self, local_speed: bool) -> &mut Self

Sets whether to display additionally the speed achieved during the last log interval.

fn log_target(&mut self, target: impl AsRef<str>) -> &mut Self

Sets the log target.

fn push_log_target(&mut self, suffix: impl AsRef<str>) -> &mut Self

Pushes a suffix to the log target.

fn pop_log_target(&mut self) -> &mut Self

Pops the last suffix pushed with push_log_target.

fn log_level(&mut self, log_level: Level) -> &mut Self

Sets the log level used for progress messages.

fn start(&mut self, msg: impl AsRef<str>)

Starts the logger, displaying the given message.

fn refresh(&mut self)

Refreshes memory information, if previously requested with display_memory. There is no need to call this method unless the logger is displayed manually.

fn update(&mut self)

Increases the count and checks whether it is time to log.

fn update_with_count_and_time(&mut self, count: usize, now: Instant)

Sets the count and checks whether it is time to log, given the current time.

fn update_and_display(&mut self)

Increases the count and forces a log.

fn stop(&mut self)

Stops the logger, fixing the final time.

fn done(&mut self)

Stops the logger, prints Completed., and displays the final stats. The number of expected updates will be cleared.

fn done_with_count(&mut self, count: usize)

Stops the logger, sets the count, prints Completed., and displays the final stats. The number of expected updates will be cleared.

fn elapsed(&self) -> Option<Duration>

Returns the elapsed time since the logger was started, or None if the logger has not been started.

fn count(&self) -> usize

Returns the last count the logger has been set to.

fn trace(&self, args: Arguments<'_>)

Outputs the given message at the trace level.

fn debug(&self, args: Arguments<'_>)

Outputs the given message at the debug level.

fn info(&self, args: Arguments<'_>)

Outputs the given message at the info level.

fn warn(&self, args: Arguments<'_>)

Outputs the given message at the warn level.

fn error(&self, args: Arguments<'_>)

Outputs the given message at the error level.

fn concurrent(&self) -> Self::Concurrent

Returns a concurrent copy of the logger.

fn update_with_count(&mut self, count: usize)

Sets the count and checks whether it is time to log.