crackerjack 0.30.3__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/services/log_manager.py

@@ -0,0 +1,286 @@
+import logging
+import os
+import shutil
+import time
+from contextlib import suppress
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+class LogManager:
+    def __init__(self, app_name: str = "crackerjack") -> None:
+        self.app_name = app_name
+        self._log_dir = self._get_log_directory()
+        self._setup_directories()
+
+    def _get_log_directory(self) -> Path:
+        cache_home = os.environ.get("XDG_CACHE_HOME")
+        base_dir = Path(cache_home) if cache_home else Path.home() / ".cache"
+
+        return base_dir / self.app_name / "logs"
+
+    def _setup_directories(self) -> None:
+        self._log_dir.mkdir(parents=True, exist_ok=True)
+
+        (self._log_dir / "debug").mkdir(exist_ok=True)
+        (self._log_dir / "error").mkdir(exist_ok=True)
+        (self._log_dir / "audit").mkdir(exist_ok=True)
+
+    @property
+    def log_dir(self) -> Path:
+        return self._log_dir
+
+    @property
+    def debug_dir(self) -> Path:
+        return self._log_dir / "debug"
+
+    @property
+    def error_dir(self) -> Path:
+        return self._log_dir / "error"
+
+    @property
+    def audit_dir(self) -> Path:
+        return self._log_dir / "audit"
+
+    def create_debug_log_file(self, session_id: str | None = None) -> Path:
+        timestamp = int(time.time())
+        if session_id:
+            filename = f"debug-{timestamp}-{session_id}.log"
+        else:
+            filename = f"debug-{timestamp}.log"
+
+        return self.debug_dir / filename
+
+    def create_error_log_file(self, error_type: str = "general") -> Path:
+        timestamp = int(time.time())
+        filename = f"error-{error_type}-{timestamp}.log"
+        return self.error_dir / filename
+
+    def rotate_logs(
+        self,
+        log_dir: Path,
+        pattern: str,
+        max_files: int = 10,
+        max_age_days: int = 30,
+    ) -> int:
+        if not log_dir.exists():
+            return 0
+
+        removed_count = 0
+        cutoff_time = time.time() - (max_age_days * 24 * 60 * 60)
+
+        log_files = sorted(
+            log_dir.glob(pattern),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+
+        for i, log_file in enumerate(log_files):
+            should_remove = False
+            reason = ""
+
+            if i >= max_files:
+                should_remove = True
+                reason = f"exceeds max files ({max_files})"
+
+            elif log_file.stat().st_mtime < cutoff_time:
+                should_remove = True
+                reason = f"older than {max_age_days} days"
+
+            if should_remove:
+                with suppress(OSError, PermissionError):
+                    log_file.unlink()
+                    removed_count += 1
+                    console.print(
+                        f"[dim]🗑️ Removed old log: {log_file.name} ({reason})[/dim]",
+                    )
+
+        return removed_count
+
+    def cleanup_all_logs(
+        self,
+        debug_max_files: int = 10,
+        error_max_files: int = 20,
+        audit_max_files: int = 50,
+        max_age_days: int = 30,
+    ) -> dict[str, int]:
+        results = {}
+
+        results["debug"] = self.rotate_logs(
+            self.debug_dir,
+            "debug-*.log",
+            debug_max_files,
+            max_age_days,
+        )
+
+        results["error"] = self.rotate_logs(
+            self.error_dir,
+            "error-*.log",
+            error_max_files,
+            max_age_days,
+        )
+
+        results["audit"] = self.rotate_logs(
+            self.audit_dir,
+            "audit-*.log",
+            audit_max_files,
+            max_age_days,
+        )
+
+        return results
+
+    def migrate_legacy_logs(
+        self,
+        source_dir: Path,
+        dry_run: bool = False,
+    ) -> dict[str, int]:
+        if not source_dir.exists():
+            return {"moved": 0, "failed": 0, "found": 0}
+
+        debug_pattern = "crackerjack-debug-*.log"
+        legacy_files = list(source_dir.glob(debug_pattern))
+
+        results = {"found": len(legacy_files), "moved": 0, "failed": 0}
+
+        if not legacy_files:
+            console.print("[green]✅ No legacy log files found to migrate[/green]")
+            return results
+
+        console.print(
+            f"[yellow]📦 Found {len(legacy_files)} legacy debug log files to migrate[/yellow]",
+        )
+
+        for legacy_file in legacy_files:
+            try:
+                parts = legacy_file.stem.split(" - ")
+                if len(parts) >= 3 and parts[-1].isdigit():
+                    timestamp = parts[-1]
+                else:
+                    timestamp = str(int(legacy_file.stat().st_mtime))
+
+                new_filename = f"debug-{timestamp}-migrated.log"
+                new_path = self.debug_dir / new_filename
+
+                if dry_run:
+                    console.print(
+                        f"[cyan]📋 Would move: {legacy_file.name} → {new_filename}[/cyan]",
+                    )
+                    results["moved"] += 1
+                else:
+                    shutil.move(str(legacy_file), str(new_path))
+                    results["moved"] += 1
+                    console.print(
+                        f"[green]✅ Moved: {legacy_file.name} → {new_filename}[/green]",
+                    )
+
+            except (OSError, ValueError) as e:
+                results["failed"] += 1
+                console.print(
+                    f"[red]❌ Failed to migrate {legacy_file.name}: {e}[/red]",
+                )
+
+        return results
+
+    def get_log_stats(self) -> dict[str, dict[str, int | str]]:
+        stats = {}
+
+        for log_type, log_dir in (
+            ("debug", self.debug_dir),
+            ("error", self.error_dir),
+            ("audit", self.audit_dir),
+        ):
+            if log_dir.exists():
+                files = list(log_dir.glob("*.log"))
+                total_size = sum(f.stat().st_size for f in files if f.exists())
+
+                stats[log_type] = {
+                    "count": len(files),
+                    "size_mb": round(total_size / (1024 * 1024), 2),
+                    "location": str(log_dir),
+                }
+            else:
+                stats[log_type] = {
+                    "count": 0,
+                    "size_mb": 0.0,
+                    "location": str(log_dir),
+                }
+
+        return stats
+
+    def setup_rotating_file_handler(
+        self,
+        logger: logging.Logger,
+        log_type: str = "debug",
+        max_bytes: int = 10 * 1024 * 1024,
+        backup_count: int = 5,
+    ) -> logging.FileHandler:
+        from logging.handlers import RotatingFileHandler
+
+        if log_type == "error":
+            log_dir = self.error_dir
+        elif log_type == "audit":
+            log_dir = self.audit_dir
+        else:
+            log_dir = self.debug_dir
+
+        log_file = log_dir / f"{log_type}.log"
+
+        handler = RotatingFileHandler(
+            log_file,
+            maxBytes=max_bytes,
+            backupCount=backup_count,
+            encoding="utf-8",
+        )
+
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        )
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        return handler
+
+    def print_log_summary(self) -> None:
+        stats = self.get_log_stats()
+
+        console.print("\n[bold]📊 Log File Summary[/bold]")
+        console.print(f"[dim]Location: {self.log_dir}[/dim]")
+
+        total_files = 0
+        total_size = 0.0
+
+        for log_type, data in stats.items():
+            count = (
+                int(data["count"]) if isinstance(data["count"], str) else data["count"]
+            )
+            size = (
+                float(data["size_mb"])
+                if isinstance(data["size_mb"], str)
+                else data["size_mb"]
+            )
+
+            total_files += count
+            total_size += size
+
+            if count > 0:
+                console.print(f" {log_type.capitalize()}: {count} files, {size}MB")
+            else:
+                console.print(f" {log_type.capitalize()}: No files")
+
+        if total_files > 0:
+            console.print(
+                f"\n[bold]Total: {total_files} files, {total_size:.2f}MB[/bold]",
+            )
+        else:
+            console.print("\n[dim]No log files found[/dim]")
+
+
+log_manager = LogManager()
+
+
+def get_log_manager() -> LogManager:
+    return log_manager

crackerjack/services/logging.py

@@ -0,0 +1,174 @@
+import logging
+import sys
+import time
+import typing as t
+import uuid
+from contextvars import ContextVar
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+import structlog
+
+correlation_id: ContextVar[str | None] = ContextVar("correlation_id", default=None)
+
+
+def set_correlation_id(cid: str) -> None:
+    correlation_id.set(cid)
+
+
+def get_correlation_id() -> str:
+    cid = correlation_id.get()
+    if cid is None:
+        cid = str(uuid.uuid4())[:8]
+        correlation_id.set(cid)
+    return cid
+
+
+def add_correlation_id(_: Any, __: Any, event_dict: dict[str, Any]) -> dict[str, Any]:
+    event_dict["correlation_id"] = get_correlation_id()
+    return event_dict
+
+
+def add_timestamp(_: Any, __: Any, event_dict: dict[str, Any]) -> dict[str, Any]:
+    event_dict["timestamp"] = time.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+    return event_dict
+
+
+def setup_structured_logging(
+    level: str = "INFO",
+    json_output: bool = True,
+    log_file: Path | None = None,
+) -> None:
+    processors = [
+        structlog.stdlib.filter_by_level,
+        add_timestamp,
+        add_correlation_id,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+    ]
+
+    if json_output:
+        processors.append(structlog.processors.JSONRenderer())  # type: ignore[arg-type]
+    else:
+        processors.append(structlog.dev.ConsoleRenderer(colors=True))  # type: ignore[arg-type]
+
+    structlog.configure(
+        processors=processors,  # type: ignore[arg-type]
+        wrapper_class=structlog.stdlib.BoundLogger,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    log_level = getattr(logging, level.upper())
+
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+
+    handlers = [console_handler]
+
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(log_level)
+        handlers.append(file_handler)
+
+    logging.basicConfig(
+        level=log_level,
+        handlers=handlers,
+        format="%(message)s",
+    )
+
+
+def get_logger(name: str) -> structlog.BoundLogger:
+    return structlog.get_logger(name)
+
+
+class LoggingContext:
+    def __init__(self, operation: str, **kwargs: Any) -> None:
+        self.operation = operation
+        self.kwargs = kwargs
+        self.correlation_id = str(uuid.uuid4())[:8]
+        self.logger = get_logger("crackerjack.context")
+        self.start_time = time.time()
+
+    def __enter__(self) -> str:
+        set_correlation_id(self.correlation_id)
+        self.logger.info("Operation started", operation=self.operation, **self.kwargs)
+        return self.correlation_id
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        _: TracebackType | None,
+    ) -> None:
+        duration = time.time() - self.start_time
+
+        if exc_type is None:
+            self.logger.info(
+                "Operation completed",
+                operation=self.operation,
+                duration_seconds=round(duration, 3),
+                **self.kwargs,
+            )
+        else:
+            self.logger.error(
+                "Operation failed",
+                operation=self.operation,
+                duration_seconds=round(duration, 3),
+                error=str(exc_val),
+                error_type=exc_type.__name__ if exc_type else None,
+                **self.kwargs,
+            )
+
+
+def log_performance(
+    operation: str,
+    **kwargs: Any,
+) -> t.Callable[[t.Callable[..., t.Any]], t.Callable[..., t.Any]]:
+    def decorator(func: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
+        def wrapper(*args: t.Any, **func_kwargs: t.Any) -> t.Any:
+            logger = get_logger(f"crackerjack.perf.{func.__name__}")
+            start_time = time.time()
+
+            try:
+                result = func(*args, **func_kwargs)
+                duration = time.time() - start_time
+                logger.info(
+                    "Function completed",
+                    operation=operation,
+                    function=func.__name__,
+                    duration_seconds=round(duration, 3),
+                    success=True,
+                    **kwargs,
+                )
+                return result
+            except Exception as e:
+                duration = time.time() - start_time
+                logger.exception(
+                    "Function failed",
+                    operation=operation,
+                    function=func.__name__,
+                    duration_seconds=round(duration, 3),
+                    success=False,
+                    error=str(e),
+                    error_type=type(e).__name__,
+                    **kwargs,
+                )
+                raise
+
+        return wrapper
+
+    return decorator
+
+
+hook_logger = get_logger("crackerjack.hooks")
+test_logger = get_logger("crackerjack.tests")
+config_logger = get_logger("crackerjack.config")
+cache_logger = get_logger("crackerjack.cache")
+security_logger = get_logger("crackerjack.security")
+performance_logger = get_logger("crackerjack.performance")