Struct EventMetadata 

pub struct EventMetadata { /* private fields */ }

Fields shared by every event: timestamp, raw bytes, and raw-bytes hash.

Constructed via EventMetadata::new, which computes the raw_bytes_hash from raw_bytes to enforce the invariant that the hash always matches. This is critical for server-side deduplication via event fingerprints.

The timestamp is Option<DateTime<Utc>> because some log entries lack a parseable timestamp in the header. None means “no timestamp found in the log entry” — downstream consumers must handle this explicitly rather than receiving a synthetic Utc::now() that would break fingerprinting and chronological ordering.

All fields are private to protect the hash invariant. Use the accessor methods to read them.

Deserialization also enforces this invariant: the hash is recomputed from raw_bytes during deserialization rather than trusting the serialized value.

Implementations

impl EventMetadata

pub fn new(timestamp: Option<DateTime<Utc>>, raw_bytes: Vec<u8>) -> Self

Creates a new EventMetadata, computing raw_bytes_hash as the SHA-256 digest of raw_bytes.

timestamp is None when the log entry header did not contain a parseable timestamp. This preserves the distinction between “real timestamp from the log” and “no timestamp available” for downstream consumers.

instant_utc is set to None. Use EventMetadata::with_instant when a true UTC instant is available from an embedded epoch-ms field.

pub fn with_instant( timestamp: Option<DateTime<Utc>>, instant_utc: Option<DateTime<Utc>>, raw_bytes: Vec<u8>, ) -> Self

Creates a new EventMetadata with a true UTC instant from an embedded epoch-ms timestamp in the event payload, computing raw_bytes_hash as the SHA-256 digest of raw_bytes.

timestamp is the local wall-clock value parsed from the log entry header (mislabeled as UTC — see EventMetadata::local_timestamp).

instant_utc is the true UTC instant derived from the event payload’s embedded "timestamp" field (epoch-milliseconds). Pass None when the embedded field is absent or unparseable.

pub fn local_timestamp(&self) -> Option<NaiveDateTime>

Returns the local wall-clock timestamp from the log entry header, or None if the entry did not contain a parseable timestamp.

The returned value is a zone-less NaiveDateTime representing the player’s local time as written in the log header. The MTGA log does not include timezone information, so no UTC conversion is applied.

For the true UTC instant (where available), use EventMetadata::instant_utc.

pub fn instant_utc(&self) -> Option<DateTime<Utc>>

Returns the true UTC instant derived from the event’s embedded epoch-ms field, or None when no embedded timestamp is available.

Populated for match-lifecycle events (matchGameRoomStateChangedEvent). All other events return None; fall back to EventMetadata::local_timestamp in that case.

pub fn timestamp(&self) -> Option<DateTime<Utc>>

👎Deprecated:

header timestamps are local wall-clock mislabeled as UTC; use instant_utc() for the true UTC instant (match-lifecycle events) or local_timestamp() for the zone-less local header value

Returns the log-header timestamp, mislabeled as UTC.

The underlying value is a local wall-clock NaiveDateTime promoted with .and_utc(), so the DateTime<Utc> type is misleading: the inner value is not a true UTC instant.

Prefer EventMetadata::instant_utc for the absolute UTC instant (available for match-lifecycle events), or EventMetadata::local_timestamp for the honest zone-less local time.

pub fn raw_bytes(&self) -> &[u8]

Returns the original log entry bytes.

pub fn raw_bytes_hash(&self) -> &[u8; 32]

Returns the SHA-256 hash of raw_bytes.

Trait Implementations

impl Clone for EventMetadata

fn clone(&self) -> EventMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventMetadata

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventMetadata

Custom Deserialize that recomputes raw_bytes_hash from raw_bytes, ensuring the hash invariant survives serialization round-trips.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EventMetadata

fn eq(&self, other: &EventMetadata) -> 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 EventMetadata

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EventMetadata