aiecs 1.0.1__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/infrastructure/monitoring/global_metrics_manager.py

@@ -0,0 +1,212 @@
+"""
+Global Metrics Manager
+
+This module provides a singleton ExecutorMetrics instance that can be shared
+across all components in the application. It follows the same pattern as
+other global managers in the infrastructure layer.
+
+Usage:
+    # In main.py startup:
+    await initialize_global_metrics()
+
+    # In any component:
+    from aiecs.infrastructure.monitoring.global_metrics_manager import get_global_metrics
+    metrics = get_global_metrics()
+"""
+
+import logging
+import asyncio
+import os
+from typing import Optional, Dict, Any
+from .executor_metrics import ExecutorMetrics
+
+logger = logging.getLogger(__name__)
+
+# Global singleton instance
+_global_metrics: Optional[ExecutorMetrics] = None
+_initialization_lock = asyncio.Lock()
+_initialized = False
+
+
+async def initialize_global_metrics(
+    enable_metrics: bool = True,
+    metrics_port: Optional[int] = None,
+    config: Optional[Dict[str, Any]] = None,
+) -> Optional[ExecutorMetrics]:
+    """
+    Initialize the global ExecutorMetrics instance.
+
+    This should be called once during application startup (in main.py lifespan).
+
+    Args:
+        enable_metrics: Whether to enable metrics collection (default: True)
+        metrics_port: Port for metrics server (default: from env or 8001)
+        config: Additional configuration options
+
+    Returns:
+        The initialized ExecutorMetrics instance or None if initialization fails
+
+    Example:
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            # Startup
+            await initialize_global_metrics()
+            yield
+            # Shutdown
+            await close_global_metrics()
+    """
+    global _global_metrics, _initialized
+
+    if _initialized and _global_metrics:
+        logger.info("Global metrics already initialized")
+        return _global_metrics
+
+    async with _initialization_lock:
+        # Double-check after acquiring lock
+        if _initialized and _global_metrics:
+            return _global_metrics
+
+        try:
+            # Determine metrics port
+            if metrics_port is None:
+                metrics_port = int(os.environ.get("METRICS_PORT", "8001"))
+
+            # Check if metrics should be enabled
+            if not enable_metrics:
+                enable_metrics = os.environ.get("ENABLE_METRICS", "true").lower() == "true"
+
+            logger.info(f"Initializing global metrics (port: {metrics_port}, enabled: {enable_metrics})...")
+
+            # Create metrics instance
+            _global_metrics = ExecutorMetrics(enable_metrics=enable_metrics, metrics_port=metrics_port)
+
+            _initialized = True
+            logger.info("✅ Global metrics initialized successfully")
+            return _global_metrics
+
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize global metrics: {e}")
+            logger.warning("Application will continue without metrics (degraded mode)")
+            _global_metrics = None
+            _initialized = False
+            return None
+
+
+def get_global_metrics() -> Optional[ExecutorMetrics]:
+    """
+    Get the global ExecutorMetrics instance.
+
+    Returns:
+        The global ExecutorMetrics instance or None if not initialized
+
+    Raises:
+        RuntimeError: If metrics are requested but not initialized
+
+    Example:
+        metrics = get_global_metrics()
+        if metrics:
+            metrics.record_operation('my_operation', 1)
+    """
+    if _global_metrics is None:
+        logger.warning("Global metrics not initialized - call initialize_global_metrics() first")
+        return None
+
+    return _global_metrics
+
+
+async def close_global_metrics():
+    """
+    Close the global metrics instance.
+
+    This should be called during application shutdown.
+    """
+    global _global_metrics, _initialized
+
+    if _global_metrics:
+        try:
+            # ExecutorMetrics doesn't have a close method, but we can clean up
+            logger.info("Closing global metrics...")
+            _global_metrics = None
+            _initialized = False
+            logger.info("✅ Global metrics closed successfully")
+        except Exception as e:
+            logger.error(f"❌ Error closing global metrics: {e}")
+
+
+def is_metrics_initialized() -> bool:
+    """
+    Check if global metrics are initialized.
+
+    Returns:
+        True if metrics are initialized, False otherwise
+    """
+    return _initialized and _global_metrics is not None
+
+
+def get_metrics_summary() -> Dict[str, Any]:
+    """
+    Get a summary of the global metrics status.
+
+    Returns:
+        Dictionary containing metrics status information
+    """
+    if not is_metrics_initialized():
+        return {
+            "initialized": False,
+            "message": "Global metrics not initialized",
+        }
+
+    if _global_metrics is None:
+        return {
+            "initialized": False,
+            "message": "Global metrics not initialized",
+        }
+    try:
+        return _global_metrics.get_metrics_summary()
+    except Exception as e:
+        return {
+            "initialized": True,
+            "error": str(e),
+            "message": "Failed to get metrics summary",
+        }
+
+
+# Convenience functions for common operations
+def record_operation(
+    operation_type: str,
+    success: bool = True,
+    duration: Optional[float] = None,
+    **kwargs,
+):
+    """Record an operation using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_operation(operation_type, success, duration, **kwargs)
+
+
+def record_duration(operation: str, duration: float, labels: Optional[Dict[str, str]] = None):
+    """Record operation duration using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_duration(operation, duration, labels)
+
+
+def record_operation_success(operation: str, labels: Optional[Dict[str, str]] = None):
+    """Record operation success using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_operation_success(operation, labels)
+
+
+def record_operation_failure(operation: str, error_type: str, labels: Optional[Dict[str, str]] = None):
+    """Record operation failure using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_operation_failure(operation, error_type, labels)
+
+
+def record_retry(operation: str, attempt_number: int):
+    """Record retry using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_retry(operation, attempt_number)

aiecs/infrastructure/monitoring/structured_logger.py

@@ -1,7 +1,7 @@
 """Structured logging setup for aiecs."""
+
 import logging
 import sys
-from typing import Optional
 
 
 def setup_structured_logging(level: str = "INFO", format_type: str = "json") -> None:
@@ -18,14 +18,10 @@ def setup_structured_logging(level: str = "INFO", format_type: str = "json") ->
     # Create formatter
     if format_type.lower() == "json":
         # Simple JSON-like format for now
-        formatter = logging.Formatter(
-            '{"timestamp": "%(asctime)s", "level": "%(levelname)s", "module": "%(name)s", "message": "%(message)s"}'
-        )
+        formatter = logging.Formatter('{"timestamp": "%(asctime)s", "level": "%(levelname)s", "module": "%(name)s", "message": "%(message)s"}')
     else:
         # Standard text format
-        formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
+        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
     # Setup root logger
     root_logger = logging.getLogger()

aiecs/infrastructure/monitoring/tracing_manager.py

@@ -4,7 +4,7 @@ import os
 from typing import Dict, Any, Optional
 import jaeger_client
 import jaeger_client.config
-from opentracing import tracer, Span
+from opentracing import Span
 
 logger = logging.getLogger(__name__)
 
@@ -14,12 +14,16 @@ class TracingManager:
     Specialized handler for distributed tracing and link tracking
     """
 
-    def __init__(self, service_name: str = "service_executor",
-                 jaeger_host: Optional[str] = None,
-                 jaeger_port: Optional[int] = None,
-                 enable_tracing: Optional[bool] = None):
+    def __init__(
+        self,
+        service_name: str = "service_executor",
+        jaeger_host: Optional[str] = None,
+        jaeger_port: Optional[int] = None,
+        enable_tracing: Optional[bool] = None,
+    ):
         self.service_name = service_name
-        # Get configuration from environment variables, use defaults if not available
+        # Get configuration from environment variables, use defaults if not
+        # available
         self.jaeger_host = jaeger_host or os.getenv("JAEGER_AGENT_HOST", "jaeger")
         self.jaeger_port = jaeger_port or int(os.getenv("JAEGER_AGENT_PORT", "6831"))
         self.enable_tracing = enable_tracing if enable_tracing is not None else os.getenv("JAEGER_ENABLE_TRACING", "true").lower() == "true"
@@ -33,18 +37,18 @@ class TracingManager:
         try:
             config = jaeger_client.config.Config(
                 config={
-                    'sampler': {
-                        'type': 'const',
-                        'param': 1,
+                    "sampler": {
+                        "type": "const",
+                        "param": 1,
                     },
-                    'local_agent': {
-                        'reporting_host': self.jaeger_host,
-                        'reporting_port': self.jaeger_port,
+                    "local_agent": {
+                        "reporting_host": self.jaeger_host,
+                        "reporting_port": self.jaeger_port,
                     },
-                    'logging': True,
+                    "logging": True,
                 },
                 service_name=self.service_name,
-                validate=True
+                validate=True,
             )
             self.tracer = config.initialize_tracer()
             logger.info(f"Jaeger tracer initialized for service '{self.service_name}' at {self.jaeger_host}:{self.jaeger_port}")
@@ -53,8 +57,12 @@ class TracingManager:
             self.tracer = None
             self.enable_tracing = False
 
-    def start_span(self, operation_name: str, parent_span: Optional[Span] = None,
-                   tags: Optional[Dict[str, Any]] = None) -> Optional[Span]:
+    def start_span(
+        self,
+        operation_name: str,
+        parent_span: Optional[Span] = None,
+        tags: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Span]:
         """
         Start a tracing span
 
@@ -70,10 +78,7 @@ class TracingManager:
             return None
 
         try:
-            span = self.tracer.start_span(
-                operation_name=operation_name,
-                child_of=parent_span
-            )
+            span = self.tracer.start_span(operation_name=operation_name, child_of=parent_span)
 
             # Set initial tags
             if tags:
@@ -89,8 +94,13 @@ class TracingManager:
             logger.error(f"Error starting span '{operation_name}': {e}")
             return None
 
-    def finish_span(self, span: Optional[Span], tags: Optional[Dict[str, Any]] = None,
-                    logs: Optional[Dict[str, Any]] = None, error: Optional[Exception] = None):
+    def finish_span(
+        self,
+        span: Optional[Span],
+        tags: Optional[Dict[str, Any]] = None,
+        logs: Optional[Dict[str, Any]] = None,
+        error: Optional[Exception] = None,
+    ):
         """
         Finish tracing span
 
@@ -132,6 +142,7 @@ class TracingManager:
             operation_name: Operation name
             tags: Initial tags
         """
+
         def decorator(func):
             @functools.wraps(func)
             async def async_wrapper(*args, **kwargs):
@@ -185,6 +196,7 @@ class TracingManager:
 
             # Return appropriate wrapper based on function type
             import asyncio
+
             if asyncio.iscoroutinefunction(func):
                 return async_wrapper
             else:
@@ -202,29 +214,31 @@ class TracingManager:
             for i, arg in enumerate(args):
                 if isinstance(arg, (str, int, float, bool)):
                     span.set_tag(f"arg_{i}", arg)
-                elif hasattr(arg, '__class__'):
+                elif hasattr(arg, "__class__"):
                     span.set_tag(f"arg_{i}_type", arg.__class__.__name__)
 
             # Add keyword arguments
             for key, value in kwargs.items():
                 if isinstance(value, (str, int, float, bool)):
                     span.set_tag(key, value)
-                elif isinstance(value, dict) and len(str(value)) < 1000:  # Avoid overly large dictionaries
+                # Avoid overly large dictionaries
+                elif isinstance(value, dict) and len(str(value)) < 1000:
                     span.set_tag(f"{key}_json", str(value))
-                elif hasattr(value, '__class__'):
+                elif hasattr(value, "__class__"):
                     span.set_tag(f"{key}_type", value.__class__.__name__)
         except Exception as e:
             logger.debug(f"Error adding function args to span: {e}")
 
-    def trace_database_operation(self, operation: str, table: str = None, query: str = None):
+    def trace_database_operation(self, operation: str, table: Optional[str] = None, query: Optional[str] = None):
         """Database operation tracing decorator"""
+
         def decorator(func):
             @functools.wraps(func)
             async def wrapper(*args, **kwargs):
                 tags = {
                     "component": "database",
                     "db.type": "postgresql",
-                    "db.statement.type": operation
+                    "db.statement.type": operation,
                 }
 
                 if table:
@@ -237,7 +251,10 @@ class TracingManager:
                 try:
                     result = await func(*args, **kwargs)
                     if span:
-                        span.set_tag("db.rows_affected", len(result) if isinstance(result, list) else 1)
+                        span.set_tag(
+                            "db.rows_affected",
+                            len(result) if isinstance(result, list) else 1,
+                        )
                     return result
                 except Exception as e:
                     self.finish_span(span, error=e)
@@ -247,17 +264,19 @@ class TracingManager:
                         self.finish_span(span)
 
             return wrapper
+
         return decorator
 
-    def trace_external_call(self, service_name: str, endpoint: str = None):
+    def trace_external_call(self, service_name: str, endpoint: Optional[str] = None):
         """External service call tracing decorator"""
+
         def decorator(func):
             @functools.wraps(func)
             async def wrapper(*args, **kwargs):
                 tags = {
                     "component": "http",
                     "span.kind": "client",
-                    "peer.service": service_name
+                    "peer.service": service_name,
                 }
 
                 if endpoint:
@@ -280,17 +299,19 @@ class TracingManager:
                         self.finish_span(span)
 
             return wrapper
+
         return decorator
 
     def trace_tool_execution(self, tool_name: str, operation: str):
         """Tool execution tracing decorator"""
+
         def decorator(func):
             @functools.wraps(func)
             async def wrapper(*args, **kwargs):
                 tags = {
                     "component": "tool",
                     "tool.name": tool_name,
-                    "tool.operation": operation
+                    "tool.operation": operation,
                 }
 
                 span = self.start_span(f"tool.{tool_name}.{operation}", tags=tags)
@@ -299,7 +320,7 @@ class TracingManager:
                     result = await func(*args, **kwargs)
                     if span:
                         span.set_tag("tool.success", True)
-                        if hasattr(result, '__len__'):
+                        if hasattr(result, "__len__"):
                             span.set_tag("tool.result_size", len(result))
                     return result
                 except Exception as e:
@@ -312,10 +333,15 @@ class TracingManager:
                         self.finish_span(span)
 
             return wrapper
+
         return decorator
 
-    def create_child_span(self, parent_span: Optional[Span], operation_name: str,
-                         tags: Optional[Dict[str, Any]] = None) -> Optional[Span]:
+    def create_child_span(
+        self,
+        parent_span: Optional[Span],
+        operation_name: str,
+        tags: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Span]:
         """Create child span"""
         if not self.enable_tracing or not parent_span:
             return None
@@ -329,6 +355,7 @@ class TracingManager:
 
         try:
             from opentracing.propagation import Format
+
             self.tracer.inject(span.context, Format.TEXT_MAP, carrier)
         except Exception as e:
             logger.error(f"Error injecting span context: {e}")
@@ -340,6 +367,7 @@ class TracingManager:
 
         try:
             from opentracing.propagation import Format
+
             return self.tracer.extract(Format.TEXT_MAP, carrier)
         except Exception as e:
             logger.error(f"Error extracting span context: {e}")
@@ -372,5 +400,5 @@ class TracingManager:
             "service_name": self.service_name,
             "jaeger_host": self.jaeger_host,
             "jaeger_port": self.jaeger_port,
-            "tracer_initialized": self.tracer is not None
+            "tracer_initialized": self.tracer is not None,
         }

aiecs/infrastructure/persistence/__init__.py

@@ -4,9 +4,22 @@ Contains data persistence and storage infrastructure.
 """
 
 from .database_manager import DatabaseManager
-from .redis_client import RedisClient
+from .redis_client import RedisClient, get_redis_client
+from .context_engine_client import (
+    initialize_context_engine,
+    get_context_engine,
+    close_context_engine,
+    is_context_engine_initialized,
+    reset_context_engine,
+)
 
 __all__ = [
     "DatabaseManager",
     "RedisClient",
+    "get_redis_client",
+    "initialize_context_engine",
+    "get_context_engine",
+    "close_context_engine",
+    "is_context_engine_initialized",
+    "reset_context_engine",
 ]