import asyncio import logging from contextlib import asynccontextmanager from collections.abc import Mapping from uuid import uuid4 from fastapi import FastAPI, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse from minio.error import MinioException from redis.exceptions import ConnectionError as RedisConnectionError from redis.exceptions import TimeoutError as RedisTimeoutError from sqlalchemy.exc import DBAPIError, InterfaceError, OperationalError, SQLAlchemyError from sqlalchemy.exc import TimeoutError as PoolTimeoutError from starlette.exceptions import HTTPException as StarletteHTTPException from starlette.requests import ClientDisconnect from urllib3.exceptions import HTTPError as StorageHTTPError from app.core.instance import INSTANCE_ID_HEADER from app.core.request_id import REQUEST_ID_HEADER from app.errors.exceptions import ( ApiError, internal_error, invalid_request, not_found, unavailable, ) logger = logging.getLogger(__name__) TRANSIENT_SQLSTATE_CLASSES = ("08", "40", "53", "57") TRANSIENT_SQLSTATES = frozenset({"55P03"}) RECOVERABLE_STORAGE_ERRORS = ( ApiError, SQLAlchemyError, MinioException, StorageHTTPError, OSError, TimeoutError, ) @asynccontextmanager async def operation_timeout(seconds: float, error: ApiError): """Единое преобразование таймаутов; владелец операции задаёт ожидаемую ошибку.""" try: async with asyncio.timeout(seconds): yield except TimeoutError: raise error from None async def client_disconnect_handler(request: Request, exc: Exception) -> JSONResponse: return await api_error_handler( request, invalid_request("Загрузка прервана клиентом") ) def log_recoverable_error(operation: str, error: Exception) -> None: """Согласованный безопасный лог восстановления без содержимого SDK-ошибки.""" logger.warning("%s deferred: %s", operation, type(error).__name__) def _get_request_id(request: Request) -> str: request_id = getattr(request.state, "request_id", None) if request_id is None: request_id = str(uuid4()) request.state.request_id = request_id return request_id def _build_response( request: Request, status_code: int, code: str, message: str, headers: Mapping[str, str] | None = None, ) -> JSONResponse: request_id = _get_request_id(request) response_headers = { **(headers or {}), REQUEST_ID_HEADER: request_id, } instance_id = getattr(request.app.state, "instance_id", None) if instance_id is not None: response_headers[INSTANCE_ID_HEADER] = instance_id body = { "error": { "code": code, "message": message, "request_id": request_id, } } return JSONResponse( status_code=status_code, content=body, headers=response_headers, ) async def api_error_handler( request: Request, exc: Exception, ) -> JSONResponse: assert isinstance(exc, ApiError) return _build_response( request, exc.status_code, exc.code, exc.message, exc.headers, ) async def routing_error_handler( request: Request, exc: Exception, ) -> JSONResponse: assert isinstance(exc, StarletteHTTPException) error = invalid_request() if exc.status_code == 404: error = not_found() return _build_response( request, exc.status_code, error.code, error.message, exc.headers, ) async def validation_error_handler( request: Request, exc: Exception, ) -> JSONResponse: assert isinstance(exc, RequestValidationError) fields = sorted({".".join(map(str, error["loc"])) for error in exc.errors()}) message = "Неверный запрос" if fields: message = f"{message}: {', '.join(fields)}" return _build_response( request, 400, "invalid_request", message, ) async def dependency_unavailable_handler( request: Request, exc: Exception, ) -> JSONResponse: """PostgreSQL/Redis/S3 недоступны либо исчерпан пул: 503 без внутренних деталей.""" request_id = _get_request_id(request) logger.error( "Dependency unavailable request_id=%s: %s", request_id, type(exc).__name__, ) error = unavailable() return _build_response( request, error.status_code, error.code, error.message, {"Retry-After": "1"}, ) def _is_transient_database_error(exc: DBAPIError) -> bool: sqlstate = getattr(exc.orig, "sqlstate", None) or "" return ( sqlstate.startswith(TRANSIENT_SQLSTATE_CLASSES) or sqlstate in TRANSIENT_SQLSTATES ) async def database_error_handler( request: Request, exc: Exception, ) -> JSONResponse: """Временные ошибки PostgreSQL (таймаут запроса, блокировки, нехватка ресурсов) — 503.""" assert isinstance(exc, DBAPIError) handler = unhandled_error_handler if _is_transient_database_error(exc): handler = dependency_unavailable_handler return await handler(request, exc) async def unhandled_error_handler( request: Request, exc: Exception, ) -> JSONResponse: request_id = _get_request_id(request) logger.error( "Unhandled error request_id=%s", request_id, exc_info=exc, ) error = internal_error() return _build_response( request, error.status_code, error.code, error.message, ) def register_exception_handlers(app: FastAPI) -> None: app.add_exception_handler(ApiError, api_error_handler) app.add_exception_handler(ClientDisconnect, client_disconnect_handler) app.add_exception_handler(MinioException, dependency_unavailable_handler) app.add_exception_handler(StorageHTTPError, dependency_unavailable_handler) app.add_exception_handler(StarletteHTTPException, routing_error_handler) app.add_exception_handler(RequestValidationError, validation_error_handler) app.add_exception_handler(OperationalError, dependency_unavailable_handler) app.add_exception_handler(InterfaceError, dependency_unavailable_handler) app.add_exception_handler(PoolTimeoutError, dependency_unavailable_handler) app.add_exception_handler(DBAPIError, database_error_handler) app.add_exception_handler(RedisConnectionError, dependency_unavailable_handler) app.add_exception_handler(RedisTimeoutError, dependency_unavailable_handler) app.add_exception_handler(OSError, dependency_unavailable_handler) app.add_exception_handler(Exception, unhandled_error_handler)