crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/logging.py

@@ -1,99 +1,145 @@
-import logging
-import sys
+"""Crackerjack logging compatibility layer using ACB's logger.
+
+This module provides backward compatibility with Crackerjack's logging API
+while delegating to ACB's logger system. It maintains the same public API
+for LoggingContext, get_logger(), and other utilities.
+"""
+
+from __future__ import annotations
+
 import time
-import typing as t
 import uuid
+from collections.abc import Callable
 from contextvars import ContextVar
 from pathlib import Path
 from types import TracebackType
 from typing import Any
 
-import structlog
-from structlog.types import EventDict, Processor
+# Use ACB's Logger instead of loguru directly
+from acb.logger import Logger
 
-correlation_id: ContextVar[str | None] = ContextVar("correlation_id", default=None)
+_correlation_id_var: ContextVar[str | None] = ContextVar(
+    "crackerjack_correlation_id",
+    default=None,
+)
 
+_logger_cache: dict[str, Any] = {}
 
-def set_correlation_id(cid: str) -> None:
-    correlation_id.set(cid)
 
+def _get_acb_logger() -> Logger:
+    """Get ACB logger instance from dependency injection."""
+    # Create a new logger instance directly
+    # ACB's Logger class is already properly initialized
+    try:
+        # Attempt to get logger via ACB's dependency injection
+        logger = Logger()
+        # If Logger is a tuple (dependency injection marker), we need to handle it differently
+        if isinstance(logger, tuple):
+            # For now, fall back to a basic logger configuration
+            # In a proper ACB setup, this would be handled by the dependency system
 
-def get_correlation_id() -> str:
-    cid = correlation_id.get()
-    if cid is None:
-        cid = str(uuid.uuid4())[:8]
-        correlation_id.set(cid)
-    return cid
+            from loguru import logger as loguru_logger
+
+            return loguru_logger.opt(depth=1)
+        return logger
+    except Exception:
+        # If there's an issue with ACB logger, fall back to loguru
+        from loguru import logger as loguru_logger
 
+        return loguru_logger.opt(depth=1)
 
-def add_correlation_id(_: Any, __: Any, event_dict: EventDict) -> EventDict:
-    event_dict["correlation_id"] = get_correlation_id()
-    return event_dict
 
+def _generate_correlation_id() -> str:
+    """Generate a unique correlation ID."""
+    return uuid.uuid4().hex[:8]
 
-def add_timestamp(_: Any, __: Any, event_dict: EventDict) -> EventDict:
-    event_dict["timestamp"] = time.strftime("%Y-%m-%dT%H: %M: %S.%f")[:-3] + "Z"
-    return event_dict
+
+def get_correlation_id() -> str:
+    """Get or create correlation ID for current context."""
+    correlation = _correlation_id_var.get()
+    if correlation is None:
+        correlation = _generate_correlation_id()
+        _correlation_id_var.set(correlation)
+    return correlation
+
+
+def set_correlation_id(correlation_id: str) -> None:
+    """Set correlation ID for current context."""
+    _correlation_id_var.set(correlation_id)
 
 
 def setup_structured_logging(
+    *,
     level: str = "INFO",
-    json_output: bool = True,
+    json_output: bool = False,
     log_file: Path | None = None,
 ) -> None:
-    processors: list[Processor] = [
-        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())
+    """Setup structured logging using ACB's logger.
+
+    This function is maintained for backward compatibility but now uses
+    ACB's logger configuration system.
+    """
+    # ACB logger is already configured via adapters
+    # This function is kept for API compatibility but delegates to ACB
+    _get_acb_logger()
+
+    # ACB's logger is already configured, but we can adjust settings if needed
+    # The actual configuration is handled by ACB's adapter system
+    pass
+
+
+def get_logger(name: str) -> Any:
+    """Get a logger bound to a specific name using ACB's logger.
+
+    This function provides backward compatibility with Crackerjack's
+    logging API while using ACB's logger internally.
+    """
+    # Check cache first for performance
+    if name in _logger_cache:
+        return _logger_cache[name]
+
+    # Get ACB logger and bind with context
+    acb_logger = _get_acb_logger()
+
+    # Check if the logger has a bind method (ACB logger) or if it's a loguru logger
+    if hasattr(acb_logger, "bind"):
+        logger_with_context = acb_logger.bind(logger=name)
+
+        # Add correlation ID if available
+        correlation_id = get_correlation_id()
+        if correlation_id:
+            logger_with_context = logger_with_context.bind(
+                correlation_id=correlation_id
+            )
     else:
-        processors.append(structlog.dev.ConsoleRenderer(colors=True))
-
-    structlog.configure(
-        processors=processors,
-        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: list[logging.Handler] = [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)
+        # For loguru logger, we can add context via patch or extra
+        logger_with_context = acb_logger
+        # Add logger name to extra so it shows up in logs
+        import loguru
+
+        if isinstance(logger_with_context, loguru.Logger):
+            logger_with_context = acb_logger.patch(
+                lambda record: record["extra"].update({"logger": name})
+            )
+        else:
+            # If it's not even a loguru logger, just return as is
+            logger_with_context = acb_logger
 
-    logging.basicConfig(
-        level=log_level,
-        handlers=handlers,
-        format="%(message)s",
-    )
+    # Cache the logger for reuse
+    _logger_cache[name] = logger_with_context
+    return logger_with_context
 
 
-def get_logger(name: str) -> structlog.BoundLogger:
-    logger: structlog.BoundLogger = structlog.get_logger(name)
-    return logger
+class LoggingContext:
+    """Context manager for operation logging with correlation IDs.
 
+    Uses ACB's logger internally while maintaining Crackerjack's API.
+    """
 
-class LoggingContext:
     def __init__(self, operation: str, **kwargs: Any) -> None:
         self.operation = operation
         self.kwargs = kwargs
-        self.correlation_id = str(uuid.uuid4())[:8]
+        self.correlation_id = _generate_correlation_id()
         self.logger = get_logger("crackerjack.context")
         self.start_time = time.time()
 
@@ -131,9 +177,14 @@ class LoggingContext:
 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:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator for performance logging using ACB's logger.
+
+    Maintains Crackerjack's API while delegating to ACB's logger.
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        def wrapper(*args: Any, **func_kwargs: Any) -> Any:
             logger = get_logger(f"crackerjack.perf.{func.__name__}")
             start_time = time.time()
 
@@ -168,6 +219,7 @@ def log_performance(
     return decorator
 
 
+# Module-level logger instances using ACB's logger
 hook_logger = get_logger("crackerjack.hooks")
 test_logger = get_logger("crackerjack.tests")
 config_logger = get_logger("crackerjack.config")

crackerjack/services/lsp_client.py

@@ -1,10 +1,12 @@
 import asyncio
+import concurrent.futures
 import subprocess
 import typing as t
 from pathlib import Path
 from typing import Protocol
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 from rich.progress import (
     BarColumn,
     Progress,
@@ -36,8 +38,9 @@ class ProgressCallback(Protocol):
 class RealTimeTypingFeedback:
     """Provides real-time feedback during type checking operations."""
 
-    def __init__(self, console: Console | None = None) -> None:
-        self.console = console or Console()
+    @depends.inject
+    def __init__(self, console: Inject[Console]) -> None:
+        self.console = console
         self._total_errors = 0
         self._files_checked = 0
 
@@ -143,8 +146,9 @@ class JSONRPCClient:
 class LSPClient:
     """Client for communicating with Zuban LSP server."""
 
-    def __init__(self, console: Console | None = None) -> None:
-        self.console = console or Console()
+    @depends.inject
+    def __init__(self, console: Inject[Console]) -> None:
+        self.console = console
         self._server_port: int | None = None
         self._server_host: str = "127.0.0.1"
         self._lsp_service: ZubanLSPService | None = None
@@ -243,7 +247,7 @@ class LSPClient:
     ) -> dict[str, list[dict[str, t.Any]]]:
         """Check files with progress display."""
         diagnostics = {}
-        feedback = RealTimeTypingFeedback(self.console)
+        feedback = RealTimeTypingFeedback()
 
         with feedback.create_progress_display() as progress:
             task = progress.add_task("Type checking files...", total=total_files)
@@ -300,8 +304,6 @@ class LSPClient:
             try:
                 asyncio.get_running_loop()
                 # We're already in an async context, use a thread pool
-                import concurrent.futures
-
                 with concurrent.futures.ThreadPoolExecutor() as executor:
                     future = executor.submit(
                         self._run_async_lsp_check,
@@ -409,7 +411,7 @@ class LSPClient:
     ) -> dict[str, list[dict[str, t.Any]]]:
         """Process files with progress display."""
         diagnostics = {}
-        feedback = RealTimeTypingFeedback(self.console)
+        feedback = RealTimeTypingFeedback()
 
         with feedback.create_progress_display() as progress:
             task = progress.add_task("LSP type checking files...", total=total_files)
@@ -508,8 +510,6 @@ class LSPClient:
 
     def _execute_zuban_check(self, file_path: str) -> subprocess.CompletedProcess[str]:
         """Execute zuban check command for a file."""
-        import subprocess
-
         return subprocess.run(
             ["zuban", "check", file_path],
             capture_output=True,
@@ -610,7 +610,7 @@ class LSPClient:
         if not python_files:
             return {}, "📁 No Python files found to check"
 
-        feedback = RealTimeTypingFeedback(self.console)
+        feedback = RealTimeTypingFeedback()
 
         self.console.print(
             f"🔍 Starting type check of {len(python_files)} files...", style="bold blue"

crackerjack/services/memory_optimizer.py

@@ -1,6 +1,8 @@
 import gc
+import os
 import sys
 import time
+import tracemalloc
 import typing as t
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -9,7 +11,9 @@ from threading import Lock
 from typing import Any
 from weakref import WeakSet
 
-from crackerjack.services.logging import get_logger
+import psutil
+from acb.depends import Inject, depends
+from acb.logger import Logger
 
 
 @dataclass
@@ -27,6 +31,7 @@ class LazyLoader:
     def __init__(
         self,
         factory: Callable[[], Any],
+        logger: Logger,
         name: str = "unnamed",
         auto_dispose: bool = True,
     ):
@@ -37,8 +42,7 @@ class LazyLoader:
         self._loaded = False
         self._lock = Lock()
         self._access_count = 0
-        self._last_access = time.time()
-        self._logger = get_logger(f"crackerjack.lazy_loader.{name}")
+        self._logger = logger
 
         MemoryOptimizer.get_instance().register_lazy_object(self)
 
@@ -102,6 +106,7 @@ class ResourcePool:
     def __init__(
         self,
         factory: Callable[[], Any],
+        logger: Logger,
         max_size: int = 5,
         name: str = "unnamed",
     ):
@@ -113,7 +118,7 @@ class ResourcePool:
         self._lock = Lock()
         self._created_count = 0
         self._reused_count = 0
-        self._logger = get_logger(f"crackerjack.resource_pool.{name}")
+        self._logger = logger
 
     def acquire(self) -> Any:
         with self._lock:
@@ -177,11 +182,11 @@ class ResourcePool:
 
 
 class MemoryProfiler:
-    def __init__(self) -> None:
+    def __init__(self, logger: Logger) -> None:
         self._start_memory = 0.0
         self._peak_memory = 0.0
         self._measurements: list[tuple[float, float]] = []
-        self._logger = get_logger("crackerjack.memory_profiler")
+        self._logger = logger
 
     def start_profiling(self) -> None:
         self._start_memory = self._get_memory_usage()
@@ -218,16 +223,10 @@ class MemoryProfiler:
 
     def _get_memory_usage(self) -> float:
         try:
-            import os
-
-            import psutil
-
             process = psutil.Process(os.getpid())
             memory_mb: float = process.memory_info().rss / 1024 / 1024
             return memory_mb
         except ImportError:
-            import tracemalloc
-
             if tracemalloc.is_tracing():
                 current, _peak = tracemalloc.get_traced_memory()
                 return current / 1024 / 1024
@@ -239,16 +238,20 @@ class MemoryOptimizer:
     _instance: t.Optional["MemoryOptimizer"] = None
     _lock = Lock()
 
-    def __init__(self) -> None:
+    @depends.inject
+    def __init__(
+        self,
+        logger: Inject[Logger],
+    ) -> None:
         self._lazy_objects: WeakSet[t.Any] = WeakSet()
         self._resource_pools: dict[str, ResourcePool] = {}
-        self._profiler = MemoryProfiler()
+        self._profiler = MemoryProfiler(logger=logger)
         self._stats_lock = Lock()
         self._lazy_created_count = 0
         self._lazy_loaded_count = 0
         self._gc_threshold = 100
         self._auto_gc = True
-        self._logger = get_logger("crackerjack.memory_optimizer")
+        self._logger = logger
 
     @classmethod
     def get_instance(cls) -> "MemoryOptimizer":
@@ -356,7 +359,9 @@ def lazy_property(factory: t.Callable[[], t.Any]) -> property:
         attr_name = f"_lazy_{factory.__name__}"
 
         if not hasattr(self, attr_name):
-            loader = LazyLoader(factory, factory.__name__)
+            # Get logger from DI instead of MemoryOptimizer to avoid circular dependency
+            logger = depends.get_sync(Logger)
+            loader = LazyLoader(factory, logger=logger, name=factory.__name__)
             setattr(self, attr_name, loader)
 
         return getattr(self, attr_name).get()
@@ -391,12 +396,10 @@ def memory_optimized(func: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
     return wrapper
 
 
-def get_memory_optimizer() -> MemoryOptimizer:
-    return MemoryOptimizer.get_instance()
-
-
 def create_lazy_service(factory: Callable[[], Any], name: str) -> LazyLoader:
-    return LazyLoader(factory, name)
+    # Get logger from DI instead of MemoryOptimizer to avoid circular dependency
+    logger = depends.get_sync(Logger)
+    return LazyLoader(factory, logger=logger, name=name)
 
 
 def create_resource_pool(
@@ -404,6 +407,8 @@ def create_resource_pool(
     max_size: int = 5,
     name: str = "unnamed",
 ) -> ResourcePool:
-    pool = ResourcePool(factory, max_size, name)
+    # Get logger from DI instead of MemoryOptimizer to avoid circular dependency
+    logger = depends.get_sync(Logger)
+    pool = ResourcePool(factory, logger=logger, max_size=max_size, name=name)
     MemoryOptimizer.get_instance().register_resource_pool(name, pool)
     return pool

crackerjack/services/monitoring/README.md

@@ -0,0 +1,30 @@
+# Monitoring Services
+
+System health, performance metrics, and error pattern analysis services.
+
+## Services
+
+- **`health_metrics.py`** - System health monitoring and metric collection
+- **`metrics.py`** - Performance metrics aggregation and reporting
+- **`dependency_monitor.py`** - Dependency health tracking and version monitoring
+- **`error_pattern_analyzer.py`** - Error pattern detection and analysis
+- **`performance_benchmarks.py`** - Performance baseline tracking and regression detection
+
+## Features
+
+- **Health Checks** - Real-time system health status
+- **Performance Tracking** - Benchmark execution times and resource usage
+- **Error Analysis** - Pattern detection in test failures and build errors
+- **Dependency Monitoring** - Track outdated or vulnerable dependencies
+- **Metric Aggregation** - Collect and report quality metrics
+
+## Integration
+
+These services are used throughout Crackerjack for:
+
+- MCP server health endpoints
+- Test execution monitoring
+- Quality trend analysis
+- Performance regression detection
+
+See parent `services/README.md` for service architecture details.

crackerjack/services/monitoring/__init__.py

@@ -0,0 +1,9 @@
+"""Monitoring and telemetry services."""
+
+from .dependency_monitor import *  # noqa: F401,F403
+from .error_pattern_analyzer import *  # noqa: F401,F403
+from .health_metrics import *  # noqa: F401,F403
+from .metrics import *  # noqa: F401,F403
+from .performance_benchmarks import *  # noqa: F401,F403
+from .performance_cache import *  # noqa: F401,F403
+from .performance_monitor import *  # noqa: F401,F403