Enum FailurePolicy 

#[non_exhaustive]
pub enum FailurePolicy {
    FailFast,
    Drop,
    Retry,
    RetryAfter(Duration),
    Skip,
}

What a subscriber does when it cannot process a message.

Set per subscriber, separately for a handler panic and for a decode failure, with the #[subscriber(.., on_failure(panic = .., decode = ..))] clause. Each maps onto a settlement of the offending message, except FailFast, which tears the service down so an orchestrator restarts it.

Examples

use std::time::Duration;

use ruststream::prelude::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct Order {
    id: u64,
}

/// A schema change rolls out producer-first: a payload this version cannot read yet comes
/// back in a minute rather than being dropped.
#[subscriber("orders", on_failure(decode = retry_after(Duration::from_secs(60))))]
async fn accept(order: &Order) -> HandlerOutcome {
    tracing::info!(order.id, "accepted");
    HandlerOutcome::ack()
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

FailFast

Log a loud error naming the subscription, then initiate a graceful app shutdown and make run return Err, so an orchestrator restarts the service and the failure lands in the logs. The default for a handler panic. Only takes effect under an unwinding panic profile; with panic = "abort" the process is already gone and there is nothing to catch.

Drop

Drop the message: nack(false). The broker discards or dead-letters it. The default for a decode failure - one malformed payload should not stop the consumer.

Retry

Requeue the message: nack(true). Useful when the failure is transient (a dependency not yet available, a schema not yet propagated).

RetryAfter(Duration)

Requeue the message, but ask the broker to redeliver no sooner than the given delay: nack_after(..). A broker without native delayed redelivery takes the copy the runtime publishes instead - see HandlerOutcome::retry_after.

Skip

Acknowledge the failed message to move past it: ack. A deliberate poison-message escape hatch - it advances past a message that could not be processed. This is not success; the message is gone and was never handled.

Trait Implementations

impl Clone for FailurePolicy

fn clone(&self) -> FailurePolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FailurePolicy

impl Debug for FailurePolicy

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

Formats the value using the given formatter.

impl Eq for FailurePolicy

impl PartialEq for FailurePolicy

fn eq(&self, other: &FailurePolicy) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for FailurePolicy