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

src/core/server.py

@@ -0,0 +1,586 @@
+"""
+Standalone MCP Server for Instana Events and Infrastructure Resources
+
+This module provides a dedicated MCP server that exposes Instana MCP Server.
+Supports stdio and Streamable HTTP transports.
+"""
+
+import argparse
+import logging
+import os
+import sys
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, fields
+from typing import Any
+
+from dotenv import load_dotenv
+
+from src.prompts import PROMPT_REGISTRY
+
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,  # Default level, can be overridden
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stderr)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def set_log_level(level_name):
+    """Set the logging level based on the provided level name"""
+    level_map = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO,
+        "WARNING": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL
+    }
+
+    level = level_map.get(level_name.upper(), logging.INFO)
+    logger.setLevel(level)
+    logging.getLogger().setLevel(level)
+    logger.info(f"Log level set to {level_name.upper()}")
+
+# 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.core.utils import MCP_TOOLS, register_as_tool
+except ImportError:
+    logger.error("Failed to import required modules", exc_info=True)
+    sys.exit(1)
+
+from fastmcp import FastMCP
+
+
+@dataclass
+class MCPState:
+    """State for the MCP server."""
+    events_client: Any = None
+    infra_client: Any = None
+    app_resource_client: Any = None
+    app_metrics_client: Any = None
+    app_alert_client: Any = None
+    infra_catalog_client: Any = None
+    infra_topo_client: Any = None
+    infra_analyze_client: Any = None
+    infra_metrics_client: Any = None
+    app_catalog_client: Any = None
+    app_topology_client: Any = None
+    app_analyze_client: Any = None
+    app_settings_client: Any = None
+    app_global_alert_client: Any = None
+    website_metrics_client: Any = None
+    website_catalog_client: Any = None
+    website_analyze_client: Any = None
+    website_configuration_client: Any = None
+
+# Global variables to store credentials for lifespan
+_global_token = None
+_global_base_url = None
+
+def get_instana_credentials():
+    """Get Instana credentials from environment variables for stdio mode."""
+    # For stdio mode, use INSTANA_API_TOKEN and INSTANA_BASE_URL
+    token = (os.getenv("INSTANA_API_TOKEN") or "")
+    base_url = (os.getenv("INSTANA_BASE_URL") or "")
+
+    return token, base_url
+
+def validate_credentials(token: str, base_url: str) -> bool:
+    """Validate that Instana credentials are provided for stdio mode."""
+    # For stdio mode, validate INSTANA_API_TOKEN and INSTANA_BASE_URL
+    return not (not token or not base_url)
+
+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:
+            logger.error(f"Failed to create {attr_name}: {e}", exc_info=True)
+            setattr(state, attr_name, None)
+
+    return state
+
+
+@asynccontextmanager
+async def lifespan(server: FastMCP) -> AsyncIterator[MCPState]:
+    """Set up and tear down the Instana clients."""
+    # Get credentials from environment variables
+    token, base_url = get_instana_credentials()
+
+    try:
+        # For lifespan, we'll create all clients since we don't have access to command line args here
+        state = create_clients(token, base_url, "all")
+
+        yield state
+    except Exception:
+        logger.error("Error during lifespan", exc_info=True)
+
+        # Yield empty state if client creation failed
+        yield MCPState()
+
+def create_app(token: str, base_url: str, port: int = int(os.getenv("PORT", "8080")), enabled_categories: str = "all") -> tuple[FastMCP, int]:
+    """Create and configure the MCP server with the given credentials."""
+    try:
+        server = FastMCP(name="Instana MCP Server", host="0.0.0.0", port=port)
+
+        # Only create and register enabled clients/tools
+        clients_state = create_clients(token, base_url, enabled_categories)
+
+        tools_registered = 0
+        for tool_name, _tool_func in MCP_TOOLS.items():
+            try:
+                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
+                        break
+            except Exception as e:
+                logger.error(f"Failed to register tool {tool_name}: {e}", exc_info=True)
+
+        # Register prompts from the prompt registry
+        # Get enabled prompt categories - use the same categories as tools
+        prompt_categories = get_prompt_categories()
+
+        # Use the same categories for prompts as for tools
+        enabled_prompt_categories = []
+        if enabled_categories.lower() == "all" or not enabled_categories:
+            enabled_prompt_categories = list(prompt_categories.keys())
+            logger.info("Enabling all prompt categories")
+        else:
+            enabled_prompt_categories = [cat.strip() for cat in enabled_categories.split(",") if cat.strip() in prompt_categories]
+            logger.info(f"Enabling prompt categories: {', '.join(enabled_prompt_categories)}")
+
+        # Register prompts to the server
+        logger.info("Registering prompts by category:")
+        registered_prompts = set()
+
+        for category, prompt_groups in prompt_categories.items():
+            if category in enabled_prompt_categories:
+                logger.info(f"  - {category}: {len(prompt_groups)} prompt groups")
+
+                for group_name, prompts in prompt_groups:
+                    prompt_count = len(prompts)
+                    logger.info(f"    - {group_name}: {prompt_count} prompts")
+
+                    for prompt_name, prompt_func in prompts:
+                        server.add_prompt(prompt_func)
+                        registered_prompts.add(prompt_name)
+                        logger.debug(f"      * Registered prompt: {prompt_name}")
+            else:
+                logger.info(f"  - {category}: DISABLED")
+
+        # Register any remaining prompts that might not be in categories
+        uncategorized_count = 0
+
+        # Just log the count of remaining prompts
+        remaining_prompts = len(PROMPT_REGISTRY) - len(registered_prompts)
+        if remaining_prompts > 0:
+            logger.info(f"  - uncategorized: {remaining_prompts} prompts (not registered)")
+
+        if uncategorized_count > 0:
+            logger.info(f"  - uncategorized: {uncategorized_count} prompts")
+
+
+        return server, tools_registered
+
+    except Exception:
+        logger.error("Error creating app", exc_info=True)
+        fallback_server = FastMCP("Instana Tools")
+        return fallback_server, 0  # Return a tuple with 0 tools registered
+
+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}: {e!s}"
+
+def get_client_categories():
+    """Get client categories with lazy imports to avoid circular dependencies"""
+    try:
+        from src.application.application_alert_config import ApplicationAlertMCPTools
+        from src.application.application_analyze import ApplicationAnalyzeMCPTools
+        from src.application.application_catalog import ApplicationCatalogMCPTools
+        from src.application.application_global_alert_config import (
+            ApplicationGlobalAlertMCPTools,
+        )
+        from src.application.application_metrics import ApplicationMetricsMCPTools
+        from src.application.application_resources import ApplicationResourcesMCPTools
+        from src.application.application_settings import ApplicationSettingsMCPTools
+        from src.application.application_topology import ApplicationTopologyMCPTools
+        from src.automation.action_catalog import ActionCatalogMCPTools
+        from src.automation.action_history import ActionHistoryMCPTools
+        from src.event.events_tools import AgentMonitoringEventsMCPTools
+        from src.infrastructure.infrastructure_analyze import (
+            InfrastructureAnalyzeMCPTools,
+        )
+        from src.infrastructure.infrastructure_catalog import (
+            InfrastructureCatalogMCPTools,
+        )
+        from src.infrastructure.infrastructure_metrics import (
+            InfrastructureMetricsMCPTools,
+        )
+        from src.infrastructure.infrastructure_resources import (
+            InfrastructureResourcesMCPTools,
+        )
+        from src.infrastructure.infrastructure_topology import (
+            InfrastructureTopologyMCPTools,
+        )
+        from src.settings.custom_dashboard_tools import CustomDashboardMCPTools
+        from src.website.website_analyze import WebsiteAnalyzeMCPTools
+        from src.website.website_catalog import WebsiteCatalogMCPTools
+        from src.website.website_configuration import WebsiteConfigurationMCPTools
+        from src.website.website_metrics import WebsiteMetricsMCPTools
+    except ImportError as e:
+        logger.warning(f"Could not import client classes: {e}")
+        return {}
+
+    return {
+        "infra": [
+            ('infra_client', InfrastructureResourcesMCPTools),
+            ('infra_catalog_client', InfrastructureCatalogMCPTools),
+            ('infra_topo_client', InfrastructureTopologyMCPTools),
+            ('infra_analyze_client', InfrastructureAnalyzeMCPTools),
+            ('infra_metrics_client', InfrastructureMetricsMCPTools),
+        ],
+        "app": [
+            ('app_resource_client', ApplicationResourcesMCPTools),
+            ('app_metrics_client', ApplicationMetricsMCPTools),
+            ('app_alert_client', ApplicationAlertMCPTools),
+            ('app_catalog_client', ApplicationCatalogMCPTools),
+            ('app_topology_client', ApplicationTopologyMCPTools),
+            ('app_analyze_client', ApplicationAnalyzeMCPTools),
+            ('app_settings_client', ApplicationSettingsMCPTools),
+            ('app_global_alert_client', ApplicationGlobalAlertMCPTools),
+        ],
+        "events": [
+            ('events_client', AgentMonitoringEventsMCPTools),
+        ],
+        "automation": [
+            ('action_catalog_client', ActionCatalogMCPTools),
+            ('action_history_client', ActionHistoryMCPTools),
+        ],
+        "website": [
+            ('website_metrics_client', WebsiteMetricsMCPTools),
+            ('website_catalog_client', WebsiteCatalogMCPTools),
+            ('website_analyze_client', WebsiteAnalyzeMCPTools),
+            ('website_configuration_client', WebsiteConfigurationMCPTools),
+        ],
+        "settings": [
+            ('custom_dashboard_client', CustomDashboardMCPTools),
+        ]
+    }
+
+def get_prompt_categories():
+    """Get prompt categories organized by functionality"""
+    # Import the class-based prompts
+    from src.prompts.application.application_alerts import ApplicationAlertsPrompts
+    from src.prompts.application.application_catalog import ApplicationCatalogPrompts
+    from src.prompts.application.application_metrics import ApplicationMetricsPrompts
+    from src.prompts.application.application_resources import (
+        ApplicationResourcesPrompts,
+    )
+    from src.prompts.application.application_settings import ApplicationSettingsPrompts
+    from src.prompts.application.application_topology import ApplicationTopologyPrompts
+    from src.prompts.infrastructure.infrastructure_analyze import (
+        InfrastructureAnalyzePrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_catalog import (
+        InfrastructureCatalogPrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_metrics import (
+        InfrastructureMetricsPrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_resources import (
+        InfrastructureResourcesPrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_topology import (
+        InfrastructureTopologyPrompts,
+    )
+    from src.prompts.settings.custom_dashboard import CustomDashboardPrompts
+    from src.prompts.website.website_analyze import WebsiteAnalyzePrompts
+    from src.prompts.website.website_catalog import WebsiteCatalogPrompts
+    from src.prompts.website.website_configuration import WebsiteConfigurationPrompts
+    from src.prompts.website.website_metrics import WebsiteMetricsPrompts
+
+    # Use the get_prompts method to get all prompts from the classes
+    infra_analyze_prompts = InfrastructureAnalyzePrompts.get_prompts()
+    infra_metrics_prompts = InfrastructureMetricsPrompts.get_prompts()
+    infra_catalog_prompts = InfrastructureCatalogPrompts.get_prompts()
+    infra_topology_prompts = InfrastructureTopologyPrompts.get_prompts()
+    infra_resources_prompts = InfrastructureResourcesPrompts.get_prompts()
+    app_resources_prompts = ApplicationResourcesPrompts.get_prompts()
+    app_metrics_prompts = ApplicationMetricsPrompts.get_prompts()
+    app_catalog_prompts = ApplicationCatalogPrompts.get_prompts()
+    app_settings_prompts = ApplicationSettingsPrompts.get_prompts()
+    app_topology_prompts = ApplicationTopologyPrompts.get_prompts()
+    app_alert_prompts = ApplicationAlertsPrompts.get_prompts()
+    website_metrics_prompts = WebsiteMetricsPrompts.get_prompts()
+    website_catalog_prompts = WebsiteCatalogPrompts.get_prompts()
+    website_analyze_prompts = WebsiteAnalyzePrompts.get_prompts()
+    website_configuration_prompts = WebsiteConfigurationPrompts.get_prompts()
+    custom_dashboard_prompts = CustomDashboardPrompts.get_prompts()
+
+    # Return the categories with their prompt groups
+    return {
+        "infra": [
+            ('infra_resources_prompts', infra_resources_prompts),
+            ('infra_catalog_prompts', infra_catalog_prompts),
+            ('infra_topology_prompts', infra_topology_prompts),
+            ('infra_analyze_prompts', infra_analyze_prompts),
+            ('infra_metrics_prompts', infra_metrics_prompts),
+        ],
+        "app": [
+            ('app_resources_prompts', app_resources_prompts),
+            ('app_metrics_prompts', app_metrics_prompts),
+            ('app_catalog_prompts', app_catalog_prompts),
+            ('app_settings_prompts', app_settings_prompts),
+            ('app_topology_prompts', app_topology_prompts),
+            ('app_alert_prompts', app_alert_prompts),
+        ],
+        "website": [
+            ('website_metrics_prompts', website_metrics_prompts),
+            ('website_catalog_prompts', website_catalog_prompts),
+            ('website_analyze_prompts', website_analyze_prompts),
+            ('website_configuration_prompts', website_configuration_prompts),
+        ],
+        "settings": [
+            ('custom_dashboard_prompts', custom_dashboard_prompts),
+        ],
+    }
+
+def get_enabled_client_configs(enabled_categories: str):
+    """Get client configurations based on enabled categories"""
+    # Get client categories with lazy imports
+    client_categories = get_client_categories()
+
+    if not enabled_categories or 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:
+            logger.warning(f"Unknown category '{category}'")
+    return enabled_configs
+
+def main():
+    """Main entry point for the MCP server."""
+    try:
+        # 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(
+            "--log-level",
+            type=str,
+            choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            default="INFO",
+            help="Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)"
+        )
+        parser.add_argument(
+            "--debug",
+            action="store_true",
+            help="Enable debug mode with additional logging (shortcut for --log-level DEBUG)"
+        )
+        parser.add_argument(
+            "--tools",
+            type=str,
+            metavar='<categories>',
+            help="Comma-separated list of tool categories to enable (--tools infra,app,events,automation,website, settings). Also controls which prompts are enabled. If not provided, all tools and prompts are enabled."
+        )
+        parser.add_argument(
+            "--list-tools",
+            action="store_true",
+            help="List all available tool categories and exit."
+        )
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=int(os.getenv("PORT", "8080")),
+            help="Port to listen on (default: 8080, can be overridden with PORT env var)"
+        )
+        # 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:
+                logger.error("Argument -h/--h/--help/-help: not allowed with other arguments")
+                sys.exit(2)
+
+            # Show help and exit
+            try:
+                logger.info("Available 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()
+                        logger.info(f"{opt_str:<24} {action.help}")
+                sys.exit(0)
+            except Exception as e:
+                logger.error(f"Error displaying help: {e}")
+                sys.exit(0)  # Still exit with 0 for help
+
+        args = parser.parse_args()
+
+        # Set log level based on command line arguments
+        if args.debug:
+            set_log_level("DEBUG")
+        else:
+            set_log_level(args.log_level)
+
+        all_categories = {"infra", "app", "events", "automation", "website", "settings"}
+
+        # Handle --list-tools option
+        if args.list_tools:
+            logger.info("Available tool categories:")
+            client_categories = get_client_categories()
+            for category, tools in client_categories.items():
+                tool_names = [cls.__name__ for _, cls in tools]
+                logger.info(f"  {category}: {len(tool_names)} tools")
+                for tool_name in tool_names:
+                    logger.info(f"    - {tool_name}")
+            sys.exit(0)
+
+        # By default, enable all categories
+        enabled = set(all_categories)
+        invalid = set()
+
+        # Enable only specified categories if --tools is provided
+        if args.tools:
+            specified_tools = {cat.strip() for cat in args.tools.split(",")}
+            invalid = specified_tools - all_categories
+            enabled = specified_tools & all_categories
+
+            # If no valid tools specified, default to all
+            if not enabled:
+                enabled = set(all_categories)
+
+        if invalid:
+            logger.error(f"Error: Unknown category/categories: {', '.join(invalid)}. Available categories: infra, app, events, automation, website, settings")
+            sys.exit(2)
+
+        # Print enabled tools for user information
+        enabled_tool_classes = []
+        client_categories = get_client_categories()
+
+        # Log enabled categories and tools
+        logger.info(f"Enabled tool categories: {', '.join(enabled)}")
+
+        for category in enabled:
+            if category in client_categories:
+                category_tools = [cls.__name__ for _, cls in client_categories[category]]
+                enabled_tool_classes.extend(category_tools)
+                logger.info(f"  - {category}: {len(category_tools)} tools")
+                for tool_name in category_tools:
+                    logger.info(f"    * {tool_name}")
+
+        if enabled_tool_classes:
+            logger.info(
+                f"Total enabled tools: {len(enabled_tool_classes)}"
+            )
+
+        # Get credentials from environment variables for stdio mode
+        INSTANA_API_TOKEN, INSTANA_BASE_URL = get_instana_credentials()
+
+        if args.transport == "stdio" or args.transport is None:
+            if not validate_credentials(INSTANA_API_TOKEN, INSTANA_BASE_URL):
+                logger.error("Error: Instana credentials are required for stdio mode but not provided. Please set INSTANA_API_TOKEN and INSTANA_BASE_URL environment variables.")
+                sys.exit(1)
+
+        # Create and configure the MCP server
+        try:
+            enabled_categories = ",".join(enabled)
+            # Ensure create_app is always called, even if credentials are missing
+            # This is needed for test_main_function_missing_token
+            app, registered_tool_count = create_app(INSTANA_API_TOKEN, INSTANA_BASE_URL, args.port, enabled_categories)
+        except Exception as e:
+            print(f"Failed to create MCP server: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        # Run the server with the appropriate transport
+        if args.transport == "streamable-http":
+            if args.debug:
+                logger.info(f"FastMCP instance: {app}")
+                logger.info(f"Registered tools: {registered_tool_count}")
+            try:
+                app.run(transport="streamable-http")
+            except Exception as e:
+                logger.error(f"Failed to start HTTP server: {e}")
+                if args.debug:
+                    logger.error("HTTP server error details", exc_info=True)
+                sys.exit(1)
+        else:
+            logger.info("Starting stdio transport")
+            try:
+                app.run(transport="stdio")
+            except AttributeError as e:
+                # Handle the case where sys.stdout is a StringIO object (in tests)
+                if "'_io.StringIO' object has no attribute 'buffer'" in str(e):
+                    logger.info("Running in test mode, skipping stdio server")
+                else:
+                    raise
+
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Server error: {e}", exc_info=True)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        logger.error("Unhandled exception in main", exc_info=True)
+        sys.exit(1)