Struct TaskEvent 

pub struct TaskEvent {

    pub base: EventMessage,
    pub uuid: Uuid,
    pub name: Option<String>,
    pub args: Option<String>,
    pub kwargs: Option<String>,
    pub retries: Option<u32>,
    pub eta: Option<String>,
    pub expires: Option<String>,
    pub parent_id: Option<Uuid>,
    pub root_id: Option<Uuid>,
    pub result: Option<Value>,
    pub exception: Option<String>,
    pub traceback: Option<String>,
    pub runtime: Option<f64>,
    pub queue: Option<String>,
    pub exchange: Option<String>,
    pub routing_key: Option<String>,
}

Task-specific event data

Fields

base: EventMessage

Base event

uuid: Uuid

Task ID (UUID)

name: Option<String>

Task name

args: Option<String>

Task arguments (as JSON string)

kwargs: Option<String>

Task keyword arguments (as JSON string)

retries: Option<u32>

Retry count

eta: Option<String>

ETA for delayed tasks

expires: Option<String>

Task expiration

parent_id: Option<Uuid>

Parent task ID

root_id: Option<Uuid>

Root task ID

result: Option<Value>

Result (for task-succeeded)

exception: Option<String>

Exception type (for task-failed)

traceback: Option<String>

Traceback (for task-failed)

runtime: Option<f64>

Runtime in seconds (for task-succeeded)

queue: Option<String>

Queue name

exchange: Option<String>

Exchange name

routing_key: Option<String>

Routing key

Implementations

impl TaskEvent

pub fn new(event_type: EventType, task_id: Uuid) -> Self

Create a new task event

pub fn sent(task_id: Uuid, task_name: &str) -> Self

Create a task-sent event

pub fn received(task_id: Uuid, task_name: &str) -> Self

Create a task-received event

pub fn started(task_id: Uuid, task_name: &str) -> Self

Create a task-started event

pub fn succeeded(task_id: Uuid, result: Value, runtime: f64) -> Self

Create a task-succeeded event

pub fn failed(task_id: Uuid, exception: &str, traceback: Option<&str>) -> Self

Create a task-failed event

pub fn retried(task_id: Uuid, exception: &str, retries: u32) -> Self

Create a task-retried event

pub fn revoked(task_id: Uuid, terminated: bool, signum: Option<i32>) -> Self

Create a task-revoked event

pub fn rejected(task_id: Uuid, requeue: bool) -> Self

Create a task-rejected event

pub fn with_name(self, name: impl Into<String>) -> Self

Set task name

pub fn with_args(self, args: impl Into<String>) -> Self

Set task args

pub fn with_kwargs(self, kwargs: impl Into<String>) -> Self

Set task kwargs

pub fn with_hostname(self, hostname: impl Into<String>) -> Self

Set hostname

pub fn with_queue(self, queue: impl Into<String>) -> Self

Set queue

pub fn with_parent(self, parent_id: Uuid) -> Self

Set parent task ID

pub fn with_root(self, root_id: Uuid) -> Self

Set root task ID

pub fn to_json(&self) -> Result<Vec<u8>, Error>

Serialize to JSON bytes

pub fn from_json(bytes: &[u8]) -> Result<Self, Error>

Deserialize from JSON bytes

Trait Implementations

impl Clone for TaskEvent

fn clone(&self) -> TaskEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TaskEvent

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

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 TaskEvent