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

src/application/application_topology.py

@@ -0,0 +1,107 @@
+"""
+Application Topology MCP Tools Module
+
+This module provides application topology-specific MCP tools for Instana monitoring.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from src.core.utils import BaseInstanaClient, register_as_tool
+
+try:
+    from instana_client.api.application_topology_api import ApplicationTopologyApi
+    from instana_client.api_client import ApiClient
+    from instana_client.configuration import Configuration
+except ImportError as e:
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.error(f"Error importing Instana SDK: {e}", exc_info=True)
+    raise
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+class ApplicationTopologyMCPTools(BaseInstanaClient):
+    """Tools for application topology in Instana MCP."""
+
+    def __init__(self, read_token: str, base_url: str):
+        """Initialize the Application Topology MCP tools client."""
+        super().__init__(read_token=read_token, base_url=base_url)
+
+        try:
+
+            # 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 ApplicationTopologyMCPTools with our configured client
+            self.topology_api = ApplicationTopologyApi(api_client=api_client)
+
+        except Exception as e:
+            logger.error(f"Error initializing ApplicationTopologyMCPTools: {e}", exc_info=True)
+            raise
+
+    @register_as_tool
+    async def get_application_topology(self,
+                              window_size: Optional[int] = None,
+                              to_timestamp: Optional[int] = None,
+                              application_id: Optional[str] = None,
+                              application_boundary_scope: Optional[str] = None,
+                              ctx = None) -> Dict[str, Any]:
+        """
+        Get the service topology from Instana Server.
+        This tool retrieves services and connections (call paths) between them for calls in the scope given by the parameters.
+
+        Args:
+            window_size: Size of time window in milliseconds
+            to_timestamp: Timestamp since Unix Epoch in milliseconds of the end of the time window
+            application_id: Filter by application ID
+            application_boundary_scope: Filter by application scope, i.e., INBOUND or ALL. The default value is INBOUND.
+            ctx: Context information
+
+        Returns:
+            A dictionary containing the service topology data
+        """
+
+        try:
+            logger.debug("Fetching service topology data")
+
+            # Set default values if not provided
+            if not to_timestamp:
+                to_timestamp = int(datetime.now().timestamp() * 1000)
+
+            if not window_size:
+                window_size = 3600000  # Default to 1 hour in milliseconds
+
+            # Call the API
+            # Note: The SDK expects parameters in camelCase, but we use snake_case in Python
+            # The SDK will handle the conversion
+            result = self.topology_api.get_services_map(
+                window_size=window_size,
+                to=to_timestamp,
+                application_id=application_id,
+                application_boundary_scope=application_boundary_scope
+            )
+
+            # Ensure we always return a dictionary
+            if hasattr(result, "to_dict"):
+                result_dict = result.to_dict()
+            elif isinstance(result, dict):
+                result_dict = result
+            else:
+                # Convert to dictionary using __dict__ or as a fallback, create a new dict with string representation
+                result_dict = getattr(result, "__dict__", {"data": str(result)})
+
+            logger.debug("Successfully retrieved service topology data")
+            return result_dict
+
+        except Exception as e:
+            logger.error(f"Error in get_application_topology: {e}", exc_info=True)
+            return {"error": f"Failed to get application topology: {e!s}"}

src/core/__init__.py

@@ -0,0 +1 @@
+# Core module for MCP Instana

src/core/server.py

@@ -0,0 +1,436 @@
+"""
+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.prompt_loader import register_prompts
+
+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
+
+# 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 = 8000, 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
+        register_prompts(server)
+
+        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_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.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,
+        )
+    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),
+        ],
+        "events": [
+            ('events_client', AgentMonitoringEventsMCPTools),
+        ]
+    }
+
+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 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). If not provided, all tools 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=8000,
+            help="Port to listen on (default: 8000)"
+        )
+        # 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"}
+
+        # 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")
+            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)
+            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)