Files

69 lines
3.1 KiB
Python

import uuid
import asyncpg
from redis.exceptions import RedisError
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.middleware.base import BaseHTTPMiddleware
CODES = {400: 'invalid_request', 401: 'unauthorized', 404: 'not_found', 409: 'conflict',
413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited',
503: 'unavailable', 500: 'internal_error'}
class ApiError(Exception):
"""Бизнес-ошибка: HTTP-статус + код контракта + безопасное сообщение."""
def __init__(self, status_code: int, message: str, code: str | None = None,
headers: dict | None = None):
self.status_code = status_code
self.code = code or CODES.get(status_code, 'internal_error')
self.message = message
self.headers = headers or {}
class RequestIdMiddleware(BaseHTTPMiddleware):
"""Каждый ответ, включая 204 и ошибки, несёт непустой X-Request-Id."""
async def dispatch(self, request: Request, call_next):
request.state.request_id = str(uuid.uuid4())
response = await call_next(request)
response.headers['X-Request-Id'] = request.state.request_id
return response
def _body(request: Request, status_code: int, code: str, message: str,
headers: dict | None = None) -> JSONResponse:
rid = getattr(request.state, 'request_id', str(uuid.uuid4()))
return JSONResponse(status_code=status_code, headers=headers,
content={'error': {'code': code, 'message': message, 'request_id': rid}})
def register_error_handlers(app: FastAPI) -> None:
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return _body(request, exc.status_code, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation(request: Request, exc: RequestValidationError):
return _body(request, 400, 'invalid_request', 'Request validation failed')
@app.exception_handler(StarletteHTTPException)
async def on_http(request: Request, exc: StarletteHTTPException):
code = CODES.get(exc.status_code, 'invalid_request')
return _body(request, exc.status_code, code, 'Route or method not found')
async def on_dependency_failure(request: Request, exc: Exception):
return _body(request, 503, 'unavailable', 'A required service is unavailable')
app.add_exception_handler(asyncpg.PostgresError, on_dependency_failure)
app.add_exception_handler(RedisError, on_dependency_failure)
app.add_exception_handler(OSError, on_dependency_failure)
app.add_exception_handler(TimeoutError, on_dependency_failure)
@app.exception_handler(Exception)
async def on_unexpected(request: Request, exc: Exception):
return _body(request, 500, 'internal_error', 'Internal error')