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

claude_mpm/services/agents/registry/modification_tracker.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 #!/usr/bin/env python3
 """
 Agent Modification Tracker - Consolidated Service
@@ -25,23 +23,27 @@ combining all functionality into a single module for better maintainability.
 import asyncio
 import hashlib
 import json
-import logging
 import shutil
 import time
 import uuid
 from dataclasses import asdict, dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple
 
 from watchdog.events import FileSystemEvent, FileSystemEventHandler
 from watchdog.observers import Observer
 
 from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.enums import OperationResult
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_agent_registry import UnifiedAgentRegistry as AgentRegistry
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
 
+logger = get_logger(__name__)
+
 # ============================================================================
 # Data Models
 # ============================================================================
@@ -90,7 +92,7 @@ class AgentModification:
     @property
     def modification_datetime(self) -> datetime:
         """Get modification timestamp as datetime."""
-        return datetime.fromtimestamp(self.timestamp)
+        return datetime.fromtimestamp(self.timestamp, tz=timezone.utc)
 
     @property
     def age_seconds(self) -> float:
@@ -154,14 +156,20 @@ class AgentFileSystemHandler(FileSystemEventHandler):
 
     def __init__(self, tracker: "AgentModificationTracker"):
         self.tracker = tracker
-        self.logger = logging.getLogger(__name__)
+
+    def _create_tracked_task(self, coro):
+        """Create a task with automatic tracking and cleanup."""
+        task = asyncio.create_task(coro)
+        self.tracker._file_event_tasks.add(task)
+        task.add_done_callback(self.tracker._file_event_tasks.discard)
+        return task
 
     def on_created(self, event: FileSystemEvent) -> None:
         """Handle file creation events."""
         if not event.is_directory and event.src_path.endswith(
             (".md", ".json", ".yaml")
         ):
-            asyncio.create_task(
+            self._create_tracked_task(
                 self.tracker._handle_file_modification(
                     event.src_path, ModificationType.CREATE
                 )
@@ -172,7 +180,7 @@ class AgentFileSystemHandler(FileSystemEventHandler):
         if not event.is_directory and event.src_path.endswith(
             (".md", ".json", ".yaml")
         ):
-            asyncio.create_task(
+            self._create_tracked_task(
                 self.tracker._handle_file_modification(
                     event.src_path, ModificationType.MODIFY
                 )
@@ -183,7 +191,7 @@ class AgentFileSystemHandler(FileSystemEventHandler):
         if not event.is_directory and event.src_path.endswith(
             (".md", ".json", ".yaml")
         ):
-            asyncio.create_task(
+            self._create_tracked_task(
                 self.tracker._handle_file_modification(
                     event.src_path, ModificationType.DELETE
                 )
@@ -194,7 +202,7 @@ class AgentFileSystemHandler(FileSystemEventHandler):
         if not event.is_directory and event.src_path.endswith(
             (".md", ".json", ".yaml")
         ):
-            asyncio.create_task(
+            self._create_tracked_task(
                 self.tracker._handle_file_move(event.src_path, event.dest_path)
             )
 
@@ -248,6 +256,7 @@ class AgentModificationTracker(BaseService):
         # Background tasks
         self._persistence_task: Optional[asyncio.Task] = None
         self._cleanup_task: Optional[asyncio.Task] = None
+        self._file_event_tasks: Set[asyncio.Task] = set()  # Track file event tasks
 
         # Callbacks
         self.modification_callbacks: List[Callable[[AgentModification], None]] = []
@@ -473,7 +482,7 @@ class AgentModificationTracker(BaseService):
                 metadata["file_size_after"] = path.stat().st_size
 
                 # File hash
-                with open(path, "rb") as f:
+                with path.open("rb") as f:
                     metadata["file_hash_after"] = hashlib.sha256(f.read()).hexdigest()
 
                 # File type
@@ -512,7 +521,7 @@ class AgentModificationTracker(BaseService):
             }
 
             metadata_path = backup_dir / "metadata.json"
-            with open(metadata_path, "w") as f:
+            with metadata_path.open("w") as f:
                 json.dump(metadata, f, indent=2)
 
             return str(backup_path)
@@ -543,12 +552,14 @@ class AgentModificationTracker(BaseService):
                     errors.append(f"File does not exist: {modification.file_path}")
 
             # Update validation status
-            modification.validation_status = "failed" if errors else "passed"
+            modification.validation_status = (
+                OperationResult.FAILED if errors else OperationResult.SUCCESS
+            )
             modification.validation_errors = errors
 
         except Exception as e:
             self.logger.error(f"Validation error: {e}")
-            modification.validation_status = "error"
+            modification.validation_status = OperationResult.ERROR
             modification.validation_errors.append(str(e))
 
     async def _invalidate_agent_cache(self, agent_name: str) -> None:
@@ -661,7 +672,7 @@ class AgentModificationTracker(BaseService):
             # Load active modifications
             active_path = self.persistence_root / "active_modifications.json"
             if active_path.exists():
-                with open(active_path) as f:
+                with active_path.open() as f:
                     data = json.load(f)
                     self.active_modifications = {
                         k: AgentModification.from_dict(v) for k, v in data.items()
@@ -669,7 +680,7 @@ class AgentModificationTracker(BaseService):
 
             # Load modification history
             for history_file in self.history_root.glob("*.json"):
-                with open(history_file) as f:
+                with history_file.open() as f:
                     data = json.load(f)
                     agent_name = data["agent_name"]
                     history = ModificationHistory(agent_name=agent_name)
@@ -699,7 +710,7 @@ class AgentModificationTracker(BaseService):
             active_data = {k: v.to_dict() for k, v in self.active_modifications.items()}
             active_path = self.persistence_root / "active_modifications.json"
 
-            with open(active_path, "w") as f:
+            with active_path.open("w") as f:
                 json.dump(active_data, f, indent=2)
 
             # Save modification history
@@ -714,7 +725,7 @@ class AgentModificationTracker(BaseService):
                 }
 
                 history_path = self.history_root / f"{agent_name}_history.json"
-                with open(history_path, "w") as f:
+                with history_path.open("w") as f:
                     json.dump(history_data, f, indent=2)
 
             self.logger.debug("Saved modification history to disk")
@@ -767,7 +778,7 @@ class AgentModificationTracker(BaseService):
                 if backup_dir.is_dir():
                     metadata_path = backup_dir / "metadata.json"
                     if metadata_path.exists():
-                        with open(metadata_path) as f:
+                        with metadata_path.open() as f:
                             metadata = json.load(f)
                             if metadata.get("backup_time", 0) < cutoff_time:
                                 shutil.rmtree(backup_dir)

claude_mpm/services/async_session_logger.py

@@ -22,18 +22,22 @@ import os
 import sys
 import time
 from dataclasses import asdict, dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from queue import Full, Queue
 from threading import Lock, Thread
 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
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class LogFormat(Enum):
@@ -67,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,
@@ -89,104 +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")
-        )
+        # 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
 
-        # 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
+            # Load configuration from YAML file or use provided config
+            if config is None:
+                config = Config()
+            self.config = config
 
-        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)
-        )
+            # Get response logging configuration section
+            response_config = self.config.get("response_logging", {})
 
-        # 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)
-        )
+            # Apply configuration with parameter overrides
+            self.base_dir = Path(
+                base_dir
+                or response_config.get("session_directory", ".claude-mpm/responses")
+            )
 
-        # Create base directory
-        self.base_dir.mkdir(parents=True, exist_ok=True)
+            # 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
 
-        # Session management
-        self.session_id = self._get_claude_session_id()
+            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)
+            )
 
-        # Async infrastructure
-        self._queue: Queue = Queue(maxsize=self.max_queue_size)
-        self._worker_thread: Optional[Thread] = None
-        self._shutdown = False
-        self._lock = Lock()
+            # 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"
+                    )
 
-        # Statistics
-        self.stats = {
-            "logged": 0,
-            "queued": 0,
-            "dropped": 0,
-            "errors": 0,
-            "avg_write_time_ms": 0.0,
-        }
+            # 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)
+            )
 
-        # Initialize format-specific handlers
-        self._init_format_handler()
+            # 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}"
+            )
 
-        # Start background worker if async enabled
-        if self.enable_async:
-            self._start_worker()
-
-    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
-
-        # Generate timestamp-based session ID
-        session_id = datetime.now().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."""
@@ -323,7 +336,7 @@ class AsyncSessionLogger:
             with gzip.open(file_path, "wt", encoding="utf-8") as f:
                 json.dump(data, f, indent=2, ensure_ascii=False)
         else:
-            with open(file_path, "w", encoding="utf-8") as f:
+            with file_path.open("w", encoding="utf-8") as f:
                 json.dump(data, f, indent=2, ensure_ascii=False)
 
         logger.debug(f"Wrote log entry to {file_path}")
@@ -406,7 +419,7 @@ class AsyncSessionLogger:
             agent_name = metadata["agent"].replace(" ", "_").lower()
 
         # Create timestamp with microsecond precision
-        now = datetime.now()
+        now = datetime.now(timezone.utc)
         timestamp = now.isoformat()
         microseconds = now.microsecond
 
@@ -470,8 +483,19 @@ class AsyncSessionLogger:
         Args:
             timeout: Maximum time to wait for shutdown
         """
+        # Only log shutdown if we're actually shutting down an active logger
+        if self._shutdown:
+            logger.debug("AsyncSessionLogger already shut down")
+            return
+
         if self.enable_async:
-            logger.info("Shutting down async logger")
+            # Only log at INFO level if we actually processed something
+            if self.stats.get("logged", 0) > 0 or self.stats.get("queued", 0) > 0:
+                logger.info(
+                    f"Shutting down async logger (logged: {self.stats.get('logged', 0)}, queued: {self.stats.get('queued', 0)})"
+                )
+            else:
+                logger.debug("Shutting down async logger (no activity)")
 
             # Signal shutdown
             self._shutdown = True
@@ -483,8 +507,18 @@ class AsyncSessionLogger:
                 if self._worker_thread.is_alive():
                     logger.warning("Worker thread did not shutdown cleanly")
 
-            # Log final statistics
-            logger.info(f"Logger stats: {self.stats}")
+            # Log final statistics only if we actually logged something
+            if self.stats.get("logged", 0) > 0:
+                logger.info(f"AsyncSessionLogger final stats: {self.stats}")
+            elif self.stats.get("queued", 0) > 0 or self.stats.get("dropped", 0) > 0:
+                logger.debug(
+                    f"AsyncSessionLogger stats (incomplete session): {self.stats}"
+                )
+            else:
+                # Use debug level when nothing was logged
+                logger.debug(
+                    f"AsyncSessionLogger stats (no sessions logged): {self.stats}"
+                )
 
     def get_stats(self) -> Dict[str, Any]:
         """Get logger statistics."""
@@ -492,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."""