Update policy_engine.py

policy_engine.py

@@ -62,7 +62,15 @@ DEFAULT_HEALING_POLICIES = [
 
 class PolicyEngine:
     """
-    Thread-safe policy engine with cooldown and rate limiting.
+    Thread‑safe policy engine with cooldown and rate limiting.
+
+    Policies are evaluated in priority order. Each policy has:
+      - conditions (AND logic)
+      - cooldown per (policy, component)
+      - rate limit per hour
+
+    The engine maintains an LRU cache of last execution timestamps
+    (using OrderedDict) to bound memory usage.
     """
 
     def __init__(
@@ -71,9 +79,16 @@ class PolicyEngine:
         max_cooldown_history: int = 10000,
         max_execution_history: int = 1000
     ):
+        """
+        Args:
+            policies: List of HealingPolicy objects. If None, DEFAULT_HEALING_POLICIES used.
+            max_cooldown_history: Maximum number of (policy, component) entries to keep.
+            max_execution_history: Maximum number of timestamps stored per policy for rate limiting.
+        """
         self.policies = policies or DEFAULT_HEALING_POLICIES
         self._lock = threading.RLock()
-        self.last_execution: Dict[str, float] = OrderedDict()
+        # OrderedDict acts as an LRU cache: last item is most recent.
+        self.last_execution: OrderedDict[str, float] = OrderedDict()
         self.max_cooldown_history = max_cooldown_history
         self.execution_timestamps: Dict[str, List[float]] = {}
         self.max_execution_history = max_execution_history
@@ -81,6 +96,10 @@ class PolicyEngine:
         logger.info(f"Initialized PolicyEngine with {len(self.policies)} policies")
 
     def evaluate_policies(self, event: ReliabilityEvent) -> List[HealingAction]:
+        """
+        Evaluate all policies against the event and return the set of actions
+        triggered (deduplicated). Returns [NO_ACTION] if none triggered.
+        """
         applicable_actions = []
         current_time = datetime.datetime.now(datetime.timezone.utc).timestamp()
         for policy in self.policies:
@@ -95,8 +114,15 @@ class PolicyEngine:
                     continue
                 if self._evaluate_conditions(policy.conditions, event):
                     applicable_actions.extend(policy.actions)
+                    # Update cooldown
                     self.last_execution[policy_key] = current_time
+                    self.last_execution.move_to_end(policy_key)  # mark as most recent
+                    # Enforce cache size
+                    if len(self.last_execution) > self.max_cooldown_history:
+                        self.last_execution.popitem(last=False)
                     self._record_execution(policy_key, current_time)
+
+        # Deduplicate actions while preserving order
         seen = set()
         unique = []
         for a in applicable_actions:
@@ -106,6 +132,7 @@ class PolicyEngine:
         return unique if unique else [HealingAction.NO_ACTION]
 
     def _evaluate_conditions(self, conditions: List[PolicyCondition], event: ReliabilityEvent) -> bool:
+        """Return True if all conditions are satisfied."""
         for cond in conditions:
             metric = cond.metric
             op = cond.operator
@@ -133,6 +160,7 @@ class PolicyEngine:
         return True
 
     def _is_rate_limited(self, key: str, policy: HealingPolicy, now: float) -> bool:
+        """Check if the policy has exceeded its hourly execution limit."""
         if key not in self.execution_timestamps:
             return False
         one_hour_ago = now - 3600
@@ -141,6 +169,7 @@ class PolicyEngine:
         return len(recent) >= policy.max_executions_per_hour
 
     def _record_execution(self, key: str, ts: float):
+        """Record an execution timestamp for rate limiting."""
         if key not in self.execution_timestamps:
             self.execution_timestamps[key] = []
         self.execution_timestamps[key].append(ts)