resilient-circuit 0.4.1__py3-none-any.whl → 0.4.2__py3-none-any.whl

resilient_circuit/circuit_breaker.py

@@ -1,7 +1,8 @@
 import abc
 import enum
 import logging
-from datetime import datetime, timedelta
+import time
+from datetime import timedelta
 from fractions import Fraction
 from functools import wraps
 from typing import Callable, Optional, TypeVar
@@ -11,7 +12,10 @@ from typing_extensions import ParamSpec
 from resilient_circuit.buffer import BinaryCircularBuffer
 from resilient_circuit.exceptions import ProtectedCallError
 from resilient_circuit.policy import ProtectionPolicy
-from resilient_circuit.storage import CircuitBreakerStorage, InMemoryStorage, create_storage
+from resilient_circuit.storage import (
+    CircuitBreakerStorage,
+    create_storage,
+)
 
 R = TypeVar("R")
 P = ParamSpec("P")
@@ -56,7 +60,7 @@ class CircuitProtectorPolicy(ProtectionPolicy):
         self._load_state()
 
     def _load_state(self) -> None:
-        """Load circuit breaker state from storage."""
+        """Load circuit breaker state from storage including execution log buffer."""
         try:
             state_data = self.storage.get_state(self.resource_key)
             if state_data:
@@ -64,6 +68,7 @@ class CircuitProtectorPolicy(ProtectionPolicy):
                 state = CircuitStatus(state_data["state"])
                 failure_count = int(state_data.get("failure_count", 0))
                 open_until = float(state_data.get("open_until", 0))
+                execution_log_data = state_data.get("execution_log")
 
                 # Initialize status based on stored state
                 status: CircuitStatusBase
@@ -77,6 +82,13 @@ class CircuitProtectorPolicy(ProtectionPolicy):
                 else:  # HALF_OPEN
                     status = StatusHalfOpen(policy=self, failure_count=failure_count)
 
+                # Restore execution_log buffer if available
+                if execution_log_data and isinstance(execution_log_data, list):
+                    if hasattr(status, 'execution_log') and hasattr(status.execution_log, '_items'):
+                        # Restore buffer maintaining size limit
+                        status.execution_log._items = execution_log_data[-status.execution_log.size:]
+                        logger.debug(f"Restored buffer for {self.resource_key}: {len(status.execution_log._items)} entries")
+
                 self._status = status
                 logger.debug(f"Loaded circuit breaker state for {self.resource_key}: {state.value}")
             else:
@@ -89,7 +101,7 @@ class CircuitProtectorPolicy(ProtectionPolicy):
             self._status = StatusClosed(policy=self)
 
     def _save_state(self) -> None:
-        """Save circuit breaker state to storage."""
+        """Save circuit breaker state to storage including execution log buffer."""
         try:
             state_value: str = self._status.status_type.value
             failure_count_val: int = int(getattr(self._status, 'failure_count', 0))
@@ -99,13 +111,19 @@ class CircuitProtectorPolicy(ProtectionPolicy):
                 if hasattr(self._status, 'open_until_timestamp') else 0
             )
 
+            # Extract execution_log buffer if available
+            execution_log_data = None
+            if hasattr(self._status, 'execution_log') and hasattr(self._status.execution_log, '_items'):
+                execution_log_data = list(self._status.execution_log._items)
+
             self.storage.set_state(
                 self.resource_key,
                 state_value,
                 failure_count_val,
-                open_until_val
+                open_until_val,
+                execution_log=execution_log_data
             )
-            logger.debug(f"Saved circuit breaker state for {self.resource_key}: {state_value}")
+            logger.debug(f"Saved circuit breaker state for {self.resource_key}: {state_value}, buffer_size={len(execution_log_data) if execution_log_data else 0}")
         except Exception as e:
             logger.error(f"Failed to save state for {self.resource_key}: {e}")
 
@@ -126,10 +144,8 @@ class CircuitProtectorPolicy(ProtectionPolicy):
             new_status_obj = StatusClosed(policy=self, failure_count=0)
         elif new_status is CircuitStatus.OPEN:
             # When transitioning to OPEN, keep the failure count from current status
-            current_failure_count = getattr(self._status, 'failure_count', 0)
             # Calculate the open_until timestamp based on current time and cooldown
-            from datetime import datetime
-            open_until = (datetime.now() + self.cooldown).timestamp()
+            open_until = time.time() + self.cooldown.total_seconds()
             new_status_obj = StatusOpen(policy=self, previous_status=self._status, open_until=open_until)
         else:  # HALF_OPEN
             # When transitioning to HALF_OPEN, reset failure count
@@ -147,17 +163,28 @@ class CircuitProtectorPolicy(ProtectionPolicy):
     def __call__(self, func: Callable[P, R]) -> Callable[P, R]:
         @wraps(func)
         def decorated(*args: P.args, **kwargs: P.kwargs) -> R:
+            import logging
+            logger = logging.getLogger(__name__)
+
             self._status.validate_execution()
             try:
                 result = func(*args, **kwargs)
             except Exception as e:
-                if self.should_consider_failure(e):
+                should_fail = self.should_consider_failure(e)
+                logger.warning(
+                    f"🚨 CB {self.resource_key}: Exception {type(e).__name__}: {e}, "
+                    f"should_consider_failure={should_fail}"
+                )
+                if should_fail:
+                    logger.warning(f"❌ CB {self.resource_key}: Calling mark_failure()")
                     self._status.mark_failure()
                 else:
+                    logger.warning(f"✅ CB {self.resource_key}: Exception ignored, calling mark_success()")
                     self._status.mark_success()
                 self._save_state()  # Persist state after exception
                 raise
             else:
+                logger.warning(f"✅ CB {self.resource_key}: Success, calling mark_success()")
                 self._status.mark_success()
                 self._save_state()  # Persist state after success
                 return result
@@ -205,13 +232,31 @@ class StatusClosed(CircuitStatusBase):
         pass
 
     def mark_failure(self) -> None:
+        import logging
+        logger = logging.getLogger(__name__)
+
         self.failure_count += 1  # Increment failure count
         self.execution_log.add(False)
+
+        logger.warning(
+            f"📊 CB {self.policy.resource_key} mark_failure: "
+            f"buffer={list(self.execution_log._items)}, "
+            f"is_full={self.execution_log.is_full}, "
+            f"size={self.execution_log.size}, "
+            f"failure_rate={self.execution_log.failure_rate}, "
+            f"threshold={self.policy.failure_limit}"
+        )
+
         if (
             self.execution_log.is_full
             and self.execution_log.failure_rate >= self.policy.failure_limit
         ):
-            self.policy.status = CircuitStatus.OPEN
+            logger.warning(f"🔴 CB {self.policy.resource_key}: Opening circuit!")
+            try:
+                self.policy.status = CircuitStatus.OPEN
+                logger.warning(f"✅ CB {self.policy.resource_key}: Successfully set status to OPEN")
+            except Exception as e:
+                logger.error(f"❌ CB {self.policy.resource_key}: Failed to set status to OPEN: {type(e).__name__}: {e}", exc_info=True)
 
     def mark_success(self) -> None:
         self.failure_count = 0  # Reset failure count on success
@@ -232,17 +277,15 @@ class StatusOpen(CircuitStatusBase):
 
         # Store the timestamp when the OPEN state should end (cooldown period)
         # If open_until is 0, circuit should be blocked for the full cooldown period
-        from datetime import datetime
         if open_until and open_until > 0:
             self.open_until_timestamp = open_until  # This is when cooldown ends
         else:
             # Calculate when cooldown should end based on current time and policy cooldown
-            self.open_until_timestamp = (datetime.now() + policy.cooldown).timestamp()
+            self.open_until_timestamp = time.time() + policy.cooldown.total_seconds()
 
     def validate_execution(self) -> None:
-        from datetime import datetime
         # Check if cooldown period has expired
-        if datetime.now().timestamp() >= self.open_until_timestamp:
+        if time.time() >= self.open_until_timestamp:
             # Cooldown expired, transition to HALF_OPEN to allow test requests
             self.policy.status = CircuitStatus.HALF_OPEN
             return  # Allow execution in HALF_OPEN state

resilient_circuit/cli.py

@@ -5,7 +5,6 @@ CLI module for Highway Circuit Breaker
 import argparse
 import os
 import sys
-from typing import Optional
 
 try:
     import psycopg
@@ -66,7 +65,7 @@ def create_postgres_table(config: dict) -> bool:
 
                 table_exists = cur.fetchone()[0]
                 if table_exists:
-                    print(f"ℹ️  Table 'rc_circuit_breakers' already exists, checking for updates...")
+                    print("ℹ️  Table 'rc_circuit_breakers' already exists, checking for updates...")
 
                 # Create the circuit breaker table
                 cur.execute("""
@@ -180,7 +179,7 @@ def run_pg_setup(args: argparse.Namespace) -> int:
     # Get config from environment
     config = get_db_config_from_env()
 
-    print(f"🔧 Using database configuration from environment:")
+    print("🔧 Using database configuration from environment:")
     print(f"   Host: {config['host']}")
     print(f"   Port: {config['port']}")
     print(f"   Database: {config['dbname']}")
@@ -258,4 +257,4 @@ def main():
         return 1
 
 if __name__ == '__main__':
-    sys.exit(main())
+    sys.exit(main())

resilient_circuit/retry.py

@@ -5,7 +5,7 @@ from typing import Callable, Optional, TypeVar
 from typing_extensions import ParamSpec
 
 from resilient_circuit.backoff import ExponentialDelay
-from resilient_circuit.exceptions import ProtectedCallError, RetryLimitReached
+from resilient_circuit.exceptions import RetryLimitReached
 from resilient_circuit.policy import ProtectionPolicy
 
 R = TypeVar("R")

resilient_circuit/storage.py

@@ -1,8 +1,8 @@
+import logging
 import os
 import time
 from abc import ABC, abstractmethod
-from typing import Optional, Dict, Any
-import logging
+from typing import Any, Dict, Optional
 
 try:
     from dotenv import load_dotenv
@@ -23,20 +23,24 @@ logger = logging.getLogger(__name__)
 
 class CircuitBreakerStorage(ABC):
     """Abstract base class for circuit breaker storage backends."""
-    
+
     @abstractmethod
     def get_state(self, resource_key: str) -> Optional[Dict[str, Any]]:
         """Get the state for a given resource key.
-        
+
         Returns:
-            Dictionary with keys: state, failure_count, open_until
+            Dictionary with keys: state, failure_count, open_until, execution_log (optional)
             or None if no state found
         """
         pass
-    
+
     @abstractmethod
-    def set_state(self, resource_key: str, state: str, failure_count: int, open_until: float) -> None:
-        """Set the state for a given resource key."""
+    def set_state(self, resource_key: str, state: str, failure_count: int, open_until: float, execution_log: Optional[list] = None) -> None:
+        """Set the state for a given resource key.
+
+        Args:
+            execution_log: Optional list of boolean success/failure results
+        """
         pass
 
 
@@ -49,12 +53,15 @@ class InMemoryStorage(CircuitBreakerStorage):
     def get_state(self, resource_key: str) -> Optional[Dict[str, Any]]:
         return self._states.get(resource_key)
 
-    def set_state(self, resource_key: str, state: str, failure_count: int, open_until: float) -> None:
-        self._states[resource_key] = {
+    def set_state(self, resource_key: str, state: str, failure_count: int, open_until: float, execution_log: Optional[list] = None) -> None:
+        state_dict = {
             "state": state,
             "failure_count": failure_count,
             "open_until": open_until
         }
+        if execution_log is not None:
+            state_dict["execution_log"] = execution_log
+        self._states[resource_key] = state_dict
 
 
 class PostgresStorage(CircuitBreakerStorage):
@@ -67,11 +74,11 @@ class PostgresStorage(CircuitBreakerStorage):
         self.connection_string = connection_string
         self.namespace = namespace
         self._ensure_table_exists()
-    
+
     def _get_connection(self) -> Connection:
         """Get a database connection."""
         return psycopg.connect(self.connection_string)
-    
+
     def _ensure_table_exists(self) -> None:
         """Ensure the circuit breaker table exists with namespace support."""
         try:
@@ -154,7 +161,7 @@ class PostgresStorage(CircuitBreakerStorage):
         except Exception as e:
             logger.error(f"Failed to ensure table exists: {e}")
             raise
-    
+
     def get_state(self, resource_key: str) -> Optional[Dict[str, Any]]:
         """Get the state for a given resource key within this namespace.
 
@@ -166,7 +173,7 @@ class PostgresStorage(CircuitBreakerStorage):
             with self._get_connection() as conn:
                 with conn.cursor() as cur:
                     cur.execute(
-                        "SELECT state, failure_count, open_until "
+                        "SELECT state, failure_count, open_until, execution_log "
                         "FROM rc_circuit_breakers "
                         "WHERE resource_key = %s AND namespace = %s "
                         "FOR UPDATE",
@@ -174,19 +181,32 @@ class PostgresStorage(CircuitBreakerStorage):
                     )
                     row = cur.fetchone()
                     if row:
-                        return {
+                        result = {
                             "state": row[0],
                             "failure_count": row[1],
                             "open_until": row[2].timestamp() if row[2] else 0
                         }
+                        # Add execution_log if present
+                        if row[3] is not None:
+                            result["execution_log"] = row[3]
+                        return result
                     return None
         except Exception as e:
             logger.error(f"Failed to get state for {resource_key} (namespace={self.namespace}): {e}")
             raise
-    
-    def set_state(self, resource_key: str, state: str, failure_count: int, open_until: float) -> None:
-        """Set the state for a given resource key within this namespace."""
+
+    def set_state(self, resource_key: str, state: str, failure_count: int, open_until: float, execution_log: Optional[list] = None) -> None:
+        """Set the state for a given resource key within this namespace.
+
+        Args:
+            resource_key: Unique circuit breaker identifier
+            state: Circuit state (CLOSED, OPEN, HALF_OPEN)
+            failure_count: Number of consecutive failures
+            open_until: Timestamp when circuit can transition from OPEN
+            execution_log: Optional list of boolean success/failure results for the circular buffer
+        """
         try:
+            import json
             with self._get_connection() as conn:
                 with conn.cursor() as cur:
                     # Convert timestamp to PostgreSQL timestamp
@@ -194,19 +214,40 @@ class PostgresStorage(CircuitBreakerStorage):
                     if open_until > 0:
                         open_until_ts = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(open_until))
 
-                    cur.execute(
-                        """
-                        INSERT INTO rc_circuit_breakers
-                            (resource_key, namespace, state, failure_count, open_until)
-                        VALUES (%s, %s, %s, %s, %s)
-                        ON CONFLICT (resource_key, namespace) DO UPDATE SET
-                            state = EXCLUDED.state,
-                            failure_count = EXCLUDED.failure_count,
-                            open_until = EXCLUDED.open_until,
-                            updated_at = CURRENT_TIMESTAMP
-                        """,
-                        (resource_key, self.namespace, state, failure_count, open_until_ts)
-                    )
+                    # Serialize execution_log to JSON if provided
+                    execution_log_json = json.dumps(execution_log) if execution_log is not None else None
+
+                    if execution_log is not None:
+                        # Update including execution_log
+                        cur.execute(
+                            """
+                            INSERT INTO rc_circuit_breakers
+                                (resource_key, namespace, state, failure_count, open_until, execution_log)
+                            VALUES (%s, %s, %s, %s, %s, %s::jsonb)
+                            ON CONFLICT (resource_key, namespace) DO UPDATE SET
+                                state = EXCLUDED.state,
+                                failure_count = EXCLUDED.failure_count,
+                                open_until = EXCLUDED.open_until,
+                                execution_log = EXCLUDED.execution_log,
+                                updated_at = CURRENT_TIMESTAMP
+                            """,
+                            (resource_key, self.namespace, state, failure_count, open_until_ts, execution_log_json)
+                        )
+                    else:
+                        # Update without execution_log (preserve existing value)
+                        cur.execute(
+                            """
+                            INSERT INTO rc_circuit_breakers
+                                (resource_key, namespace, state, failure_count, open_until)
+                            VALUES (%s, %s, %s, %s, %s)
+                            ON CONFLICT (resource_key, namespace) DO UPDATE SET
+                                state = EXCLUDED.state,
+                                failure_count = EXCLUDED.failure_count,
+                                open_until = EXCLUDED.open_until,
+                                updated_at = CURRENT_TIMESTAMP
+                            """,
+                            (resource_key, self.namespace, state, failure_count, open_until_ts)
+                        )
                     conn.commit()
         except Exception as e:
             logger.error(f"Failed to set state for {resource_key} (namespace={self.namespace}): {e}")
@@ -249,4 +290,4 @@ def create_storage(namespace: Optional[str] = None) -> CircuitBreakerStorage:
     else:
         # Default to in-memory storage
         logger.info(f"Using in-memory storage for circuit breaker (no PostgreSQL config found), namespace={namespace}")
-        return InMemoryStorage()
+        return InMemoryStorage()

{resilient_circuit-0.4.1.dist-info → resilient_circuit-0.4.2.dist-info}/METADATA

@@ -1,15 +1,14 @@
 Metadata-Version: 2.4
 Name: resilient-circuit
-Version: 0.4.1
+Version: 0.4.2
 Summary: A resilient circuit breaker and retry library with PostgreSQL support for distributed systems
 Author-email: Farshid Ashouri <farsheed.ashouri@gmail.com>
-License: Apache Software License 2.0
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/rodmena-limited/resilient-circuit
 Project-URL: Repository, https://github.com/rodmena-limited/resilient-circuit
 Project-URL: Documentation, https://resilient-circuit.readthedocs.io
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10

{resilient_circuit-0.4.1.dist-info → resilient_circuit-0.4.2.dist-info}/RECORD

@@ -1,17 +1,17 @@
 resilient_circuit/__init__.py,sha256=Z3WOzwCT5fP0VptBNu-bkrbKGGljaDB9QL9FwkcBpQI,552
 resilient_circuit/backoff.py,sha256=aLSFYqU_CROrkDaepZaTF_vUy05fBvRhUruXe3Wcmlk,1148
 resilient_circuit/buffer.py,sha256=UIOxPgo07TmveTbaSSJXHzDZwu_aYRVkgIWbGuMhH-8,1385
-resilient_circuit/circuit_breaker.py,sha256=RwQu490pBulAk5Fl4Kn3URsfrEHqwXqVGa3WxSZuwHc,12190
-resilient_circuit/cli.py,sha256=fQpoajQWO-KOpxjVcRsw_oPtXXPw8mfid4pqFwHmRkw,9563
+resilient_circuit/circuit_breaker.py,sha256=yawdm0bJz11kqeIs5UIWlCJehQeF1t9X2E1Pvo1HkDY,14472
+resilient_circuit/cli.py,sha256=_XdXdPaCewVL0Tg6MP-zRLWx7qpbJ54ysMnUht6nEBw,9534
 resilient_circuit/exceptions.py,sha256=f1A9hK1y9kxOFtzldIMCOy0Ui9cKnLuCkUzPUU7zyR4,162
 resilient_circuit/failsafe.py,sha256=B6piP5gWAn88maJnk_Gp3nSRp0FCCtZ4Lnd7Ekrgo-M,1068
 resilient_circuit/policy.py,sha256=MJeETZKw_oMrRkgfq160nrFrSm6tv1N2pgkGxsaQmRs,289
 resilient_circuit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-resilient_circuit/retry.py,sha256=I0QWkhXlEj3Pn6yMbTgT70XPM99Rr3wEoIWL6ThaLCY,1476
-resilient_circuit/storage.py,sha256=PI31JdWT11H7Sxc8YrwSth351bWPT_ZfdzTGuhZ78E8,10874
-resilient_circuit-0.4.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-resilient_circuit-0.4.1.dist-info/METADATA,sha256=PmpXbOfalK3TjPz6LEDbapvtRgealXZhtRskcl8AKec,14761
-resilient_circuit-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-resilient_circuit-0.4.1.dist-info/entry_points.txt,sha256=JbXU75gDeU3PsVykHG7Bq1lYJG7hr5KG-3ny-HGCcZI,65
-resilient_circuit-0.4.1.dist-info/top_level.txt,sha256=SFJWwSDlbsmTWV8F67fdmfAK_dtTT9c8L-kfdnior4s,18
-resilient_circuit-0.4.1.dist-info/RECORD,,
+resilient_circuit/retry.py,sha256=DYeqVLHfMszM7UiV89rxJ7QA_eRofJwz7vmOeSTtJwM,1456
+resilient_circuit/storage.py,sha256=1eyhDnP5jReZIpzsIvVrn7HBet_lJFCVaJoe6CTFh1M,13150
+resilient_circuit-0.4.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+resilient_circuit-0.4.2.dist-info/METADATA,sha256=uHeP4j7TX_WcxMh4yDYbJEipWN2ENqD0jtMqJieRpD8,14692
+resilient_circuit-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+resilient_circuit-0.4.2.dist-info/entry_points.txt,sha256=JbXU75gDeU3PsVykHG7Bq1lYJG7hr5KG-3ny-HGCcZI,65
+resilient_circuit-0.4.2.dist-info/top_level.txt,sha256=SFJWwSDlbsmTWV8F67fdmfAK_dtTT9c8L-kfdnior4s,18
+resilient_circuit-0.4.2.dist-info/RECORD,,