Enum SnapshotBridgeEvent 

#[non_exhaustive]
pub enum SnapshotBridgeEvent {
    CaptureUnavailable {
        tag: String,
    },
    Overwrite {
        tag: String,
        prior_schema: String,
    },
    Eviction {
        evicted_tag: String,
        new_tag: String,
        cap: usize,
    },
    DrainOrderingInvariantViolation {
        tag: String,
        drain_variant: &'static str,
    },
    CapInvariantViolation {
        reports_len: usize,
        cap: usize,
    },
    EventLogTruncated {
        dropped_count: u64,
    },
}

A structured event surfaced by the SnapshotBridge during its own operation (capture, storage, drain). Promotes the previous tracing::warn!-only diagnostic channel into an operator- drainable structured row so tests can assert on bridge-side conditions (eviction, missing capture, invariant violations) instead of grepping stderr.

Distinct from crate::assert::AssertDetail: an AssertDetail is a per-assertion outcome (Starved / Stuck / etc.); a SnapshotBridgeEvent is a per-bridge meta-event about the storage pipeline itself. Mixing them at the assertion level would conflate “scheduler behavior failed” with “bridge dropped an entry due to cap” — two orthogonal concerns. Test authors who want to fail their scenario on a bridge event compose the two streams themselves (drain events, convert to AssertDetail if needed) — see SnapshotBridge::drain_events.

Every bridge site that previously emitted only tracing::warn! still emits the warn (preserved for stderr visibility) AND appends the structured variant here. “Promote, don’t replace.”

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

CaptureUnavailable

Capture callback returned None for tag — the corresponding Op::CaptureSnapshot was a no-op. Fires from SnapshotBridge::capture when the host couldn’t freeze / build the report (scheduler died before the freeze, scan accessor unavailable, etc.).

Fields

tag: String

Tag the failed capture was attempted under.

Overwrite

Storage of tag overwrote a prior entry. Fires from SnapshotBridge::store / SnapshotBridge::store_with_stats when bridge.store(tag, ...) is called with a tag that already has a stored report. FIFO order is refreshed to back, prior (stats, elapsed_ms) parallel slots are replaced.

Fields

tag: String

Tag whose prior entry was overwritten.

prior_schema: String

schema of the prior entry — included for diagnostic context (a schema bump alongside an unintended overwrite is the textbook double-tag bug).

Eviction

FIFO eviction of evicted_tag triggered by storing new_tag. Fires from the cap-enforcement loop in store_internal when reports.len() exceeds MAX_STORED_SNAPSHOTS after insertion. cap is the limit at the time of eviction.

Fields

evicted_tag: String

Tag that was popped from the FIFO to make room.

new_tag: String

Tag whose storage triggered the cap-overflow.

cap: usize

Cap value at the time — folded in so the operator doesn’t have to cross-reference MAX_STORED_SNAPSHOTS.

DrainOrderingInvariantViolation

A drain found tag in reports but missing from order — internal invariant violation. The report was surfaced at the tail of the drain output rather than dropped silently; this event flags the bug so test authors who care can fail their scenario.

Fields

tag: String

Tag whose desynchronised entry was surfaced at the tail.

drain_variant: &'static str

Which drain variant fired the warning — "drain_ordered" or "drain_ordered_with_stats". Lets post-mortem analysis disambiguate the two code paths.

CapInvariantViolation

The cap-enforcement loop in store_internal found reports.len() > cap while order was empty — a worse invariant violation than Self::DrainOrderingInvariantViolation because the bulk-clear branch nukes ALL reports / stats / elapsed_ms to restore the invariant. Unreachable through the current public API (every insert site appends to order alongside reports), but recorded for the same future-proofing reason as the drain variant: a refactor that desynchronised the two collections must not be allowed to silently drop the entire bridge state.

Fields

reports_len: usize

reports.len() at the moment the bulk-clear was triggered. Folded in so the operator can see how much state was nuked.

cap: usize

Cap value at the time — same definition as Self::Eviction::cap.

EventLogTruncated

The events log itself hit MAX_STORED_EVENTS and dropped dropped_count oldest events to keep memory bounded. The bridge appends this variant at the tail of every SnapshotBridge::drain_events result whenever events_dropped > 0 (resets to 0 after drain), so the operator never silently loses events — they see a count of how many were dropped between drains. Test authors who care about exhaustive coverage should assert!(!matches!(events .last(), Some(SnapshotBridgeEvent::EventLogTruncated { .. }))) to fail when the bridge truncated.

Fields

dropped_count: u64

Number of events evicted from the front of the log since the last SnapshotBridge::drain_events call. Resets to 0 after drain.

Trait Implementations

impl Clone for SnapshotBridgeEvent

fn clone(&self) -> SnapshotBridgeEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SnapshotBridgeEvent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deserialize<'static> for SnapshotBridgeEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'static>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SnapshotBridgeEvent

fn eq(&self, other: &SnapshotBridgeEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SnapshotBridgeEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SnapshotBridgeEvent

impl StructuralPartialEq for SnapshotBridgeEvent