Struct ResilientStorage 

pub struct ResilientStorage { /* private fields */ }

Resilient storage wrapper with circuit breaker protection

Wraps TursoStorage operations with circuit breaker pattern to provide:

• Fast failure when service is down
• Automatic recovery attempts
• Failure statistics and monitoring

Implementations

impl ResilientStorage

pub fn new(storage: TursoStorage, config: CircuitBreakerConfig) -> Self

Create a new resilient storage wrapper

Arguments

• storage - Turso storage backend to wrap
• config - Circuit breaker configuration

Example

let turso = TursoStorage::new("libsql://localhost:8080", "token").await?;

let config = CircuitBreakerConfig {
    failure_threshold: 5,
    timeout: std::time::Duration::from_secs(30),
    ..Default::default()
};

let resilient = ResilientStorage::new(turso, config);

pub async fn circuit_state(&self) -> CircuitState

Get the current circuit breaker state

Useful for monitoring and health checks.

Example

let state = storage.circuit_state().await;
match state {
    CircuitState::Closed => println!("Circuit is healthy"),
    CircuitState::Open => println!("Circuit is open - service down"),
    CircuitState::HalfOpen => println!("Circuit is testing recovery"),
}

pub async fn circuit_stats(&self) -> CircuitBreakerStats

Get circuit breaker statistics

Example

let stats = storage.circuit_stats().await;
println!("Total calls: {}", stats.total_calls);
println!("Failures: {}", stats.failed_calls);
println!("Circuit opened {} times", stats.circuit_opened_count);

pub async fn reset_circuit(&self)

Reset the circuit breaker

Useful for manual intervention or testing.

pub async fn health_check(&self) -> Result<bool>

Health check with circuit breaker awareness

Returns true if both the storage is healthy AND the circuit is closed.

Trait Implementations

impl StorageBackend for ResilientStorage

fn store_episode<'life0, 'life1, 'async_trait>( &'life0 self, episode: &'life1 Episode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store an episode

fn get_episode<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Episode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve an episode by ID

fn delete_episode<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete an episode by ID

fn store_pattern<'life0, 'life1, 'async_trait>( &'life0 self, pattern: &'life1 Pattern, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a pattern

fn get_pattern<'life0, 'async_trait>( &'life0 self, id: PatternId, ) -> Pin<Box<dyn Future<Output = Result<Option<Pattern>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a pattern by ID

fn store_heuristic<'life0, 'life1, 'async_trait>( &'life0 self, heuristic: &'life1 Heuristic, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a heuristic

fn get_heuristic<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Heuristic>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a heuristic by ID

fn query_episodes_since<'life0, 'async_trait>( &'life0 self, since: DateTime<Utc>, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Episode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Query episodes modified since a given timestamp

fn query_episodes_by_metadata<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, value: &'life2 str, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Episode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Query episodes by metadata key-value pair

fn store_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store embedding for an episode or pattern

fn get_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve embedding by ID

fn delete_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete embedding by ID

fn store_embeddings_batch<'life0, 'async_trait>( &'life0 self, embeddings: Vec<(String, Vec<f32>)>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Store multiple embeddings in batch

fn get_embeddings_batch<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Vec<f32>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get embeddings for multiple IDs

fn store_recommendation_session<'life0, 'life1, 'async_trait>( &'life0 self, session: &'life1 RecommendationSession, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist a recommendation session for durability and analytics.

fn get_recommendation_session<'life0, 'async_trait>( &'life0 self, session_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationSession>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a recommendation session by ID.

fn get_recommendation_session_for_episode<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationSession>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve the most recent recommendation session for an episode.

fn store_recommendation_feedback<'life0, 'life1, 'async_trait>( &'life0 self, feedback: &'life1 RecommendationFeedback, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist feedback associated with a recommendation session.

fn get_recommendation_feedback<'life0, 'async_trait>( &'life0 self, session_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationFeedback>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve feedback for a recommendation session.

fn get_recommendation_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<RecommendationStats>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Compute global recommendation statistics.

fn store_relationship<'life0, 'life1, 'async_trait>( &'life0 self, relationship: &'life1 EpisodeRelationship, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Store a relationship between two episodes

fn remove_relationship<'life0, 'async_trait>( &'life0 self, relationship_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Remove a relationship by ID

fn get_relationships<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, direction: Direction, ) -> Pin<Box<dyn Future<Output = Result<Vec<EpisodeRelationship>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Get relationships for an episode

fn relationship_exists<'life0, 'async_trait>( &'life0 self, from_episode_id: Uuid, to_episode_id: Uuid, relationship_type: RelationshipType, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Check if a relationship exists

fn cleanup_episodes<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 EpisodeRetentionPolicy, ) -> Pin<Box<dyn Future<Output = Result<CleanupResult, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Clean up expired episodes based on retention policy

fn count_cleanup_candidates<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 EpisodeRetentionPolicy, ) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Get count of episodes that would be cleaned up (dry run)