mcp-mesh 0.7.12__py3-none-any.whl → 0.7.14__py3-none-any.whl

_mcp_mesh/shared/logging_config.py

@@ -2,12 +2,34 @@
 Centralized logging configuration for MCP Mesh runtime.
 
 This module configures logging based on the MCP_MESH_LOG_LEVEL environment variable.
+
+Log Levels:
+    CRITICAL (50) - Fatal errors
+    ERROR    (40) - Errors
+    WARNING  (30) - Warnings
+    INFO     (20) - Normal operation (heartbeat counts, connections)
+    DEBUG    (10) - Debugging info (tool calls, actual issues)
+    TRACE    (5)  - Verbose internals (heartbeat steps, SSE parsing)
 """
 
 import logging
 import os
 import sys
 
+# Define TRACE level (below DEBUG)
+TRACE = 5
+logging.addLevelName(TRACE, "TRACE")
+
+
+def _trace(self, message, *args, **kwargs):
+    """Log a message with TRACE level."""
+    if self.isEnabledFor(TRACE):
+        self._log(TRACE, message, args, **kwargs)
+
+
+# Add trace method to Logger class
+logging.Logger.trace = _trace
+
 
 class SafeStreamHandler(logging.StreamHandler):
     """A stream handler that gracefully handles closed streams."""
@@ -41,6 +63,7 @@ def configure_logging():
 
     # Map string to logging level
     log_levels = {
+        "TRACE": TRACE,
         "DEBUG": logging.DEBUG,
         "INFO": logging.INFO,
         "WARNING": logging.WARNING,
@@ -51,13 +74,16 @@ def configure_logging():
 
     log_level = log_levels.get(log_level_str, logging.INFO)
 
-    # Check if debug mode is enabled
+    # Check if debug mode is enabled (sets DEBUG level)
     debug_mode = os.environ.get("MCP_MESH_DEBUG_MODE", "").lower() in (
         "true",
         "1",
         "yes",
     )
 
+    # Check if trace mode is enabled via log level
+    trace_mode = log_level_str == "TRACE"
+
     # Clear any existing handlers to avoid conflicts
     root_logger = logging.getLogger()
     for handler in root_logger.handlers[:]:
@@ -65,18 +91,32 @@ def configure_logging():
 
     # Configure with safe stream handler for background threads
     handler = SafeStreamHandler(sys.stdout)
-    handler.setLevel(logging.DEBUG)  # Handler allows all, loggers filter
+    handler.setLevel(TRACE)  # Handler allows all levels including TRACE
     handler.setFormatter(logging.Formatter("%(levelname)-8s %(message)s"))
 
     root_logger.addHandler(handler)
 
     # Root logger always INFO - all third-party libs stay quiet
     # This is the allowlist approach: instead of blocklisting noisy loggers one by one,
-    # we keep root at INFO and only elevate mcp-mesh loggers to DEBUG
+    # we keep root at INFO and only elevate mcp-mesh loggers
     root_logger.setLevel(logging.INFO)
 
-    # Only MCP Mesh loggers get DEBUG when debug mode is on
-    if debug_mode:
+    # Suppress noisy third-party loggers (FastMCP/MCP library logs)
+    # These produce verbose INFO logs like "Terminating session: None" and
+    # "Processing request of type CallToolRequest" that clutter debug output
+    logging.getLogger("mcp").setLevel(logging.WARNING)
+    logging.getLogger("mcp.server").setLevel(logging.WARNING)
+    logging.getLogger("mcp.client").setLevel(logging.WARNING)
+    logging.getLogger("fastmcp").setLevel(logging.WARNING)
+
+    # Set MCP Mesh logger levels based on configuration
+    if trace_mode:
+        # TRACE mode: show everything including verbose heartbeat internals
+        logging.getLogger("mesh").setLevel(TRACE)
+        logging.getLogger("mcp_mesh").setLevel(TRACE)
+        logging.getLogger("_mcp_mesh").setLevel(TRACE)
+    elif debug_mode:
+        # DEBUG mode: show debug info but not verbose trace logs
         logging.getLogger("mesh").setLevel(logging.DEBUG)
         logging.getLogger("mcp_mesh").setLevel(logging.DEBUG)
         logging.getLogger("_mcp_mesh").setLevel(logging.DEBUG)
@@ -86,9 +126,152 @@ def configure_logging():
         logging.getLogger("mcp_mesh").setLevel(log_level)
         logging.getLogger("_mcp_mesh").setLevel(log_level)
 
-    # Return the configured level for reference (DEBUG if debug mode, else configured level)
-    return logging.DEBUG if debug_mode else log_level
+    # Return the configured level for reference
+    if trace_mode:
+        return TRACE
+    elif debug_mode:
+        return logging.DEBUG
+    else:
+        return log_level
 
 
 # Configure logging on module import
 _configured_level = configure_logging()
+
+
+# ============================================================================
+# Log Value Formatting Helpers
+# ============================================================================
+
+
+def get_trace_prefix() -> str:
+    """Get trace ID prefix for log lines if tracing is active.
+
+    Returns:
+        String like "[trace=abc12345] " if trace context exists, empty string otherwise.
+    """
+    try:
+        from ..tracing.context import TraceContext
+
+        trace_info = TraceContext.get_current()
+        if trace_info and trace_info.trace_id:
+            # Use first 8 chars for readability
+            short_id = trace_info.trace_id[:8]
+            return f"[{short_id}] "
+    except Exception:
+        # Tracing not available or not configured
+        pass
+    return ""
+
+
+def format_log_value(value, max_len: int = 1000) -> str:
+    """Format a value for logging with truncation.
+
+    Provides a readable representation of values with size info and truncation
+    for large payloads. Suitable for DEBUG level logging.
+
+    Args:
+        value: Any value to format
+        max_len: Maximum length before truncation (default 1000)
+
+    Returns:
+        Formatted string representation
+    """
+    if value is None:
+        return "None"
+
+    type_name = type(value).__name__
+
+    try:
+        if isinstance(value, dict):
+            content = str(value)
+            if len(content) > max_len:
+                return f"{type_name}({len(value)} keys): {content[:max_len]}..."
+            return content
+
+        elif isinstance(value, (list, tuple)):
+            content = str(value)
+            if len(content) > max_len:
+                return f"{type_name}({len(value)} items): {content[:max_len]}..."
+            return content
+
+        elif isinstance(value, str):
+            if len(value) > max_len:
+                return f'"{value[:max_len]}..." ({len(value)} chars)'
+            return f'"{value}"'
+
+        elif isinstance(value, bytes):
+            return f"bytes({len(value)} bytes)"
+
+        elif hasattr(value, "__dict__"):
+            # Object with attributes - show class name and key attributes
+            content = str(value)
+            if len(content) > max_len:
+                return f"{type_name}: {content[:max_len]}..."
+            return f"{type_name}: {content}"
+
+        else:
+            content = str(value)
+            if len(content) > max_len:
+                return f"{type_name}: {content[:max_len]}..."
+            return content
+
+    except Exception as e:
+        return f"{type_name}: <error formatting: {e}>"
+
+
+def format_args_summary(args: tuple, kwargs: dict) -> str:
+    """Format function arguments as a summary (keys only).
+
+    Suitable for concise DEBUG logging showing what was passed.
+
+    Args:
+        args: Positional arguments tuple
+        kwargs: Keyword arguments dict
+
+    Returns:
+        Summary string like "args=(2), kwargs=['name', 'value']"
+    """
+    parts = []
+
+    if args:
+        parts.append(f"args=({len(args)})")
+
+    if kwargs:
+        keys = list(kwargs.keys())
+        parts.append(f"kwargs={keys}")
+
+    return ", ".join(parts) if parts else "no args"
+
+
+def format_result_summary(result) -> str:
+    """Format a result value as a summary (type and size).
+
+    Suitable for concise DEBUG logging showing what was returned.
+
+    Args:
+        result: The return value
+
+    Returns:
+        Summary string like "dict(3 keys)" or "str(150 chars)"
+    """
+    if result is None:
+        return "None"
+
+    type_name = type(result).__name__
+
+    try:
+        if isinstance(result, dict):
+            return f"dict({len(result)} keys)"
+        elif isinstance(result, (list, tuple)):
+            return f"{type_name}({len(result)} items)"
+        elif isinstance(result, str):
+            return f"str({len(result)} chars)"
+        elif isinstance(result, bytes):
+            return f"bytes({len(result)} bytes)"
+        elif isinstance(result, (int, float, bool)):
+            return str(result)
+        else:
+            return type_name
+    except Exception:
+        return type_name

_mcp_mesh/shared/registry_client_wrapper.py

@@ -72,7 +72,7 @@ class RegistryClientWrapper:
                 )
 
             registration_json = json.dumps(registration_dict, indent=2, default=str)
-            self.logger.debug(
+            self.logger.trace(
                 f"🔍 Full heartbeat registration payload:\n{registration_json}"
             )
 
@@ -148,7 +148,7 @@ class RegistryClientWrapper:
                                 )
 
                             parsed_dep["kwargs"] = kwargs_data
-                            self.logger.debug(
+                            self.logger.trace(
                                 f"🔧 Parsed kwargs for {dep_resolution.get('capability')}: {kwargs_data}"
                             )
                         except (json.JSONDecodeError, TypeError) as e:
@@ -178,7 +178,7 @@ class RegistryClientWrapper:
             FastHeartbeatStatus indicating required action
         """
         try:
-            self.logger.debug(
+            self.logger.trace(
                 f"🚀 Performing fast heartbeat check for agent '{agent_id}'"
             )
 
@@ -189,14 +189,14 @@ class RegistryClientWrapper:
 
             # Extract the actual HTTP status code from the response
             status_code = http_response.status_code
-            self.logger.debug(
+            self.logger.trace(
                 f"Fast heartbeat HEAD request for agent '{agent_id}' returned HTTP {status_code}"
             )
 
             # Convert HTTP status to semantic status
             status = FastHeartbeatStatusUtil.from_http_code(status_code)
 
-            self.logger.debug(
+            self.logger.trace(
                 f"✅ Fast heartbeat check completed for agent '{agent_id}': {status.value}"
             )
             return status
@@ -214,7 +214,7 @@ class RegistryClientWrapper:
 
             # Handle 410 Gone specifically (agent unknown)
             if "(410)" in error_str or "Gone" in error_str:
-                self.logger.debug(
+                self.logger.trace(
                     f"🔍 Fast heartbeat: Agent '{agent_id}' unknown (410 Gone) - re-registration needed"
                 )
                 return FastHeartbeatStatus.AGENT_UNKNOWN
@@ -423,7 +423,7 @@ class RegistryClientWrapper:
                         "filter_mode": filter_mode,
                     }
 
-                    self.logger.debug(
+                    self.logger.trace(
                         f"🤖 Extracted llm_filter for {func_name}: {len(normalized_filter)} filters, mode={filter_mode}"
                     )
                     break
@@ -449,7 +449,7 @@ class RegistryClientWrapper:
                             namespace=provider.get("namespace", "default"),
                         )
 
-                        self.logger.debug(
+                        self.logger.trace(
                             f"🔌 Extracted llm_provider for {func_name}: {llm_provider_data.model_dump()}"
                         )
                     break

_mcp_mesh/shared/sse_parser.py

@@ -34,11 +34,11 @@ class SSEParser:
         Raises:
             RuntimeError: If SSE response cannot be parsed
         """
-        logger.debug(f"🔧 SSEParser.parse_sse_response called from {context}")
-        logger.debug(
+        logger.trace(f"🔧 SSEParser.parse_sse_response called from {context}")
+        logger.trace(
             f"🔧 Response text length: {len(response_text)}, starts with 'event:': {response_text.startswith('event:')}"
         )
-        logger.debug(f"🔧 Response preview: {repr(response_text[:100])}...")
+        logger.trace(f"🔧 Response preview: {repr(response_text[:100])}...")
 
         # Check if this is SSE format (can be malformed and not start with "event:")
         is_sse_format = (
@@ -49,13 +49,13 @@ class SSEParser:
 
         if not is_sse_format:
             # Not an SSE response, try parsing as plain JSON
-            logger.debug(f"🔧 {context}: Parsing as plain JSON (not SSE format)")
-            logger.debug(
+            logger.trace(f"🔧 {context}: Parsing as plain JSON (not SSE format)")
+            logger.trace(
                 f"🔧 {context}: Response preview: {repr(response_text[:200])}..."
             )
             try:
                 result = json.loads(response_text)
-                logger.debug(f"🔧 {context}: Plain JSON parsed successfully")
+                logger.trace(f"🔧 {context}: Plain JSON parsed successfully")
                 return result
             except json.JSONDecodeError as e:
                 logger.error(f"🔧 {context}: Plain JSON parse failed: {e}")
@@ -65,7 +65,7 @@ class SSEParser:
                 raise RuntimeError(f"Invalid JSON response in {context}: {e}")
 
         # Parse SSE format: find first valid JSON in data lines
-        logger.debug(f"🔧 {context}: Parsing SSE format - looking for first valid JSON")
+        logger.trace(f"🔧 {context}: Parsing SSE format - looking for first valid JSON")
         data_line_count = 0
         first_valid_json = None
 
@@ -79,22 +79,24 @@ class SSEParser:
                         parsed_json = json.loads(data_content)
                         if first_valid_json is None:
                             first_valid_json = parsed_json
-                            logger.debug(f"🔧 {context}: Found first valid JSON in data line {data_line_count}")
+                            logger.trace(
+                                f"🔧 {context}: Found first valid JSON in data line {data_line_count}"
+                            )
                     except json.JSONDecodeError:
                         # Skip invalid JSON lines - this is expected behavior
-                        logger.debug(f"🔧 {context}: Skipping invalid JSON in data line {data_line_count}: {data_content[:50]}...")
+                        logger.trace(
+                            f"🔧 {context}: Skipping invalid JSON in data line {data_line_count}: {data_content[:50]}..."
+                        )
                         continue
 
-        logger.debug(
-            f"🔧 {context}: Processed {data_line_count} data lines"
-        )
+        logger.trace(f"🔧 {context}: Processed {data_line_count} data lines")
 
         # Return first valid JSON found
         if first_valid_json is None:
             logger.error(f"🔧 {context}: No valid JSON found in SSE response")
-            raise RuntimeError(f"Could not parse SSE response from FastMCP")
+            raise RuntimeError("Could not parse SSE response from FastMCP")
 
-        logger.debug(
+        logger.trace(
             f"🔧 {context}: SSE parsing successful! Result type: {type(first_valid_json)}"
         )
         return first_valid_json
@@ -152,14 +154,14 @@ class SSEStreamProcessor:
         Returns:
             List of complete JSON objects found in this chunk
         """
-        self.logger.debug(
+        self.logger.trace(
             f"🌊 SSEStreamProcessor.process_chunk called for {self.context}, chunk size: {len(chunk_bytes)}"
         )
 
         try:
             chunk_text = chunk_bytes.decode("utf-8")
             self.buffer += chunk_text
-            self.logger.debug(
+            self.logger.trace(
                 f"🌊 {self.context}: Buffer size after chunk: {len(self.buffer)}"
             )
         except UnicodeDecodeError:
@@ -190,7 +192,7 @@ class SSEStreamProcessor:
                         if parsed:
                             results.append(parsed)
 
-        self.logger.debug(
+        self.logger.trace(
             f"🌊 {self.context}: Processed {events_processed} complete SSE events, yielding {len(results)} JSON objects"
         )
         return results

_mcp_mesh/tracing/execution_tracer.py

@@ -27,7 +27,9 @@ class ExecutionTracer:
         self.function_name = function_name
         self.logger = logger_instance
         self.start_time: float | None = None
-        self.trace_context: Any | None = None
+        self.trace_context: Any | None = (
+            None  # Parent's trace context (to restore after execution)
+        )
         self.execution_metadata: dict = {}
 
     def start_execution(
@@ -138,11 +140,34 @@ class ExecutionTracer:
             # Save execution trace to Redis for distributed tracing storage
             publish_trace_with_fallback(self.execution_metadata, self.logger)
 
+            # CRITICAL: Restore parent's trace context so sibling calls have correct parent
+            # Without this, subsequent calls become children of this span instead of siblings
+            self._restore_parent_context()
+
         except Exception as e:
             self.logger.warning(
                 f"Failed to complete execution logging for {self.function_name}: {e}"
             )
 
+    def _restore_parent_context(self) -> None:
+        """Restore the parent's trace context after this span completes.
+
+        This ensures sibling function calls share the same parent instead of
+        becoming nested children of each other.
+        """
+        try:
+            from .context import TraceContext
+
+            if self.trace_context:
+                # Restore to parent's context (the context that existed before this span)
+                TraceContext.set_current(
+                    trace_id=self.trace_context.trace_id,
+                    span_id=self.trace_context.span_id,
+                    parent_span=self.trace_context.parent_span,
+                )
+        except Exception as e:
+            self.logger.debug(f"Failed to restore parent trace context: {e}")
+
     @staticmethod
     def trace_function_execution(
         func: Callable,

_mcp_mesh/tracing/fastapi_tracing_middleware.py

@@ -40,6 +40,9 @@ class FastAPITracingMiddleware(BaseHTTPMiddleware):
         if not is_tracing_enabled():
             return await call_next(request)
 
+        self.logger.debug(
+            f"[TRACE] Processing request {request.method} {request.url.path}"
+        )
 
         # Setup distributed tracing context from request headers
         try:
@@ -50,7 +53,6 @@ class FastAPITracingMiddleware(BaseHTTPMiddleware):
                 request
             )
 
-
             # Setup trace context for this request lifecycle
             TraceContextHelper.setup_request_trace_context(trace_context, self.logger)
 
@@ -62,7 +64,6 @@ class FastAPITracingMiddleware(BaseHTTPMiddleware):
         route_name = self._extract_route_name(request)
         start_time = time.time()
 
-
         try:
             # Process the request
             response = await call_next(request)
@@ -83,7 +84,6 @@ class FastAPITracingMiddleware(BaseHTTPMiddleware):
                 status_code=response.status_code,
             )
 
-
             return response
 
         except Exception as e:
@@ -103,7 +103,6 @@ class FastAPITracingMiddleware(BaseHTTPMiddleware):
                 error=str(e),
             )
 
-
             raise  # Re-raise the original exception
 
     def _extract_route_name(self, request: Request) -> str:

_mcp_mesh/tracing/trace_context_helper.py

@@ -11,6 +11,23 @@ from typing import Any, Optional
 logger = logging.getLogger(__name__)
 
 
+def get_header_case_insensitive(headers_list: list, name: str) -> str:
+    """Get header value case-insensitively from ASGI headers list.
+
+    Args:
+        headers_list: List of (key, value) tuples with bytes
+        name: Header name to find (case-insensitive)
+
+    Returns:
+        Header value as string, or empty string if not found
+    """
+    name_lower = name.lower()
+    for key, value in headers_list:
+        if key.decode().lower() == name_lower:
+            return value.decode()
+    return ""
+
+
 class TraceContextHelper:
     """Helper class to handle HTTP request trace context setup and distributed tracing."""
 
@@ -37,16 +54,18 @@ class TraceContextHelper:
             extracted_trace_id = trace_context.get("trace_id")
             if extracted_trace_id and extracted_trace_id.strip():
                 # EXISTING TRACE: This service is being called by another service
-                from .utils import generate_span_id
-
-                current_span_id = generate_span_id()
+                # Pass through the incoming parent_span directly - ExecutionTracer will create
+                # the actual function span as a child of this parent.
+                # This avoids creating an unpublished intermediate middleware span.
                 parent_span_id = trace_context.get("parent_span")
 
-                # Set context that will be used throughout request lifecycle
+                # Set context with incoming parent_span as the current span
+                # When ExecutionTracer runs, it will create a child span with this as parent
                 TraceContext.set_current(
                     trace_id=extracted_trace_id,
-                    span_id=current_span_id,
-                    parent_span=parent_span_id,
+                    span_id=parent_span_id
+                    or "",  # Use parent as current (will be overwritten by ExecutionTracer)
+                    parent_span=None,  # No grandparent needed at this level
                 )
             else:
                 # NEW ROOT TRACE: This service is the entry point (no incoming trace headers)

{mcp_mesh-0.7.12.dist-info → mcp_mesh-0.7.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.7.12
+Version: 0.7.14
 Summary: Kubernetes-native platform for distributed MCP applications
 Project-URL: Homepage, https://github.com/dhyansraj/mcp-mesh
 Project-URL: Documentation, https://github.com/dhyansraj/mcp-mesh/tree/main/docs