Retry & Resilience

from agent_sentinel import with_retry

@with_retry()
def call_external_api():
    # May fail due to network issues
    return requests.get("https://api.example.com/data")

# Automatically retries up to 3 times with exponential backoff
result = call_external_api()

from agent_sentinel import with_retry, RetryConfig

# Configure retry behavior
config = RetryConfig(
    max_attempts=5,           # Try up to 5 times
    initial_delay=2.0,        # Start with 2 second delay
    max_delay=60.0,           # Cap at 60 seconds
    exponential_base=2.0,     # Double delay each time
    jitter=True,              # Add randomness to prevent thundering herd
)

@with_retry(config=config)
def flaky_operation():
    # Your code here
    pass

from agent_sentinel import with_retry, RetryConfig, NetworkError, TimeoutError

# Only retry on network and timeout errors
config = RetryConfig(
    max_attempts=3,
    retryable_exceptions=[NetworkError, TimeoutError]
)

@with_retry(config=config)
def sensitive_operation():
    # Only retries if NetworkError or TimeoutError is raised
    # Other exceptions propagate immediately
    pass

from agent_sentinel import with_retry

def on_retry_callback(attempt: int, exception: Exception):
    print(f"Retry attempt {attempt} after error: {exception}")
    # Log to monitoring system, send alert, etc.

@with_retry(on_retry=on_retry_callback)
def monitored_operation():
    pass

from agent_sentinel import with_circuit_breaker

@with_circuit_breaker(
    failure_threshold=5,    # Open after 5 consecutive failures
    recovery_timeout=60.0,  # Try recovery after 60 seconds
)
def call_unreliable_service():
    return external_service.call()

try:
    result = call_unreliable_service()
except AgentSentinelError as e:
    if e.error_code == "CIRCUIT_OPEN":
        print("Circuit breaker is open, service unavailable")
        # Use fallback behavior

from agent_sentinel import with_retry, with_circuit_breaker, RetryConfig

# Apply circuit breaker first (outer), then retry (inner)
@with_circuit_breaker(failure_threshold=10, recovery_timeout=120.0)
@with_retry(config=RetryConfig(max_attempts=3))
def resilient_operation():
    # 1. Circuit breaker checks if service is available
    # 2. If available, retry logic handles transient failures
    # 3. If too many failures, circuit opens
    pass

@with_circuit_breaker(failure_threshold=5)
def monitored_call():
    pass

# Access the breaker instance
breaker = monitored_call.breaker

print(f"State: {breaker.state}")  # CLOSED, OPEN, or HALF_OPEN
print(f"Failures: {breaker.failure_count}")
print(f"Last failure: {breaker.last_failure_time}")

# Delay calculation:
delay = initial_delay * (exponential_base ^ attempt)
delay = min(delay, max_delay)

# With jitter (±10% randomness):
delay = delay + random.uniform(-delay * 0.1, delay * 0.1)

from agent_sentinel import (
    AgentSentinelError,     # Base exception
    NetworkError,           # Network/connectivity issues
    TimeoutError,           # Request timeout
    SyncError,              # Remote sync failure
    ConfigurationError,     # Invalid configuration
)

# Default retryable exceptions: NetworkError, TimeoutError

from agent_sentinel import enable_remote_sync

# Remote sync automatically uses:
# - Retry with exponential backoff (3 attempts)
# - Circuit breaker (opens after 5 failures)
# - Graceful degradation (continues local logging if sync fails)

enable_remote_sync(
    base_url="https://sentinel.example.com",
    api_key="your-key",
)

from agent_sentinel import with_retry, with_circuit_breaker, RetryConfig, TimeoutError
import requests

@with_circuit_breaker(failure_threshold=5, recovery_timeout=60.0)
@with_retry(config=RetryConfig(
    max_attempts=3,
    initial_delay=1.0,
    retryable_exceptions=[TimeoutError, requests.exceptions.RequestException]
))
def call_api(endpoint: str):
    response = requests.get(endpoint, timeout=5.0)
    response.raise_for_status()
    return response.json()

from agent_sentinel import with_retry, RetryConfig
import psycopg2

@with_retry(config=RetryConfig(
    max_attempts=5,
    initial_delay=0.5,
    retryable_exceptions=[psycopg2.OperationalError]
))
def query_database(query: str):
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute(query)
    return cursor.fetchall()

from agent_sentinel import with_retry, RetryConfig
from openai import RateLimitError

@with_retry(config=RetryConfig(
    max_attempts=5,
    initial_delay=1.0,
    max_delay=32.0,
    retryable_exceptions=[RateLimitError]
))
def call_llm(prompt: str):
    return client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )

# ✅ Correct - exception is retryable
config = RetryConfig(retryable_exceptions=[ValueError])

@with_retry(config=config)
def may_fail():
    raise ValueError("Transient error")

# ❌ Won't retry - exception not in list
@with_retry(config=config)
def may_fail():
    raise RuntimeError("Different error")

# Not recommended for production, but useful for testing
breaker.state = breaker.CLOSED
breaker.failure_count = 0