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

src/infrastructure/infrastructure_analyze.py

@@ -10,7 +10,9 @@ from typing import Any, Dict, Optional, Union
 
 # Import the necessary classes from the SDK
 try:
-    from instana_client.api.infrastructure_analyze_api import InfrastructureAnalyzeApi
+    from instana_client.api.infrastructure_analyze_api import (
+        InfrastructureAnalyzeApi,
+    )
     from instana_client.api_client import ApiClient
     from instana_client.configuration import Configuration
     from instana_client.models.get_available_metrics_query import (
@@ -22,7 +24,9 @@ try:
     from instana_client.models.get_infrastructure_groups_query import (
         GetInfrastructureGroupsQuery,
     )
-    from instana_client.models.get_infrastructure_query import GetInfrastructureQuery
+    from instana_client.models.get_infrastructure_query import (
+        GetInfrastructureQuery,
+    )
 except ImportError as e:
     import logging
     logger = logging.getLogger(__name__)
@@ -271,7 +275,7 @@ class InfrastructureAnalyzeMCPTools(BaseInstanaClient):
             # Create the GetInfrastructureQuery object
             try:
                 # Create the query object directly from the request body
-                get_infra_query = GetInfrastructureQuery(**request_body)
+                get_infra_query = GetInfrastructureQuery(**request_body) #type: ignore
                 logger.debug("Successfully created GetInfrastructureQuery object")
             except Exception as model_error:
                 error_msg = f"Failed to create GetInfrastructureQuery object: {model_error}"

src/infrastructure/infrastructure_catalog.py

@@ -9,7 +9,9 @@ from typing import Any, Dict, List, Optional
 
 # Import the necessary classes from the SDK
 try:
-    from instana_client.api.infrastructure_catalog_api import InfrastructureCatalogApi
+    from instana_client.api.infrastructure_catalog_api import (
+        InfrastructureCatalogApi,
+    )
     from instana_client.api_client import ApiClient
     from instana_client.configuration import Configuration
 except ImportError as e:

src/infrastructure/infrastructure_metrics.py

@@ -18,8 +18,12 @@ from src.core.utils import (
 )
 
 try:
-    from instana_client.api.infrastructure_metrics_api import InfrastructureMetricsApi
-    from instana_client.models.get_combined_metrics import GetCombinedMetrics
+    from instana_client.api.infrastructure_metrics_api import (
+        InfrastructureMetricsApi,
+    )
+    from instana_client.models.get_combined_metrics import (
+        GetCombinedMetrics,
+    )
 except ImportError as e:
     import logging
     logger = logging.getLogger(__name__)

src/infrastructure/infrastructure_resources.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Optional, Union
 
 # Import the necessary classes from the SDK
 try:
-    from instana_client.api.infrastructure_resources_api import (
+    from instana_client.api.infrastructure_resources_api import (  #type: ignore
         InfrastructureResourcesApi,
     )
     # Check if GetSnapshotsQuery exists, otherwise we'll handle it differently
@@ -411,7 +411,9 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
             logger.debug(f"Using to_time={to_time}, window_size={window_size}")
 
             if has_get_snapshots_query:
-                from instana_client.models.get_snapshots_query import GetSnapshotsQuery
+                from instana_client.models.get_snapshots_query import (
+                    GetSnapshotsQuery,  #type: ignore
+                )
 
                 query_obj = GetSnapshotsQuery(
                     snapshot_ids=snapshot_ids,
@@ -594,8 +596,8 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
 
                     # Limit the number of items to return
                     if items_count > 10:
-                        result_dict['summary'] = f"Showing 10 of {items_count} items"
-                        result_dict['items'] = result_dict['items'][:10]
+                        result_dict['summary'] = f"Showing 10 of {items_count} items" #type: ignore
+                        result_dict['items'] = result_dict['items'][:10] #type: ignore
 
                 # If tagTree exists, extract tag names
                 if 'tagTree' in result_dict and isinstance(result_dict['tagTree'], list):
@@ -612,7 +614,7 @@ class InfrastructureResourcesMCPTools(BaseInstanaClient):
                                     })
 
                     # Replace the large tagTree with the extracted tag names
-                    result_dict['tagNames'] = tag_names
+                    result_dict['tagNames'] = tag_names #type: ignore
                     del result_dict['tagTree']
 
             return result_dict

src/infrastructure/infrastructure_topology.py

@@ -10,9 +10,11 @@ from typing import Any, Dict, Optional
 
 # Import the necessary classes from the SDK
 try:
-    from instana_client.api.infrastructure_topology_api import InfrastructureTopologyApi
-    from instana_client.api_client import ApiClient
-    from instana_client.configuration import Configuration
+    from instana_client.api.infrastructure_topology_api import (
+        InfrastructureTopologyApi,  #type: ignore
+    )
+    from instana_client.api_client import ApiClient  #type: ignore
+    from instana_client.configuration import Configuration  #type: ignore
 
 except ImportError:
     import logging

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."""

src/prompts/events/events_tools.py

@@ -0,0 +1,161 @@
+from typing import List, Optional, Union
+
+from src.prompts import auto_register_prompt
+
+
+class EventsPrompts:
+    """Class containing events related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_event(
+        event_id: str
+    ) -> str:
+        """Get an overview of a specific event"""
+        return f"""
+        Get specific event:
+        - Event ID: {event_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_kubernetes_info_events(
+        from_time: Optional[int] = None,
+        to_time: Optional[int] = None,
+        time_range: Optional[str] = None,
+        max_events: Optional[int] = 50
+    ) -> str:
+        """Get Kubernetes info events and analyze them"""
+        return f"""
+        Get Kubernetes info events:
+        - From time: {from_time or '(default: 24 hours ago)'}
+        - To time: {to_time or '(default: current time)'}
+        - Time range: {time_range or '(not specified)'}
+        - Max events: {max_events}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_agent_monitoring_events(
+        query: Optional[str] = None,
+        from_time: Optional[int] = None,
+        to_time: Optional[int] = None,
+        size: Optional[int] = 100,
+        max_events: Optional[int] = 50,
+        time_range: Optional[str] = None
+    ) -> str:
+        """Get Agent monitoring events and analyze them"""
+        return f"""
+        Get Agent monitoring events:
+        - Query: {query or '(not specified)'}
+        - From time: {from_time or '(default: 1 hour ago)'}
+        - To time: {to_time or '(default: current time)'}
+        - Size: {size}
+        - Max events: {max_events}
+        - Time range: {time_range or '(not specified)'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_issues(
+        query: Optional[str] = None,
+        from_time: Optional[int] = None,
+        to_time: Optional[int] = None,
+        filter_event_updates: Optional[bool] = None,
+        exclude_triggered_before: Optional[int] = None,
+        event_type_filters: Optional[list[str]] = None,
+        max_events: Optional[int] = 50,
+        size: Optional[int] = 100,
+        time_range: Optional[str] = None
+    ) -> str:
+        """Get all issues within a specified time range"""
+        return f"""
+        Get all events:
+        - Query: {query or '(not specified)'}
+        - From time: {from_time or '(default: 1 hour ago)'}
+        - To time: {to_time or '(default: current time)'}
+        - Size: {size}
+        - Max events: {max_events}
+        - Time range: {time_range or '(not specified)'}
+        - Filter event updates: {filter_event_updates or 'False'}
+        - Exclude triggered before: {exclude_triggered_before or 'None'}
+        - Event type filters: {event_type_filters or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_incidents(
+        query: Optional[str] = None,
+        from_time: Optional[int] = None,
+        to_time: Optional[int] = None,
+        filter_event_updates: Optional[bool] = None,
+        exclude_triggered_before: Optional[int] = None,
+        event_type_filters: Optional[list[str]] = None,
+        max_events: Optional[int] = 50,
+        size: Optional[int] = 100,
+        time_range: Optional[str] = None
+    ) -> str:
+        """Get all incidents within a specified time range"""
+        return f"""
+        Get all events:
+        - Query: {query or '(not specified)'}
+        - From time: {from_time or '(default: 1 hour ago)'}
+        - To time: {to_time or '(default: current time)'}
+        - Size: {size}
+        - Max events: {max_events}
+        - Time range: {time_range or '(not specified)'}
+        - Filter event updates: {filter_event_updates or 'False'}
+        - Exclude triggered before: {exclude_triggered_before or 'None'}
+        - Event type filters: {event_type_filters or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_changes(
+        query: Optional[str] = None,
+        from_time: Optional[int] = None,
+        to_time: Optional[int] = None,
+        filter_event_updates: Optional[bool] = None,
+        exclude_triggered_before: Optional[int] = None,
+        event_type_filters: Optional[list[str]] = None,
+        max_events: Optional[int] = 50,
+        size: Optional[int] = 100,
+        time_range: Optional[str] = None
+    ) -> str:
+        """Get all changes within a specified time range"""
+        return f"""
+        Get all events:
+        - Query: {query or '(not specified)'}
+        - From time: {from_time or '(default: 1 hour ago)'}
+        - To time: {to_time or '(default: current time)'}
+        - Size: {size}
+        - Max events: {max_events}
+        - Time range: {time_range or '(not specified)'}
+        - Filter event updates: {filter_event_updates or 'False'}
+        - Exclude triggered before: {exclude_triggered_before or 'None'}
+        - Event type filters: {event_type_filters or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_events_by_ids(
+        event_ids: Union[List[str], str]
+    ) -> str:
+        """Get multiple events by their IDs"""
+        return f"""
+        Get events by IDs:
+        - Event IDs: {event_ids}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_event', cls.get_event),
+            ('get_kubernetes_info_events', cls.get_kubernetes_info_events),
+            ('get_agent_monitoring_events', cls.get_agent_monitoring_events),
+            ('get_issues', cls.get_issues),
+            ('get_incidents', cls.get_incidents),
+            ('get_changes', cls.get_changes),
+            ('get_events_by_ids', cls.get_events_by_ids),
+        ]

src/prompts/infrastructure/infrastructure_analyze.py

@@ -0,0 +1,72 @@
+"""
+Infrastructure Analyze MCP Prompts Module
+
+This module provides infrastructure analyze-specific MCP prompts for Instana monitoring.
+"""
+
+from typing import Callable, Dict, List, Optional, Tuple
+
+from src.prompts import auto_register_prompt
+
+
+class InfrastructureAnalyzePrompts:
+    """Class containing prompts for infrastructure analysis in Instana."""
+
+    @auto_register_prompt
+    @staticmethod
+    def infra_available_metrics(
+        type: str,
+        query: Optional[str] = None,
+        var_from: Optional[int] = None,
+        to: Optional[int] = None,
+        windowSize: Optional[int] = None) -> str:
+        """Get available infrastructure metrics for a given entity type"""
+        return f"""
+        Get available infrastructure metrics:
+        - Type: {type}
+        - Query: {query or 'None'}
+        - From: {var_from or 'None'}
+        - To: {to or 'None'}
+        - Window size: {windowSize or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def infra_get_entities(
+        type: str,
+        metrics: Optional[str] = None,
+        windowSize: Optional[int] = None,
+        to: Optional[int] = None) -> str:
+        """Fetch infrastructure entities and their metrics"""
+        return f"""
+        Get infrastructure entities:
+        - Type: {type}
+        - Metrics: {metrics}
+        - Window size: {windowSize or 'None'}
+        - To: {to or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def infra_available_plugins(
+        offline: bool,
+        query: Optional[str] = None,
+        windowSize: Optional[int] = None,
+        to: Optional[int] = None) -> str:
+        """List available infrastructure monitoring plugins"""
+        return f"""
+        Get available infrastructure plugins:
+        - Query: {query or 'None'}
+        - Offline: {offline or 'False'}
+        - Window size: {windowSize or 'None'}
+        - To: {to or 'None'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Get all prompts defined in this class"""
+        return [
+            ('infra_available_metrics', cls.infra_available_metrics),
+            ('infra_get_entities', cls.infra_get_entities),
+            ('infra_available_plugins', cls.infra_available_plugins),
+        ]