Struct ProgressTracker 

pub struct ProgressTracker { /* private fields */ }

Thread-safe progress tracker for logging progress at regular intervals.

Maintains an internal count and logs progress messages when the count crosses interval boundaries. Safe to use from multiple threads.

When a total is set via with_total, progress messages include percentage complete and an ETA estimate using an exponential moving average of the processing rate with bias correction.

Example

use fgumi_lib::progress::ProgressTracker;

let tracker = ProgressTracker::new("Processed records")
    .with_interval(100);

// Add items and log at interval boundaries
for _ in 0..250 {
    tracker.log_if_needed(1);  // Logs at 100, 200
}
tracker.log_final();  // Logs "Processed records 250 (complete)"

Multi-threaded Example

use fgumi_lib::progress::ProgressTracker;
use std::sync::Arc;

let tracker = Arc::new(ProgressTracker::new("Processed records").with_interval(1000));

// Multiple threads can safely add to the same tracker
let tracker_clone = Arc::clone(&tracker);
std::thread::spawn(move || {
    tracker_clone.log_if_needed(500);
});

Implementations

impl ProgressTracker

pub fn new(message: impl Into<String>) -> Self

Create a new progress tracker with the specified message.

The tracker starts with a count of 0 and a default interval of 10,000.

Arguments

• message - Message prefix for progress logs (e.g., “Processed records”)

pub fn with_interval(self, interval: u64) -> Self

Set the logging interval.

Progress will be logged each time the count crosses a multiple of this interval. For example, with interval=1000, logs will occur at 1000, 2000, 3000, etc.

Arguments

• interval - The interval between progress logs

pub fn with_total(self, total: u64) -> Self

Set the total expected count.

When set, progress messages include percentage complete and an ETA estimate using an exponential moving average of the processing rate.

Arguments

• total - The total expected count of items

pub fn log_if_needed(&self, additional: u64) -> bool

Add to the count and log if an interval boundary was crossed.

This method is thread-safe and can be called from multiple threads. It atomically adds additional to the internal count and logs progress for each interval boundary crossed.

When a total is set, log messages include percentage and ETA.

Arguments

• additional - Number of items to add to the count

Returns

true if the final count is exactly a multiple of the interval, false otherwise. This is useful for log_final() to know if a final message is needed.

pub fn log_final(&self)

Log final progress.

When a total is set, always logs a completion message with elapsed time. Otherwise, logs only if the current count is not on an interval boundary.

pub fn count(&self) -> u64

Get the current count.

Returns

The current count of items processed.