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

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),
+        ]

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),
+        ]