Merge pull request #19 from flacatus/fix_e2e

feat: Improve e2e tests errors and incidents tools

Author: flacatus

konflux-devlake-mcp.py

@@ -199,6 +199,7 @@ async def run_server(config: KonfluxDevLakeConfig) -> int:
                 "port": config.server.port,
                 "timeout_keep_alive": config.server.timeout_keep_alive,
                 "timeout_graceful_shutdown": config.server.timeout_graceful_shutdown,
+                "config": config,
             }
             if config.server.transport == "http"
             else {}
@@ -226,9 +227,17 @@ async def run_server(config: KonfluxDevLakeConfig) -> int:
             logger.info("Server shutdown complete")
         except (asyncio.CancelledError, KeyboardInterrupt):
             # Ignore cancellation errors during shutdown
-            logger.debug("Shutdown interrupted")
+            pass
+        except (ValueError, OSError):
+            # Ignore I/O errors during shutdown (handlers may be closed)
+            pass
         except Exception as e:
-            logger.error(f"Error during shutdown: {e}")
+            # Only log non-I/O errors during shutdown
+            try:
+                logger.error(f"Error during shutdown: {e}")
+            except (ValueError, OSError):
+                # If logging fails, just pass silently
+                pass
 
 
 async def main():

server/factory/server_factory.py

@@ -85,11 +85,13 @@ def create_transport(self, transport_type: str, **kwargs) -> BaseTransport:
             port = kwargs.get("port", 3000)
             timeout_keep_alive = kwargs.get("timeout_keep_alive", 300)
             timeout_graceful_shutdown = kwargs.get("timeout_graceful_shutdown", 60)
+            config = kwargs.get("config")
             return HttpTransport(
                 host=host,
                 port=port,
                 timeout_keep_alive=timeout_keep_alive,
                 timeout_graceful_shutdown=timeout_graceful_shutdown,
+                config=config,
             )
         else:
             raise ValueError(f"Unsupported transport type: {transport_type}")

server/transport/http_transport.py

@@ -30,6 +30,7 @@ def __init__(
         port: int = 3000,
         timeout_keep_alive: int = 600,
         timeout_graceful_shutdown: int = 120,
+        config=None,
     ):
         """
         Initialize the HTTP transport.
@@ -39,11 +40,13 @@ def __init__(
             port: Port number to listen on
             timeout_keep_alive: Keep-alive timeout in seconds (default: 600 for LLM connections)
             timeout_graceful_shutdown: Graceful shutdown timeout in seconds (default: 120)
+            config: Optional configuration object for security manager
         """
         self.host = host
         self.port = port
         self.timeout_keep_alive = timeout_keep_alive
         self.timeout_graceful_shutdown = timeout_graceful_shutdown
+        self.config = config
         self.logger = get_logger(f"{__name__}.HttpTransport")
         self._session_manager = None
         self._server = None
@@ -174,6 +177,50 @@ async def wrapped_handle_request(scope, receive, send):
         session_manager.handle_request = wrapped_handle_request
         return session_manager
 
+    def _create_health_endpoints(self):
+        """Create ASGI app for health check and security endpoints."""
+        from starlette.applications import Starlette
+        from starlette.responses import JSONResponse
+        from starlette.routing import Route
+        from utils.security import KonfluxDevLakeSecurityManager
+
+        # Create a minimal config object if not provided
+        if self.config is None:
+
+            class MinimalConfig:
+                allowed_ips = []
+                api_keys = {}
+
+            config = MinimalConfig()
+        else:
+            config = self.config
+
+        security_manager = KonfluxDevLakeSecurityManager(config)
+
+        async def health_check(request):
+            """Health check endpoint."""
+            return JSONResponse(
+                {
+                    "status": "healthy",
+                    "service": "konflux-devlake-mcp-server",
+                    "transport": "http",
+                }
+            )
+
+        async def security_stats(request):
+            """Security statistics endpoint."""
+            stats = security_manager.get_security_stats()
+            return JSONResponse(stats)
+
+        app = Starlette(
+            routes=[
+                Route("/health", health_check, methods=["GET"]),
+                Route("/security/stats", security_stats, methods=["GET"]),
+            ]
+        )
+
+        return app
+
     def _create_mcp_app(self, app):
         """Create ASGI app that handles MCP requests with improved error handling."""
         from starlette.responses import Response

tools/devlake/incident_tools.py

@@ -49,12 +49,12 @@ def get_tools(self) -> List[Tool]:
                     "from the Konflux DevLake database with advanced filtering capabilities. "
                     "This tool automatically deduplicates incidents by incident_key to show "
                     "only the most recent version of each incident. Supports filtering by "
-                    "status (e.g., 'DONE', 'IN_PROGRESS', 'OPEN'), component name, and "
-                    "flexible date ranges. Provides comprehensive incident data including "
-                    "incident_key, title, description, status, created_date, "
-                    "resolution_date, lead_time_minutes, component, and URL. Perfect for "
-                    "incident analysis, reporting, and understanding operational issues. "
-                    "Returns incidents sorted by creation date (newest first)."
+                    "status (e.g., 'DONE', 'IN_PROGRESS', 'OPEN'), component name, and flexible "
+                    "date ranges. Provides comprehensive incident data including incident_key, "
+                    "title, description, status, created_date, resolution_date, "
+                    "lead_time_minutes, component, and URL. Perfect for incident analysis, "
+                    "reporting, and understanding operational issues. Returns incidents sorted "
+                    "by creation date (newest first)."
                 ),
                 inputSchema={
                     "type": "object",

utils/logger.py

@@ -87,8 +87,9 @@ def _setup_logging() -> logging.Logger:
     # Clear existing handlers
     root_logger.handlers.clear()
 
-    # Console handler with filter
-    console_handler = logging.StreamHandler(sys.stdout)
+    # Console handler with filter - use stderr for stdio transport compatibility
+    # When using stdio transport, stdout must only contain JSONRPC messages
+    console_handler = logging.StreamHandler(sys.stderr)
     console_handler.setLevel(logging.INFO)
     console_handler.setFormatter(formatter)
     console_handler.addFilter(closed_resource_filter)
@@ -218,16 +219,24 @@ def log_tool_call(tool_name: str, arguments: dict = None, success: bool = True,
 
 def shutdown_logging():
     """Shutdown logging system"""
-    logger = get_logger(__name__)
-    logger.info("Shutting down logging system")
-
-    # Flush all handlers
-    root_logger = logging.getLogger()
-    for handler in root_logger.handlers:
-        handler.flush()
-        handler.close()
+    try:
+        logger = get_logger(__name__)
+        logger.info("Shutting down logging system")
 
-    logger.info("Logging system shutdown complete")
+        # Flush all handlers
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers:
+            try:
+                handler.flush()
+                handler.close()
+            except (ValueError, OSError):
+                # Ignore errors when closing handlers (file may already be closed)
+                pass
+
+        logger.info("Logging system shutdown complete")
+    except (ValueError, OSError):
+        # Ignore errors during shutdown (handlers may already be closed)
+        pass
 
 
 class LoggerMixin: