Struct EventEnvelope 

pub struct EventEnvelope {
    pub run_id: RunId,
    pub seq: SequenceNumber,
    pub schema_version: u32,
    pub recorded_at: OffsetDateTime,
    pub event: Event,
}

One record in a run’s append-only log.

The envelope carries run identity, the event’s position in the log, the schema version, when it was recorded, and the payload that says what happened. Serializing an envelope always includes schema_version, so the wire form is self-describing.

Fields

run_id: RunId

The run this event belongs to.

seq: SequenceNumber

This event’s monotonic position in the run’s log.

schema_version: u32

The event schema version. Always SCHEMA_VERSION for events this build writes; older values may appear when reading an old log.

recorded_at: OffsetDateTime

When the event was recorded, as an RFC 3339 timestamp on the wire.

Passed in by the caller. Nothing in this crate reads the clock.

event: Event

What happened.

Implementations

impl EventEnvelope

pub const fn new( run_id: RunId, seq: SequenceNumber, recorded_at: OffsetDateTime, event: Event, ) -> EventEnvelope

Wraps a payload with its run identity, log position, and recorded timestamp, stamping the current SCHEMA_VERSION.

The timestamp is a parameter on purpose: this constructor never reads the clock, so it stays usable from the pure replay path.

Trait Implementations

impl Clone for EventEnvelope

fn clone(&self) -> EventEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventEnvelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventEnvelope

fn deserialize<__D>( __deserializer: __D, ) -> Result<EventEnvelope, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EventEnvelope

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for EventEnvelope

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EventEnvelope