claude-mpm 4.5.6__py3-none-any.whl → 4.5.11__py3-none-any.whl

claude_mpm/services/async_session_logger.py

@@ -31,6 +31,9 @@ from typing import Any, Dict, Optional
 from claude_mpm.core.constants import PerformanceConfig, SystemLimits, TimeoutConfig
 from claude_mpm.core.logging_utils import get_logger
 
+# Import centralized session manager
+from claude_mpm.services.session_manager import get_session_manager
+
 # Import configuration manager
 from ..core.config import Config
 
@@ -68,8 +71,13 @@ class AsyncSessionLogger:
     - Configurable log formats (JSON, syslog, journald)
     - Fire-and-forget pattern for zero latency impact
     - Graceful degradation on errors
+    - Thread-safe singleton pattern with initialization flag
     """
 
+    _initialization_lock = Lock()
+    _initialized = False
+    _worker_started = False
+
     def __init__(
         self,
         base_dir: Optional[Path] = None,
@@ -90,109 +98,108 @@ class AsyncSessionLogger:
             enable_compression: Enable gzip compression for JSON logs (overrides config)
             config: Configuration instance to use (creates new if not provided)
         """
-        # Load configuration from YAML file or use provided config
-        if config is None:
-            config = Config()
-        self.config = config
-
-        # Get response logging configuration section
-        response_config = self.config.get("response_logging", {})
-
-        # Apply configuration with parameter overrides
-        self.base_dir = Path(
-            base_dir
-            or response_config.get("session_directory", ".claude-mpm/responses")
-        )
-
-        # Convert log format string to enum
-        format_str = response_config.get("format", "json").lower()
-        if log_format is not None:
-            self.log_format = log_format
-        elif format_str == "syslog":
-            self.log_format = LogFormat.SYSLOG
-        elif format_str == "journald":
-            self.log_format = LogFormat.JOURNALD
-        else:
-            self.log_format = LogFormat.JSON
-
-        self.max_queue_size = (
-            max_queue_size
-            if max_queue_size is not None
-            else response_config.get("max_queue_size", SystemLimits.MAX_QUEUE_SIZE)
-        )
-
-        # Handle async configuration with backward compatibility
-        if enable_async is not None:
-            self.enable_async = enable_async
-        else:
-            # Check configuration first, then environment variables for backward compatibility
-            self.enable_async = response_config.get("use_async", True)
-            # Override with environment variable if set (backward compatibility)
-            if os.environ.get("CLAUDE_USE_ASYNC_LOG"):
-                self.enable_async = (
-                    os.environ.get("CLAUDE_USE_ASYNC_LOG", "true").lower() == "true"
-                )
-
-        # Check debug sync mode (forces synchronous for debugging)
-        if (
-            response_config.get("debug_sync", False)
-            or os.environ.get("CLAUDE_LOG_SYNC", "").lower() == "true"
-        ):
-            logger.info("Debug sync mode enabled - forcing synchronous logging")
-            self.enable_async = False
-
-        self.enable_compression = (
-            enable_compression
-            if enable_compression is not None
-            else response_config.get("enable_compression", False)
-        )
+        # Use initialization flag to prevent duplicate setup
+        with self._initialization_lock:
+            if self._initialized and hasattr(self, "config"):
+                logger.debug("AsyncSessionLogger already initialized, skipping setup")
+                return
 
-        # Create base directory
-        self.base_dir.mkdir(parents=True, exist_ok=True)
+            # Load configuration from YAML file or use provided config
+            if config is None:
+                config = Config()
+            self.config = config
 
-        # Session management
-        self.session_id = self._get_claude_session_id()
+            # Get response logging configuration section
+            response_config = self.config.get("response_logging", {})
 
-        # Async infrastructure
-        self._queue: Queue = Queue(maxsize=self.max_queue_size)
-        self._worker_thread: Optional[Thread] = None
-        self._shutdown = False
-        self._lock = Lock()
+            # Apply configuration with parameter overrides
+            self.base_dir = Path(
+                base_dir
+                or response_config.get("session_directory", ".claude-mpm/responses")
+            )
 
-        # Statistics
-        self.stats = {
-            "logged": 0,
-            "queued": 0,
-            "dropped": 0,
-            "errors": 0,
-            "avg_write_time_ms": 0.0,
-        }
+            # Convert log format string to enum
+            format_str = response_config.get("format", "json").lower()
+            if log_format is not None:
+                self.log_format = log_format
+            elif format_str == "syslog":
+                self.log_format = LogFormat.SYSLOG
+            elif format_str == "journald":
+                self.log_format = LogFormat.JOURNALD
+            else:
+                self.log_format = LogFormat.JSON
 
-        # Initialize format-specific handlers
-        self._init_format_handler()
+            self.max_queue_size = (
+                max_queue_size
+                if max_queue_size is not None
+                else response_config.get("max_queue_size", SystemLimits.MAX_QUEUE_SIZE)
+            )
 
-        # Start background worker if async enabled
-        if self.enable_async:
-            self._start_worker()
+            # Handle async configuration with backward compatibility
+            if enable_async is not None:
+                self.enable_async = enable_async
+            else:
+                # Check configuration first, then environment variables for backward compatibility
+                self.enable_async = response_config.get("use_async", True)
+                # Override with environment variable if set (backward compatibility)
+                if os.environ.get("CLAUDE_USE_ASYNC_LOG"):
+                    self.enable_async = (
+                        os.environ.get("CLAUDE_USE_ASYNC_LOG", "true").lower() == "true"
+                    )
 
-        # Log initialization status
-        logger.info(
-            f"AsyncSessionLogger initialized: session_id={self.session_id}, async={self.enable_async}, format={self.log_format.value}"
-        )
+            # Check debug sync mode (forces synchronous for debugging)
+            if (
+                response_config.get("debug_sync", False)
+                or os.environ.get("CLAUDE_LOG_SYNC", "").lower() == "true"
+            ):
+                logger.info("Debug sync mode enabled - forcing synchronous logging")
+                self.enable_async = False
+
+            self.enable_compression = (
+                enable_compression
+                if enable_compression is not None
+                else response_config.get("enable_compression", False)
+            )
 
-    def _get_claude_session_id(self) -> str:
-        """Get or generate a Claude session ID."""
-        # Check environment variables in order of preference
-        for env_var in ["CLAUDE_SESSION_ID", "ANTHROPIC_SESSION_ID", "SESSION_ID"]:
-            session_id = os.environ.get(env_var)
-            if session_id:
-                logger.info(f"Using session ID from {env_var}: {session_id}")
-                return session_id
+            # Create base directory
+            self.base_dir.mkdir(parents=True, exist_ok=True)
+
+            # Use centralized SessionManager for session ID
+            session_manager = get_session_manager()
+            self.session_id = session_manager.get_session_id()
+
+            # Async infrastructure
+            self._queue: Queue = Queue(maxsize=self.max_queue_size)
+            self._worker_thread: Optional[Thread] = None
+            self._shutdown = False
+            self._lock = Lock()
+
+            # Statistics
+            self.stats = {
+                "logged": 0,
+                "queued": 0,
+                "dropped": 0,
+                "errors": 0,
+                "avg_write_time_ms": 0.0,
+            }
+
+            # Initialize format-specific handlers
+            self._init_format_handler()
+
+            # Mark as initialized
+            self._initialized = True
+
+            # Log initialization status
+            logger.debug(
+                f"AsyncSessionLogger initialized with SessionManager: session_id={self.session_id}, async={self.enable_async}, format={self.log_format.value}"
+            )
 
-        # Generate timestamp-based session ID
-        session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-        logger.info(f"Generated session ID: {session_id}")
-        return session_id
+        # Start background worker if async enabled (outside initialization lock)
+        if self.enable_async and not self._worker_started:
+            with self._initialization_lock:
+                if not self._worker_started:
+                    self._start_worker()
+                    self._worker_started = True
 
     def _init_format_handler(self):
         """Initialize format-specific logging handlers."""
@@ -519,9 +526,18 @@ class AsyncSessionLogger:
             return self.stats.copy()
 
     def set_session_id(self, session_id: str):
-        """Set a new session ID."""
+        """Set a new session ID.
+
+        Note: This updates both the local session ID and the SessionManager.
+
+        Args:
+            session_id: The new session ID to use
+        """
         self.session_id = session_id
-        logger.info(f"Session ID updated to: {session_id}")
+        # Also update SessionManager to keep consistency
+        session_manager = get_session_manager()
+        session_manager.set_session_id(session_id)
+        logger.debug(f"Session ID updated to: {session_id}")
 
     def is_enabled(self) -> bool:
         """Check if logging is enabled."""

claude_mpm/services/claude_session_logger.py

@@ -13,11 +13,15 @@ Configuration via .claude-mpm/configuration.yaml.
 import json
 import os
 from datetime import datetime, timezone
+from threading import Lock
 from typing import Any, Dict, Optional
 
 # Import configuration manager
 from claude_mpm.core.config import Config
 
+# Import centralized session manager
+from claude_mpm.services.session_manager import get_session_manager
+
 # Try to import async logger for performance optimization
 try:
     from claude_mpm.services.async_session_logger import (
@@ -38,6 +42,9 @@ logger = get_logger(__name__)
 class ClaudeSessionLogger:
     """Simplified response logger for Claude Code sessions."""
 
+    _initialization_lock = Lock()
+    _initialized = False
+
     def __init__(
         self,
         base_dir: Optional[Path] = None,
@@ -52,29 +59,41 @@ class ClaudeSessionLogger:
             use_async: Use async logging if available. Overrides config.
             config: Configuration instance to use (creates new if not provided)
         """
-        # Load configuration
-        if config is None:
-            config = Config()
-        self.config = config
-
-        # Get response logging configuration
-        response_config = self.config.get("response_logging", {})
-
-        # Determine base directory
-        if base_dir is None:
-            # Check configuration first
-            base_dir = response_config.get("session_directory")
-            if not base_dir:
-                # Fall back to default response directory
-                base_dir = ".claude-mpm/responses"
-            base_dir = Path(base_dir)
-
-        self.base_dir = Path(base_dir)
-        self.base_dir.mkdir(parents=True, exist_ok=True)
+        # Use initialization flag to prevent duplicate setup
+        with self._initialization_lock:
+            if self._initialized and hasattr(self, "config"):
+                logger.debug("ClaudeSessionLogger already initialized, skipping setup")
+                return
+
+            # Load configuration
+            if config is None:
+                config = Config()
+            self.config = config
+
+            # Get response logging configuration
+            response_config = self.config.get("response_logging", {})
+
+            # Determine base directory
+            if base_dir is None:
+                # Check configuration first
+                base_dir = response_config.get("session_directory")
+                if not base_dir:
+                    # Fall back to default response directory
+                    base_dir = ".claude-mpm/responses"
+                base_dir = Path(base_dir)
+
+            self.base_dir = Path(base_dir)
+            self.base_dir.mkdir(parents=True, exist_ok=True)
+
+            # Use centralized SessionManager for session ID
+            session_manager = get_session_manager()
+            self.session_id = session_manager.get_session_id()
+            logger.debug(
+                f"ClaudeSessionLogger using session ID from SessionManager: {self.session_id}"
+            )
 
-        # Try to get session ID from environment
-        self.session_id = self._get_claude_session_id()
-        self.response_counter = {}  # Track response count per session
+            self.response_counter = {}  # Track response count per session
+            self._initialized = True
 
         # Determine if we should use async logging
         if use_async is None:
@@ -106,49 +125,17 @@ class ClaudeSessionLogger:
                 # Synchronize session IDs - use the one we already generated
                 if self.session_id and hasattr(self._async_logger, "set_session_id"):
                     self._async_logger.set_session_id(self.session_id)
-                    logger.info(
+                    logger.debug(
                         f"Using async logger with session ID: {self.session_id}"
                     )
                 else:
-                    logger.info("Using async logger for improved performance")
+                    logger.debug("Using async logger for improved performance")
             except Exception as e:
                 logger.warning(
                     f"Failed to initialize async logger, falling back to sync: {e}"
                 )
                 self.use_async = False
 
-    def _get_claude_session_id(self) -> Optional[str]:
-        """
-        Get the Claude Code session ID from environment.
-
-        Returns:
-            Session ID if available, None otherwise
-        """
-        # Claude Code may set various environment variables
-        # Check common patterns
-        session_id = None
-
-        # Check for CLAUDE_SESSION_ID
-        session_id = os.environ.get("CLAUDE_SESSION_ID")
-
-        # Check for ANTHROPIC_SESSION_ID
-        if not session_id:
-            session_id = os.environ.get("ANTHROPIC_SESSION_ID")
-
-        # Check for generic SESSION_ID
-        if not session_id:
-            session_id = os.environ.get("SESSION_ID")
-
-        # Generate a default based on timestamp if nothing found
-        if not session_id:
-            # Use a timestamp-based session ID as fallback
-            session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            logger.info(f"Session ID: {session_id} (generated)")
-        else:
-            logger.info(f"Session ID: {session_id}")
-
-        return session_id
-
     def _generate_filename(self, agent: Optional[str] = None) -> str:
         """
         Generate a flat filename with session ID, agent, and timestamp.
@@ -251,10 +238,15 @@ class ClaudeSessionLogger:
         """
         Manually set the session ID.
 
+        Note: This updates both the local session ID and the SessionManager.
+
         Args:
             session_id: The session ID to use
         """
         self.session_id = session_id
+        # Also update SessionManager to keep consistency
+        session_manager = get_session_manager()
+        session_manager.set_session_id(session_id)
         logger.info(f"Session ID set to: {session_id}")
 
     def get_session_path(self) -> Optional[Path]:
@@ -280,13 +272,16 @@ class ClaudeSessionLogger:
         return self.session_id is not None
 
 
-# Singleton instance for easy access
+# Singleton instance with thread-safe initialization
 _logger_instance = None
+_logger_lock = Lock()
 
 
 def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
     """
-    Get the singleton session logger instance.
+    Get the singleton session logger instance with thread-safe initialization.
+
+    Uses double-checked locking pattern to ensure thread safety.
 
     Args:
         config: Optional configuration instance to use
@@ -295,9 +290,16 @@ def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
         The shared ClaudeSessionLogger instance
     """
     global _logger_instance
-    if _logger_instance is None:
-        _logger_instance = ClaudeSessionLogger(config=config)
-    return _logger_instance
+
+    # Fast path - check without lock
+    if _logger_instance is not None:
+        return _logger_instance
+
+    # Slow path - acquire lock and double-check
+    with _logger_lock:
+        if _logger_instance is None:
+            _logger_instance = ClaudeSessionLogger(config=config)
+        return _logger_instance
 
 
 def log_response(