73 lines
3.2 KiB
Python
73 lines
3.2 KiB
Python
import os
|
|
import socket
|
|
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
|
|
response.headers['X-Instance-Id'] = os.environ.get('INSTANCE_ID') or socket.gethostname()
|
|
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')
|