Method emit

nodedb/src/event/bus.rs:64–125

Try to emit a write event. Returns `true` if enqueued, `false` if dropped. The Data Plane NEVER blocks waiting for the Event Plane to process — fire-and-forget into the ring buffer. Dropped events are WAL-backed: the Event Plane detects gaps via sequence numbers and replays from WAL. Updates backpressure state after each emit. When Suspended (>95%), events are dropped more aggressively (the Even

(&mut self, event: WriteEvent)

    /// events are dropped more aggressively (the Event Plane will enter
    /// WAL Catchup Mode to recover).
    pub fn emit(&mut self, event: WriteEvent) -> bool {
        let util = self.inner.utilization();

        // Update backpressure state.
        if let Some(new_state) = self.backpressure.update(util) {
            match new_state {
                PressureState::Throttled => {
                    tracing::info!(
                        core = self.core_id,
                        utilization = util,
                        "event bus backpressure: THROTTLED (>85%)"
                    );
                }
                PressureState::Suspended => {
                    tracing::warn!(
                        core = self.core_id,
                        utilization = util,
                        "event bus backpressure: SUSPENDED (>95%) — events will be dropped, WAL catchup needed"
                    );
                }
                PressureState::Normal => {
                    tracing::info!(
                        core = self.core_id,
                        utilization = util,
                        "event bus backpressure: NORMAL"
                    );
                }
            }
        }

        match self.inner.try_push(event) {
            Ok(()) => true,
            Err(BridgeError::Full { .. }) => {
                tracing::warn!(
                    core = self.core_id,
                    utilization = util,
                    "event bus full — event dropped (WAL-backed, will replay on gap)"
                );
                false
            }
            Err(BridgeError::Disconnected { .. }) => {
                // Consumer dropped — Event Plane is gone (shutdown or lifecycle bug).
                // Log once per producer; further events would just be noise.
                if !self.disconnect_logged.swap(true, Ordering::Relaxed) {
                    tracing::warn!(
                        core = self.core_id,
                        "event bus consumer disconnected — Event Plane is not running; \
                         events will be silently dropped on this core until restart"
                    );
                }
                false
            }
            Err(e) => {
                tracing::warn!(
                    core = self.core_id,
                    error = %e,
                    "event bus push failed — event dropped"
                );