claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/event_bus/direct_relay.py

@@ -2,15 +2,27 @@
 
 This module provides a relay that connects EventBus directly to the
 Socket.IO server's broadcaster, avoiding the client loopback issue.
+
+IMPORTANT - Claude Event Format:
+Claude sends hook events with these REQUIRED fields:
+- hook_event_name: The event type (UserPromptSubmit, PreToolUse, PostToolUse, etc.)
+- hook_event_type: Usually same as hook_event_name
+- hook_input_data: Contains the actual event data
+- sessionId: Session identifier
+- timestamp: ISO format timestamp
+
+DO NOT use "event" or "type" fields - use "hook_event_name" instead!
 """
 
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any
 
+from claude_mpm.core.logging_utils import get_logger
+
 from .event_bus import EventBus
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class DirectSocketIORelay:
@@ -37,9 +49,12 @@ class DirectSocketIORelay:
             "last_relay_time": None,
         }
         self.debug = logger.isEnabledFor(logging.DEBUG)
+        self.connection_retries = 0
+        self.max_retries = 10
+        self.retry_delay = 1.0  # Start with 1 second
 
     def start(self) -> None:
-        """Start the relay by subscribing to EventBus events."""
+        """Start the relay by subscribing to EventBus events with retry logic."""
         if not self.enabled:
             logger.warning("DirectSocketIORelay is disabled")
             return
@@ -59,14 +74,67 @@ class DirectSocketIORelay:
 
         # Add debug logging for verification
         logger.info("[DirectRelay] Subscribed to hook.* events on EventBus")
+
+        # Check and log broadcaster availability with retry logic
+        broadcaster_available = self._check_broadcaster_with_retry()
+
         logger.info(
-            f"[DirectRelay] Server broadcaster available: {self.server and self.server.broadcaster is not None}"
+            f"[DirectRelay] Server broadcaster available: {broadcaster_available}"
         )
+        if not broadcaster_available:
+            if not self.server:
+                logger.warning(
+                    "[DirectRelay] No server instance provided - events will not be relayed!"
+                )
+            elif not hasattr(self.server, "broadcaster"):
+                logger.warning(
+                    "[DirectRelay] Server has no broadcaster attribute - events will not be relayed!"
+                )
+            else:
+                logger.warning(
+                    "[DirectRelay] Server broadcaster is None after retries - events will not be relayed!"
+                )
+
         logger.info(f"[DirectRelay] EventBus instance: {self.event_bus is not None}")
 
         # Mark as connected after successful subscription
-        self.connected = True
-        logger.info("[DirectRelay] Started and subscribed to hook events")
+        self.connected = broadcaster_available
+        logger.info(f"[DirectRelay] Started with connection status: {self.connected}")
+
+    def _check_broadcaster_with_retry(self) -> bool:
+        """Check broadcaster availability with exponential backoff retry.
+
+        Returns:
+            True if broadcaster is available, False after max retries
+        """
+        import time
+
+        retry_delay = self.retry_delay
+
+        for attempt in range(self.max_retries):
+            broadcaster_available = (
+                self.server
+                and hasattr(self.server, "broadcaster")
+                and self.server.broadcaster is not None
+            )
+
+            if broadcaster_available:
+                self.connection_retries = 0  # Reset counter on success
+                return True
+
+            if attempt < self.max_retries - 1:
+                logger.info(
+                    f"[DirectRelay] Broadcaster not ready, retry {attempt + 1}/{self.max_retries} "
+                    f"in {retry_delay:.1f}s"
+                )
+                time.sleep(retry_delay)
+                retry_delay = min(retry_delay * 2, 30.0)  # Exponential backoff, max 30s
+            else:
+                logger.error(
+                    f"[DirectRelay] Broadcaster not available after {self.max_retries} attempts"
+                )
+
+        return False
 
     def _handle_hook_event(self, event_type: str, data: Any):
         """Internal method to handle hook events and broadcast them.
@@ -76,9 +144,28 @@ class DirectSocketIORelay:
             data: The event data
         """
         try:
-            # Log the event reception
+            # Enhanced debug logging for troubleshooting
             if self.debug:
                 logger.debug(f"[DirectRelay] Received event: {event_type}")
+                logger.debug(f"[DirectRelay] Event data type: {type(data).__name__}")
+                logger.debug(
+                    f"[DirectRelay] Event data keys: {list(data.keys()) if isinstance(data, dict) else 'not-dict'}"
+                )
+                logger.debug(
+                    f"[DirectRelay] Relay state - enabled: {self.enabled}, connected: {self.connected}"
+                )
+                logger.debug(
+                    f"[DirectRelay] Server state - has_server: {self.server is not None}, has_broadcaster: {self.server and hasattr(self.server, 'broadcaster') and self.server.broadcaster is not None}"
+                )
+
+            # Always log reception of important events
+            if event_type in [
+                "hook.pre_tool",
+                "hook.post_tool",
+                "hook.user_prompt",
+                "hook.subagent_stop",
+            ]:
+                logger.info(f"[DirectRelay] Processing important event: {event_type}")
 
             # Only relay hook events
             if event_type.startswith("hook."):
@@ -133,19 +220,71 @@ class DirectSocketIORelay:
 
                     # Use the full event_type (e.g., "hook.pre_tool") as the event name
                     # The normalizer handles dotted names and will extract type and subtype correctly
-                    self.server.broadcaster.broadcast_event(event_type, broadcast_data)
+                    try:
+                        self.server.broadcaster.broadcast_event(
+                            event_type, broadcast_data
+                        )
+                        self.stats["events_relayed"] += 1
+                        self.stats["last_relay_time"] = datetime.now(
+                            timezone.utc
+                        ).isoformat()
 
-                    self.stats["events_relayed"] += 1
-                    self.stats["last_relay_time"] = datetime.now().isoformat()
+                        # Reset retry counter on successful broadcast
+                        if self.connection_retries > 0:
+                            self.connection_retries = 0
+                            self.connected = True
+                            logger.info("[DirectRelay] Connection restored")
 
-                    if self.debug:
-                        logger.debug(
-                            f"[DirectRelay] Broadcasted hook event: {event_type}"
+                        if self.debug:
+                            logger.debug(
+                                f"[DirectRelay] Broadcasted hook event: {event_type}"
+                            )
+                    except Exception as broadcast_error:
+                        logger.error(
+                            f"[DirectRelay] Broadcast failed for {event_type}: {broadcast_error}"
                         )
+                        self.stats["events_failed"] += 1
+
+                        # Try to reconnect if broadcast fails
+                        if self.connection_retries < self.max_retries:
+                            self.connection_retries += 1
+                            self.connected = self._check_broadcaster_with_retry()
+                            if self.connected:
+                                # Retry the broadcast
+                                try:
+                                    self.server.broadcaster.broadcast_event(
+                                        event_type, broadcast_data
+                                    )
+                                    self.stats["events_relayed"] += 1
+                                    self.stats[
+                                        "events_failed"
+                                    ] -= 1  # Undo the failure count
+                                    logger.info(
+                                        f"[DirectRelay] Retry successful for {event_type}"
+                                    )
+                                except Exception:
+                                    pass  # Already counted as failed
                 else:
+                    # Enhanced logging when broadcaster is not available
                     logger.warning(
                         f"[DirectRelay] Server broadcaster not available for {event_type}"
                     )
+                    if self.server:
+                        logger.warning(
+                            "[DirectRelay] Server exists but broadcaster is None"
+                        )
+                        logger.warning(
+                            f"[DirectRelay] Server type: {type(self.server).__name__}"
+                        )
+                        logger.warning(
+                            f"[DirectRelay] Server has broadcaster attr: {hasattr(self.server, 'broadcaster')}"
+                        )
+                        if hasattr(self.server, "broadcaster"):
+                            logger.warning(
+                                f"[DirectRelay] Broadcaster value: {self.server.broadcaster}"
+                            )
+                    else:
+                        logger.warning("[DirectRelay] Server is None")
                     self.stats["events_failed"] += 1
 
         except Exception as e:

claude_mpm/services/event_bus/event_bus.py

@@ -11,13 +11,15 @@ WHY pyee over alternatives:
 import asyncio
 import logging
 import threading
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional, Set
 
 from pyee.asyncio import AsyncIOEventEmitter
 
 # Configure logger
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class EventBus:
@@ -63,6 +65,12 @@ class EventBus:
         self._event_history: List[Dict[str, Any]] = []
         self._max_history_size = 100
 
+        # Track async handler tasks to prevent garbage collection
+        self._handler_tasks: Set[asyncio.Task] = set()
+
+        # Track handler wrappers for removal
+        self._handler_wrappers: Dict[tuple, Callable] = {}
+
         logger.info("EventBus initialized")
 
     @classmethod
@@ -188,13 +196,17 @@ class EventBus:
                             try:
                                 # Call with event_type and data for wildcard handlers
                                 if asyncio.iscoroutinefunction(handler):
-                                    # Schedule async handlers
+                                    # Schedule async handlers with tracking
                                     try:
                                         loop = asyncio.get_event_loop()
                                         if loop.is_running():
-                                            asyncio.create_task(
+                                            task = asyncio.create_task(
                                                 handler(event_type, data)
                                             )
+                                            self._handler_tasks.add(task)
+                                            task.add_done_callback(
+                                                self._handler_tasks.discard
+                                            )
                                         else:
                                             loop.run_until_complete(
                                                 handler(event_type, data)
@@ -210,7 +222,7 @@ class EventBus:
 
             # Update stats
             self._stats["events_published"] += 1
-            self._stats["last_event_time"] = datetime.now().isoformat()
+            self._stats["last_event_time"] = datetime.now(timezone.utc).isoformat()
 
             if self._debug:
                 logger.debug(f"Published event: {event_type}")
@@ -257,8 +269,20 @@ class EventBus:
 
             logger.debug(f"Registered wildcard handler for: {event_type}")
         else:
-            # Regular event registration
-            self._emitter.on(event_type, handler)
+            # Wrap handler to catch exceptions and prevent them from stopping other handlers
+            def safe_handler(data):
+                try:
+                    handler(data)
+                except Exception as e:
+                    if self._debug:
+                        logger.debug(f"Handler error for {event_type}: {e}")
+
+            # Store mapping for later removal
+            wrapper_key = (event_type, handler)
+            self._handler_wrappers[wrapper_key] = safe_handler
+
+            # Regular event registration with wrapped handler
+            self._emitter.on(event_type, safe_handler)
             logger.debug(f"Registered handler for: {event_type}")
 
     def once(self, event_type: str, handler: Callable) -> None:
@@ -278,7 +302,17 @@ class EventBus:
             event_type: The event type
             handler: The handler to remove
         """
-        self._emitter.remove_listener(event_type, handler)
+        # Check if we have a wrapped version of this handler
+        wrapper_key = (event_type, handler)
+        if wrapper_key in self._handler_wrappers:
+            # Remove the wrapped handler from pyee
+            wrapped_handler = self._handler_wrappers[wrapper_key]
+            self._emitter.remove_listener(event_type, wrapped_handler)
+            # Remove from our tracking dict
+            del self._handler_wrappers[wrapper_key]
+        else:
+            # No wrapper, remove directly (e.g., for wildcard handlers or direct registrations)
+            self._emitter.remove_listener(event_type, handler)
         logger.debug(f"Removed handler for: {event_type}")
 
     def remove_all_listeners(self, event_type: Optional[str] = None) -> None:
@@ -289,9 +323,17 @@ class EventBus:
         """
         if event_type:
             self._emitter.remove_all_listeners(event_type)
+            # Clean up wrappers for this event type
+            wrappers_to_remove = [
+                key for key in self._handler_wrappers if key[0] == event_type
+            ]
+            for key in wrappers_to_remove:
+                del self._handler_wrappers[key]
             logger.debug(f"Removed all handlers for: {event_type}")
         else:
             self._emitter.remove_all_listeners()
+            # Clean up all wrappers
+            self._handler_wrappers.clear()
             logger.debug("Removed all event handlers")
 
     def _record_event(self, event_type: str, data: Any) -> None:
@@ -302,7 +344,7 @@ class EventBus:
             data: The event data
         """
         event_record = {
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "type": event_type,
             "data": data,
         }

claude_mpm/services/event_bus/relay.py

@@ -8,10 +8,10 @@ WHY separate relay component:
 - Supports batching and retry logic in one place
 """
 
-import logging
 import os
+import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 # Socket.IO imports
@@ -25,10 +25,12 @@ except ImportError:
 
 import contextlib
 
+# Configure logger
+from claude_mpm.core.logging_utils import get_logger
+
 from .event_bus import EventBus
 
-# Configure logger
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class SocketIORelay:
@@ -151,7 +153,7 @@ class SocketIORelay:
                 # Verify connection is still alive
                 if self.client.connected:
                     return True
-            except:
+            except Exception:
                 pass
 
         # Need to create or reconnect
@@ -187,7 +189,9 @@ class SocketIORelay:
                     "subtype": (
                         event_type.split(".", 1)[1] if "." in event_type else "generic"
                     ),
-                    "timestamp": data.get("timestamp", datetime.now().isoformat()),
+                    "timestamp": data.get(
+                        "timestamp", datetime.now(timezone.utc).isoformat()
+                    ),
                     "data": data,
                     "source": "event_bus",
                 },
@@ -195,7 +199,7 @@ class SocketIORelay:
 
             # Update statistics
             self.stats["events_relayed"] += 1
-            self.stats["last_relay_time"] = datetime.now().isoformat()
+            self.stats["last_relay_time"] = datetime.now(timezone.utc).isoformat()
 
             if self.debug:
                 logger.debug(f"Relayed event to Socket.IO: {event_type}")
@@ -268,11 +272,15 @@ class SocketIORelay:
 
 # Global relay instance
 _relay_instance: Optional[SocketIORelay] = None
+_relay_lock = threading.Lock()
 
 
 def get_relay(port: Optional[int] = None) -> SocketIORelay:
     """Get or create the global SocketIO relay instance.
 
+    Thread-safe implementation using double-checked locking pattern to
+    prevent race conditions during concurrent initialization.
+
     Args:
         port: Optional port number
 
@@ -280,9 +288,16 @@ def get_relay(port: Optional[int] = None) -> SocketIORelay:
         SocketIORelay: The relay instance
     """
     global _relay_instance
-    if _relay_instance is None:
-        _relay_instance = SocketIORelay(port)
-    return _relay_instance
+
+    # Fast path - check without lock
+    if _relay_instance is not None:
+        return _relay_instance
+
+    # Slow path - acquire lock and double-check
+    with _relay_lock:
+        if _relay_instance is None:
+            _relay_instance = SocketIORelay(port)
+        return _relay_instance
 
 
 def start_relay(port: Optional[int] = None) -> SocketIORelay:
@@ -300,8 +315,12 @@ def start_relay(port: Optional[int] = None) -> SocketIORelay:
 
 
 def stop_relay() -> None:
-    """Stop the global SocketIO relay."""
+    """Stop the global SocketIO relay.
+
+    Thread-safe implementation ensures proper cleanup.
+    """
     global _relay_instance
-    if _relay_instance:
-        _relay_instance.stop()
-        _relay_instance = None
+    with _relay_lock:
+        if _relay_instance:
+            _relay_instance.stop()
+            _relay_instance = None

claude_mpm/services/events/consumers/dead_letter.py

@@ -6,7 +6,7 @@ Handles events that failed processing in other consumers.
 """
 
 import json
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -109,7 +109,7 @@ class DeadLetterConsumer(IEventConsumer):
                 self._rotate_file()
 
             # Write to file
-            with open(self._current_file, "a") as f:
+            with self._current_file.open("a") as f:
                 f.write(event_json)
 
             # Update metrics
@@ -165,7 +165,7 @@ class DeadLetterConsumer(IEventConsumer):
         # Find files in time range
         for file_path in sorted(self.output_dir.glob("dead-letter-*.jsonl")):
             try:
-                with open(file_path) as f:
+                with file_path.open() as f:
                     for line in f:
                         event_data = json.loads(line)
 
@@ -284,7 +284,7 @@ class DeadLetterConsumer(IEventConsumer):
 
     def _rotate_file(self) -> None:
         """Rotate to a new output file."""
-        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
         self._current_file = self.output_dir / f"dead-letter-{timestamp}.jsonl"
         self._current_file_size = 0
         self._metrics["files_created"] += 1
@@ -293,7 +293,9 @@ class DeadLetterConsumer(IEventConsumer):
 
     async def _cleanup_old_files(self) -> None:
         """Remove files older than retention period."""
-        cutoff_time = datetime.now().timestamp() - (self.retention_days * 86400)
+        cutoff_time = datetime.now(timezone.utc).timestamp() - (
+            self.retention_days * 86400
+        )
 
         for file_path in self.output_dir.glob("dead-letter-*.jsonl"):
             try:

claude_mpm/services/events/core.py

@@ -12,7 +12,7 @@ import time
 import uuid
 from collections import defaultdict, deque
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from typing import Any, Deque, Dict, List, Optional, Set
 
@@ -225,7 +225,7 @@ class EventBus(IEventBus):
 
         # Add metadata
         if event.metadata:
-            event.metadata.published_at = datetime.now()
+            event.metadata.published_at = datetime.now(timezone.utc)
 
         # Queue event
         self._event_queues[event.priority].append(event)
@@ -353,7 +353,7 @@ class EventBus(IEventBus):
                 # Update metrics
                 if events_processed > 0:
                     self._metrics["events_processed"] += events_processed
-                    self._metrics["last_event_time"] = datetime.now()
+                    self._metrics["last_event_time"] = datetime.now(timezone.utc)
                     self._metrics["queue_size"] = sum(
                         len(q) for q in self._event_queues.values()
                     )
@@ -412,9 +412,8 @@ class EventBus(IEventBus):
         """
         try:
             # Apply filter if configured
-            if consumer.config.filter_func:
-                if not consumer.config.filter_func(event):
-                    return
+            if consumer.config.filter_func and not consumer.config.filter_func(event):
+                return
 
             # Apply transformation if configured
             if consumer.config.transform_func:

claude_mpm/services/events/producers/hook.py

@@ -7,7 +7,7 @@ This replaces direct Socket.IO emission in the hook handler.
 """
 
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.logging_config import get_logger
@@ -96,7 +96,7 @@ class HookEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="hook.response",
             type="AssistantResponse",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data=response_data,
             correlation_id=correlation_id,
@@ -128,7 +128,7 @@ class HookEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="hook.tool",
             type="ToolUse",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "tool": tool_name,
@@ -164,7 +164,7 @@ class HookEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="hook.error",
             type="Error",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "error_type": error_type,
@@ -200,7 +200,7 @@ class HookEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic=f"hook.subagent.{event_type.lower()}",
             type=f"Subagent{event_type}",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "subagent": subagent_name,
@@ -255,7 +255,7 @@ class HookEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic=topic,
             type=hook_type,
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data=hook_data,
             correlation_id=correlation_id,

claude_mpm/services/events/producers/system.py

@@ -6,7 +6,7 @@ Publishes system-level events to the event bus.
 """
 
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.logging_config import get_logger
@@ -100,7 +100,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.lifecycle.startup",
             type="ServiceStartup",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,
@@ -133,7 +133,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.lifecycle.shutdown",
             type="ServiceShutdown",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,
@@ -168,7 +168,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.health",
             type="HealthStatus",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,
@@ -206,7 +206,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.config",
             type="ConfigChange",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,
@@ -238,7 +238,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.performance",
             type="PerformanceMetrics",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,
@@ -274,7 +274,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.error",
             type="SystemError",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,
@@ -311,7 +311,7 @@ class SystemEventProducer(IEventProducer):
             id=str(uuid.uuid4()),
             topic="system.warning",
             type="SystemWarning",
-            timestamp=datetime.now(),
+            timestamp=datetime.now(timezone.utc),
             source=self.source_name,
             data={
                 "service": service_name,