brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/alerts/events.py

@@ -17,11 +17,15 @@ from brawny.alerts.errors import (
     EventNotFoundError,
     ReceiptRequiredError,
 )
+from brawny.logging import get_logger
 
 if TYPE_CHECKING:
     from brawny.jobs.base import TxReceipt
 
 
+logger = get_logger(__name__)
+
+
 class AttributeDict(dict):
     """Dictionary that allows attribute-style access to values.
 
@@ -145,7 +149,16 @@ class EventAccessor:
             log = LogEntry.from_dict(log_dict)
 
             # Filter by contract address
-            if to_checksum_address(log.address) != self._address:
+            try:
+                log_address = to_checksum_address(log.address)
+            except ValueError:
+                logger.debug(
+                    "events.invalid_log_address",
+                    address=log.address,
+                    tx_hash=log.transaction_hash,
+                )
+                continue
+            if log_address != self._address:
                 continue
 
             # Skip if no topics (anonymous event)
@@ -168,8 +181,14 @@ class EventAccessor:
                         if event_name not in result:
                             result[event_name] = []
                         result[event_name].append(decoded)
-                    except Exception:
-                        # Skip logs that fail to decode
+                    except Exception as e:
+                        logger.debug(
+                            "events.decode_log_failed",
+                            event_name=event_name,
+                            tx_hash=log.transaction_hash,
+                            log_index=log.log_index,
+                            error=str(e)[:200],
+                        )
                         continue
                     break
 
@@ -213,7 +232,14 @@ class EventAccessor:
                 types = [i["type"] for i in non_indexed_inputs]
                 try:
                     non_indexed_values = list(abi_decode(types, data_bytes))
-                except Exception:
+                except Exception as e:
+                    logger.debug(
+                        "events.decode_non_indexed_failed",
+                        event_name=event_name,
+                        tx_hash=log.transaction_hash,
+                        log_index=log.log_index,
+                        error=str(e)[:200],
+                    )
                     non_indexed_values = [None] * len(non_indexed_inputs)
 
         # Build args dict
@@ -607,7 +633,14 @@ def decode_logs(
             decoded["_address"] = log.get("address", "")
             decoded["_name"] = event_abi["name"]
             decoded_events.append(decoded)
-        except Exception:
+        except Exception as e:
+            logger.debug(
+                "events.decode_event_failed",
+                event_name=event_abi.get("name"),
+                tx_hash=log.get("transactionHash"),
+                log_index=log.get("logIndex"),
+                error=str(e)[:200],
+            )
             continue
 
     return EventDict(decoded_events)

brawny/alerts/health.py

@@ -7,6 +7,8 @@ import threading
 from datetime import datetime, timedelta
 from typing import Any, Callable, Literal
 
+from cachetools import TTLCache
+
 from brawny.logging import get_logger
 
 logger = get_logger(__name__)
@@ -14,9 +16,11 @@ logger = get_logger(__name__)
 DEFAULT_COOLDOWN_SECONDS = 1800
 MAX_FIELD_LEN = 200
 
-_last_fired: dict[str, datetime] = {}
-_first_seen: dict[str, datetime] = {}
-_suppressed_count: dict[str, int] = {}
+# Multi-threaded access - protected by _lock
+# Medium cardinality keys (fingerprint hashes): maxsize=10K, ttl=1h
+_last_fired: TTLCache[str, datetime] = TTLCache(maxsize=10_000, ttl=3600)
+_first_seen: TTLCache[str, datetime] = TTLCache(maxsize=10_000, ttl=3600)
+_suppressed_count: TTLCache[str, int] = TTLCache(maxsize=10_000, ttl=3600)
 _lock = threading.Lock()
 
 
@@ -172,14 +176,16 @@ def health_alert(
 
 
 def cleanup_stale_fingerprints(cooldown_seconds: int = DEFAULT_COOLDOWN_SECONDS) -> int:
-    """Remove fingerprints older than 2x cooldown. Returns count removed."""
-    cutoff = datetime.utcnow() - timedelta(seconds=cooldown_seconds * 2)
-    removed = 0
+    """Remove fingerprints older than 2x cooldown. Returns count removed.
+
+    Note: With TTLCache, stale entries are automatically evicted. This function
+    now triggers cache expiration and returns 0 (actual eviction count is not
+    tracked by TTLCache). Kept for API compatibility.
+    """
     with _lock:
-        stale = [fp for fp, ts in _last_fired.items() if ts < cutoff]
-        for fp in stale:
-            _last_fired.pop(fp, None)
-            _first_seen.pop(fp, None)
-            _suppressed_count.pop(fp, None)
-            removed += 1
-    return removed
+        # TTLCache automatically evicts expired entries on access
+        # Trigger expiration by calling expire() if available, or just access
+        _last_fired.expire()
+        _first_seen.expire()
+        _suppressed_count.expire()
+    return 0  # TTLCache doesn't track eviction count