Struct ProcessorEvent 

pub struct ProcessorEvent<T> {
    pub event: T,
    pub event_time: DateTime<Utc>,
    pub processing_time: DateTime<Utc>,
    pub key: String,
}

Wrapper around events with metadata for stream processing

This structure wraps any event type with additional metadata needed for processing, including event time, processing time, and aggregation key.

Fields

event: T

The actual event payload

event_time: DateTime<Utc>

Timestamp when the event occurred (event time semantics)

processing_time: DateTime<Utc>

Timestamp when the event was processed (processing time semantics)

key: String

Aggregation key for grouping related events

Implementations

impl<T> ProcessorEvent<T>

pub fn new(event: T, event_time: DateTime<Utc>, key: String) -> Self

Create a new ProcessorEvent

pub fn with_processing_time( event: T, event_time: DateTime<Utc>, processing_time: DateTime<Utc>, key: String, ) -> Self

Create a ProcessorEvent with a custom processing time

pub fn processing_delay(&self) -> Duration

Calculate the processing delay (processing_time - event_time)

pub fn is_late(&self, threshold: Duration) -> bool

Check if the event is late (processing delay exceeds threshold)

pub fn map<U, F>(self, f: F) -> ProcessorEvent<U>

where F: FnOnce(T) -> U,

Map the event to a different type while preserving metadata

pub fn event_ref(&self) -> &T

Get a reference to the event

pub fn event_mut(&mut self) -> &mut T

Get a mutable reference to the event

Trait Implementations

impl<T: Clone> Clone for ProcessorEvent<T>

fn clone(&self) -> ProcessorEvent<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ProcessorEvent<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ProcessorEvent<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display> Display for ProcessorEvent<T>

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

Formats the value using the given formatter.

impl<T> Serialize for ProcessorEvent<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.