mcp-instana 0.1.0__py3-none-any.whl

src/client/log_alert_configuration_mcp_tools.py

@@ -0,0 +1,316 @@
+"""
+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

@@ -0,0 +1,28 @@
+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

src/mcp_server.py

@@ -0,0 +1,343 @@
+"""
+Standalone MCP Server for Instana Events and Infrastructure Resources
+
+This module provides a dedicated MCP server that exposes Instana tools.
+Supports stdio and Streamable HTTP transports.
+"""
+
+import argparse
+import os
+import sys
+import warnings
+import traceback
+import json
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, fields
+from dotenv import load_dotenv
+load_dotenv()
+
+# Add the project root to the Python path
+current_path = os.path.abspath(__file__)
+project_root = os.path.dirname(os.path.dirname(current_path))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+# Import the necessary modules
+try:
+    from src.client.events_mcp_tools import AgentMonitoringEventsMCPTools
+    from src.client.infrastructure_resources_mcp_tools import InfrastructureResourcesMCPTools
+    from src.client.infrastructure_catalog_mcp_tools import InfrastructureCatalogMCPTools
+    from src.client.application_resources_mcp_tools import ApplicationResourcesMCPTools
+    from src.client.application_metrics_mcp_tools import ApplicationMetricsMCPTools
+    from src.client.infrastructure_topology_mcp_tools import InfrastructureTopologyMCPTools
+    from src.client.infrastructure_analyze_mcp_tools import InfrastructureAnalyzeMCPTools
+    from src.client.application_alert_config_mcp_tools import ApplicationAlertMCPTools
+    
+    from src.client.instana_client_base import register_as_tool, MCP_TOOLS
+except ImportError as e:
+    traceback.print_exc(file=sys.stderr)
+    sys.exit(1)
+
+from mcp.server.fastmcp import FastMCP
+
+@dataclass
+class MCPState:
+    """State for the MCP server."""
+    events_client: AgentMonitoringEventsMCPTools = None
+    infra_client: InfrastructureResourcesMCPTools = None
+    app_resource_client: ApplicationResourcesMCPTools = None
+    app_metrics_client: ApplicationMetricsMCPTools = None
+    app_alert_client: ApplicationAlertMCPTools = None
+    infra_catalog_client: InfrastructureCatalogMCPTools = None
+    infra_topo_client: InfrastructureTopologyMCPTools = None
+    infra_analyze_client: InfrastructureAnalyzeMCPTools = None
+
+# Global variables to store credentials for lifespan
+_global_token = ""
+_global_base_url = ""
+
+def get_client_configs():
+    """Get client configurations dynamically from MCPState dataclass"""
+    # Map field names to their corresponding client classes
+    client_class_mapping = {
+        'events_client': AgentMonitoringEventsMCPTools,
+        'infra_client': InfrastructureResourcesMCPTools,
+        'infra_catalog_client': InfrastructureCatalogMCPTools,
+        'infra_topo_client': InfrastructureTopologyMCPTools,
+        'infra_analyze_client': InfrastructureAnalyzeMCPTools,
+        'app_resource_client': ApplicationResourcesMCPTools,
+        'app_metrics_client': ApplicationMetricsMCPTools,
+        'app_alert_client': ApplicationAlertMCPTools,
+    }
+    
+    # Get all field names from MCPState dataclass
+    state_fields = [field.name for field in fields(MCPState)]
+    
+    # Return configurations for fields that have corresponding client classes
+    configs = []
+    for field_name in state_fields:
+        if field_name in client_class_mapping:
+            configs.append((field_name, client_class_mapping[field_name]))
+        else:
+            print(f"Warning: No client class mapping found for field '{field_name}'", file=sys.stderr)
+    
+    return configs
+
+def create_clients(token: str, base_url: str, enabled_categories: str = "all") -> MCPState:
+    """Create only the enabled Instana clients"""
+    state = MCPState()
+    
+    # Get enabled client configurations
+    enabled_client_configs = get_enabled_client_configs(enabled_categories)
+    
+    for attr_name, client_class in enabled_client_configs:
+        try:
+            client = client_class(read_token=token, base_url=base_url)
+            setattr(state, attr_name, client)
+        except Exception as e:
+            print(f"Failed to create {attr_name}: {e}", file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+            setattr(state, attr_name, None)
+    
+    return state
+
+
+@asynccontextmanager
+async def lifespan(server: FastMCP) -> AsyncIterator[MCPState]:
+    """Set up and tear down the Instana clients."""
+    # Use global credentials set by create_app
+    token = _global_token or os.getenv("INSTANA_API_TOKEN", "")
+    base_url = _global_base_url or os.getenv("INSTANA_BASE_URL", "")
+    enabled_categories = os.getenv("INSTANA_ENABLED_TOOLS", "all")
+    
+    try:
+        state = create_clients(token, base_url, enabled_categories)
+        
+        yield state
+    except Exception as e:
+        traceback.print_exc(file=sys.stderr)
+        
+        # Yield empty state if client creation failed
+        yield MCPState()
+
+def create_app(instana_api_token_value: str, instana_base_url: str) -> FastMCP:
+    global _global_token, _global_base_url
+
+    try:
+        _global_token = instana_api_token_value
+        _global_base_url = instana_base_url
+
+        server = FastMCP("Instana Tools", lifespan=lifespan)
+
+        # Use the enabled categories from the environment
+        enabled_categories = os.getenv("INSTANA_ENABLED_TOOLS", "all")
+
+        # Only create and register enabled clients/tools
+        clients_state = create_clients(instana_api_token_value, instana_base_url, enabled_categories)
+
+        tools_registered = 0
+        for tool_name, tool_func in MCP_TOOLS.items():
+            try:
+                client_found = False
+                client_attr_names = [field.name for field in fields(MCPState)]
+                for attr_name in client_attr_names:
+                    client = getattr(clients_state, attr_name, None)
+                    if client and hasattr(client, tool_name):
+                        bound_method = getattr(client, tool_name)
+                        server.tool()(bound_method)
+                        tools_registered += 1
+                        client_found = True
+                        break
+            except Exception as e:
+                print(f"Failed to register tool {tool_name}: {e}", file=sys.stderr)
+                traceback.print_exc(file=sys.stderr)
+
+        return server, tools_registered
+
+    except Exception as e:
+        traceback.print_exc(file=sys.stderr)
+        fallback_server = FastMCP("Instana Tools")
+        return fallback_server
+
+async def execute_tool(tool_name: str, arguments: dict, clients_state) -> str:
+    """Execute a tool and return result"""
+    try:
+        # Get all field names from MCPState dataclass
+        client_attr_names = [field.name for field in fields(MCPState)]
+        
+        for attr_name in client_attr_names:
+            client = getattr(clients_state, attr_name, None)
+            if client and hasattr(client, tool_name):
+                method = getattr(client, tool_name)
+                result = await method(**arguments)
+                return str(result)
+        
+        return f"Tool {tool_name} not found"
+    except Exception as e:
+        return f"Error executing tool {tool_name}: {str(e)}"
+
+
+client_categories = {
+    "infra": [
+        ('infra_client', InfrastructureResourcesMCPTools),
+        ('infra_catalog_client', InfrastructureCatalogMCPTools),
+        ('infra_topo_client', InfrastructureTopologyMCPTools),
+        ('infra_analyze_client', InfrastructureAnalyzeMCPTools),
+    ],
+    "app": [
+        ('app_resource_client', ApplicationResourcesMCPTools),
+        ('app_metrics_client', ApplicationMetricsMCPTools),
+        ('app_alert_client', ApplicationAlertMCPTools),
+    ],
+    "events": [
+        ('events_client', AgentMonitoringEventsMCPTools),
+    ]
+}
+
+def get_enabled_client_configs(enabled_categories: str):
+    """Get client configurations based on enabled categories"""
+    # Use the global client_categories mapping
+    if enabled_categories.lower() == "all":
+        all_configs = []
+        for category_clients in client_categories.values():
+            all_configs.extend(category_clients)
+        return all_configs
+    categories = [cat.strip() for cat in enabled_categories.split(",")]
+    enabled_configs = []
+    for category in categories:
+        if category in client_categories:
+            enabled_configs.extend(client_categories[category])
+        else:
+            print(f"Warning: Unknown category '{category}'", file=sys.stderr)
+    return enabled_configs
+
+
+def main():
+    """Main entry point for the MCP server."""
+    try:
+        # Get token from environment
+        instana_api_token_value = os.getenv("INSTANA_API_TOKEN")
+        if not instana_api_token_value:
+            warnings.warn(
+                "Instana API token not provided. Some functionality will be limited. "
+                "Provide token via --api-token argument or INSTANA_API_TOKEN environment variable."
+            )
+
+        # Get base URL from environment
+        instana_base_url = os.getenv("INSTANA_BASE_URL")
+
+        # Create and configure the MCP server
+        parser = argparse.ArgumentParser(description="Instana MCP Server", add_help=False)
+        parser.add_argument(
+                "-h", "--help",
+                action="store_true",
+                dest="help",
+                help="show this help message and exit"
+            )
+        parser.add_argument(
+            "--transport",
+            type=str,
+            choices=["streamable-http","stdio"],
+            metavar='<mode>',
+            help="Transport mode. Choose from: streamable-http, stdio."
+        )
+        parser.add_argument(
+            "--debug",
+            action="store_true",
+            help="Enable debug mode with additional logging"
+        )
+        parser.add_argument(
+            "--disable",
+            type=str,
+            metavar='<categories>',
+            help="Disable categories: Choose from (infra (infrastructure), app (application), events (event-based))."
+        )
+        # Check for help arguments before parsing
+        if len(sys.argv) > 1 and any(arg in ['-h','--h','--help','-help'] for arg in sys.argv[1:]):
+            # Check if help is combined with other arguments
+            help_args = ['-h','--h','--help','-help']
+            other_args = [arg for arg in sys.argv[1:] if arg not in help_args]
+            
+            if other_args:
+                print("error: argument -h/--h/--help/-help: not allowed with other arguments", file=sys.stderr)
+                sys.exit(2)
+            
+            # Show help and exit
+            print("options:")
+            for action in parser._actions:
+                # Only print options that start with '--' and have a help string
+                if any(opt.startswith('--') for opt in action.option_strings) and action.help:
+                    # Find the first long option
+                    long_opt = next((opt for opt in action.option_strings if opt.startswith('--')), None)
+                    metavar = action.metavar or ''
+                    opt_str = f"{long_opt} {metavar}".strip()
+                    print(f"{opt_str:<24} {action.help}")
+            sys.exit(0)
+        
+        args = parser.parse_args()
+
+        all_categories = {"infra", "app", "events"}
+
+        # By default, enable all categories
+        enabled = set(all_categories)
+        invalid = set() 
+        # Remove disabled categories if specified
+        if args.disable:
+            disabled = set(cat.strip() for cat in args.disable.split(","))
+            invalid = disabled - all_categories
+            enabled = enabled - disabled
+
+        if invalid:
+            print(f"Error: Unknown category/categories: {', '.join(invalid)}")
+            print(f"Available categories: infra, app, events")
+            sys.exit(2)
+
+        if args.disable:
+            disabled_tool_classes = []
+            for category in disabled:
+                if category in client_categories:
+                    disabled_tool_classes.extend(
+                        [cls.__name__ for _, cls in client_categories[category]]
+                    )
+            if disabled_tool_classes:
+                print(
+                    f"The following tools are disabled: {', '.join(disabled_tool_classes)}"
+                )
+
+        os.environ["INSTANA_ENABLED_TOOLS"] = ",".join(enabled)
+
+        # Create and configure the MCP server
+        app, registered_tool_count = create_app(instana_api_token_value or "", instana_base_url or "")
+
+        # Run the server with the appropriate transport
+        if args.transport == "streamable-http":
+            if args.debug:
+                print(f"FastMCP instance: {app}", file=sys.stderr)
+                print(f"Registered tools: {registered_tool_count}", file=sys.stderr)
+            try:
+                app.run(transport="streamable-http")
+            except Exception as e:
+                print(f"Failed to start HTTP server: {e}", file=sys.stderr)
+                if args.debug:
+                    traceback.print_exc(file=sys.stderr)
+                sys.exit(1)
+        else:  
+            print("Starting stdio transport", file=sys.stderr)
+            app.run(transport="stdio")    
+            
+    except KeyboardInterrupt:
+        print("Server stopped by user", file=sys.stderr)
+        sys.exit(0)
+    except Exception as e:  
+        print(f"Server error: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(1)
+