mcp-instana 0.3.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

src/event/events_tools.py

@@ -578,11 +578,12 @@ class AgentMonitoringEventsMCPTools(BaseInstanaClient):
         """
 
         try:
-            logger.debug(f"get_issue_events called with query={query}, time_range={time_range}, from_time={from_time}, to_time={to_time}, size={size}")
+            logger.debug(f"get_issues called with query={query}, time_range={time_range}, from_time={from_time}, to_time={to_time}, size={size}")
             from_time, to_time = self._process_time_range(time_range, from_time, to_time)
             if not from_time:
                 from_time = to_time - (60 * 60 * 1000)
             try:
+                # Use the optimized without_preload_content approach for faster response
                 response_data = api_client.get_events_without_preload_content(
                     var_from=from_time,
                     to=to_time,
@@ -591,20 +592,35 @@ class AgentMonitoringEventsMCPTools(BaseInstanaClient):
                     exclude_triggered_before=exclude_triggered_before,
                     event_type_filters=["issue"]
                 )
+
+                # Check response status immediately
                 if response_data.status != 200:
                     return {"error": f"Failed to get issue events: HTTP {response_data.status}"}
+
+                # Process the response data directly without additional parsing
                 response_text = response_data.data.decode('utf-8')
                 result = json.loads(response_text)
+
+                # Create a standardized result format
                 if isinstance(result, list):
-                    result_dict = {"events": result, "events_count": len(result)}
+                    # Include a summary of the events for quicker analysis
+                    events_count = len(result)
+                    result_dict = {
+                        "events": result[:max_events],  # Limit to max_events for performance
+                        "events_count": events_count,
+                        "total_events": events_count,
+                        "time_range": f"From {datetime.fromtimestamp(from_time/1000).strftime('%Y-%m-%d %H:%M:%S')} to {datetime.fromtimestamp(to_time/1000).strftime('%Y-%m-%d %H:%M:%S')}"
+                    }
                 else:
                     result_dict = result
+
+                logger.debug(f"Successfully retrieved {result_dict.get('events_count', 0)} issue events")
                 return result_dict
             except Exception as api_error:
                 logger.error(f"API call failed: {api_error}", exc_info=True)
                 return {"error": f"Failed to get issue events: {api_error}"}
         except Exception as e:
-            logger.error(f"Error in get_issue_events: {e}", exc_info=True)
+            logger.error(f"Error in get_issues: {e}", exc_info=True)
             return {"error": f"Failed to get issue events: {e!s}"}
 
     @register_as_tool(
@@ -649,11 +665,12 @@ class AgentMonitoringEventsMCPTools(BaseInstanaClient):
         """
 
         try:
-            logger.debug(f"get_incident_events called with query={query}, time_range={time_range}, from_time={from_time}, to_time={to_time}, size={size}")
+            logger.debug(f"get_incidents called with query={query}, time_range={time_range}, from_time={from_time}, to_time={to_time}, size={size}")
             from_time, to_time = self._process_time_range(time_range, from_time, to_time)
             if not from_time:
                 from_time = to_time - (60 * 60 * 1000)
             try:
+                # Use the optimized without_preload_content approach for faster response
                 response_data = api_client.get_events_without_preload_content(
                     var_from=from_time,
                     to=to_time,
@@ -662,20 +679,35 @@ class AgentMonitoringEventsMCPTools(BaseInstanaClient):
                     exclude_triggered_before=exclude_triggered_before,
                     event_type_filters=["incident"]
                 )
+
+                # Check response status immediately
                 if response_data.status != 200:
                     return {"error": f"Failed to get incident events: HTTP {response_data.status}"}
+
+                # Process the response data directly without additional parsing
                 response_text = response_data.data.decode('utf-8')
                 result = json.loads(response_text)
+
+                # Create a standardized result format
                 if isinstance(result, list):
-                    result_dict = {"events": result, "events_count": len(result)}
+                    # Include a summary of the events for quicker analysis
+                    events_count = len(result)
+                    result_dict = {
+                        "events": result[:max_events],  # Limit to max_events for performance
+                        "events_count": events_count,
+                        "total_events": events_count,
+                        "time_range": f"From {datetime.fromtimestamp(from_time/1000).strftime('%Y-%m-%d %H:%M:%S')} to {datetime.fromtimestamp(to_time/1000).strftime('%Y-%m-%d %H:%M:%S')}"
+                    }
                 else:
                     result_dict = result
+
+                logger.debug(f"Successfully retrieved {result_dict.get('events_count', 0)} incident events")
                 return result_dict
             except Exception as api_error:
                 logger.error(f"API call failed: {api_error}", exc_info=True)
                 return {"error": f"Failed to get incident events: {api_error}"}
         except Exception as e:
-            logger.error(f"Error in get_incident_events: {e}", exc_info=True)
+            logger.error(f"Error in get_incidents: {e}", exc_info=True)
             return {"error": f"Failed to get incident events: {e!s}"}
 
     @register_as_tool(
@@ -720,11 +752,12 @@ class AgentMonitoringEventsMCPTools(BaseInstanaClient):
         """
 
         try:
-            logger.debug(f"get_change_events called with query={query}, time_range={time_range}, from_time={from_time}, to_time={to_time}, size={size}")
+            logger.debug(f"get_changes called with query={query}, time_range={time_range}, from_time={from_time}, to_time={to_time}, size={size}")
             from_time, to_time = self._process_time_range(time_range, from_time, to_time)
             if not from_time:
                 from_time = to_time - (60 * 60 * 1000)
             try:
+                # Use the optimized without_preload_content approach for faster response
                 response_data = api_client.get_events_without_preload_content(
                     var_from=from_time,
                     to=to_time,
@@ -733,20 +766,35 @@ class AgentMonitoringEventsMCPTools(BaseInstanaClient):
                     exclude_triggered_before=exclude_triggered_before,
                     event_type_filters=["change"]
                 )
+
+                # Check response status immediately
                 if response_data.status != 200:
                     return {"error": f"Failed to get change events: HTTP {response_data.status}"}
+
+                # Process the response data directly without additional parsing
                 response_text = response_data.data.decode('utf-8')
                 result = json.loads(response_text)
+
+                # Create a standardized result format
                 if isinstance(result, list):
-                    result_dict = {"events": result, "events_count": len(result)}
+                    # Include a summary of the events for quicker analysis
+                    events_count = len(result)
+                    result_dict = {
+                        "events": result[:max_events],  # Limit to max_events for performance
+                        "events_count": events_count,
+                        "total_events": events_count,
+                        "time_range": f"From {datetime.fromtimestamp(from_time/1000).strftime('%Y-%m-%d %H:%M:%S')} to {datetime.fromtimestamp(to_time/1000).strftime('%Y-%m-%d %H:%M:%S')}"
+                    }
                 else:
                     result_dict = result
+
+                logger.debug(f"Successfully retrieved {result_dict.get('events_count', 0)} change events")
                 return result_dict
             except Exception as api_error:
                 logger.error(f"API call failed: {api_error}", exc_info=True)
                 return {"error": f"Failed to get change events: {api_error}"}
         except Exception as e:
-            logger.error(f"Error in get_change_events: {e}", exc_info=True)
+            logger.error(f"Error in get_changes: {e}", exc_info=True)
             return {"error": f"Failed to get change events: {e!s}"}
 
     @register_as_tool(

src/infrastructure/infrastructure_catalog.py

@@ -88,6 +88,11 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
                     result_dict = {"data": str(result), "plugin_id": plugin_id}
 
                 logger.debug(f"Result from get_available_payload_keys_by_plugin_id: {result_dict}")
+
+                # Safety check: ensure we never return a raw list
+                if isinstance(result_dict, list):
+                    result_dict = {"payload_keys": result_dict, "plugin_id": plugin_id}
+
                 return result_dict
 
             except Exception as sdk_error:
@@ -111,7 +116,16 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
                     # Try to parse as JSON first
                     import json
                     try:
-                        result_dict = json.loads(response_text)
+                        parsed_result = json.loads(response_text)
+
+                        # Ensure we always return a dictionary, not a raw list
+                        if isinstance(parsed_result, list):
+                            result_dict = {"payload_keys": parsed_result, "plugin_id": plugin_id}
+                        elif isinstance(parsed_result, dict):
+                            result_dict = parsed_result
+                        else:
+                            result_dict = {"data": parsed_result, "plugin_id": plugin_id}
+
                         logger.debug(f"Result from fallback method (JSON): {result_dict}")
                         return result_dict
                     except json.JSONDecodeError:
@@ -390,14 +404,26 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
                 return result_dict
 
             except Exception as sdk_error:
-                logger.error(f"SDK method failed: {sdk_error}, trying with custom headers")
+                logger.error(f"SDK method failed: {sdk_error}, evaluating fallback conditions")
 
                 # Check if it's a 406 error
                 is_406_error = False
                 if hasattr(sdk_error, 'status') and sdk_error.status == 406 or "406" in str(sdk_error) and "Not Acceptable" in str(sdk_error):
                     is_406_error = True
 
-                if is_406_error:
+                # Check for Pydantic ValidationError (SDK model deserialization issues)
+                is_pydantic_error = False
+                try:
+                    from pydantic import (
+                        ValidationError as _PydanticValidationError,  # type: ignore
+                    )
+                    is_pydantic_error = isinstance(sdk_error, _PydanticValidationError)
+                except Exception:
+                    # Fallback to string inspection if pydantic not importable in runtime
+                    err_str = str(sdk_error).lower()
+                    is_pydantic_error = ("pydantic" in err_str and "validation" in err_str) or ("validation error" in err_str)
+
+                if is_406_error or is_pydantic_error:
                     # Try using the SDK's method with custom headers
                     # The SDK should have a method that allows setting custom headers
                     custom_headers = {
@@ -430,7 +456,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
                         logger.error(error_message)
                         return {"error": error_message}
                 else:
-                    # Re-raise if it's not a 406 error
+                    # Re-raise if it's not a 406 or Pydantic validation error
                     raise
 
         except Exception as e:

src/infrastructure/infrastructure_metrics.py

@@ -87,6 +87,7 @@ class InfrastructureMetricsMCPTools(BaseInstanaClient):
             if not plugin:
                 return {"error": "Plugin is required for this operation"}
 
+            # If no query is provided, return an error
             if not query:
                 return {"error": "Query is required for this operation"}
 

src/infrastructure/infrastructure_resources.py

@@ -68,10 +68,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
             logger.error(f"Error in get_monitoring_state: {e}", exc_info=True)
             return {"error": f"Failed to get monitoring state: {e!s}"}
 
-    @register_as_tool(
-        title="Get Plugin Payload",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # This tool is disabled since the underlying API is not giving a proper response.
     @with_header_auth(InfrastructureResourcesApi)
     async def get_plugin_payload(self,
                                  snapshot_id: str,

src/infrastructure/infrastructure_topology.py

@@ -133,6 +133,9 @@ class InfrastructureTopologyMCPTools(BaseInstanaClient):
         The topology includes nodes (representing entities like hosts, processes, containers) and edges (representing
         connections between entities). This is useful for understanding the overall structure of your environment.
 
+        This implementation uses the `get_topology_without_preload_content` method from the SDK to bypass validation
+        issues that can occur with complex Kubernetes infrastructure data.
+
         For example, use this tool when:
         - You need a complete map of your infrastructure
         - You want to understand how components are connected
@@ -152,22 +155,31 @@ class InfrastructureTopologyMCPTools(BaseInstanaClient):
 
             # Use the API client from the decorator
             try:
-                result = api_client.get_topology(include_data=include_data)
-                logger.debug("SDK call successful, processing result")
-            except Exception as sdk_error:
-                logger.error(f"SDK validation error: {sdk_error}")
+                # Use get_topology_without_preload_content to bypass validation
+                response = api_client.get_topology_without_preload_content(include_data=include_data)
+                logger.debug("SDK call successful using get_topology_without_preload_content")
 
-                # If it's a validation error, try to extract useful information from the error
-                if "validation error" in str(sdk_error).lower():
-                    return {
-                        "error": "SDK validation error occurred",
-                        "details": str(sdk_error),
-                        "suggestion": "The API response format may not match the expected SDK model structure. This often happens with complex Kubernetes or cloud infrastructure data.",
-                        "workaround": "Consider using other topology tools like get_related_hosts with specific snapshot IDs, or check if the include_data parameter affects the response format."
-                    }
-                else:
-                    # Re-raise if it's not a validation error
-                    raise sdk_error
+                # Parse the JSON response manually following the pattern from application_topology.py
+                import json
+                try:
+                    # The result from get_topology_without_preload_content is a response object
+                    # We need to read the response data and parse it as JSON
+                    response_text = response.data.decode('utf-8')
+                    result = json.loads(response_text)
+                    logger.debug("Successfully parsed topology data as JSON")
+                except (json.JSONDecodeError, AttributeError) as json_err:
+                    error_message = f"Failed to parse JSON response: {json_err}"
+                    logger.error(error_message)
+                    return {"error": error_message}
+
+            except Exception as sdk_error:
+                logger.error(f"SDK error: {sdk_error}")
+                return {
+                    "error": "Failed to get topology data",
+                    "details": str(sdk_error),
+                    "suggestion": "The API may be unavailable or the request format is incorrect.",
+                    "workaround": "Try again later or check if the include_data parameter affects the response."
+                }
 
             # Convert the result to a dictionary
             result_dict = None

src/observability.py

@@ -0,0 +1,29 @@
+import os
+import sys
+
+
+def workflow(name=None):
+    def decorator(func):
+        return func
+    return decorator
+
+def task(name=None):
+    def decorator(func):
+        return func
+    return decorator
+
+TRACELOOP_ENABLED = os.getenv("ENABLE_MCP_OBSERVABILITY", "false").lower() in ("true", "1", "yes", "on")
+
+if TRACELOOP_ENABLED:
+    try:
+        from traceloop.sdk import Traceloop
+        from traceloop.sdk.decorators import task as traceloop_task
+        from traceloop.sdk.decorators import workflow as traceloop_workflow
+        Traceloop.init(app_name="Instana-MCP-Server")
+        print("Traceloop enabled and initialized for MCP Client", file=sys.stderr)
+        # Override the no-op decorators with real ones
+        workflow = traceloop_workflow
+        task = traceloop_task
+    except ImportError:
+        print("Traceloop requested but not installed. Install with: pip install traceloop-sdk", file=sys.stderr)
+        TRACELOOP_ENABLED = False