Struct EventBus 

pub struct EventBus { /* private fields */ }

The bounded event queue plus its identity and counters. Share via Arc; emitters hold an Emitter (a cheap clone of that Arc).

Construction: EventBus::with_receiver hands the single-consumer receiver to the deliverer; EventBus::new creates a bus nobody drains yet (the DataPlane does this before spawning its deliverer, so startup publishes are queued, not lost — and if no deliverer is ever spawned, every emit is a counted drop, never a block).

Implementations

impl EventBus

pub fn new() -> Arc<Self>

New bus with EVENT_CHANNEL_CAPACITY and no receiver taken.

pub fn with_capacity(capacity: usize) -> Arc<Self>

New bus with an explicit capacity (tests).

pub fn with_receiver(capacity: usize) -> (Arc<Self>, Receiver<Event>)

New bus, returning the receiver alongside (the deliverer’s end).

pub fn with_durability( capacity: usize, durability: Arc<dyn EventDurability>, ) -> (Arc<Self>, Receiver<Event>)

REL-14 (#249): new bus with a durability layer attached. On construction, un-acked events from the WAL are replayed into the channel (so they are delivered on the next deliverer spawn). Critical events emitted after this point are persisted to the WAL before being sent to the channel.

pub fn attach_durability(&self, durability: Arc<dyn EventDurability>)

REL-14 (#249): attach a durability layer to an existing bus. The bus may already have emitted events (e.g. the startup config_published); those are NOT retroactively persisted. After this call, critical events are persisted to the WAL before emission, and un-acked events from the WAL are replayed into the channel for the next deliverer to drain. First attach wins; a second call is a no-op.

pub fn take_receiver(&self) -> Option<Receiver<Event>>

Take the single-consumer receiver (the first caller wins; later callers get None — one deliverer per bus, by design).

pub fn instance(&self) -> &str

The instance label stamped on every envelope.

pub fn emitted_total(&self) -> u64

Events handed to the channel since process start.

pub fn dropped_total(&self) -> u64

Events dropped at emit time (queue full, or no deliverer draining). Surfaced as dwara_events_dropped_total.

pub fn durability(&self) -> Option<Arc<dyn EventDurability>>

REL-14 (#249): the durability layer, if attached. The webhook deliverer uses this to ack events after dispatch.

pub fn emitter(self: &Arc<Self>) -> Emitter

A cheap emitter handle (clone of the bus Arc). A fresh Arc bump per call site is fine: emitters are taken once at build time, not per event.