mcp-instana 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

src/application/application_topology.py

@@ -0,0 +1,111 @@
+"""
+Application Topology MCP Tools Module
+
+This module provides application topology-specific MCP tools for Instana monitoring.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from src.core.utils import BaseInstanaClient, register_as_tool
+
+try:
+    from instana_client.api.application_topology_api import (
+        ApplicationTopologyApi,
+    )
+    from instana_client.api_client import ApiClient
+    from instana_client.configuration import Configuration
+except ImportError as e:
+    import logging
+    import traceback
+    logger = logging.getLogger(__name__)
+    logger.error(f"Error importing Instana SDK: {e}")
+    traceback.print_exc()
+    raise
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+class ApplicationTopologyMCPTools(BaseInstanaClient):
+    """Tools for application topology in Instana MCP."""
+
+    def __init__(self, read_token: str, base_url: str):
+        """Initialize the Application Topology MCP tools client."""
+        super().__init__(read_token=read_token, base_url=base_url)
+
+        try:
+
+            # Configure the API client with the correct base URL and authentication
+            configuration = Configuration()
+            configuration.host = base_url
+            configuration.api_key['ApiKeyAuth'] = read_token
+            configuration.api_key_prefix['ApiKeyAuth'] = 'apiToken'
+
+            # Create an API client with this configuration
+            api_client = ApiClient(configuration=configuration)
+
+            # Initialize the Instana SDK's ApplicationTopologyMCPTools with our configured client
+            self.topology_api = ApplicationTopologyApi(api_client=api_client)
+
+        except Exception as e:
+            logger.error(f"Error initializing ApplicationTopologyMCPTools: {e}", exc_info=True)
+            raise
+
+    @register_as_tool
+    async def get_application_topology(self,
+                              window_size: Optional[int] = None,
+                              to_timestamp: Optional[int] = None,
+                              application_id: Optional[str] = None,
+                              application_boundary_scope: Optional[str] = None,
+                              ctx = None) -> Dict[str, Any]:
+        """
+        Get the service topology from Instana Server.
+        This tool retrieves services and connections (call paths) between them for calls in the scope given by the parameters.
+
+        Args:
+            window_size: Size of time window in milliseconds
+            to_timestamp: Timestamp since Unix Epoch in milliseconds of the end of the time window
+            application_id: Filter by application ID
+            application_boundary_scope: Filter by application scope, i.e., INBOUND or ALL. The default value is INBOUND.
+            ctx: Context information
+
+        Returns:
+            A dictionary containing the service topology data
+        """
+
+        try:
+            logger.debug("Fetching service topology data")
+
+            # Set default values if not provided
+            if not to_timestamp:
+                to_timestamp = int(datetime.now().timestamp() * 1000)
+
+            if not window_size:
+                window_size = 3600000  # Default to 1 hour in milliseconds
+
+            # Call the API
+            # Note: The SDK expects parameters in camelCase, but we use snake_case in Python
+            # The SDK will handle the conversion
+            result = self.topology_api.get_services_map(
+                window_size=window_size,
+                to=to_timestamp,
+                application_id=application_id,
+                application_boundary_scope=application_boundary_scope
+            )
+
+            # Ensure we always return a dictionary
+            if hasattr(result, "to_dict"):
+                result_dict = result.to_dict()
+            elif isinstance(result, dict):
+                result_dict = result
+            else:
+                # Convert to dictionary using __dict__ or as a fallback, create a new dict with string representation
+                result_dict = getattr(result, "__dict__", {"data": str(result)})
+
+            logger.debug("Successfully retrieved service topology data")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in get_application_topology: {e}", exc_info=True)
+            return {"error": f"Failed to get application topology: {e!s}"}

src/automation/action_catalog.py

@@ -0,0 +1,416 @@
+"""
+Automation Action CAtalog MCP Tools Module
+
+This module provides automation action catalog tools for Instana Automation.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+# Import the necessary classes from the SDK
+try:
+    from instana_client.api.action_catalog_api import (
+        ActionCatalogApi,
+    )
+except ImportError:
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.error("Failed to import application alert configuration API", exc_info=True)
+    raise
+
+from src.core.utils import BaseInstanaClient, register_as_tool, with_header_auth
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+class ActionCatalogMCPTools(BaseInstanaClient):
+    """Tools for application alerts in Instana MCP."""
+
+    def __init__(self, read_token: str, base_url: str):
+        """Initialize the Application Alert MCP tools client."""
+        super().__init__(read_token=read_token, base_url=base_url)
+
+    @register_as_tool
+    @with_header_auth(ActionCatalogApi)
+    async def get_action_matches(self,
+                            payload: Union[Dict[str, Any], str],
+                            target_snapshot_id: Optional[str] = None,
+                            ctx=None,
+                            api_client=None) -> Dict[str, Any]:
+        """
+        Get action matches for a given action search space and target snapshot ID.
+        Args:
+            Sample payload:
+            {
+                "name": "CPU spends significant time waiting for input/output",
+                "description": "Checks whether the system spends significant time waiting for input/output."
+            }
+            target_snapshot_id: Optional[str]: The target snapshot ID to get action matches for.
+            ctx: Optional[Dict[str, Any]]: The context to get action matches for.
+            api_client: Optional[ActionCatalogApi]: The API client to get action matches for.
+        Returns:
+            Dict[str, Any]: The action matches for the given payload and target snapshot ID.
+        """
+        try:
+
+            if not payload:
+                return {"error": "payload is required"}
+
+            # Parse the payload if it's a string
+            if isinstance(payload, str):
+                logger.debug("Payload is a string, attempting to parse")
+                try:
+                    import json
+                    try:
+                        parsed_payload = json.loads(payload)
+                        logger.debug("Successfully parsed payload as JSON")
+                        request_body = parsed_payload
+                    except json.JSONDecodeError as e:
+                        logger.debug(f"JSON parsing failed: {e}, trying with quotes replaced")
+
+                        # Try replacing single quotes with double quotes
+                        fixed_payload = payload.replace("'", "\"")
+                        try:
+                            parsed_payload = json.loads(fixed_payload)
+                            logger.debug("Successfully parsed fixed JSON")
+                            request_body = parsed_payload
+                        except json.JSONDecodeError:
+                            # Try as Python literal
+                            import ast
+                            try:
+                                parsed_payload = ast.literal_eval(payload)
+                                logger.debug("Successfully parsed payload as Python literal")
+                                request_body = parsed_payload
+                            except (SyntaxError, ValueError) as e2:
+                                logger.debug(f"Failed to parse payload string: {e2}")
+                                return {"error": f"Invalid payload format: {e2}", "payload": payload}
+                except Exception as e:
+                    logger.debug(f"Error parsing payload string: {e}")
+                    return {"error": f"Failed to parse payload: {e}", "payload": payload}
+            else:
+                # If payload is already a dictionary, use it directly
+                logger.debug("Using provided payload dictionary")
+                request_body = payload
+
+            # Validate required fields in the payload
+            required_fields = ["name"]
+            for field in required_fields:
+                if field not in request_body:
+                    logger.warning(f"Missing required field: {field}")
+                    return {"error": f"Missing required field: {field}"}
+
+            # Import the ActionSearchSpace class
+            try:
+                from instana_client.models.action_search_space import (
+                    ActionSearchSpace,
+                )
+                logger.debug("Successfully imported ActionSearchSpace")
+            except ImportError as e:
+                logger.debug(f"Error importing ActionSearchSpace: {e}")
+                return {"error": f"Failed to import ActionSearchSpace: {e!s}"}
+
+            # Create an ActionSearchSpace object from the request body
+            try:
+                logger.debug(f"Creating ActionSearchSpace with params: {request_body}")
+                config_object = ActionSearchSpace(**request_body)
+                logger.debug("Successfully created config object")
+            except Exception as e:
+                logger.debug(f"Error creating ActionSearchSpace: {e}")
+                return {"error": f"Failed to create config object: {e!s}"}
+
+            # Call the get_action_matches method from the SDK
+            logger.debug("Calling get_action_matches with config object")
+            result = api_client.get_action_matches(
+                action_search_space=config_object,
+                target_snapshot_id=target_snapshot_id,
+            )
+
+            # Convert the result to a dictionary
+            if isinstance(result, list):
+                # Convert list of ActionMatch objects to list of dictionaries
+                result_dict = []
+                for action_match in result:
+                    try:
+                        if hasattr(action_match, 'to_dict'):
+                            result_dict.append(action_match.to_dict())
+                        else:
+                            result_dict.append(action_match)
+                    except Exception as e:
+                        logger.warning(f"Failed to convert action match to dict: {e}")
+                        # Add a fallback representation
+                        result_dict.append({
+                            "error": f"Failed to serialize action match: {e}",
+                            "raw_data": str(action_match)
+                        })
+
+                logger.debug(f"Result from get_action_matches: {result_dict}")
+                return {
+                    "success": True,
+                    "message": "Action matches retrieved successfully",
+                    "data": result_dict,
+                    "count": len(result_dict)
+                }
+            elif hasattr(result, 'to_dict'):
+                try:
+                    result_dict = result.to_dict()
+                    logger.debug(f"Result from get_action_matches: {result_dict}")
+                    return {
+                        "success": True,
+                        "message": "Action match retrieved successfully",
+                        "data": result_dict
+                    }
+                except Exception as e:
+                    logger.warning(f"Failed to convert result to dict: {e}")
+                    return {
+                        "success": False,
+                        "message": "Failed to serialize result",
+                        "error": str(e),
+                        "raw_data": str(result)
+                    }
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Get action matches"
+                }
+                logger.debug(f"Result from get_action_matches: {result_dict}")
+                return result_dict
+        except Exception as e:
+            logger.error(f"Error in get_action_matches: {e}")
+            return {"error": f"Failed to get action matches: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionCatalogApi)
+    async def get_actions(self,
+                         page: Optional[int] = None,
+                         page_size: Optional[int] = None,
+                         search: Optional[str] = None,
+                         types: Optional[List[str]] = None,
+                         order_by: Optional[str] = None,
+                         order_direction: Optional[str] = None,
+                         ctx=None,
+                         api_client=None) -> Dict[str, Any]:
+        """
+        Get a list of available automation actions from the action catalog.
+
+        Args:
+            page: Page number for pagination (optional)
+            page_size: Number of actions per page (optional)
+            search: Search term to filter actions by name or description (optional)
+            types: List of action types to filter by (optional)
+            order_by: Field to order results by (optional)
+            order_direction: Sort direction ('asc' or 'desc') (optional)
+            ctx: Optional[Dict[str, Any]]: The context for the action retrieval
+            api_client: Optional[ActionCatalogApi]: The API client for action catalog
+
+        Returns:
+            Dict[str, Any]: The list of available automation actions
+        """
+        try:
+            logger.debug("get_actions called")
+
+            # Call the get_actions method from the SDK
+            result = api_client.get_actions(
+                page=page,
+                page_size=page_size,
+                search=search,
+                types=types,
+                order_by=order_by,
+                order_direction=order_direction
+            )
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Actions retrieved successfully"
+                }
+
+            logger.debug(f"Result from get_actions: {result_dict}")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in get_actions: {e}")
+            return {"error": f"Failed to get actions: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionCatalogApi)
+    async def get_action_details(self,
+                                action_id: str,
+                                ctx=None,
+                                api_client=None) -> Dict[str, Any]:
+        """
+        Get detailed information about a specific automation action by ID.
+
+        Args:
+            action_id: The unique identifier of the action (required)
+            ctx: Optional[Dict[str, Any]]: The context for the action details retrieval
+            api_client: Optional[ActionCatalogApi]: The API client for action catalog
+
+        Returns:
+            Dict[str, Any]: The detailed information about the automation action
+        """
+        try:
+            if not action_id:
+                return {"error": "action_id is required"}
+
+            logger.debug(f"get_action_details called with action_id: {action_id}")
+
+            # Call the get_action method from the SDK
+            result = api_client.get_action(action_id=action_id)
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action details retrieved successfully"
+                }
+
+            logger.debug(f"Result from get_action: {result_dict}")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in get_action_details: {e}")
+            return {"error": f"Failed to get action details: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionCatalogApi)
+    async def search_actions(self,
+                            search: str,
+                            page: Optional[int] = None,
+                            page_size: Optional[int] = None,
+                            types: Optional[List[str]] = None,
+                            order_by: Optional[str] = None,
+                            order_direction: Optional[str] = None,
+                            ctx=None,
+                            api_client=None) -> Dict[str, Any]:
+        """
+        Search for automation actions in the action catalog.
+
+        Args:
+            search: Search term to find actions by name, description, or other attributes (required)
+            page: Page number for pagination (optional)
+            page_size: Number of actions per page (optional)
+            types: List of action types to filter by (optional)
+            order_by: Field to order results by (optional)
+            order_direction: Sort direction ('asc' or 'desc') (optional)
+            ctx: Optional[Dict[str, Any]]: The context for the action search
+            api_client: Optional[ActionCatalogApi]: The API client for action catalog
+
+        Returns:
+            Dict[str, Any]: The search results for automation actions
+        """
+        try:
+            if not search:
+                return {"error": "search parameter is required"}
+
+            logger.debug(f"search_actions called with search: {search}")
+
+            # Call the search_actions method from the SDK
+            result = api_client.search_actions(
+                search=search,
+                page=page,
+                page_size=page_size,
+                types=types,
+                order_by=order_by,
+                order_direction=order_direction
+            )
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action search completed successfully"
+                }
+
+            logger.debug(f"Result from search_actions: {result_dict}")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in search_actions: {e}")
+            return {"error": f"Failed to search actions: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionCatalogApi)
+    async def get_action_types(self,
+                              ctx=None,
+                              api_client=None) -> Dict[str, Any]:
+        """
+        Get a list of available action types in the action catalog.
+
+        Args:
+            ctx: Optional[Dict[str, Any]]: The context for the action types retrieval
+            api_client: Optional[ActionCatalogApi]: The API client for action catalog
+
+        Returns:
+            Dict[str, Any]: The list of available action types
+        """
+        try:
+            logger.debug("get_action_types called")
+
+            # Call the get_action_types method from the SDK
+            result = api_client.get_action_types()
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action types retrieved successfully"
+                }
+
+            logger.debug(f"Result from get_action_types: {result_dict}")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in get_action_types: {e}")
+            return {"error": f"Failed to get action types: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionCatalogApi)
+    async def get_action_categories(self,
+                                   ctx=None,
+                                   api_client=None) -> Dict[str, Any]:
+        """
+        Get a list of available action categories in the action catalog.
+
+        Args:
+            ctx: Optional[Dict[str, Any]]: The context for the action categories retrieval
+            api_client: Optional[ActionCatalogApi]: The API client for action catalog
+
+        Returns:
+            Dict[str, Any]: The list of available action categories
+        """
+        try:
+            logger.debug("get_action_categories called")
+
+            # Call the get_action_categories method from the SDK
+            result = api_client.get_action_categories()
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action categories retrieved successfully"
+                }
+
+            logger.debug(f"Result from get_action_categories: {result_dict}")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in get_action_categories: {e}")
+            return {"error": f"Failed to get action categories: {e!s}"}