Enum ErrorStrategy 

pub enum ErrorStrategy<T: Debug + Clone + Send + Sync> {
    Stop,
    Skip,
    Retry(usize),
    Custom(Arc<dyn Fn(&StreamError<T>) -> ErrorAction + Send + Sync>),
}

Strategy for handling errors in pipeline components.

Error strategies determine how components respond to errors during stream processing. Strategies can be set at the pipeline level or overridden at the component level.

Example

use streamweave::error::ErrorStrategy;

// Stop on first error (default)
let strategy = ErrorStrategy::Stop;

// Skip errors and continue
let strategy = ErrorStrategy::Skip;

// Retry up to 3 times
let strategy = ErrorStrategy::Retry(3);

// Custom error handling
let strategy = ErrorStrategy::new_custom(|error| {
    if error.retries < 2 {
        ErrorAction::Retry
    } else {
        ErrorAction::Stop
    }
});

Variants

Stop

Stop processing immediately when an error occurs.

This is the default strategy and ensures data integrity.

Skip

Skip items that cause errors and continue processing.

Useful for data cleaning scenarios where invalid records can be safely ignored.

Retry(usize)

Retry failed operations up to the specified number of times.

Arguments

• usize - Maximum number of retry attempts

Useful for transient failures like network timeouts.

Custom(Arc<dyn Fn(&StreamError<T>) -> ErrorAction + Send + Sync>)

Custom error handling logic.

Allows fine-grained control over error handling based on error context, type, or retry count.

Implementations

impl<T: Debug + Clone + Send + Sync> ErrorStrategy<T>

pub fn new_custom<F>(f: F) -> Self

where F: Fn(&StreamError<T>) -> ErrorAction + Send + Sync + 'static,

Creates a custom error handling strategy with a user-defined handler function.

Arguments

• f - A function that takes a StreamError and returns an ErrorAction.

Returns

A Custom error strategy that uses the provided handler function.

Trait Implementations

impl<T: Debug + Clone + Send + Sync> Clone for ErrorStrategy<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone + Send + Sync> Debug for ErrorStrategy<T>

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

Formats the value using the given formatter.

impl<T: Debug + Clone + Send + Sync> PartialEq for ErrorStrategy<T>

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