Struct EventRingBuffer 

pub struct EventRingBuffer { /* private fields */ }

Fixed-size ring buffer for storing recent events.

When the buffer is full, new events overwrite the oldest entries. The default capacity is 1024 events.

Examples

use grafos_observe::{EventRingBuffer, FabricEvent, ResourceType};

let mut ring = EventRingBuffer::new(4);
ring.push(FabricEvent::LeaseAcquired {
    resource_type: ResourceType::Mem,
    lease_id: 1,
    node: "node-a".into(),
    bytes: 4096,
    trace_id: None,
});
assert_eq!(ring.len(), 1);

// Iterate over stored events (oldest first)
for event in ring.iter() {
    println!("{event}");
}

// Drain removes and returns all events
let events = ring.drain();
assert!(ring.is_empty());

Implementations

impl EventRingBuffer

pub const DEFAULT_CAPACITY: usize = 1_024usize

Default ring buffer capacity.

pub fn new(capacity: usize) -> Self

Create a new ring buffer with the given capacity.

pub fn with_default_capacity() -> Self

Create a new ring buffer with the default capacity (1024).

pub fn push(&mut self, event: FabricEvent)

Push an event into the ring buffer.

If the buffer is full, the oldest event is overwritten.

pub fn len(&self) -> usize

Number of events currently stored.

pub fn is_empty(&self) -> bool

Whether the buffer is empty.

pub fn capacity(&self) -> usize

Capacity of the ring buffer.

pub fn iter(&self) -> EventRingIter<'_>

Iterate over stored events in order (oldest first).

pub fn drain(&mut self) -> Vec<FabricEvent>

Drain all events from the buffer, returning them in order (oldest first).

The buffer is empty after this call.

Trait Implementations

impl EventSink for EventRingBuffer

fn emit(&self, event: &FabricEvent)

Consume an event. Implementations should not block.