Struct RingMetrics 

pub struct RingMetrics { /* private fields */ }

Shared counter set. Hold an Arc<RingMetrics> across producer + consumer so the snapshot reflects both sides.

Implementations

impl RingMetrics

pub fn new() -> Self

pub fn record_cas_retry(&self)

Bump the CAS-retry counter. Called by the mpmc-disruptor path; the SPSC paths never retry under the wait-free invariant.

pub fn snapshot(&self) -> RingMetricsSnapshot

Capture a point-in-time snapshot of every counter. Consistent enough for monitoring; not a transactional read across all six values.

Examples found in repository

examples/sample_app.rs (line 300)

fn instrumented_handoff() {
    use subms_spsc_ring_buffer::InstrumentedSpsc;

    println!("\n== metrics: instrumented feed handoff ==");
    let (tx, rx) = SpscRingBuffer::with_capacity::<Tick>(4);
    let (mut tx, mut rx, metrics) = InstrumentedSpsc::wrap(tx, rx);

    // Fill to capacity, one overflow drop, then drain plus one empty poll.
    for seq in 0..4u64 {
        tx.try_push(Tick {
            seq,
            price_cents: 60_000,
        })
        .unwrap();
    }
    assert!(
        tx.try_push(Tick {
            seq: 99,
            price_cents: 0
        })
        .is_err()
    );
    for _ in 0..4 {
        rx.try_pop().unwrap();
    }
    assert!(rx.try_pop().is_none());

    let snap = metrics.snapshot();
    println!(
        "  enqueued {} (dropped {}), dequeued {} (empty {}), peak depth {}",
        snap.enqueue_success,
        snap.enqueue_fail,
        snap.dequeue_success,
        snap.dequeue_fail,
        snap.max_depth_observed
    );
    assert_eq!(snap.enqueue_success, 4);
    assert_eq!(snap.enqueue_fail, 1);
    assert_eq!(snap.dequeue_success, 4);
    assert_eq!(snap.dequeue_fail, 1);
    assert_eq!(snap.max_depth_observed, 4);
}

Trait Implementations

impl Default for RingMetrics

fn default() -> Self

Returns the “default value” for a type.