empathy-framework 5.0.1__py3-none-any.whl → 5.1.0__py3-none-any.whl

empathy_os/telemetry/event_streaming.py

@@ -32,10 +32,10 @@ from __future__ import annotations
 
 import json
 import logging
-import time
-from dataclasses import dataclass, field
+from collections.abc import Iterator
+from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Iterator
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -103,14 +103,14 @@ class EventStreamer:
     Publishes events to Redis Streams and provides methods for consuming
     events via polling or blocking reads.
 
-    Stream naming: empathy:events:{event_type}
+    Stream naming: stream:{event_type}
     Examples:
-    - empathy:events:agent_heartbeat
-    - empathy:events:coordination_signal
-    - empathy:events:workflow_progress
+    - stream:agent_heartbeat
+    - stream:coordination_signal
+    - stream:workflow_progress
     """
 
-    STREAM_PREFIX = "empathy:events:"
+    STREAM_PREFIX = "stream:"
     MAX_STREAM_LENGTH = 10000  # Trim streams to last 10K events
     DEFAULT_BLOCK_MS = 5000  # 5 seconds blocking read timeout
 
@@ -142,7 +142,7 @@ class EventStreamer:
             event_type: Type of event
 
         Returns:
-            Stream key (e.g., "empathy:events:agent_heartbeat")
+            Stream key (e.g., "stream:agent_heartbeat")
         """
         return f"{self.STREAM_PREFIX}{event_type}"
 
@@ -162,7 +162,7 @@ class EventStreamer:
         Returns:
             Event ID (Redis stream entry ID) if successful, empty string otherwise
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             logger.debug("Cannot publish event: no Redis backend")
             return ""
 
@@ -178,7 +178,7 @@ class EventStreamer:
 
         try:
             # Add to stream with automatic trimming (MAXLEN)
-            event_id = self.memory._redis.xadd(
+            event_id = self.memory._client.xadd(
                 stream_key,
                 entry,
                 maxlen=self.MAX_STREAM_LENGTH,
@@ -219,7 +219,7 @@ class EventStreamer:
             >>> for event in streamer.consume_events(event_types=["agent_heartbeat"]):
             ...     print(f"Agent {event.data['agent_id']} status: {event.data['status']}")
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             logger.warning("Cannot consume events: no Redis backend")
             return
 
@@ -230,7 +230,7 @@ class EventStreamer:
             streams = {self._get_stream_key(et): start_id for et in event_types}
         else:
             # Subscribe to all event streams (expensive - requires KEYS scan)
-            all_streams = self.memory._redis.keys(f"{self.STREAM_PREFIX}*")
+            all_streams = self.memory._client.keys(f"{self.STREAM_PREFIX}*")
             streams = {s.decode("utf-8") if isinstance(s, bytes) else s: start_id for s in all_streams}
 
         if not streams:
@@ -243,7 +243,7 @@ class EventStreamer:
         try:
             while True:
                 # XREAD: blocking read from multiple streams
-                results = self.memory._redis.xread(
+                results = self.memory._client.xread(
                     last_ids,
                     count=count,
                     block=block_ms,
@@ -294,7 +294,7 @@ class EventStreamer:
         Returns:
             List of recent events (newest first)
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             logger.debug("Cannot get recent events: no Redis backend")
             return []
 
@@ -302,7 +302,7 @@ class EventStreamer:
 
         try:
             # XREVRANGE: get events in reverse chronological order
-            results = self.memory._redis.xrevrange(
+            results = self.memory._client.xrevrange(
                 stream_key,
                 max=end_id,
                 min=start_id,
@@ -333,13 +333,13 @@ class EventStreamer:
         Returns:
             Dictionary with stream info (length, first_entry, last_entry, etc.)
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             return {}
 
         stream_key = self._get_stream_key(event_type)
 
         try:
-            info = self.memory._redis.xinfo_stream(stream_key)
+            info = self.memory._client.xinfo_stream(stream_key)
 
             # Decode bytes keys/values
             decoded_info = {}
@@ -365,13 +365,13 @@ class EventStreamer:
         Returns:
             True if deleted, False otherwise
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             return False
 
         stream_key = self._get_stream_key(event_type)
 
         try:
-            result = self.memory._redis.delete(stream_key)
+            result = self.memory._client.delete(stream_key)
             return result > 0
         except Exception as e:
             logger.error(f"Failed to delete stream {event_type}: {e}")
@@ -387,14 +387,14 @@ class EventStreamer:
         Returns:
             Number of events trimmed
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             return 0
 
         stream_key = self._get_stream_key(event_type)
 
         try:
             # XTRIM: trim to approximate max length
-            trimmed = self.memory._redis.xtrim(
+            trimmed = self.memory._client.xtrim(
                 stream_key,
                 maxlen=max_length,
                 approximate=True,