Struct AsyncForwarder 

pub struct AsyncForwarder<E> { /* private fields */ }

Opt-in observer-side escape hatch for slow consumers.

The leaf registries always dispatch synchronously inline, so a slow observer would block the emitter path. Wrap such an observer in an AsyncForwarder: the dispatch-path callback only does a bounded try_send (never blocks), while a dedicated worker thread runs the real callback. When the queue is full the event is dropped and dropped_count is incremented, so backpressure is explicit instead of silently stalling commits, DDL, or checkpoints.

Dropping the forwarder closes the channel and ends the worker thread. Use adapter to get an Arc callback suitable for add/subscribe.

Implementations

impl<E> AsyncForwarder<E>

where E: Clone + Send + 'static,

pub fn spawn( capacity: usize, callback: impl Fn(&E) + Send + 'static, ) -> (Arc<Self>, JoinHandle<()>)

Spawn a worker running callback for each forwarded event.

Returns the forwarder plus the worker’s join handle. Drop the forwarder (closing the channel) before joining. A panicking callback is isolated per event: the error is logged and the worker keeps consuming.

pub fn forward(&self, event: &E)

Hand an event to the worker without blocking. Drops (and counts) the event when the queue is full or the worker is gone.

pub fn dropped_count(&self) -> usize

Number of events dropped due to a full queue or a gone worker.

pub fn adapter(self: &Arc<Self>) -> Arc<dyn Fn(&E) + Send + Sync>

Dispatch-path adapter: registry.add(forwarder.adapter()).