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

src/client/instana_client_base.py

@@ -1,93 +0,0 @@
-"""
-Base Instana API Client Module
-
-This module provides the base client for interacting with the Instana API.
-"""
-
-import sys
-import requests
-from typing import Dict, Any, AsyncIterator
-from contextlib import asynccontextmanager
-
-# Registry to store all tools
-MCP_TOOLS = {}
-
-def register_as_tool(func):
-    """Decorator to register a method as an MCP tool."""
-    MCP_TOOLS[func.__name__] = func
-    return func
-
-class BaseInstanaClient:
-    """Base client for Instana API with common functionality."""
-    
-    def __init__(self, read_token: str, base_url: str):
-        self.read_token = read_token
-        self.base_url = base_url
-    
-    def get_headers(self):
-        """Get standard headers for Instana API requests."""
-        return {
-            "Authorization": f"apiToken {self.read_token}",
-            "Content-Type": "application/json",
-            "Accept": "application/json"
-        }
-    
-    async def make_request(self, endpoint: str, params: Dict[str, Any] = None, method: str = "GET", json: Dict[str, Any] = None) -> Dict[str, Any]:
-        """Make a request to the Instana API."""
-        url = f"{self.base_url}/{endpoint.lstrip('/')}"
-        headers = self.get_headers()
-        
-        try:
-            if method.upper() == "GET":
-                response = requests.get(url, headers=headers, params=params, verify=False)
-            elif method.upper() == "POST":
-                # Use the json parameter if provided, otherwise use params
-                data_to_send = json if json is not None else params
-                response = requests.post(url, headers=headers, json=data_to_send, verify=False)
-            elif method.upper() == "PUT":
-                data_to_send = json if json is not None else params
-                response = requests.put(url, headers=headers, json=data_to_send, verify=False)
-            elif method.upper() == "DELETE":
-                response = requests.delete(url, headers=headers, params=params, verify=False)
-            else:
-                return {"error": f"Unsupported HTTP method: {method}"}
-                
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.HTTPError as err:
-            print(f"HTTP Error: {err}", file=sys.stderr)
-            return {"error": f"HTTP Error: {err}"}
-        except requests.exceptions.RequestException as err:
-            print(f"Error: {err}", file=sys.stderr)
-            return {"error": f"Error: {err}"}
-        except Exception as e:
-            print(f"Unexpected error: {str(e)}", file=sys.stderr)
-            return {"error": f"Unexpected error: {str(e)}"}
-
-@asynccontextmanager
-async def instana_api_token(read_token: str, base_url: str) -> AsyncIterator[Dict[str, BaseInstanaClient]]:
-    """
-    Context manager for creating and managing Instana API clients.
-    Returns a dictionary of client instances for different API groups.
-    """
-    # Import here to avoid circular imports
-    from .infrastructure_mcp_tools import InfrastructureMCPTools
-    from .application_mcp_tools import ApplicationClient
-    
-    # Create the standard clients
-    infra_client = InfrastructureMCPTools(read_token=read_token, base_url=base_url)
-    app_client = ApplicationClient(read_token=read_token, base_url=base_url)
-    
-    # Initialize clients dictionary
-    clients = {
-        "infrastructure": infra_client,
-        "application": app_client,
-    }
-    
-    try:
-        yield clients
-    except Exception as e:
-        print(f"Error in Instana API client: {e}", file=sys.stderr)
-    finally:
-        # Clean up resources if needed
-        pass

src/client/log_alert_configuration_mcp_tools.py

@@ -1,316 +0,0 @@
-"""
-Log Alert Configuration MCP Tools Module
-
-This module provides log alert configuration-specific MCP tools for Instana monitoring.
-"""
-
-import sys
-import traceback
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-
-# 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 as e:
-    traceback.print_exc(file=sys.stderr)
-    raise
-
-from .instana_client_base import BaseInstanaClient, register_as_tool
-
-# Helper function for debug printing
-def debug_print(*args, **kwargs):
-    """Print debug information to stderr instead of stdout"""
-    print(*args, file=sys.stderr, **kwargs)
-
-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:
-            debug_print(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)
-            debug_print(f"Initialized LogAlertConfigurationApi with host: {configuration.host}")
-        except Exception as e:
-            debug_print(f"Error initializing LogAlertConfigurationApi: {e}")
-            traceback.print_exc(file=sys.stderr)
-            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:
-            debug_print(f"create_log_alert_config called with config={config}")
-            
-            # Convert dictionary to LogAlertConfig model
-            log_alert_config = LogAlertConfig(**config)
-            
-            # Call the API
-            result = self.log_alert_api.create_log_alert_config(log_alert_config=log_alert_config)
-            
-            debug_print(f"Result from create_log_alert_config: {result}")
-            return self._convert_to_dict(result)
-        except Exception as e:
-            debug_print(f"Error in create_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to create log alert configuration: {str(e)}"}
-    
-    @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:
-            debug_print(f"delete_log_alert_config called with id={id}")
-            
-            self.log_alert_api.delete_log_alert_config(id=id)
-            
-            debug_print(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:
-            debug_print(f"Error in delete_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to delete log alert configuration: {str(e)}"}
-    
-    @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:
-            debug_print(f"disable_log_alert_config called with id={id}")
-            
-            self.log_alert_api.disable_log_alert_config(id=id)
-            
-            debug_print(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:
-            debug_print(f"Error in disable_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to disable log alert configuration: {str(e)}"}
-    
-    @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:
-            debug_print(f"enable_log_alert_config called with id={id}")
-            
-            self.log_alert_api.enable_log_alert_config(id=id)
-            
-            debug_print(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:
-            debug_print(f"Error in enable_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to enable log alert configuration: {str(e)}"}
-    
-    @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:
-            debug_print(f"find_active_log_alert_configs called with alert_ids={alert_ids}")
-            
-            result = self.log_alert_api.find_active_log_alert_configs(alert_ids=alert_ids)
-            
-            debug_print(f"Result from find_active_log_alert_configs: {result}")
-            return {"configs": [self._convert_to_dict(config) for config in result]}
-        except Exception as e:
-            debug_print(f"Error in find_active_log_alert_configs: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to find active log alert configurations: {str(e)}"}
-    
-    @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:
-            debug_print(f"find_log_alert_config called with id={id}, valid_on={valid_on}")
-            
-            result = self.log_alert_api.find_log_alert_config(id=id, valid_on=valid_on)
-            
-            debug_print(f"Result from find_log_alert_config: {result}")
-            return self._convert_to_dict(result)
-        except Exception as e:
-            debug_print(f"Error in find_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to find log alert configuration: {str(e)}"}
-    
-    @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:
-            debug_print(f"find_log_alert_config_versions called with id={id}")
-            
-            result = self.log_alert_api.find_log_alert_config_versions(id=id)
-            
-            debug_print(f"Result from find_log_alert_config_versions: {result}")
-            return {"versions": [self._convert_to_dict(version) for version in result]}
-        except Exception as e:
-            debug_print(f"Error in find_log_alert_config_versions: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to find log alert configuration versions: {str(e)}"}
-    
-    @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:
-            debug_print(f"restore_log_alert_config called with id={id}, created={created}")
-            
-            self.log_alert_api.restore_log_alert_config(id=id, created=created)
-            
-            debug_print(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:
-            debug_print(f"Error in restore_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to restore log alert configuration: {str(e)}"}
-    
-    @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:
-            debug_print(f"update_log_alert_config called with id={id}, config={config}")
-            
-            # Convert dictionary to LogAlertConfig model
-            log_alert_config = LogAlertConfig(**config)
-            
-            # Call the API
-            result = self.log_alert_api.update_log_alert_config(id=id, log_alert_config=log_alert_config)
-            
-            debug_print(f"Result from update_log_alert_config: {result}")
-            return self._convert_to_dict(result)
-        except Exception as e:
-            debug_print(f"Error in update_log_alert_config: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-            return {"error": f"Failed to update log alert configuration: {str(e)}"}
-    
-    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/client/show the top 5 services with the highest

@@ -1,28 +0,0 @@
-show the top 5 services with the highest number of calls to cassandra cluster ABC_CLUST
-What is the total latency in milliseconds for HTTP calls from the service named MyService to the host named myhost in the last hour?
- What is the sum of latency in the last 1 hour for database calls from the service named MyService to the host named myhost sorted by latency in descending order?
- Show me the average response time of HTTP requests to the APPXYZ application in the last 10 minutes, group result by call name, and order result by average response time in ascending order.
- show the average latency of all HTTP calls from service XYZ
- show the average latency of HTTP calls from service XYZ to service ABC, grouped by the call name
- What is the rate of calls in the last 5 minutes for HTTP calls from the service named MyService to the host named myhost grouped by destination host?
- show the average latency of HTTP calls to the service named 'my_service'
- show the average latency for all HTTP calls from service XYZ to service ABC
- show the number of calls and errors from service XYZ to service ABC, grouped by the destination server
- What is the number of calls in the last 2 hours for HTTP calls from the service named MyService to the host named myhost grouped by the call type and sorted by the number of calls in descending order?
- Show me the total number of calls, errors, and the response time for HTTP calls from the APPXYZ application in the last 2 hours, group result by call name, and order result by response time in ascending order.
- show the mean latency and number of calls from service XYZ to service ABC, grouped by the HTTP method
- What is the rate of errors per minute for database calls from the service named MyService to the host named myhost in the last hour?
- show the number of errors from service XYZ to service ABC, grouped by the HTTP method and ordered by errors
- What is the max latency in the last 1 hour for database calls to the host named myhost of the service named MyService?
- What are the  sum of errors for HTTP calls from the service named MyService to the service named MyOtherService in the last 5 minutes?
- What is the average latency in the last 1 hour for database calls to the host named myhost of the service named MyService, ordered by the latency in descending order?
- Show me the number of failed HTTP requests between applications appXYZ and appABC in the last hour, group result by error messages, and order result by number of errors in descending order.
- How many HTTP calls were made by the service named MyService to the host named myhost in the last 2 hours?
- What is the average response time of PCFindInventoryIVSyncService calls handled by apiserver service of oms-pcity-prod-1 application?
- Show top erroneous calls handled by 'Robot Shop - EP' application since yesterday
- Show performance overview of all http calls in the past 2 hours group by call name
- What is the average response time of promo HTTP calls handled by Kubernetes cluster demo-us-cluster?
- What is the average response time of readiness calls, handled by service app of application zone in last 1 day?
- Show count of erroneous HTTP calls by call.tag.Errorcode handled by AdService application.
- Show top erroneous calls handled by AdService service since last 10 minutes.
- Show performance overview of outbound http calls from kubernetes cluster kub8-names to AC-test1 application order by calls