mcp-instana 0.3.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

src/infrastructure/infrastructure_catalog.py

@@ -34,10 +34,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
         """Initialize the Infrastructure Catalog MCP tools client."""
         super().__init__(read_token=read_token, base_url=base_url)
 
-    @register_as_tool(
-        title="Get Available Payload Keys By Plugin ID",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_available_payload_keys_by_plugin_id(self,
                                                       plugin_id: str,
@@ -88,6 +85,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 +113,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:
@@ -128,10 +139,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
             return {"error": f"Failed to get payload keys: {e!s}", "plugin_id": plugin_id}
 
 
-    @register_as_tool(
-        title="Get Infrastructure Catalog Metrics",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_infrastructure_catalog_metrics(self,
                                                  plugin: str,
@@ -234,10 +242,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
             return [f"Error: Failed to get metric catalog for plugin '{plugin}': {e!s}"]
 
 
-    @register_as_tool(
-        title="Get Infrastructure Catalog Plugins",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_infrastructure_catalog_plugins(self, ctx=None, api_client=None) -> Dict[str, Any]:
         """
@@ -307,10 +312,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
 
 
 
-    @register_as_tool(
-        title="Get Infrastructure Catalog Plugins With Custom Metrics",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_infrastructure_catalog_plugins_with_custom_metrics(self, ctx=None, api_client=None) -> Dict[str, Any] | List[Dict[str, Any]]:
         """
@@ -350,10 +352,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
             return {"error": f"Failed to get plugins with custom metrics: {e!s}"}
 
 
-    @register_as_tool(
-        title="Get Tag Catalog",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_tag_catalog(self, plugin: str, ctx=None, api_client=None) -> Dict[str, Any]:
         """
@@ -390,14 +389,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 +441,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:
@@ -438,10 +449,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
             return {"error": f"Failed to get tag catalog: {e!s}"}
 
 
-    @register_as_tool(
-        title="Get Tag Catalog All",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_tag_catalog_all(self, ctx=None, api_client=None) -> Dict[str, Any]:
         """
@@ -560,10 +568,7 @@ class InfrastructureCatalogMCPTools(BaseInstanaClient):
         return summary
 
 
-    @register_as_tool(
-        title="Get Infrastructure Catalog Search Fields",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureCatalogApi)
     async def get_infrastructure_catalog_search_fields(self, ctx=None, api_client=None) -> List[str] | Dict[str, Any]:
         """

src/infrastructure/infrastructure_metrics.py

@@ -41,10 +41,8 @@ class InfrastructureMetricsMCPTools(BaseInstanaClient):
         """Initialize the Infrastructure Analyze MCP tools client."""
         super().__init__(read_token=read_token, base_url=base_url)
 
-    @register_as_tool(
-        title="Get Infrastructure Metrics",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
+    # Note: Not exposed as direct MCP tool - accessed via smart_router_tool.py
     @with_header_auth(InfrastructureMetricsApi)
     async def get_infrastructure_metrics(self,
                                          offline: Optional[StrictBool] = False,
@@ -78,17 +76,13 @@ class InfrastructureMetricsMCPTools(BaseInstanaClient):
 
         try:
 
-            # If no metrics is provided, return an error
-            if not metrics:
-                return {"error": "Metrics is required for this operation"}
-
-
-            # If no plugin is provided, return an error
-            if not plugin:
-                return {"error": "Plugin is required for this operation"}
-
-            if not query:
-                return {"error": "Query is required for this operation"}
+            # Two-Pass Elicitation: Check for required parameters
+            elicitation_request = self._check_elicitation_for_infra_metrics(
+                metrics, plugin, query
+            )
+            if elicitation_request:
+                logger.info("Elicitation needed for infrastructure metrics")
+                return elicitation_request
 
 
             if not time_frame:
@@ -126,6 +120,7 @@ class InfrastructureMetricsMCPTools(BaseInstanaClient):
             # Create the InfrastructureMetricsApi object
             get_combined_metrics = GetCombinedMetrics(**request_body)
 
+
             # Call the get_infrastructure_metrics method from the SDK
             result = api_client.get_infrastructure_metrics(
                 offline=offline,
@@ -172,4 +167,86 @@ class InfrastructureMetricsMCPTools(BaseInstanaClient):
 
         except Exception as e:
             logger.error(f"Error in get_infrastructure_metrics: {e}", exc_info=True)
-            return {"error": f"Failed to get Infra metrics: {e!s}"}
+            return {"error": f"Failed to get infrastructure metrics: {e!s}"}
+
+    def _check_elicitation_for_infra_metrics(
+        self,
+        metrics: Optional[List[str]],
+        plugin: Optional[str],
+        query: Optional[str]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Check if required parameters are missing and create elicitation request (Two-Pass).
+
+        Infrastructure metrics require plugin and query parameters.
+
+        Args:
+            metrics: Metrics list if provided
+            plugin: Plugin name if provided
+            query: Query filter if provided
+
+        Returns:
+            Elicitation request dict if parameters are missing, None otherwise
+        """
+        missing_params = []
+
+        # Check for required parameters
+        if not metrics:
+            missing_params.append({
+                "name": "metrics",
+                "description": "List of metric names to retrieve (REQUIRED)",
+                "examples": ["cpu.used", "memory.used", "disk.used"],
+                "type": "list"
+            })
+
+        if not plugin:
+            missing_params.append({
+                "name": "plugin",
+                "description": "Plugin type for infrastructure entity (REQUIRED)",
+                "examples": ["host", "docker", "kubernetes", "jvm"],
+                "type": "string"
+            })
+
+        if not query:
+            missing_params.append({
+                "name": "query_filter",
+                "description": "Query filter to select entities (REQUIRED)",
+                "examples": ["entity.type:host", "entity.type:docker", "entity.tag:production"],
+                "type": "string"
+            })
+
+        # If any required parameters are missing, return elicitation request
+        if missing_params:
+            return self._create_elicitation_request(missing_params)
+
+        return None
+
+    def _create_elicitation_request(self, missing_params: list) -> Dict[str, Any]:
+        """
+        Create an elicitation request following MCP pattern.
+
+        Args:
+            missing_params: List of missing parameter descriptions
+
+        Returns:
+            Elicitation request dict
+        """
+        # Build simple, user-friendly parameter descriptions
+        param_lines = []
+        for param in missing_params:
+            # Use the examples from the parameter definition instead of hardcoding
+            examples = ", ".join([str(ex) for ex in param["examples"][:3]])
+            param_lines.append(f"{param['name']}: {examples}")
+
+        message = (
+            "I need:\n\n"
+            + "\n".join(param_lines)
+        )
+
+        return {
+            "elicitation_needed": True,
+            "message": message,
+            "missing_parameters": [p["name"] for p in missing_params],
+            "parameter_details": missing_params,
+            "instructions": "Call query_instana_metrics again with these parameters filled in."
+        }

src/infrastructure/infrastructure_resources.py

@@ -39,10 +39,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
         """Initialize the Infrastructure Resources MCP tools client."""
         super().__init__(read_token=read_token, base_url=base_url)
 
-    @register_as_tool(
-        title="Get Monitoring State",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureResourcesApi)
     async def get_monitoring_state(self, ctx=None, api_client=None) -> Dict[str, Any]:
         """
@@ -68,10 +65,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,
@@ -112,10 +106,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
             logger.error(f"Error in get_plugin_payload: {e}", exc_info=True)
             return {"error": f"Failed to get plugin payload: {e!s}"}
 
-    @register_as_tool(
-        title="Get Snapshot",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureResourcesApi)
     async def get_snapshot(self,
                            snapshot_id: str,
@@ -223,10 +214,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
             logger.error(f"Error in get_snapshot: {e}", exc_info=True)
             return {"error": f"Failed to get snapshot: {e!s}"}
 
-    @register_as_tool(
-        title="Get Snapshots",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureResourcesApi)
     async def get_snapshots(self,
                             query: Optional[str] = None,
@@ -381,10 +369,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
 
 
 
-    @register_as_tool(
-        title="Post Snapshots",
-        annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureResourcesApi)
     async def post_snapshots(self,
                              snapshot_ids: Union[List[str], str],
@@ -562,10 +547,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
 
 
 
-    @register_as_tool(
-        title="Software Versions",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureResourcesApi)
     async def software_versions(self, ctx=None, api_client=None) -> Dict[str, Any]:
         """

src/infrastructure/infrastructure_topology.py

@@ -51,10 +51,7 @@ class InfrastructureTopologyMCPTools(BaseInstanaClient):
         """Initialize the Infrastructure Topology MCP tools client."""
         super().__init__(read_token=read_token, base_url=base_url)
 
-    @register_as_tool(
-        title="Get Related Hosts",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureTopologyApi)
     async def get_related_hosts(self,
                                 snapshot_id: str,
@@ -115,10 +112,7 @@ class InfrastructureTopologyMCPTools(BaseInstanaClient):
             logger.error(f"Error in get_related_hosts: {e}", exc_info=True)
             return {"error": f"Failed to get related hosts: {e!s}"}
 
-    @register_as_tool(
-        title="Get Topology",
-        annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False)
-    )
+    # @register_as_tool(...)  # Disabled for future reference
     @with_header_auth(InfrastructureTopologyApi)
     async def get_topology(self,
                            include_data: Optional[bool] = False,
@@ -133,6 +127,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 +149,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

src/prompts/application/application_settings.py

@@ -18,6 +18,63 @@ class ApplicationSettingsPrompts:
         """Get an Application Perspective configuration by ID"""
         return f"Retrieve application configuration with ID: {id}"
 
+    @auto_register_prompt
+    @staticmethod
+    def create_application_config(
+        label: str,
+        scope: Optional[str] = None,
+        boundary_scope: Optional[str] = None,
+        access_rules: Optional[str] = None,
+        tag_filter_expression: Optional[dict] = None
+    ) -> str:
+        """
+        Create a new Application Perspective configuration with user-provided settings.
+
+        REQUIRED:
+        - label: Application perspective name (string)
+
+        OPTIONAL (will prompt user if not provided):
+        - scope: Monitoring scope
+          Options: "INCLUDE_ALL_DOWNSTREAM" (default), "INCLUDE_IMMEDIATE_DOWNSTREAM_DATABASE_AND_MESSAGING", "INCLUDE_NO_DOWNSTREAM"
+        - boundary_scope: Boundary scope
+          Options: "ALL" (default), "INBOUND", "DEFAULT"
+        - access_rules: Access control rules
+          Options: "READ_WRITE_GLOBAL" (default), "READ_ONLY_GLOBAL", "CUSTOM"
+        - tag_filter_expression: Tag filter to match services (optional)
+
+        ELICITATION QUESTIONS:
+        1. What scope should be used for monitoring? (INCLUDE_ALL_DOWNSTREAM/INCLUDE_IMMEDIATE_DOWNSTREAM_DATABASE_AND_MESSAGING/INCLUDE_NO_DOWNSTREAM)
+        2. What boundary scope should be applied? (ALL/INBOUND/DEFAULT)
+        3. What access rules should be configured? (READ_WRITE_GLOBAL/READ_ONLY_GLOBAL/CUSTOM)
+        4. Do you want to add a tag filter expression to match specific services? (yes/no)
+
+        Example with all options:
+        {
+            "label": "My Application",
+            "scope": "INCLUDE_ALL_DOWNSTREAM",
+            "boundaryScope": "ALL",
+            "accessRules": [{"accessType": "READ_WRITE", "relationType": "GLOBAL"}],
+            "tagFilterExpression": {
+                "type": "TAG_FILTER",
+                "name": "service.name",
+                "operator": "CONTAINS",
+                "entity": "DESTINATION",
+                "value": "my-service"
+            }
+        }
+        """
+        config_details = [f"label: {label}"]
+        if scope:
+            config_details.append(f"scope: {scope}")
+        if boundary_scope:
+            config_details.append(f"boundaryScope: {boundary_scope}")
+        if access_rules:
+            config_details.append(f"accessRules: {access_rules}")
+        if tag_filter_expression:
+            config_details.append(f"tagFilterExpression: {tag_filter_expression}")
+
+        return f"Create application perspective configuration with {', '.join(config_details)}"
+
     @auto_register_prompt
     @staticmethod
     def get_all_endpoint_configs() -> str:
@@ -67,6 +124,7 @@ class ApplicationSettingsPrompts:
         return [
             ('get_all_applications_configs', cls.get_all_applications_configs),
             ('get_application_config', cls.get_application_config),
+            ('create_application_config', cls.create_application_config),
             ('get_all_endpoint_configs', cls.get_all_endpoint_configs),
             ('get_endpoint_config', cls.get_endpoint_config),
             ('get_all_manual_service_configs', cls.get_all_manual_service_configs),