Enum InfraEvent 

pub enum InfraEvent {
    WireResponseLanded {
        cmd_id: CommandId,
    },
    OpFailure {
        op_ref: OpRef,
        error: OpError,
    },
    WireDecodeFailure {
        hash: u64,
        payload_size: usize,
        detail: String,
    },
    WireReceiveError {
        src_peer: Option<PeerId>,
        fill_index: u32,
        actual_hash: u64,
        payload_size: usize,
        kind: WireReceiveErrorKind,
    },
    AppIngressError {
        source: AppIngressSource,
        byte_count: usize,
        kind: AppIngressErrorKind,
    },
    BusOverflow {
        count: usize,
    },
    PeerResolveFailure {
        peer: Option<PeerId>,
        op_ref: OpRef,
    },
    PeerSuspect {
        site: NodeSiteId,
        phi: f64,
    },
    PeerDown {
        site: NodeSiteId,
        phi: f64,
    },
    PeerLive {
        site: NodeSiteId,
    },
    BackoffNoticeSent {
        peer: PeerId,
        cause: BackoffCause,
        min_backoff_ns: u64,
    },
    SilentDropActive {
        peer: PeerId,
    },
}

Framework-emitted infrastructure events per docs/ENGINE.md §13.1.

Variants

WireResponseLanded

A previously-suspended wire-request’s response landed.

Fields

cmd_id: CommandId

The CommandId that the wire-request was suspended on.

OpFailure

An Op invocation failed.

Fields

op_ref: OpRef

The Op that failed.

error: OpError

The failure detail.

WireDecodeFailure

An inbound wire envelope’s payload could not be decoded - the payload’s wire-type hash didn’t resolve, the bytes were malformed, or the destination address parsing failed. The engine drops the envelope’s slot fill rather than writing garbage into a slot; this event lets the host observe the drop. Emitted by the inbound envelope router.

Fields

hash: u64

Wire-type hash that the envelope advertised (0 if the failure occurred before the hash could be read).

payload_size: usize

Length of the offending payload, in bytes.

detail: String

Human-readable failure detail.

WireReceiveError

Per-fill failure on the wire-receive typed-decode path. Distinct from InfraEvent::WireDecodeFailure (envelope-level: malformed dest_suffix / header) - WireReceiveError fires after the envelope has parsed and an individual fill reached the decoder-registry lookup + typed materialisation step. Other fills in the same envelope continue to deliver (partial-delivery semantics).

Fields

src_peer: Option<PeerId>

Sender of the failing envelope, if the wire layer was able to identify them.

fill_index: u32

Position of the failing fill within the envelope (0-based). Other fills in the same envelope are still delivered.

actual_hash: u64

The type_hash the sender stamped on the fill.

payload_size: usize

Bytes that did not deliver. Tracked for telemetry, NOT for fallback decode - degrading to BytesValue is exactly the silent type-loss path this surface closes.

kind: WireReceiveErrorKind

Which failure mode fired.

AppIngressError

Application-side ingress failure - host pushed an AppEvent / Invoke / async completion whose payload could not enter engine state because allocation failed, the engine-wide ingress byte budget was exhausted, or a per-item cap rejected the request at the boundary. The offending bytes are dropped; the engine continues processing other ingress work. Audience: host / SDK author watching their own push errors (distinct from wire-side InfraEvent::WireReceiveError).

Fields

source: AppIngressSource

Which application-side entry point raised the failure and the identity it carries (module/input name for AppEvent / Invoke, CommandId for an async completion).

byte_count: usize

Bytes the boundary was asked to admit.

kind: AppIngressErrorKind

Which failure mode fired.

BusOverflow

The typed bus dropped count oldest events to make room for newer publishes when NodeConfig.bus_capacity was hit. Emitted by the bus-routing pass if any drops accumulated since the last poll.

Fields

count: usize

Number of events FIFO-dropped since the last poll.

PeerResolveFailure

Routable telemetry mirror of crate::engine::EngineStep::PeerResolveFailed. Surfaces via the bus to subscribers so dashboards can monitor peer-resolution failures alongside PeerBlocked / PeerDown / PeerUp from .

Fields

peer: Option<PeerId>

The peer whose addresses could not be resolved. None when the failing Send op had no parseable peer input.

op_ref: OpRef

The Send op that failed to resolve.

PeerSuspect

φ-accrual failure detector crossed the suspect threshold for the named logical site. Components (gossip overlays, peer-sampling services, deadline planners) subscribe to react.

Fields

site: NodeSiteId

Suspect logical site.

phi: f64

Current φ value (informational; subscribers can ignore).

PeerDown

φ-accrual failure detector crossed the hard-down threshold for the named logical site.

Fields

site: NodeSiteId

Down logical site.

phi: f64

Current φ value.

PeerLive

φ collapsed back below the suspect threshold after a PeerSuspect or PeerDown was emitted. Lets subscribers reinstate the peer.

Fields

site: NodeSiteId

Recovered logical site.

BackoffNoticeSent

A BackoffNotice envelope was emitted to peer. Surfaces the local overload decision on the bus so ops dashboards + Component authors who want to react to local overload can subscribe.

Fields

peer: PeerId

The sender the receiver asked to slow down.

cause: BackoffCause

Why the receiver requested back-off.

min_backoff_ns: u64

min_backoff_ns quoted on the notice.

SilentDropActive

peer crossed the K-notices-without-recovery threshold; subsequent envelopes from that peer are dropped silently at the inbound boundary until the peer recovers. Emitted once per silent-drop transition; the recovery path reuses the existing PeerLive event.

Fields

peer: PeerId

The sender now in silent-drop mode.

Trait Implementations

impl Clone for InfraEvent

fn clone(&self) -> InfraEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InfraEvent

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

Formats the value using the given formatter.