Struct BatchTimer 

pub struct BatchTimer<'a> { /* private fields */ }

Accumulates work time at a granularity the broker can actually resolve.

Publishes on drop, so an early return or a ? still records what was done, and so the tail of a batch is never lost.

Construct one per batch

The timer measures wall time between publishes, so anything that happens while it is alive is charged as work. Constructing it inside the per-batch callback is what keeps blocking out of the measurement: the callback is entered only once a filled buffer is in hand, so the wait for that buffer falls between two timers rather than inside one. A timer hoisted to thread scope would charge every fill to the consumer’s busy time — and busy time that includes blocking is exactly the wall-time measurement this crate exists to avoid.

Implementations

impl<'a> BatchTimer<'a>

pub fn single_writer_progress_counter(self, counter: &'a AtomicU64) -> Self

Publish item progress to a single-writer caller-owned counter.

A consumer with several hot workers can give each worker a cache-padded counter and sum those counters in Consumer::work. Busy time remains in this meter, while fine progress uses a relaxed cumulative store rather than a contended atomic read-modify-write. No other writer may update counter; it must remain cumulative across successive timers.

pub fn flush_every(self, n: u64) -> Self

Publish both progress and busy time every n items instead of the default.

Prefer Self::progress_every when only the completed-item signal needs finer resolution. That avoids adding clock reads to a hot record loop.

pub fn progress_every(self, n: u64) -> Self

Publish completed-item progress every n items.

This cadence is independent of busy-time publication: making throughput visible to short controller windows therefore costs one relaxed counter update per interval, without forcing an Instant::now() at that cadence.

pub fn time_every(self, n: u64) -> Self

Publish accumulated busy time every n items.

Most consumers should retain DEFAULT_FLUSH_EVERY. This separate control primarily lets a converged freeze policy disable all in-batch measurement for new callbacks.

pub fn tick(&mut self)

Call once per item processed.

The count is only ever compared against itself over time, so any consistent unit will do; it plays no part in sizing the split.

pub fn completed_item(&mut self) -> CompletedItem<'_, 'a>

Count one item when the returned guard leaves scope.

Use this when a loop has early exits and throughput must mean completed, rather than started, items. Construct the guard at the top of an iteration; normal completion, continue, and ? all publish the item only after that iteration’s work has finished.

Trait Implementations

impl Drop for BatchTimer<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.