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

claude_mpm/core/log_manager.py

@@ -16,18 +16,25 @@ DESIGN DECISIONS:
 
 import asyncio
 import json
-import logging
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from queue import Full, Queue
 from threading import Lock, Thread
 from typing import Any, Dict, Optional
 
+from claude_mpm.core.logging_utils import get_logger
+
 from ..core.config import Config
 from ..core.constants import SystemLimits
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
+
+# Import cleanup utility for automatic cleanup
+try:
+    from ..utils.log_cleanup import run_cleanup_on_startup
+except ImportError:
+    run_cleanup_on_startup = None
 
 
 class LogManager:
@@ -76,6 +83,9 @@ class LogManager:
         # Start background threads
         self._start_background_threads()
 
+        # Run automatic cleanup on startup if enabled
+        self._run_startup_cleanup()
+
     def _setup_logging_config(self):
         """Load and setup logging configuration from config."""
         logging_config = self.config.get("logging", {})
@@ -107,6 +117,56 @@ class LogManager:
         if not self.base_log_dir.is_absolute():
             self.base_log_dir = Path.cwd() / self.base_log_dir
 
+    def _run_startup_cleanup(self):
+        """Run automatic log cleanup on startup if enabled."""
+        if run_cleanup_on_startup is None:
+            return  # Cleanup utility not available
+
+        # Check environment variable to skip cleanup (for configure command)
+        import os
+
+        if os.environ.get("CLAUDE_MPM_SKIP_CLEANUP", "0") == "1":
+            logger.debug("Startup cleanup skipped (CLAUDE_MPM_SKIP_CLEANUP=1)")
+            return
+
+        try:
+            # Get cleanup configuration
+            cleanup_config = self.config.get("log_cleanup", {})
+
+            # Check if automatic cleanup is enabled (default: True)
+            if not cleanup_config.get("auto_cleanup_enabled", True):
+                logger.debug("Automatic log cleanup is disabled")
+                return
+
+            # Convert hours to days for cleanup utility
+            cleanup_params = {
+                "auto_cleanup_enabled": True,
+                "session_retention_days": self.retention_hours.get("sessions", 168)
+                // 24,
+                "archive_retention_days": cleanup_config.get(
+                    "archive_retention_days", 30
+                ),
+                "log_retention_days": cleanup_config.get("log_retention_days", 14),
+            }
+
+            # Run cleanup in background thread to avoid blocking startup
+            def cleanup_task():
+                try:
+                    result = run_cleanup_on_startup(self.base_log_dir, cleanup_params)
+                    if result:
+                        logger.debug(
+                            f"Startup cleanup completed: "
+                            f"Removed {result.get('total_removed', 0)} items"
+                        )
+                except Exception as e:
+                    logger.debug(f"Startup cleanup failed: {e}")
+
+            cleanup_thread = Thread(target=cleanup_task, daemon=True)
+            cleanup_thread.start()
+
+        except Exception as e:
+            logger.debug(f"Could not run startup cleanup: {e}")
+
     def _start_background_threads(self):
         """Start background threads for async operations."""
         with self._lock:
@@ -139,7 +199,7 @@ class LogManager:
                 finally:
                     self.write_queue.task_done()
 
-            except:
+            except Exception:
                 continue  # Timeout or other error, continue loop
 
     def _process_cleanup_queue(self):
@@ -159,7 +219,7 @@ class LogManager:
                 finally:
                     self.cleanup_queue.task_done()
 
-            except:
+            except Exception:
                 continue  # Timeout or other error, continue loop
 
     async def setup_logging(self, log_type: str) -> Path:
@@ -244,7 +304,7 @@ class LogManager:
             return 0
 
         # Calculate cutoff time
-        cutoff_time = datetime.now() - timedelta(hours=retention_hours)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
 
         # Schedule async cleanup
         deleted_count = await self._async_cleanup(directory, pattern, cutoff_time)
@@ -285,7 +345,9 @@ class LogManager:
 
                     try:
                         # Check file modification time
-                        mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
+                        mtime = datetime.fromtimestamp(
+                            file_path.stat().st_mtime, tz=timezone.utc
+                        )
                         if mtime < cutoff_time:
                             file_path.unlink()
                             deleted_count += 1
@@ -318,7 +380,7 @@ class LogManager:
             return 0
 
         # Calculate cutoff time
-        cutoff_time = datetime.now() - timedelta(hours=retention_hours)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
         deleted_count = 0
 
         try:
@@ -334,7 +396,9 @@ class LogManager:
 
                 try:
                     # Check file modification time
-                    mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
+                    mtime = datetime.fromtimestamp(
+                        file_path.stat().st_mtime, tz=timezone.utc
+                    )
                     if mtime < cutoff_time:
                         file_path.unlink()
                         deleted_count += 1
@@ -352,27 +416,33 @@ class LogManager:
         """
         One-time migration to move existing MPM logs to new subdirectory.
 
-        Moves mpm_*.log files from .claude-mpm/logs/ to .claude-mpm/logs/mpm/
+        Moves mpm_*.log files from old locations to .claude-mpm/logs/mpm/
         """
         try:
-            old_location = self.base_log_dir
+            # Check old possible locations (including incorrectly created ones)
+            old_locations = [
+                Path.cwd() / "logs",  # Incorrectly created in project root
+                Path.cwd() / ".claude-mpm" / "logs",  # Correct base location
+                self.base_log_dir,  # Current base location (.claude-mpm/logs/)
+            ]
             new_location = self.base_log_dir / "mpm"
 
-            # Only proceed if old location exists and has MPM logs
-            if not old_location.exists():
-                return
-
-            # Find all MPM log files in the old location
-            mpm_logs = list(old_location.glob("mpm_*.log"))
+            # Collect all MPM logs from all old locations
+            all_mpm_logs = []
+            for old_location in old_locations:
+                if old_location.exists() and old_location != new_location:
+                    # Find all MPM log files in this location
+                    mpm_logs = list(old_location.glob("mpm_*.log"))
+                    all_mpm_logs.extend(mpm_logs)
 
-            if not mpm_logs:
+            if not all_mpm_logs:
                 return  # No logs to migrate
 
             # Ensure new directory exists
             new_location.mkdir(parents=True, exist_ok=True)
 
             migrated_count = 0
-            for log_file in mpm_logs:
+            for log_file in all_mpm_logs:
                 try:
                     # Move file to new location
                     new_path = new_location / log_file.name
@@ -410,7 +480,7 @@ class LogManager:
             prompts_dir = await self.setup_logging("prompts")
 
             # Generate filename with timestamp
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f")[
                 :-3
             ]  # Microseconds to milliseconds
 
@@ -436,7 +506,7 @@ class LogManager:
 
             # Prepare prompt data
             prompt_data = {
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "type": prompt_type,
                 "content": content,
                 "metadata": metadata or {},
@@ -472,12 +542,12 @@ class LogManager:
 
                 if extension == ".json":
                     # JSON files also get structured metadata for consistency
-                    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)
                 # For markdown or text files
                 elif isinstance(data, dict):
                     # Write as formatted markdown with metadata
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         f.write("---\n")
                         f.write(f"timestamp: {data.get('timestamp', 'unknown')}\n")
                         f.write(f"type: {data.get('type', 'unknown')}\n")
@@ -489,7 +559,7 @@ class LogManager:
                         f.write(data.get("content", ""))
                 else:
                     # Write content directly
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         f.write(str(data))
             except Exception as e:
                 logger.error(f"Failed to write {file_path}: {e}")
@@ -509,16 +579,18 @@ class LogManager:
             message: Log message to write
             level: Log level (INFO, WARNING, ERROR, DEBUG)
         """
-        timestamp = datetime.now().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
         log_entry = f"[{timestamp}] [{level}] {message}\n"
 
         # Get appropriate log file based on context
         log_dir = self._get_log_directory("mpm")
-        log_file = log_dir / f"mpm_{datetime.now().strftime('%Y%m%d')}.log"
+        log_file = log_dir / f"mpm_{datetime.now(timezone.utc).strftime('%Y%m%d')}.log"
 
         def write_task():
             try:
-                with open(log_file, "a", encoding="utf-8") as f:
+                # Ensure directory exists before writing (race condition with cleanup)
+                log_dir.mkdir(parents=True, exist_ok=True)
+                with log_file.open("a", encoding="utf-8") as f:
                     f.write(log_entry)
             except Exception as e:
                 logger.error(f"Failed to write log: {e}")
@@ -594,7 +666,7 @@ class LogManager:
         try:
             self.write_queue.put_nowait(None)
             self.cleanup_queue.put_nowait(None)
-        except:
+        except Exception:
             pass
 
         # Wait for threads to finish

claude_mpm/core/logger.py

@@ -14,7 +14,7 @@ import sys
 import threading
 import time
 from collections import defaultdict
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -84,7 +84,7 @@ class StreamingHandler(logging.StreamHandler):
 
         except (KeyboardInterrupt, SystemExit):
             raise
-        except:
+        except Exception:
             self.handleError(record)
 
     def finalize_info_line(self):
@@ -232,12 +232,12 @@ def setup_logging(
             if log_dir is None:
                 # Use deployment root for logs to keep everything centralized
                 deployment_root = get_project_root()
-                log_dir = deployment_root / ".claude-mpm" / "logs"
+                log_dir = deployment_root / ".claude-mpm" / "logs" / "mpm"
 
             log_dir.mkdir(parents=True, exist_ok=True)
 
             # Create timestamped log file
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             log_file = log_dir / f"mpm_{timestamp}.log"
 
             file_handler = logging.FileHandler(log_file)
@@ -485,8 +485,8 @@ class ProjectLogger:
                 path.mkdir(parents=True, exist_ok=True)
 
         # Create session directory
-        self.session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
-        self.session_start_time = datetime.now()
+        self.session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        self.session_start_time = datetime.now(timezone.utc)
         self.session_dir = self.dirs["logs_sessions"] / self.session_id
         self.session_dir.mkdir(parents=True, exist_ok=True)
 
@@ -513,7 +513,7 @@ class ProjectLogger:
         if self.log_level == LogLevel.OFF:
             return
 
-        timestamp = datetime.now().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
         log_entry = {
             "timestamp": timestamp,
             "level": level,
@@ -523,9 +523,10 @@ class ProjectLogger:
 
         # Write to daily log file
         log_file = (
-            self.dirs["logs_system"] / f"{datetime.now().strftime('%Y%m%d')}.jsonl"
+            self.dirs["logs_system"]
+            / f"{datetime.now(timezone.utc).strftime('%Y%m%d')}.jsonl"
         )
-        with open(log_file, "a") as f:
+        with log_file.open("a") as f:
             f.write(json.dumps(log_entry) + "\n")
 
     def log_agent_invocation(
@@ -543,10 +544,10 @@ class ProjectLogger:
         if self.log_level == LogLevel.OFF:
             return
 
-        timestamp = datetime.now().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
 
         # Update statistics
-        today = datetime.now().strftime("%Y-%m-%d")
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
         self.stats[today]["total_calls"] += 1
         self.stats[today]["total_tokens"] += tokens
         self.stats[today]["total_time_seconds"] += execution_time
@@ -576,8 +577,10 @@ class ProjectLogger:
         agent_log_dir = self.dirs["logs_agents"] / agent.lower()
         agent_log_dir.mkdir(exist_ok=True)
 
-        daily_log = agent_log_dir / f"{datetime.now().strftime('%Y%m%d')}.jsonl"
-        with open(daily_log, "a") as f:
+        daily_log = (
+            agent_log_dir / f"{datetime.now(timezone.utc).strftime('%Y%m%d')}.jsonl"
+        )
+        with daily_log.open("a") as f:
             f.write(json.dumps(log_entry) + "\n")
 
     def get_session_summary(self) -> Dict[str, Any]:
@@ -586,7 +589,9 @@ class ProjectLogger:
             "session_id": self.session_id,
             "session_dir": str(self.session_dir),
             "start_time": self.session_id,
-            "stats": self.stats.get(datetime.now().strftime("%Y-%m-%d"), {}),
+            "stats": self.stats.get(
+                datetime.now(timezone.utc).strftime("%Y-%m-%d"), {}
+            ),
         }
 
 

claude_mpm/core/logging_config.py

@@ -24,6 +24,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logger import (
     JsonFormatter,
     finalize_streaming_logs,
@@ -234,7 +235,10 @@ def log_operation(
             execution_time = time.time() - start_time
             logger.info(
                 f"Completed {operation}",
-                extra={"execution_time": execution_time, "status": "success"},
+                extra={
+                    "execution_time": execution_time,
+                    "status": OperationResult.SUCCESS,
+                },
             )
         except Exception as e:
             execution_time = time.time() - start_time
@@ -242,7 +246,7 @@ def log_operation(
                 f"Failed {operation}: {e}",
                 extra={
                     "execution_time": execution_time,
-                    "status": "failure",
+                    "status": OperationResult.FAILED,
                     "error": str(e),
                 },
             )