import asyncio import logging import uuid import asyncpg from fastapi import FastAPI, Request, status from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse import redis.exceptions from starlette.exceptions import HTTPException as StarletteHTTPException from app.config import INSTANCE_ID from app.schemas import ErrorCode, ErrorDetail, ErrorResponse class StorageError(Exception): pass class UnavailableError(StorageError): pass class InvalidRequestError(StorageError): pass class NotFoundError(StorageError): pass class ConflictError(StorageError): pass class UnauthorizedError(StorageError): pass logger = logging.getLogger("app.errors") def get_request_id(request: Request) -> str: req_id = getattr(request.state, "request_id", None) if not req_id: req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4()) return req_id def make_error_response( status_code: int, code: ErrorCode, message: str, request_id: str, headers: dict[str, str] | None = None, ) -> JSONResponse: payload = ErrorResponse( error=ErrorDetail(code=code, message=message, request_id=request_id) ).model_dump() resp_headers = { "X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID, "Content-Type": "application/json", } if headers: resp_headers.update(headers) return JSONResponse( status_code=status_code, content=payload, headers=resp_headers, ) def register_error_handlers(app: FastAPI) -> None: @app.exception_handler(InvalidRequestError) async def invalid_request_handler( request: Request, exc: InvalidRequestError ) -> JSONResponse: req_id = get_request_id(request) return make_error_response( status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, str(exc), req_id ) @app.exception_handler(UnauthorizedError) async def unauthorized_handler( request: Request, exc: UnauthorizedError ) -> JSONResponse: req_id = get_request_id(request) scheme = ( 'Basic realm="messenger", charset="UTF-8"' if request.url.path == "/api/v1/auth/sessions" else 'Bearer realm="messenger"' ) return make_error_response( status.HTTP_401_UNAUTHORIZED, ErrorCode.UNAUTHORIZED, str(exc), req_id, headers={"WWW-Authenticate": scheme}, ) @app.exception_handler(NotFoundError) async def not_found_handler(request: Request, exc: NotFoundError) -> JSONResponse: req_id = get_request_id(request) return make_error_response( status.HTTP_404_NOT_FOUND, ErrorCode.NOT_FOUND, str(exc), req_id ) @app.exception_handler(ConflictError) async def conflict_handler(request: Request, exc: ConflictError) -> JSONResponse: req_id = get_request_id(request) return make_error_response( status.HTTP_409_CONFLICT, ErrorCode.CONFLICT, str(exc), req_id ) @app.exception_handler(RequestValidationError) async def validation_error_handler( request: Request, exc: RequestValidationError ) -> JSONResponse: req_id = get_request_id(request) errors = exc.errors() messages = [] for err in errors: loc = ".".join(str(x) for x in err.get("loc", []) if x != "body") msg = err.get("msg", "invalid") messages.append(f"{loc}: {msg}" if loc else msg) detail_msg = "; ".join(messages) or "Некорректное тело запроса или параметры" return make_error_response( status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, detail_msg, req_id ) @app.exception_handler(StarletteHTTPException) async def http_exception_handler( request: Request, exc: StarletteHTTPException ) -> JSONResponse: req_id = get_request_id(request) code = ErrorCode.INTERNAL_ERROR extra_headers: dict[str, str] = {} if exc.status_code == 400: code = ErrorCode.INVALID_REQUEST elif exc.status_code == 401: code = ErrorCode.UNAUTHORIZED scheme = ( 'Basic realm="messenger", charset="UTF-8"' if request.url.path == "/api/v1/auth/sessions" else 'Bearer realm="messenger"' ) extra_headers["WWW-Authenticate"] = scheme elif exc.status_code == 404: code = ErrorCode.NOT_FOUND elif exc.status_code == 409: code = ErrorCode.CONFLICT elif exc.status_code == 413: code = ErrorCode.PAYLOAD_TOO_LARGE elif exc.status_code == 415: code = ErrorCode.UNSUPPORTED_MEDIA_TYPE elif exc.status_code == 429: code = ErrorCode.RATE_LIMITED elif exc.status_code == 503: code = ErrorCode.UNAVAILABLE msg = exc.detail if isinstance(exc.detail, str) else "HTTP ошибка" return make_error_response( exc.status_code, code, msg, req_id, headers=extra_headers ) async def dependency_unavailable_handler( request: Request, exc: Exception ) -> JSONResponse: req_id = get_request_id(request) logger.warning( "Upstream storage dependency unavailable for request %s: %s", req_id, exc, ) return make_error_response( status.HTTP_503_SERVICE_UNAVAILABLE, ErrorCode.UNAVAILABLE, "Зависимость недоступна", req_id, ) for exc_cls in ( UnavailableError, asyncpg.PostgresError, asyncpg.InterfaceError, redis.exceptions.RedisError, TimeoutError, asyncio.TimeoutError, ConnectionError, OSError, ): app.add_exception_handler(exc_cls, dependency_unavailable_handler) @app.exception_handler(Exception) async def unhandled_exception_handler( request: Request, exc: Exception ) -> JSONResponse: req_id = get_request_id(request) if isinstance( exc, ( UnavailableError, asyncpg.PostgresError, asyncpg.InterfaceError, redis.exceptions.RedisError, TimeoutError, asyncio.TimeoutError, ConnectionError, OSError, ), ): return await dependency_unavailable_handler(request, exc) logger.error( "Unhandled exception for request %s: %s", req_id, exc, exc_info=True ) return make_error_response( status.HTTP_500_INTERNAL_SERVER_ERROR, ErrorCode.INTERNAL_ERROR, "Внутренняя ошибка сервера", req_id, )