Struct TaskErrorEvent 

pub struct TaskErrorEvent {
    pub id: Uuid,
    pub account_task: TaskEvent,
    pub error_msg: String,
    pub timestamp: u64,
    pub metadata: Map<String, Value>,
    pub context: ExecutionMark,
    pub run_id: Uuid,
    pub prefix_request: Uuid,
}

Error task message model.

Records processing-time errors, including error details and execution context.

Fields

id: Uuid

Unique identifier.

account_task: TaskEvent

Associated account task information.

error_msg: String

Error message.

timestamp: u64

Timestamp.

metadata: Map<String, Value>

Metadata.

context: ExecutionMark

Execution context.

run_id: Uuid

Run identifier.

prefix_request: Uuid

Predecessor request identifier (points to predecessor Request.id).

Implementations

impl TaskErrorEvent

pub fn get_context(&self) -> &ExecutionMark

pub fn with_meta<T>(self, meta: T) -> Self

where T: Serialize,

pub fn add_meta<T>(self, key: impl AsRef<str>, value: T) -> Self

where T: Serialize,

pub fn with_context(self, ctx: ExecutionMark) -> Self

Trait Implementations

impl Clone for TaskErrorEvent

fn clone(&self) -> TaskErrorEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskErrorEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskErrorEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventProcessorTrait<TaskErrorEvent, Task> for TaskModelProcessor

fn pre_status(&self, input: &TaskErrorEvent) -> Option<EventEnvelope>

fn finish_status( &self, input: &TaskErrorEvent, output: &Task, ) -> Option<EventEnvelope>

fn working_status(&self, input: &TaskErrorEvent) -> Option<EventEnvelope>

fn error_status( &self, input: &TaskErrorEvent, err: &Error, ) -> Option<EventEnvelope>

fn retry_status( &self, input: &TaskErrorEvent, retry_policy: &RetryPolicy, ) -> Option<EventEnvelope>

impl From<&Response> for TaskErrorEvent

fn from(value: &Response) -> Self

Converts to this type from the input type.

impl From<&TaskErrorEvent> for ParserTaskModelEvent

fn from(value: &TaskErrorEvent) -> Self

Converts to this type from the input type.

impl From<TaskErrorEvent> for UnifiedTaskInput

fn from(value: TaskErrorEvent) -> Self

Converts to this type from the input type.

impl Identifiable for TaskErrorEvent

fn get_id(&self) -> String

fn partition_key(&self) -> String

MQ partition key: decides which partition / stream shard / consumer a message is routed to, used for account affinity (session stickiness + tasks for the same account landing on the same node within the cluster).

impl Offloadable for TaskErrorEvent

fn should_offload(&self, _threshold: usize) -> bool

fn offload<'life0, 'life1, 'async_trait>( &'life0 mut self, _storage: &'life1 Arc<dyn BlobStorage>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn reload<'life0, 'life1, 'async_trait>( &'life0 mut self, _storage: &'life1 Arc<dyn BlobStorage>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Prioritizable for TaskErrorEvent

fn get_priority(&self) -> Priority

impl ProcessorTrait<TaskErrorEvent, Task> for TaskModelProcessor

fn name(&self) -> &'static str

Processor name.

fn process<'life0, 'async_trait>( &'life0 self, input: TaskErrorEvent, context: ProcessorContext, ) -> Pin<Box<dyn Future<Output = ProcessorResult<Task>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes input data.

fn pre_process<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _input: &'life1 TaskErrorEvent, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Optional pre-processing hook.

fn post_process<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _input: &'life1 Input, _output: &'life2 Output, _context: &'life3 ProcessorContext, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Optional post-processing hook.

fn handle_error<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _input: &'life1 Input, _error: Error, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = ProcessorResult<Output>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Optional error handling hook.

fn should_process<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _input: &'life1 Input, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Optional predicate to decide whether this input should be processed.

impl Serialize for TaskErrorEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.