Spaces:
Build error
Build error
File size: 4,238 Bytes
350b79e c8f7f2e 350b79e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | """
Error Handling Middleware
Provides centralized error handling for the API.
"""
import logging
import time
import traceback
from typing import Callable
from fastapi import Request, Response
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware
logger = logging.getLogger(__name__)
class ErrorHandlerMiddleware(BaseHTTPMiddleware):
"""
Global error handler middleware.
Catches all unhandled exceptions and returns proper JSON responses.
Also logs errors with request context.
"""
async def dispatch(self, request: Request, call_next: Callable) -> Response:
try:
response = await call_next(request)
return response
except Exception as e:
# Log the error with context
logger.error(
f"Unhandled error: {str(e)}\n"
f"Path: {request.url.path}\n"
f"Method: {request.method}\n"
f"Traceback: {traceback.format_exc()}"
)
return JSONResponse(
status_code=500,
content={
"error": "InternalServerError",
"message": str(e),
"path": request.url.path,
}
)
class RequestLoggingMiddleware(BaseHTTPMiddleware):
"""
Request logging middleware.
Logs all incoming requests with timing information.
"""
async def dispatch(self, request: Request, call_next: Callable) -> Response:
start_time = time.time()
# Log request
logger.info(
f"Request: {request.method} {request.url.path}"
)
response = await call_next(request)
# Calculate duration
duration = time.time() - start_time
# Log response
logger.info(
f"Response: {request.method} {request.url.path} "
f"status={response.status_code} duration={duration:.3f}s"
)
# Add timing header
response.headers["X-Process-Time"] = f"{duration:.3f}"
return response
class RateLimitMiddleware(BaseHTTPMiddleware):
"""
Simple rate limiting middleware.
Uses in-memory storage (for production, use Redis).
"""
def __init__(self, app, requests_per_minute: int = 60):
super().__init__(app)
self.requests_per_minute = requests_per_minute
self._requests = {} # IP -> list of timestamps
async def dispatch(self, request: Request, call_next: Callable) -> Response:
# Get client IP. Behind the HF Spaces proxy request.client.host is the
# proxy, so prefer the first hop in X-Forwarded-For when present.
forwarded = request.headers.get("x-forwarded-for")
if forwarded:
client_ip = forwarded.split(",")[0].strip()
else:
client_ip = request.client.host if request.client else "unknown"
# Skip rate limiting for health checks
if request.url.path.startswith("/health") or request.url.path in ["/ready", "/live"]:
return await call_next(request)
# Check rate limit
current_time = time.time()
window_start = current_time - 60 # 1 minute window
# Clean old requests
if client_ip in self._requests:
self._requests[client_ip] = [
t for t in self._requests[client_ip]
if t > window_start
]
else:
self._requests[client_ip] = []
# Check limit
if len(self._requests[client_ip]) >= self.requests_per_minute:
logger.warning(f"Rate limit exceeded for {client_ip}")
return JSONResponse(
status_code=429,
content={
"error": "RateLimitExceeded",
"message": f"Too many requests. Limit: {self.requests_per_minute}/minute",
"retry_after": 60,
}
)
# Record request
self._requests[client_ip].append(current_time)
return await call_next(request)
|