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

src/log/log_alert_configuration.py

@@ -0,0 +1,331 @@
+"""
+Log Alert Configuration MCP Tools Module
+
+This module provides log alert configuration-specific MCP tools for Instana monitoring.
+"""
+
+import logging
+import sys
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+# Import the necessary classes from the SDK
+try:
+    from instana_client.api.log_alert_configuration_api import LogAlertConfigurationApi
+    from instana_client.api_client import ApiClient
+    from instana_client.configuration import Configuration
+    from instana_client.models.log_alert_config import LogAlertConfig
+except ImportError:
+    logger.error("Failed to import Instana client modules", exc_info=True)
+    raise
+
+from src.core.utils import BaseInstanaClient, register_as_tool
+
+
+class LogAlertConfigurationMCPTools(BaseInstanaClient):
+    """Tools for log alert configuration in Instana MCP."""
+
+    def __init__(self, read_token: str, base_url: str):
+        """Initialize the Log Alert Configuration MCP tools client."""
+        super().__init__(read_token=read_token, base_url=base_url)
+
+        try:
+            logger.debug(f"Initializing LogAlertConfigurationMCPTools with base_url={base_url}")
+
+            # 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 LogAlertConfigurationApi with our configured client
+            self.log_alert_api = LogAlertConfigurationApi(api_client=api_client)
+            logger.debug(f"Initialized LogAlertConfigurationApi with host: {configuration.host}")
+        except Exception as e:
+            logger.error(f"Error initializing LogAlertConfigurationApi: {e}", exc_info=True)
+            raise
+
+    @register_as_tool
+    async def create_log_alert_config(self, config: Dict[str, Any], ctx=None) -> Dict[str, Any]:
+        """
+        Create a new log alert configuration.
+
+        Args:
+            config: Dictionary containing the log alert configuration
+                Required fields:
+                - name: Name of the alert
+                - query: Log query string
+                - threshold: Threshold value for the alert
+                - timeThreshold: Time threshold in milliseconds
+                - rule: Rule configuration
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the created log alert configuration or error information
+        """
+        try:
+            logger.debug(f"create_log_alert_config called with config={config}")
+
+            try:
+                # Convert dictionary to LogAlertConfig model
+                log_alert_config = LogAlertConfig(**config)
+            except Exception as e:
+                logger.error(f"Error creating LogAlertConfig: {e}", exc_info=True)
+                return {"error": f"Failed to create log alert configuration: {e!s}"}
+
+            try:
+                # Call the API
+                result = self.log_alert_api.create_log_alert_config(log_alert_config=log_alert_config)
+                logger.debug(f"Result from create_log_alert_config: {result}")
+                return self._convert_to_dict(result)
+            except Exception as e:
+                logger.error(f"Error calling create_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to create log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in create_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to create log alert configuration: {e!s}"}
+
+    @register_as_tool
+    async def delete_log_alert_config(self, id: str, ctx=None) -> Dict[str, Any]:
+        """
+        Delete a log alert configuration.
+
+        Args:
+            id: ID of the log alert configuration to delete
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the result of the deletion operation or error information
+        """
+        try:
+            logger.debug(f"delete_log_alert_config called with id={id}")
+
+            try:
+                self.log_alert_api.delete_log_alert_config(id=id)
+                logger.debug(f"Successfully deleted log alert configuration with ID {id}")
+                return {"success": True, "message": f"Log alert configuration with ID {id} deleted successfully"}
+            except Exception as e:
+                logger.error(f"Error calling delete_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to delete log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in delete_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to delete log alert configuration: {e!s}"}
+
+    @register_as_tool
+    async def disable_log_alert_config(self, id: str, ctx=None) -> Dict[str, Any]:
+        """
+        Disable a log alert configuration.
+
+        Args:
+            id: ID of the log alert configuration to disable
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the result of the disable operation or error information
+        """
+        try:
+            logger.debug(f"disable_log_alert_config called with id={id}")
+
+            try:
+                self.log_alert_api.disable_log_alert_config(id=id)
+                logger.debug(f"Successfully disabled log alert configuration with ID {id}")
+                return {"success": True, "message": f"Log alert configuration with ID {id} disabled successfully"}
+            except Exception as e:
+                logger.error(f"Error calling disable_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to disable log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in disable_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to disable log alert configuration: {e!s}"}
+
+    @register_as_tool
+    async def enable_log_alert_config(self, id: str, ctx=None) -> Dict[str, Any]:
+        """
+        Enable a log alert configuration.
+
+        Args:
+            id: ID of the log alert configuration to enable
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the result of the enable operation or error information
+        """
+        try:
+            logger.debug(f"enable_log_alert_config called with id={id}")
+
+            try:
+                self.log_alert_api.enable_log_alert_config(id=id)
+                logger.debug(f"Successfully enabled log alert configuration with ID {id}")
+                return {"success": True, "message": f"Log alert configuration with ID {id} enabled successfully"}
+            except Exception as e:
+                logger.error(f"Error calling enable_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to enable log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in enable_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to enable log alert configuration: {e!s}"}
+
+    @register_as_tool
+    async def find_active_log_alert_configs(self, alert_ids: Optional[List[str]] = None, ctx=None) -> Dict[str, Any]:
+        """
+        Get all active log alert configurations.
+
+        Args:
+            alert_ids: Optional list of alert IDs to filter by
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing active log alert configurations or error information
+        """
+        try:
+            logger.debug(f"find_active_log_alert_configs called with alert_ids={alert_ids}")
+
+            try:
+                result = self.log_alert_api.find_active_log_alert_configs(alert_ids=alert_ids)
+                logger.debug(f"Result from find_active_log_alert_configs: {result}")
+                return {"configs": [self._convert_to_dict(config) for config in result]}
+            except Exception as e:
+                logger.error(f"Error calling find_active_log_alert_configs API: {e}", exc_info=True)
+                return {"error": f"Failed to find active log alert configurations: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in find_active_log_alert_configs: {e}", exc_info=True)
+            return {"error": f"Failed to find active log alert configurations: {e!s}"}
+
+    @register_as_tool
+    async def find_log_alert_config(self, id: str, valid_on: Optional[int] = None, ctx=None) -> Dict[str, Any]:
+        """
+        Get a specific log alert configuration by ID.
+
+        Args:
+            id: ID of the log alert configuration to retrieve
+            valid_on: Optional timestamp to get the configuration valid at that time
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the log alert configuration or error information
+        """
+        try:
+            logger.debug(f"find_log_alert_config called with id={id}, valid_on={valid_on}")
+
+            try:
+                result = self.log_alert_api.find_log_alert_config(id=id, valid_on=valid_on)
+                logger.debug(f"Result from find_log_alert_config: {result}")
+                return self._convert_to_dict(result)
+            except Exception as e:
+                logger.error(f"Error calling find_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to find log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in find_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to find log alert configuration: {e!s}"}
+
+    @register_as_tool
+    async def find_log_alert_config_versions(self, id: str, ctx=None) -> Dict[str, Any]:
+        """
+        Get all versions of a log alert configuration.
+
+        Args:
+            id: ID of the log alert configuration to get versions for
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing versions of the log alert configuration or error information
+        """
+        try:
+            logger.debug(f"find_log_alert_config_versions called with id={id}")
+
+            try:
+                result = self.log_alert_api.find_log_alert_config_versions(id=id)
+                logger.debug(f"Result from find_log_alert_config_versions: {result}")
+                return {"versions": [self._convert_to_dict(version) for version in result]}
+            except Exception as e:
+                logger.error(f"Error calling find_log_alert_config_versions API: {e}", exc_info=True)
+                return {"error": f"Failed to find log alert configuration versions: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in find_log_alert_config_versions: {e}", exc_info=True)
+            return {"error": f"Failed to find log alert configuration versions: {e!s}"}
+
+    @register_as_tool
+    async def restore_log_alert_config(self, id: str, created: int, ctx=None) -> Dict[str, Any]:
+        """
+        Restore a log alert configuration to a previous version.
+
+        Args:
+            id: ID of the log alert configuration to restore
+            created: Timestamp of the version to restore
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the result of the restore operation or error information
+        """
+        try:
+            logger.debug(f"restore_log_alert_config called with id={id}, created={created}")
+
+            try:
+                self.log_alert_api.restore_log_alert_config(id=id, created=created)
+                logger.debug(f"Successfully restored log alert configuration with ID {id}")
+                return {
+                    "success": True,
+                    "message": f"Log alert configuration with ID {id} restored to version from {datetime.fromtimestamp(created/1000).isoformat()}"
+                }
+            except Exception as e:
+                logger.error(f"Error calling restore_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to restore log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in restore_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to restore log alert configuration: {e!s}"}
+
+    @register_as_tool
+    async def update_log_alert_config(self, id: str, config: Dict[str, Any], ctx=None) -> Dict[str, Any]:
+        """
+        Update a log alert configuration.
+
+        Args:
+            id: ID of the log alert configuration to update
+            config: Dictionary containing the updated log alert configuration
+            ctx: The MCP context (optional)
+
+        Returns:
+            Dictionary containing the updated log alert configuration or error information
+        """
+        try:
+            logger.debug(f"update_log_alert_config called with id={id}, config={config}")
+
+            try:
+                # Convert dictionary to LogAlertConfig model
+                log_alert_config = LogAlertConfig(**config)
+            except Exception as e:
+                logger.error(f"Error creating LogAlertConfig: {e}", exc_info=True)
+                return {"error": f"Failed to update log alert configuration: {e!s}"}
+
+            try:
+                # Call the API
+                result = self.log_alert_api.update_log_alert_config(id=id, log_alert_config=log_alert_config)
+                logger.debug(f"Result from update_log_alert_config: {result}")
+                return self._convert_to_dict(result)
+            except Exception as e:
+                logger.error(f"Error calling update_log_alert_config API: {e}", exc_info=True)
+                return {"error": f"Failed to update log alert configuration: {e!s}"}
+        except Exception as e:
+            logger.error(f"Error in update_log_alert_config: {e}", exc_info=True)
+            return {"error": f"Failed to update log alert configuration: {e!s}"}
+
+    def _convert_to_dict(self, obj: Any) -> Dict[str, Any]:
+        """
+        Convert an object to a dictionary.
+
+        Args:
+            obj: Object to convert
+
+        Returns:
+            Dictionary representation of the object
+        """
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        elif hasattr(obj, "__dict__"):
+            return obj.__dict__
+        else:
+            return obj

src/prompts/__init__.py

@@ -0,0 +1,16 @@
+"""Prompts package for MCP Instana."""
+import logging
+
+from fastmcp import FastMCP
+
+# Create an MCP server
+mcp = FastMCP("Instana MCP Server")
+
+# Global registry for all prompts
+PROMPT_REGISTRY = []
+
+def auto_register_prompt(func):
+    """Wrap MCP's @mcp.prompt to also store prompt in a registry."""
+    func = mcp.prompt()(func)  # apply MCP's decorator
+    PROMPT_REGISTRY.append(func)
+    return func

src/prompts/application/__init__.py

@@ -0,0 +1 @@
+"""Application-specific prompts package."""

src/prompts/application/application_alerts.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class ApplicationAlertsPrompts:
+    """Class containing application alerts related prompts"""
+
+
+    @auto_register_prompt
+    @staticmethod
+    def app_alerts_list(from_time: Optional[int]=None, to_time: Optional[int]=None, name_filter: Optional[str] = None, severity: Optional[str] = None) -> str:
+        """List all application alerts in Instana server"""
+        return f"""
+        List application alerts with filters:
+        - Name filter: {name_filter or 'None'}
+        - Severity: {severity or 'None'}
+        - Time range: {from_time} to {to_time or 'current time'}
+        """
+
+
+    @auto_register_prompt
+    @staticmethod
+    def app_alert_details(alert_ids: Optional[list] = None, application_id: Optional[str] = None) -> str:
+        """Get Smart Alert Configurations details for a specific application"""
+        return f"""
+        Get alert details for:
+        - Alert IDs: {alert_ids or 'None'}
+        - Application ID: {application_id or 'None'}
+        """
+
+
+    @auto_register_prompt
+    @staticmethod
+    def app_alert_config_delete(id: str) -> str:
+        """Delete a Smart Alert Configuration by ID"""
+        return f"Delete alert configuration with ID: {id}"
+
+
+    @auto_register_prompt
+    @staticmethod
+    def app_alert_config_enable(id: str) -> str:
+        """Enable a Smart Alert Configuration by ID"""
+        return f"Enable alert configuration with ID: {id}"
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('app_alerts_list', cls.app_alerts_list),
+            ('app_alert_details', cls.app_alert_details),
+            ('app_alert_config_delete', cls.app_alert_config_delete),
+            ('app_alert_config_enable', cls.app_alert_config_enable),
+        ]

src/prompts/application/application_catalog.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class ApplicationCatalogPrompts:
+    """Class containing application catalog related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def app_catalog_yesterday(limit: int, use_case: Optional[str] = None, data_source: Optional[str] = None, var_from: Optional[int] = None) -> str:
+        """List 3 available application tag catalog data for yesterday"""
+        return f"""
+        Get application catalog data:
+        - Use case: {use_case or 'None'}
+        - Data source: {data_source or 'None'}
+        - From: {var_from or 'last 24 hours'}
+        - Limit: {limit or '100'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('app_catalog_yesterday', cls.app_catalog_yesterday),
+        ]

src/prompts/application/application_metrics.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class ApplicationMetricsPrompts:
+    """Class containing application metrics related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_application_metrics(application_ids: Optional[list] = None, metrics: Optional[list] = None, time_frame: Optional[dict] = None, fill_time_series: Optional[bool] = None) -> str:
+        """Retrieve metrics for specific applications including latency, error rates, etc., over a given time frame"""
+        return f"""
+        Get application metrics for:
+        - Application IDs: {application_ids or 'None'}
+        - Metrics: {metrics or 'None'}
+        - Time frame: {time_frame or 'None'}
+        - Fill time series: {fill_time_series or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_application_endpoints_metrics(application_ids: Optional[list] = None, metrics: Optional[list] = None, time_frame: Optional[dict] = None, order: Optional[dict] = None, pagination: Optional[dict] = None, filters: Optional[dict] = None, fill_time_series: Optional[bool] = None) -> str:
+        """Retrieve metrics for endpoints within an application, such as latency, error rates, and call counts"""
+        return f"""
+        Get endpoint metrics for applications:
+        - Application IDs: {application_ids}
+        - Metrics: {metrics}
+        - Time frame: {time_frame}
+        - Order: {order or 'None'}
+        - Pagination: {pagination or 'None'}
+        - Filters: {filters or 'None'}
+        - Fill time series: {fill_time_series or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_application_service_metrics(service_ids: list, metrics: Optional[list] = None, var_from: Optional[int] = None, to: Optional[int] = None, fill_time_series: Optional[bool] = None, include_snapshot_ids: Optional[bool] = None) -> str:
+        """Fetch metrics over a specific time frame for specific services"""
+        return f"""
+        Get service metrics:
+        - Service IDs: {service_ids}
+        - Metrics: {metrics or 'None'}
+        - From: {var_from or '1 hour ago'}
+        - To: {to or 'now'}
+        - Fill time series: {fill_time_series or 'None'}
+        - Include snapshot IDs: {include_snapshot_ids or 'None'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_application_metrics', cls.get_application_metrics),
+            ('get_application_endpoints_metrics', cls.get_application_endpoints_metrics),
+            ('get_application_service_metrics', cls.get_application_service_metrics),
+        ]

src/prompts/application/application_resources.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class ApplicationResourcesPrompts:
+    """Class containing application resources related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def application_insights_summary(window_size: int, to_time: int, name_filter: Optional[str] = None, application_boundary_scope: Optional[str] = None) -> str:
+        """Retrieve a list of services within application perspectives from Instana"""
+        return f"""
+        Get application insights summary with:
+        - Name filter: {name_filter or 'None'}
+        - Window size: {window_size or '1 hour'}
+        - To time: {to_time or 'now'}
+        - Boundary scope: {application_boundary_scope or 'None'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('application_insights_summary', cls.application_insights_summary),
+        ]

src/prompts/application/application_settings.py

@@ -0,0 +1,75 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class ApplicationSettingsPrompts:
+    """Class containing application settings related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_all_applications_configs() -> str:
+        """Get a list of all Application Perspectives with their configuration settings"""
+        return "Retrieve all application configurations"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_application_config(id: str) -> str:
+        """Get an Application Perspective configuration by ID"""
+        return f"Retrieve application configuration with ID: {id}"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_all_endpoint_configs() -> str:
+        """Get a list of all Endpoint Perspectives with their configuration settings"""
+        return "Retrieve all endpoint configurations"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_endpoint_config(id: str) -> str:
+        """Retrieve the endpoint configuration of a service"""
+        return f"Get endpoint configuration with ID: {id}"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_all_manual_service_configs() -> str:
+        """Get a list of all Manual Service Perspectives with their configuration settings"""
+        return "Retrieve all manual service configurations"
+
+    @auto_register_prompt
+    @staticmethod
+    def add_manual_service_config(
+        enabled: bool,
+        tag_filter_expression: dict,
+        unmonitored_service_name: Optional[str] = None,
+        existing_service_id: Optional[str] = None,
+        description: Optional[str] = None
+    ) -> str:
+        """Create a manual service mapping configuration"""
+        return f"""
+        Add manual service configuration:
+        - Tag filter: {tag_filter_expression}
+        - Unmonitored service name: {unmonitored_service_name or 'None'}
+        - Existing service ID: {existing_service_id or 'None'}
+        - Description: {description or 'None'}
+        - Enabled: {enabled or 'True'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_service_config(id: str) -> str:
+        """Retrieve the particular custom service configuration"""
+        return f"Get service configuration with ID: {id}"
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_all_applications_configs', cls.get_all_applications_configs),
+            ('get_application_config', cls.get_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),
+            ('add_manual_service_config', cls.add_manual_service_config),
+            ('get_service_config', cls.get_service_config),
+        ]

src/prompts/application/application_topology.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class ApplicationTopologyPrompts:
+    """Class containing application topology related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_application_topology(
+        window_size: Optional[int] = None,
+        to_timestamp: Optional[int] = None,
+        application_id: Optional[str] = None,
+        application_boundary_scope: Optional[str] = None) -> str:
+        """Retrieve the service topology showing connections between services"""
+        return f"""
+        Get application topology:
+        - Window size: {window_size or '1 hour'}
+        - To timestamp: {to_timestamp or 'current time'}
+        - Application ID: {application_id or 'None'}
+        - Boundary scope: {application_boundary_scope or 'INBOUND'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_application_topology', cls.get_application_topology),
+        ]

src/prompts/events/__init__.py

@@ -0,0 +1 @@
+"""Events-specific prompts package."""