Enum DurableError 

pub enum DurableError {
    Execution {
        message: String,
        termination_reason: TerminationReason,
    },
    Invocation {
        message: String,
        termination_reason: TerminationReason,
    },
    Checkpoint {
        message: String,
        is_retriable: bool,
        aws_error: Option<AwsError>,
    },
    Callback {
        message: String,
        callback_id: Option<String>,
    },
    NonDeterministic {
        message: String,
        operation_id: Option<String>,
    },
    Validation {
        message: String,
    },
    SerDes {
        message: String,
    },
    Suspend {
        scheduled_timestamp: Option<f64>,
    },
    OrphanedChild {
        message: String,
        operation_id: String,
    },
    UserCode {
        message: String,
        error_type: String,
        stack_trace: Option<String>,
    },
    SizeLimit {
        message: String,
        actual_size: Option<usize>,
        max_size: Option<usize>,
    },
    Throttling {
        message: String,
        retry_after_ms: Option<u64>,
    },
    ResourceNotFound {
        message: String,
        resource_id: Option<String>,
    },
    Configuration {
        message: String,
    },
}

The main error type for the AWS Durable Execution SDK.

This enum covers all possible error conditions that can occur during durable execution workflows.

Examples

Creating common error types:

use durable_execution_sdk::DurableError;

// Execution error (fails workflow without retry)
let exec_err = DurableError::execution("Order validation failed");
assert!(!exec_err.is_retriable());

// Validation error
let val_err = DurableError::validation("Invalid input format");

// Retriable checkpoint error
let cp_err = DurableError::checkpoint_retriable("Temporary network issue");
assert!(cp_err.is_retriable());

Checking error types:

use durable_execution_sdk::DurableError;

let err = DurableError::size_limit("Payload too large");
assert!(err.is_size_limit());
assert!(!err.is_throttling());

let throttle_err = DurableError::throttling("Rate limit exceeded");
assert!(throttle_err.is_throttling());

Variants

Execution

Execution error that returns FAILED status without Lambda retry.

Fields

message: String

Error message describing what went wrong

termination_reason: TerminationReason

The reason for termination

Invocation

Invocation error that triggers Lambda retry.

Fields

message: String

Error message describing what went wrong

termination_reason: TerminationReason

The reason for termination

Checkpoint

Checkpoint error for checkpoint failures.

Fields

message: String

Error message describing what went wrong

is_retriable: bool

Whether this error is retriable

aws_error: Option<AwsError>

Optional underlying AWS error details

Callback

Callback error for callback-specific failures.

Fields

message: String

Error message describing what went wrong

callback_id: Option<String>

The callback ID if available

NonDeterministic

Non-deterministic execution error for replay mismatches.

Fields

message: String

Error message describing the mismatch

operation_id: Option<String>

The operation ID where the mismatch occurred

Validation

Validation error for invalid configuration or arguments.

Fields

message: String

Error message describing the validation failure

SerDes

Serialization/deserialization error.

Fields

message: String

Error message describing the serialization failure

Suspend

Suspend execution signal to pause and return control to Lambda runtime.

Fields

scheduled_timestamp: Option<f64>

Optional timestamp when execution should resume

OrphanedChild

Orphaned child error when a child operation’s parent has completed.

Fields

message: String

Error message describing the orphaned state

operation_id: String

The operation ID of the orphaned child

UserCode

User code error wrapping errors from user-provided closures.

Fields

message: String

Error message from the user code

error_type: String

The type of error

stack_trace: Option<String>

Optional stack trace

SizeLimit

Size limit exceeded error for payload size violations.

This error occurs when:

• Checkpoint payload exceeds the maximum allowed size
• Response payload exceeds Lambda’s 6MB limit
• History size exceeds service limits

This error is NOT retriable - the operation should fail without retry.

Fields

message: String

Error message describing the size limit violation

actual_size: Option<usize>

The actual size that exceeded the limit (in bytes)

max_size: Option<usize>

The maximum allowed size (in bytes)

Throttling

Throttling error for rate limit exceeded.

This error occurs when the AWS API rate limit is exceeded. This error IS retriable with exponential backoff.

Fields

message: String

Error message describing the throttling condition

retry_after_ms: Option<u64>

Suggested retry delay in milliseconds (if provided by AWS)

ResourceNotFound

Resource not found error for missing executions or operations.

This error occurs when:

• The durable execution ARN does not exist
• The operation ID is not found
• The Lambda function does not exist

This error is NOT retriable.

Fields

message: String

Error message describing what resource was not found

resource_id: Option<String>

The resource identifier that was not found

Configuration

Configuration error for missing or invalid SDK configuration.

This error occurs when:

• No AWS credentials provider is configured
• HTTP client construction fails
• Required configuration values are missing

This error is NOT retriable.

Fields

message: String

Error message describing the configuration issue

Implementations

impl DurableError

pub fn execution(message: impl Into<String>) -> DurableError

Creates a new Execution error.

pub fn invocation(message: impl Into<String>) -> DurableError

Creates a new Invocation error.

pub fn checkpoint_retriable(message: impl Into<String>) -> DurableError

Creates a new retriable Checkpoint error.

pub fn checkpoint_non_retriable(message: impl Into<String>) -> DurableError

Creates a new non-retriable Checkpoint error.

pub fn validation(message: impl Into<String>) -> DurableError

Creates a new Validation error.

pub fn serdes(message: impl Into<String>) -> DurableError

Creates a new SerDes error.

pub fn suspend() -> DurableError

Creates a new Suspend signal.

pub fn suspend_until(timestamp: f64) -> DurableError

Creates a new Suspend signal with a scheduled timestamp.

pub fn size_limit(message: impl Into<String>) -> DurableError

Creates a new SizeLimit error.

Arguments

• message - Description of the size limit violation

pub fn size_limit_with_details( message: impl Into<String>, actual_size: usize, max_size: usize, ) -> DurableError

Creates a new SizeLimit error with size details.

Arguments

• message - Description of the size limit violation
• actual_size - The actual size that exceeded the limit
• max_size - The maximum allowed size

pub fn throttling(message: impl Into<String>) -> DurableError

Creates a new Throttling error.

Arguments

• message - Description of the throttling condition

pub fn throttling_with_retry_delay( message: impl Into<String>, retry_after_ms: u64, ) -> DurableError

Creates a new Throttling error with retry delay.

Arguments

• message - Description of the throttling condition
• retry_after_ms - Suggested retry delay in milliseconds

pub fn resource_not_found(message: impl Into<String>) -> DurableError

Creates a new ResourceNotFound error.

Arguments

• message - Description of what resource was not found

pub fn resource_not_found_with_id( message: impl Into<String>, resource_id: impl Into<String>, ) -> DurableError

Creates a new ResourceNotFound error with resource ID.

Arguments

• message - Description of what resource was not found
• resource_id - The identifier of the resource that was not found

pub fn is_retriable(&self) -> bool

Returns true if this is a Checkpoint error that is retriable.

pub fn is_suspend(&self) -> bool

Returns true if this is a Suspend signal.

pub fn is_invalid_checkpoint_token(&self) -> bool

Returns true if this is an invalid checkpoint token error.

Invalid checkpoint token errors occur when:

• The token has already been consumed by a previous checkpoint
• The token is malformed or expired

These errors are retriable because Lambda will provide a fresh token on the next invocation.

pub fn is_size_limit(&self) -> bool

Returns true if this is a SizeLimit error.

Size limit errors are NOT retriable - the operation should fail.

pub fn is_throttling(&self) -> bool

Returns true if this is a Throttling error.

Throttling errors ARE retriable with exponential backoff.

pub fn is_resource_not_found(&self) -> bool

Returns true if this is a ResourceNotFound error.

Resource not found errors are NOT retriable.

pub fn get_retry_after_ms(&self) -> Option<u64>

Returns the suggested retry delay for throttling errors.

Returns None if this is not a throttling error or if no retry delay was provided.

Trait Implementations

impl Debug for DurableError

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

Formats the value using the given formatter.

impl Display for DurableError

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

Formats the value using the given formatter.

impl Error for DurableError

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 From<&DurableError> for ErrorObject

fn from(error: &DurableError) -> ErrorObject

Converts to this type from the input type.

impl From<Box<dyn Error>> for DurableError

fn from(error: Box<dyn Error>) -> DurableError

Converts to this type from the input type.

impl From<Box<dyn Error + Send + Sync>> for DurableError

fn from(error: Box<dyn Error + Send + Sync>) -> DurableError

Converts to this type from the input type.

impl From<DurableError> for TestError

fn from(source: DurableError) -> Self

Converts to this type from the input type.

impl From<Error> for DurableError

fn from(error: Error) -> DurableError

Converts to this type from the input type.

impl From<Error> for DurableError

fn from(error: Error) -> DurableError

Converts to this type from the input type.