Struct ErrorContext 

pub struct ErrorContext {
    pub provider: String,
    pub endpoint: String,
    pub request_id: Option<String>,
    pub timestamp: DateTime<Utc>,
    pub retry_count: u32,
    pub suggested_action: SuggestedAction,
}

Context information for error tracking

Fields

provider: String

AI provider that generated the error

endpoint: String

API endpoint that was called

request_id: Option<String>

Request ID for tracking

timestamp: DateTime<Utc>

Timestamp when the error occurred

retry_count: u32

Number of retry attempts

suggested_action: SuggestedAction

Suggested action to take

Implementations

impl ErrorContext

pub fn new(provider: String, endpoint: String) -> Self

Create a new error context

Examples found in repository

examples/resilience_example.rs (line 153)

async fn demonstrate_error_handling() -> Result<(), Box<dyn std::error::Error>> {
    let error_manager = ErrorRecoveryManager::new();
    
    // Simulate different types of errors
    let errors = vec![
        ("Rate Limit", ai_lib::types::AiLibError::RateLimitExceeded("API rate limit exceeded".to_string())),
        ("Network", ai_lib::types::AiLibError::NetworkError("Connection timeout".to_string())),
        ("Authentication", ai_lib::types::AiLibError::AuthenticationError("Invalid API key".to_string())),
        ("Context Length", ai_lib::types::AiLibError::ContextLengthExceeded("Request too long".to_string())),
    ];
    
    println!("Error Handling and Pattern Analysis:");
    for (error_type, error) in errors {
        let context = ErrorContext::new("demo_provider".to_string(), "/demo/endpoint".to_string());
        let result = error_manager.handle_error(&error, &context).await;
        
        println!("  {} Error: {}", error_type, error);
        println!("    Suggested Action: {:?}", context.suggested_action);
        println!("    Recovery Result: {}", if result.is_ok() { "Success" } else { "Failed" });
    }
    
    // Show error statistics
    let stats = error_manager.get_error_statistics();
    println!("\nError Statistics:");
    println!("  Total Errors: {}", stats.total_errors);
    println!("  Unique Error Types: {}", stats.unique_error_types);
    println!("  Most Common: {:?}", stats.most_common_error);
    
    // Show error patterns
    let patterns = error_manager.get_error_patterns();
    for (error_type, pattern) in patterns {
        println!("  {:?}: {} occurrences, {:.2} errors/min", 
                error_type, pattern.count, pattern.frequency);
    }
    
    Ok(())
}

async fn demonstrate_integrated_resilience() -> Result<(), Box<dyn std::error::Error>> {
    // Create all resilience components
    let circuit_breaker = CircuitBreaker::new(CircuitBreakerConfig::development());
    let rate_limiter = TokenBucket::new(RateLimiterConfig::development());
    let error_manager = ErrorRecoveryManager::new();
    
    println!("Integrated Resilience Components:");
    println!("  Circuit Breaker: {:?}", circuit_breaker.state());
    println!("  Rate Limiter: {:.1}% success rate", rate_limiter.success_rate());
    println!("  Error Manager: {} total errors", error_manager.get_error_statistics().total_errors);
    
    // Simulate a resilient operation
    println!("\nSimulating resilient operation:");
    for i in 1..=5 {
        println!("  Operation {}:", i);
        
        // Step 1: Rate limiting
        match rate_limiter.acquire(1).await {
            Ok(_) => println!("    ✅ Rate limit passed"),
            Err(e) => {
                println!("    ❌ Rate limited: {}", e);
                continue;
            }
        }
        
        // Step 2: Circuit breaker protection
        let result = circuit_breaker.call(async {
            // Simulate API call with occasional failures
            if i % 4 == 0 {
                Err(ai_lib::types::AiLibError::ProviderError("Simulated provider error".to_string()))
            } else {
                Ok(format!("API response {}", i))
            }
        }).await;
        
        // Step 3: Error handling
        match result {
            Ok(response) => {
                println!("    ✅ Success: {}", response);
                rate_limiter.adjust_rate(true);
            }
            Err(e) => {
                println!("    ❌ Failed: {}", e);
                rate_limiter.adjust_rate(false);
                
                // Convert CircuitBreakerError to AiLibError for error manager
                let ai_error = match e {
                    CircuitBreakerError::Underlying(err) => err,
                    CircuitBreakerError::CircuitOpen(msg) => ai_lib::types::AiLibError::ProviderError(msg),
                    CircuitBreakerError::RequestTimeout(msg) => ai_lib::types::AiLibError::TimeoutError(msg),
                    CircuitBreakerError::Disabled => ai_lib::types::AiLibError::ConfigurationError("Circuit breaker disabled".to_string()),
                };
                
                let context = ErrorContext::new("demo_provider".to_string(), "/demo/endpoint".to_string());
                let _ = error_manager.handle_error(&ai_error, &context).await;
            }
        }
        
        // Show current state
        println!("    State: CB={:?}, RL={:.1}%", 
                circuit_breaker.state(), rate_limiter.success_rate());
    }
    
    Ok(())
}

pub fn with_retry(self, retry_count: u32) -> Self

Create error context with retry information

pub fn with_request_id(self, request_id: String) -> Self

Create error context with request ID

Trait Implementations

impl Clone for ErrorContext

fn clone(&self) -> ErrorContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorContext

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorContext

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ErrorContext

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

where __S: Serializer,

Serialize this value into the given Serde serializer.