Struct TaskException 

pub struct TaskException {
    pub exc_type: String,
    pub exc_message: String,
    pub traceback: Vec<TracebackFrame>,
    pub traceback_str: Option<String>,
    pub category: ExceptionCategory,
    pub cause: Option<Box<TaskException>>,
    pub context: Option<Box<TaskException>>,
    pub metadata: HashMap<String, Value>,
    pub timestamp: Option<f64>,
    pub hostname: Option<String>,
    pub task_id: Option<String>,
}

A structured exception from task execution

Fields

exc_type: String

Exception type name (e.g., “ValueError”, “TimeoutError”)

exc_message: String

Exception message

traceback: Vec<TracebackFrame>

Full traceback as structured frames

traceback_str: Option<String>

Raw traceback string (for Python compatibility)

category: ExceptionCategory

Exception category

cause: Option<Box<TaskException>>

Cause exception (for chained exceptions)

context: Option<Box<TaskException>>

Context exception (for exception context)

metadata: HashMap<String, Value>

Additional metadata

timestamp: Option<f64>

Timestamp when exception occurred (Unix timestamp)

hostname: Option<String>

Worker hostname where exception occurred

task_id: Option<String>

Task ID that raised the exception

Implementations

impl TaskException

pub fn new(exc_type: impl Into<String>, exc_message: impl Into<String>) -> Self

Create a new task exception

pub fn from_error<E: Error>(error: &E) -> Self

Create from a Rust error

pub fn with_traceback(self, frames: Vec<(String, String, u32)>) -> Self

Add structured traceback frames

pub fn with_traceback_frames(self, frames: Vec<TracebackFrame>) -> Self

Add traceback frames

pub fn with_traceback_str(self, traceback: impl Into<String>) -> Self

Add raw traceback string

pub fn with_category(self, category: ExceptionCategory) -> Self

Set exception category

pub fn with_cause(self, cause: TaskException) -> Self

Set cause exception

pub fn with_context(self, context: TaskException) -> Self

Set context exception

pub fn with_metadata(self, key: impl Into<String>, value: Value) -> Self

Add metadata

pub fn with_timestamp(self, timestamp: f64) -> Self

Set timestamp

pub fn with_timestamp_now(self) -> Self

Set timestamp to now

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

Set hostname

pub fn with_task_id(self, task_id: impl Into<String>) -> Self

Set task ID

pub const fn is_retryable(&self) -> bool

Check if this exception is retryable

pub const fn is_fatal(&self) -> bool

Check if this exception is fatal

pub const fn is_ignorable(&self) -> bool

Check if this exception should be ignored

pub fn exception_chain(&self) -> Vec<&TaskException>

Get the full exception chain as a vector

pub fn format_traceback(&self) -> String

Format the traceback as a string

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

Serialize to JSON for cross-language compatibility

Errors

Returns an error if serialization fails.

pub fn from_json(json: &str) -> Result<Self, Error>

Deserialize from JSON

Errors

Returns an error if deserialization fails.

pub fn to_celery_format(&self) -> Value

Convert to Celery-compatible format

Trait Implementations

impl Clone for TaskException

fn clone(&self) -> TaskException

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskException

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskException

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TaskException

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

Formats the value using the given formatter.

impl Error for TaskException

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl Serialize for TaskException

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

where __S: Serializer,

Serialize this value into the given Serde serializer.