Download kiro-gateway/kiro/debug_middleware.py from shimen/API: direct link, hf CLI and curl.
- Browser
- Download file 4.49 kB
-
https://huggingface.co/spaces/shimen/API/resolve/main/kiro-gateway/kiro/debug_middleware.py
- Command line
-
hf download hf://spaces/shimen/API/kiro-gateway/kiro/debug_middleware.py
-
curl -L -o debug_middleware.py https://huggingface.co/spaces/shimen/API/resolve/main/kiro-gateway/kiro/debug_middleware.py
4.49 kB
| # -*- coding: utf-8 -*- | |
| # Kiro Gateway | |
| # https://github.com/jwadow/kiro-gateway | |
| # Copyright (C) 2025 Jwadow | |
| # | |
| # This program is free software: you can redistribute it and/or modify | |
| # it under the terms of the GNU Affero General Public License as published by | |
| # the Free Software Foundation, either version 3 of the License, or | |
| # (at your option) any later version. | |
| # | |
| # This program is distributed in the hope that it will be useful, | |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| # GNU Affero General Public License for more details. | |
| # | |
| # You should have received a copy of the GNU Affero General Public License | |
| # along with this program. If not, see <https://www.gnu.org/licenses/>. | |
| """ | |
| Debug logging middleware for Kiro Gateway. | |
| This middleware initializes debug logging BEFORE Pydantic validation, | |
| which allows capturing validation errors (422) in debug logs. | |
| The middleware: | |
| 1. Intercepts requests to API endpoints (/v1/chat/completions, /v1/messages) | |
| 2. Calls prepare_new_request() to initialize buffers and loguru sink | |
| 3. Reads and logs the raw request body | |
| 4. Passes the request to the next handler | |
| Flush/discard operations are handled by: | |
| - Route handlers (for successful requests and Kiro API errors) | |
| - Exception handlers (for validation errors and other exceptions) | |
| """ | |
| from starlette.middleware.base import BaseHTTPMiddleware | |
| from starlette.requests import Request | |
| from starlette.responses import Response | |
| from loguru import logger | |
| from kiro.config import DEBUG_MODE | |
| # API endpoints that should have debug logging enabled | |
| # These are the main API endpoints that process user requests | |
| LOGGED_ENDPOINTS = frozenset({ | |
| "/v1/chat/completions", # OpenAI-compatible endpoint | |
| "/v1/messages", # Anthropic-compatible endpoint | |
| }) | |
| class DebugLoggerMiddleware(BaseHTTPMiddleware): | |
| """ | |
| Middleware for initializing debug logging on API requests. | |
| This middleware runs BEFORE Pydantic validation, which means it can | |
| capture the raw request body even for requests that fail validation. | |
| The middleware only activates for API endpoints defined in LOGGED_ENDPOINTS. | |
| Health checks, documentation, and other endpoints are not logged. | |
| Lifecycle: | |
| - prepare_new_request(): Called here (before validation) | |
| - log_request_body(): Called here (raw body from client) | |
| - log_kiro_request_body(): Called in route handlers (transformed payload) | |
| - flush_on_error() / discard_buffers(): Called in routes or exception handlers | |
| """ | |
| async def dispatch(self, request: Request, call_next) -> Response: | |
| """ | |
| Process the request and initialize debug logging if needed. | |
| Args: | |
| request: The incoming HTTP request | |
| call_next: The next middleware or route handler | |
| Returns: | |
| The response from the next handler | |
| """ | |
| # Skip logging for non-API endpoints (health, docs, etc.) | |
| if request.url.path not in LOGGED_ENDPOINTS: | |
| return await call_next(request) | |
| # Skip if debug mode is disabled | |
| if DEBUG_MODE == "off": | |
| return await call_next(request) | |
| # Import here to avoid circular imports and allow graceful degradation | |
| try: | |
| from kiro.debug_logger import debug_logger | |
| except ImportError: | |
| logger.warning("debug_logger not available, skipping debug logging") | |
| return await call_next(request) | |
| # Initialize debug logging for this request | |
| # This sets up buffers and creates a loguru sink to capture app logs | |
| debug_logger.prepare_new_request() | |
| # Read and log the raw request body | |
| # FastAPI caches the body after first read, so this is safe | |
| try: | |
| body = await request.body() | |
| if body: | |
| debug_logger.log_request_body(body) | |
| except Exception as e: | |
| logger.warning(f"Failed to read request body for debug logging: {e}") | |
| # Continue to validation and route handler | |
| # flush_on_error() or discard_buffers() will be called by: | |
| # - Route handlers (for successful requests and Kiro API errors) | |
| # - validation_exception_handler (for 422 validation errors) | |
| # - Generic exception handlers (for other errors) | |
| response = await call_next(request) | |
| return response | |