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

src/prompts/infrastructure/infrastructure_catalog.py

@@ -0,0 +1,53 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class InfrastructureCatalogPrompts:
+    """Class containing infrastructure catalog related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_available_payload_keys_by_plugin_id(plugin_id: str) -> str:
+        """Retrieve available payload keys for a specific plugin"""
+        return f"Get payload keys for plugin ID: {plugin_id}"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_infrastructure_catalog_metrics(plugin: str, filter: Optional[str] = None) -> str:
+        """
+        Get the list of available metrics for a specified plugin, supporting metric exploration for dashboards and queries.
+
+        Args:
+            plugin (str): Plugin (e.g., host, JVM, Kubernetes)
+            filter (Optional[str], optional): Filter string for narrowing down metrics
+        """
+        return f"""
+        Get infrastructure catalog metrics:
+        - Plugin: {plugin}
+        - Filter: {filter or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_tag_catalog(plugin: str) -> str:
+        """Get available tags for a specific plugin"""
+        return f"Get tag catalog for plugin: {plugin}"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_tag_catalog_all() -> str:
+        """Retrieve the complete list of tags available across all monitored entities"""
+        return "Get all tag catalogs"
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_available_payload_keys_by_plugin_id', cls.get_available_payload_keys_by_plugin_id),
+            ('get_infrastructure_catalog_metrics', cls.get_infrastructure_catalog_metrics),
+            ('get_tag_catalog', cls.get_tag_catalog),
+            ('get_tag_catalog_all', cls.get_tag_catalog_all),
+        ]
+
+

src/prompts/infrastructure/infrastructure_metrics.py

@@ -0,0 +1,45 @@
+"""
+Infrastructure Metrics MCP Prompts Module
+
+This module provides infrastructure metrics-specific MCP prompts for Instana monitoring.
+"""
+
+from typing import Callable, List, Optional, Tuple
+
+from src.prompts import auto_register_prompt
+
+
+class InfrastructureMetricsPrompts:
+    """Class containing prompts for infrastructure metrics in Instana."""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_infrastructure_metrics(
+        offline: bool,
+        rollup: int,
+        plugin: str,
+        window_size: Optional[int] = None,
+        query: Optional[str] = None,
+        metrics: Optional[List] = None,
+        snapshot_ids: Optional[List] = None,
+        to: Optional[int] = None,
+    ) -> str:
+        """Retrieve infrastructure metrics for plugin and query with a given time frame"""
+        return f"""
+        Get infrastructure metrics:
+        - Plugin: {plugin}
+        - Query: {query}
+        - Metrics: {metrics}
+        - Snapshot IDs: {snapshot_ids or 'None'}
+        - Offline: {offline or 'False'}
+        - Window size: {window_size or '1 hour'}
+        - To: {to or 'current time'}
+        - Rollup: {rollup or '60 seconds'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Get all prompts defined in this class"""
+        return [
+            ('get_infrastructure_metrics', cls.get_infrastructure_metrics),
+        ]

src/prompts/infrastructure/infrastructure_resources.py

@@ -0,0 +1,74 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class InfrastructureResourcesPrompts:
+    """Class containing infrastructure resources related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_infrastructure_monitoring_state() -> str:
+        """Get an overview of the current Instana monitoring state"""
+        return "Get infrastructure monitoring state"
+
+    @auto_register_prompt
+    @staticmethod
+    def get_infrastructure_plugin_payload(
+        snapshot_id: str,
+        payload_key: str,
+        to_time: Optional[int] = None,
+        window_size: Optional[int] = None
+    ) -> str:
+        """Get raw plugin payload data for a specific snapshot entity"""
+        return f"""
+        Get plugin payload:
+        - Snapshot ID: {snapshot_id}
+        - Payload key: {payload_key}
+        - To time: {to_time or 'current time'}
+        - Window size: {window_size or '1 hour'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_infrastructure_metrics_snapshot(
+        snapshot_id: str,
+        to_time: Optional[int] = None,
+        window_size: Optional[int] = None
+    ) -> str:
+        """Get detailed information for a single infrastructure snapshot"""
+        return f"""
+        Get infrastructure snapshot:
+        - Snapshot ID: {snapshot_id}
+        - To time: {to_time or 'current time'}
+        - Window size: {window_size or '1 hour'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def post_infrastructure_metrics_snapshot(
+        snapshot_ids: list[str],
+        to_time: Optional[int] = None,
+        window_size: Optional[int] = None,
+        detailed: Optional[bool] = False,
+    ) -> str:
+        """Fetch details of multiple snapshots by their IDs"""
+        return f"""
+        Get multiple infrastructure snapshots:
+        - Snapshot IDs: {snapshot_ids}
+        - To time: {to_time or 'current time'}
+        - Window size: {window_size or '1 hour'}
+        - Detailed: {detailed or 'False'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_infrastructure_monitoring_state', cls.get_infrastructure_monitoring_state),
+            ('get_infrastructure_plugin_payload', cls.get_infrastructure_plugin_payload),
+            ('get_infrastructure_metrics_snapshot', cls.get_infrastructure_metrics_snapshot),
+            ('post_infrastructure_metrics_snapshot', cls.post_infrastructure_metrics_snapshot),
+        ]
+
+

src/prompts/infrastructure/infrastructure_topology.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class InfrastructureTopologyPrompts:
+    """Class containing infrastructure topology related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_related_hosts(
+        snapshot_id: str,
+        to_time: Optional[int] = None,
+        window_size: Optional[int] = None
+    ) -> str:
+        """Get hosts related to a specific snapshot"""
+        return f"""
+        Get related hosts:
+        - Snapshot ID: {snapshot_id}
+        - To time: {to_time or '1 hour'}
+        - Window size: {window_size or '1 hour'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_topology(include_data: Optional[bool] = False) -> str:
+        """Retrieve the complete infrastructure topology"""
+        return f"Get complete topology with include_data: {include_data or 'False'}"
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_related_hosts', cls.get_related_hosts),
+            ('get_topology', cls.get_topology),
+        ]
+
+

src/prompts/settings/custom_dashboard.py

@@ -0,0 +1,157 @@
+from typing import Any, Dict, List, Optional
+
+from src.prompts import auto_register_prompt
+
+
+class CustomDashboardPrompts:
+    """Class containing custom dashboard related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def create_dashboard(title: str,
+                        widgets: Optional[List[Dict[str, Any]]] = None,
+                        access_rules: Optional[List[Dict[str, Any]]] = None,
+                        description: Optional[str] = None,
+                        tags: Optional[List[str]] = None) -> str:
+        """Create a new custom dashboard with specified configuration"""
+        return f"""
+        Create a new custom dashboard with:
+        - Title: {title}
+        - Description: {description or 'None'}
+        - Widgets: {widgets or 'None'}
+        - Access rules: {access_rules or 'None'}
+        - Tags: {tags or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_dashboard_list(limit: Optional[int] = None,
+                          tags: Optional[List[str]] = None,
+                          search: Optional[str] = None) -> str:
+        """Retrieve a list of all custom dashboards"""
+        return f"""
+        Get custom dashboards list:
+        - Limit: {limit or 'None'}
+        - Tags filter: {tags or 'None'}
+        - Search: {search or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_dashboard_details(dashboard_id: str) -> str:
+        """Get detailed information about a specific custom dashboard"""
+        return f"""
+        Get custom dashboard details:
+        - Dashboard ID: {dashboard_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def update_dashboard(dashboard_id: str,
+                        title: Optional[str] = None,
+                        widgets: Optional[List[Dict[str, Any]]] = None,
+                        access_rules: Optional[List[Dict[str, Any]]] = None,
+                        description: Optional[str] = None,
+                        tags: Optional[List[str]] = None) -> str:
+        """Update an existing custom dashboard configuration"""
+        return f"""
+        Update custom dashboard:
+        - Dashboard ID: {dashboard_id}
+        - Title: {title or 'None'}
+        - Description: {description or 'None'}
+        - Widgets: {widgets or 'None'}
+        - Access rules: {access_rules or 'None'}
+        - Tags: {tags or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def delete_dashboard(dashboard_id: str) -> str:
+        """Delete a custom dashboard"""
+        return f"""
+        Delete custom dashboard:
+        - Dashboard ID: {dashboard_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_shareable_users(dashboard_id: str) -> str:
+        """Get list of users who can be granted access to a custom dashboard"""
+        return f"""
+        Get shareable users for dashboard:
+        - Dashboard ID: {dashboard_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_shareable_api_tokens(dashboard_id: str) -> str:
+        """Get list of API tokens that can access a custom dashboard"""
+        return f"""
+        Get shareable API tokens for dashboard:
+        - Dashboard ID: {dashboard_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def create_metric_widget(title: str,
+                           metric_name: str,
+                           time_range: Optional[str] = None,
+                           aggregation: Optional[str] = None,
+                           filters: Optional[Dict[str, Any]] = None) -> str:
+        """Create a metric widget for a custom dashboard"""
+        return f"""
+        Create metric widget:
+        - Title: {title}
+        - Metric: {metric_name}
+        - Time range: {time_range or 'last 1 hour'}
+        - Aggregation: {aggregation or 'None'}
+        - Filters: {filters or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def create_chart_widget(title: str,
+                          chart_type: str,
+                          metrics: List[str],
+                          time_range: Optional[str] = None,
+                          group_by: Optional[str] = None) -> str:
+        """Create a chart widget for a custom dashboard"""
+        return f"""
+        Create chart widget:
+        - Title: {title}
+        - Chart type: {chart_type}
+        - Metrics: {metrics}
+        - Time range: {time_range or 'last 1 hour'}
+        - Group by: {group_by or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def create_application_dashboard(application_name: str,
+                                   include_metrics: Optional[List[str]] = None,
+                                   include_topology: Optional[bool] = None,
+                                   time_range: Optional[str] = None) -> str:
+        """Create a comprehensive dashboard for a specific application"""
+        return f"""
+        Create application dashboard:
+        - Application: {application_name}
+        - Metrics: {include_metrics or 'None'}
+        - Include topology: {include_topology or 'None'}
+        - Time range: {time_range or 'last 1 hour'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('create_dashboard', cls.create_dashboard),
+            ('get_dashboard_list', cls.get_dashboard_list),
+            ('get_dashboard_details', cls.get_dashboard_details),
+            ('update_dashboard', cls.update_dashboard),
+            ('delete_dashboard', cls.delete_dashboard),
+            ('get_shareable_users', cls.get_shareable_users),
+            ('get_shareable_api_tokens', cls.get_shareable_api_tokens),
+            ('create_metric_widget', cls.create_metric_widget),
+            ('create_chart_widget', cls.create_chart_widget),
+            ('create_application_dashboard', cls.create_application_dashboard),
+        ]

src/prompts/website/__init__.py

@@ -0,0 +1 @@
+# Website prompts module

src/prompts/website/website_analyze.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class WebsiteAnalyzePrompts:
+    """Class containing website analyze related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_beacon_groups(payload: Optional[dict] = None, fill_time_series: Optional[bool] = None) -> str:
+        """Retrieve grouped website beacon metrics for analyzing performance across different dimensions like page URLs, browsers, or geographic locations"""
+        return f"""
+        Get website beacon groups with payload:
+        - Payload: {payload or 'None (will use default payload)'}
+        - Fill time series: {fill_time_series or 'None'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_beacons(payload: Optional[dict] = None, fill_time_series: Optional[bool] = None) -> str:
+        """Retrieve individual website beacon metrics providing detailed information about specific beacon events"""
+        return f"""
+        Get website beacons with payload:
+        - Payload: {payload or 'None (will use default payload)'}
+        - Fill time series: {fill_time_series or 'None'}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_website_beacon_groups', cls.get_website_beacon_groups),
+            ('get_website_beacons', cls.get_website_beacons),
+        ]

src/prompts/website/website_catalog.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class WebsiteCatalogPrompts:
+    """Class containing website catalog related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_catalog_metrics() -> str:
+        """Retrieve all available metric definitions for website monitoring to discover what metrics are available"""
+        return """
+        Get website catalog metrics to discover available website monitoring metrics.
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_catalog_tags() -> str:
+        """Retrieve all available tags for website monitoring to discover what tags are available for filtering beacons"""
+        return """
+        Get website catalog tags to discover available website monitoring tags for filtering.
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_tag_catalog() -> str:
+        """Retrieve all available tags for website monitoring to discover what tags are available for filtering beacons"""
+        return """
+        Get website tag catalog to discover available website monitoring tags for filtering.
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_website_catalog_metrics', cls.get_website_catalog_metrics),
+            ('get_website_catalog_tags', cls.get_website_catalog_tags),
+            ('get_website_tag_catalog', cls.get_website_tag_catalog),
+        ]

src/prompts/website/website_configuration.py

@@ -0,0 +1,105 @@
+from typing import Optional, Union
+
+from src.prompts import auto_register_prompt
+
+
+class WebsiteConfigurationPrompts:
+    """Class containing website configuration related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_websites() -> str:
+        """Retrieve all configured websites in your Instana environment"""
+        return """
+        Get all websites to see configured website monitoring setups.
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website(website_id: str) -> str:
+        """Retrieve configuration details for a specific website"""
+        return f"""
+        Get website configuration:
+        - Website ID: {website_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def create_website(payload: Union[dict, str]) -> str:
+        """Create a new website configuration in your Instana environment"""
+        return f"""
+        Create website with configuration:
+        - Payload: {payload}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def delete_website(website_id: str) -> str:
+        """Delete a website configuration from your Instana environment"""
+        return f"""
+        Delete website:
+        - Website ID: {website_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def rename_website(website_id: str, payload: Union[dict, str]) -> str:
+        """Rename a website configuration in your Instana environment"""
+        return f"""
+        Rename website:
+        - Website ID: {website_id}
+        - Rename payload: {payload}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_geo_location_configuration(website_id: str) -> str:
+        """Retrieve geo-location configuration for a specific website"""
+        return f"""
+        Get website geo-location configuration:
+        - Website ID: {website_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def update_website_geo_location_configuration(website_id: str, payload: Union[dict, str]) -> str:
+        """Update geo-location configuration for a specific website"""
+        return f"""
+        Update website geo-location configuration:
+        - Website ID: {website_id}
+        - Configuration payload: {payload}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_ip_masking_configuration(website_id: str) -> str:
+        """Retrieve IP masking configuration for a specific website"""
+        return f"""
+        Get website IP masking configuration:
+        - Website ID: {website_id}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def update_website_ip_masking_configuration(website_id: str, payload: Union[dict, str]) -> str:
+        """Update IP masking configuration for a specific website"""
+        return f"""
+        Update website IP masking configuration:
+        - Website ID: {website_id}
+        - Configuration payload: {payload}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_websites', cls.get_websites),
+            ('get_website', cls.get_website),
+            ('create_website', cls.create_website),
+            ('delete_website', cls.delete_website),
+            ('rename_website', cls.rename_website),
+            ('get_website_geo_location_configuration', cls.get_website_geo_location_configuration),
+            ('update_website_geo_location_configuration', cls.update_website_geo_location_configuration),
+            ('get_website_ip_masking_configuration', cls.get_website_ip_masking_configuration),
+            ('update_website_ip_masking_configuration', cls.update_website_ip_masking_configuration),
+        ]

src/prompts/website/website_metrics.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+from src.prompts import auto_register_prompt
+
+
+class WebsiteMetricsPrompts:
+    """Class containing website metrics related prompts"""
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_beacon_metrics_v2(payload: Optional[dict] = None) -> str:
+        """Retrieve website beacon metrics using the v2 API including page load times, error rates, etc., over a given time frame"""
+        return f"""
+        Get website beacon metrics v2 with payload:
+        - Payload: {payload or 'None (will use default payload)'}
+        """
+
+    @auto_register_prompt
+    @staticmethod
+    def get_website_page_load(page_id: str, timestamp: int) -> str:
+        """Retrieve detailed beacon information for a specific page load event"""
+        return f"""
+        Get website page load details:
+        - Page ID: {page_id}
+        - Timestamp: {timestamp}
+        """
+
+    @classmethod
+    def get_prompts(cls):
+        """Return all prompts defined in this class"""
+        return [
+            ('get_website_beacon_metrics_v2', cls.get_website_beacon_metrics_v2),
+            ('get_website_page_load', cls.get_website_page_load),
+        ]

src/settings/__init__.py

@@ -0,0 +1 @@
+# Settings Module for Instana MCP