Enum DomainEvent 

pub enum DomainEvent {
    SessionActivated {
        session_id: SessionId,
        timestamp: DateTime<Utc>,
    },
    SessionClosed {
        session_id: SessionId,
        timestamp: DateTime<Utc>,
    },
    SessionExpired {
        session_id: SessionId,
        timestamp: DateTime<Utc>,
    },
    SessionTimedOut {
        session_id: SessionId,
        original_state: SessionState,
        timeout_duration: u64,
        timestamp: DateTime<Utc>,
    },
    SessionTimeoutExtended {
        session_id: SessionId,
        additional_seconds: u64,
        new_expires_at: DateTime<Utc>,
        timestamp: DateTime<Utc>,
    },
    StreamCreated {
        session_id: SessionId,
        stream_id: StreamId,
        timestamp: DateTime<Utc>,
    },
    StreamStarted {
        session_id: SessionId,
        stream_id: StreamId,
        timestamp: DateTime<Utc>,
    },
    StreamCompleted {
        session_id: SessionId,
        stream_id: StreamId,
        timestamp: DateTime<Utc>,
    },
    StreamFailed {
        session_id: SessionId,
        stream_id: StreamId,
        error: String,
        timestamp: DateTime<Utc>,
    },
    StreamCancelled {
        session_id: SessionId,
        stream_id: StreamId,
        timestamp: DateTime<Utc>,
    },
    SkeletonGenerated {
        session_id: SessionId,
        stream_id: StreamId,
        frame_size_bytes: u64,
        timestamp: DateTime<Utc>,
    },
    PatchFramesGenerated {
        session_id: SessionId,
        stream_id: StreamId,
        frame_count: usize,
        total_bytes: u64,
        highest_priority: u8,
        timestamp: DateTime<Utc>,
    },
    FramesBatched {
        session_id: SessionId,
        frame_count: usize,
        timestamp: DateTime<Utc>,
    },
    PriorityThresholdAdjusted {
        session_id: SessionId,
        old_threshold: u8,
        new_threshold: u8,
        reason: String,
        timestamp: DateTime<Utc>,
    },
    StreamConfigUpdated {
        session_id: SessionId,
        stream_id: StreamId,
        timestamp: DateTime<Utc>,
    },
    PerformanceMetricsRecorded {
        session_id: SessionId,
        metrics: PerformanceMetrics,
        timestamp: DateTime<Utc>,
    },
}

Domain events that represent business-relevant state changes

Variants

SessionActivated

Session was activated and is ready to accept streams

Fields

session_id: SessionId

ID of the activated session

timestamp: DateTime<Utc>

When the session was activated

SessionClosed

Session was closed gracefully

Fields

session_id: SessionId

ID of the closed session

timestamp: DateTime<Utc>

When the session was closed

SessionExpired

Session expired due to timeout

Fields

session_id: SessionId

ID of the expired session

timestamp: DateTime<Utc>

When the session expired

SessionTimedOut

Session was forcefully closed due to timeout

Fields

session_id: SessionId

ID of the timed out session

original_state: SessionState

State the session was in before timeout

timeout_duration: u64

Duration in seconds before timeout occurred

timestamp: DateTime<Utc>

When the timeout occurred

SessionTimeoutExtended

Session timeout was extended

Fields

session_id: SessionId

ID of the session with extended timeout

additional_seconds: u64

Additional seconds added to the timeout

new_expires_at: DateTime<Utc>

New expiration timestamp

timestamp: DateTime<Utc>

When the extension was applied

StreamCreated

New stream was created in the session

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the newly created stream

timestamp: DateTime<Utc>

When the stream was created

StreamStarted

Stream started sending data

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the stream that started

timestamp: DateTime<Utc>

When the stream started

StreamCompleted

Stream completed successfully

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the completed stream

timestamp: DateTime<Utc>

When the stream completed

StreamFailed

Stream failed with error

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the failed stream

error: String

Error message describing the failure

timestamp: DateTime<Utc>

When the stream failed

StreamCancelled

Stream was cancelled

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the cancelled stream

timestamp: DateTime<Utc>

When the stream was cancelled

SkeletonGenerated

Skeleton frame was generated for a stream

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the stream that generated the skeleton

frame_size_bytes: u64

Size of the skeleton frame in bytes

timestamp: DateTime<Utc>

When the skeleton was generated

PatchFramesGenerated

Patch frames were generated for a stream

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the stream that generated patches

frame_count: usize

Number of patch frames generated

total_bytes: u64

Total size of all patches in bytes

highest_priority: u8

Highest priority level among the patches

timestamp: DateTime<Utc>

When the patches were generated

FramesBatched

Multiple frames were batched for efficient sending

Fields

session_id: SessionId

ID of the session containing the frames

frame_count: usize

Number of frames in the batch

timestamp: DateTime<Utc>

When the batch was created

PriorityThresholdAdjusted

Priority threshold was adjusted for adaptive streaming

Fields

session_id: SessionId

ID of the session with adjusted threshold

old_threshold: u8

Previous priority threshold value

new_threshold: u8

New priority threshold value

reason: String

Reason for the adjustment

timestamp: DateTime<Utc>

When the threshold was adjusted

StreamConfigUpdated

Stream configuration was updated

Fields

session_id: SessionId

ID of the session containing the stream

stream_id: StreamId

ID of the stream with updated configuration

timestamp: DateTime<Utc>

When the configuration was updated

PerformanceMetricsRecorded

Performance metrics were recorded

Fields

session_id: SessionId

ID of the session being measured

metrics: PerformanceMetrics

Recorded performance metrics

timestamp: DateTime<Utc>

When the metrics were recorded

Implementations

impl DomainEvent

pub fn session_id(&self) -> SessionId

Get the session ID associated with this event

pub fn stream_id(&self) -> Option<StreamId>

Get the stream ID if this is a stream-specific event

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

Get the timestamp of this event

pub fn event_type(&self) -> &'static str

Get the event type as a string

pub fn is_critical(&self) -> bool

Check if this is a critical event that requires immediate attention

pub fn is_error(&self) -> bool

Check if this is an error event

pub fn is_completion(&self) -> bool

Check if this is a completion event

impl DomainEvent

Extension methods for DomainEvent

pub fn event_id(&self) -> EventId

Get event ID for tracking (generated if not exists)

pub fn occurred_at(&self) -> DateTime<Utc>

Get event timestamp

pub fn metadata(&self) -> HashMap<String, String>

Get event metadata as key-value pairs

Trait Implementations

impl Clone for DomainEvent

fn clone(&self) -> DomainEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DomainEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DomainEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DomainEvent> for DomainEventDto

fn from(event: DomainEvent) -> Self

Converts to this type from the input type.

impl FromDto<DomainEventDto> for DomainEvent

type Error = DomainError

fn from_dto(dto: DomainEventDto) -> Result<Self, Self::Error>

impl PartialEq for DomainEvent

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

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 ToDto<DomainEventDto> for DomainEvent

fn to_dto(self) -> DomainEventDto

impl StructuralPartialEq for DomainEvent