qena-shared-lib 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

qena_shared_lib/__init__.py

@@ -5,8 +5,8 @@ from . import (
     exceptions,
     http,
     logging,
-    logstash,
     rabbitmq,
+    remotelogging,
     scheduler,
     security,
     utils,
@@ -19,7 +19,7 @@ __all__ = [
     "exceptions",
     "http",
     "logging",
-    "logstash",
+    "remotelogging",
     "rabbitmq",
     "scheduler",
     "security",

qena_shared_lib/application.py

@@ -2,17 +2,17 @@ from enum import Enum
 from typing import Any, TypeVar
 
 from fastapi import APIRouter, FastAPI
-from fastapi.exceptions import RequestValidationError
 from prometheus_fastapi_instrumentator import Instrumentator
 from punq import Container, Scope, empty
 from starlette.types import Lifespan
+from typing_extensions import Self
 
 from .exception_handlers import (
-    handle_general_http_exception,
-    handle_http_service_error,
-    handle_request_validation_error,
+    AbstractHttpExceptionHandler,
+    GeneralHttpExceptionHandler,
+    HTTPServiceExceptionHandler,
+    RequestValidationErrorHandler,
 )
-from .exceptions import ServiceException
 from .http import ControllerBase
 
 __all__ = [
@@ -21,6 +21,7 @@ __all__ = [
     "FastAPI",
 ]
 
+
 D = TypeVar("D")
 
 
@@ -46,7 +47,7 @@ class Builder:
         self._container = Container()
         self._built = False
 
-    def with_environment(self, environment: Environment) -> "Builder":
+    def with_environment(self, environment: Environment) -> Self:
         match environment:
             case Environment.DEVELOPMENT:
                 self._environment = Environment.DEVELOPMENT
@@ -60,35 +61,33 @@ class Builder:
 
         return self
 
-    def with_title(self, title: str) -> "Builder":
+    def with_title(self, title: str) -> Self:
         self._title = title
 
         return self
 
-    def with_description(self, description: str) -> "Builder":
+    def with_description(self, description: str) -> Self:
         self._description = description
 
         return self
 
-    def with_version(self, version: str) -> "Builder":
+    def with_version(self, version: str) -> Self:
         self._version = version
 
         return self
 
-    def with_lifespan(self, lifespan: Lifespan) -> "Builder":
+    def with_lifespan(self, lifespan: Lifespan) -> Self:
         self._lifespan = lifespan
 
         return self
 
-    def with_controllers(
-        self, controllers: list[type[ControllerBase]]
-    ) -> "Builder":
+    def with_controllers(self, *controllers: type[ControllerBase]) -> Self:
         for index, controller in enumerate(controllers):
             if not isinstance(controller, type) or not issubclass(
                 controller, ControllerBase
             ):
                 raise TypeError(
-                    f"controller {index} is {type(ControllerBase)}, expected instance of type or subclass of `ControllerBase`"
+                    f"controller {index} is {type(controller)}, expected instance of type or subclass of `ControllerBase`"
                 )
 
             self._container.register(
@@ -99,7 +98,7 @@ class Builder:
 
         return self
 
-    def with_routers(self, routers: list[APIRouter]) -> "Builder":
+    def with_routers(self, *routers: APIRouter) -> Self:
         if any(not isinstance(router, APIRouter) for router in routers):
             raise TypeError("some routers are not type `APIRouter`")
 
@@ -107,13 +106,41 @@ class Builder:
 
         return self
 
+    def with_exception_handlers(
+        self, *exception_handlers: type[AbstractHttpExceptionHandler]
+    ) -> Self:
+        for index, exception_handler in enumerate(exception_handlers):
+            if not isinstance(exception_handler, type) or not issubclass(
+                exception_handler, AbstractHttpExceptionHandler
+            ):
+                raise TypeError(
+                    f"exception handler {index} is {type(exception_handler)}, expected instance of type or subclass of `AbstractHttpExceptionHandler`"
+                )
+
+            self._container.register(
+                service=AbstractHttpExceptionHandler,
+                factory=exception_handler,
+                scope=Scope.singleton,
+            )
+
+        return self
+
+    def with_default_exception_handlers(self) -> Self:
+        self.with_exception_handlers(
+            GeneralHttpExceptionHandler,
+            HTTPServiceExceptionHandler,
+            RequestValidationErrorHandler,
+        )
+
+        return self
+
     def with_singleton(
         self,
         service: type[D],
         factory: Any = empty,
         instance: Any = empty,
         **kwargs: Any,
-    ) -> "Builder":
+    ) -> Self:
         self._container.register(
             service=service,
             factory=factory,
@@ -126,7 +153,7 @@ class Builder:
 
     def with_transient(
         self, service: type[D], factory: Any = empty, **kwargs: Any
-    ) -> "Builder":
+    ) -> Self:
         self._container.register(
             service=service,
             factory=factory,
@@ -136,7 +163,7 @@ class Builder:
 
         return self
 
-    def with_metrics(self, endpoint: str = "/metrics") -> "Builder":
+    def with_metrics(self, endpoint: str = "/metrics") -> Self:
         self._metrics_endpoint = endpoint
         self._instrumentator = Instrumentator()
 
@@ -158,13 +185,8 @@ class Builder:
         )
         app.state.container = self._container
 
-        app.exception_handler(ServiceException)(handle_http_service_error)
-        app.exception_handler(RequestValidationError)(
-            handle_request_validation_error
-        )
-        app.exception_handler(Exception)(handle_general_http_exception)
-
-        self._resolve_api_controllers(app)
+        self._register_api_controllers(app)
+        self._register_exception_handlers(app)
 
         if self._instrumentator is not None:
             self._instrumentator.instrument(app).expose(
@@ -177,14 +199,34 @@ class Builder:
 
         return app
 
-    def _resolve_api_controllers(self, app: FastAPI) -> None:
-        api_controller_routers = [
+    def _register_api_controllers(self, app: FastAPI) -> None:
+        for router in self._routers + self._resolve_api_controllers():
+            app.include_router(router)
+
+    def _resolve_api_controllers(self) -> list[APIRouter]:
+        return [
             api_controller.register_route_handlers()
             for api_controller in self._container.resolve_all(ControllerBase)
         ]
 
-        for router in self._routers + api_controller_routers:
-            app.include_router(router)
+    def _register_exception_handlers(self, app: FastAPI) -> None:
+        for exception_handler in self._resolve_exception_handlers():
+            if not callable(exception_handler):
+                raise ValueError(
+                    f"exception handler {exception_handler.__class__.__name__} is not callable"
+                )
+
+            app.exception_handler(exception_handler.exception)(
+                exception_handler
+            )
+
+    def _resolve_exception_handlers(self) -> list[AbstractHttpExceptionHandler]:
+        return [
+            exception_handler
+            for exception_handler in self._container.resolve_all(
+                AbstractHttpExceptionHandler
+            )
+        ]
 
     @property
     def environment(self) -> Environment:

qena_shared_lib/background.py

@@ -3,13 +3,14 @@ from asyncio import (
     Task,
     gather,
 )
+from typing import Any
 from uuid import uuid4
 
 from prometheus_client import Enum as PrometheusEnum
 from starlette.background import BackgroundTask
 
 from .logging import LoggerProvider
-from .logstash import BaseLogstashSender
+from .remotelogging import BaseRemoteLogSender
 from .utils import AsyncEventLoopMixin
 
 __all__ = [
@@ -27,14 +28,14 @@ class Background(AsyncEventLoopMixin):
 
     def __init__(
         self,
-        logstash: BaseLogstashSender,
+        remote_logger: BaseRemoteLogSender,
     ) -> None:
         self._queue: Queue[tuple[BackgroundTask | None, str | None]] = Queue()
         self._started = False
         self._stopped = False
-        self._logstash = logstash
+        self._remote_logger = remote_logger
         self._logger = LoggerProvider.default().get_logger("backgroud")
-        self._tasks: dict[str, Task] = {}
+        self._tasks: dict[str, Task[Any]] = {}
 
     async def _task_manager(
         self, task: BackgroundTask, task_id: str | None = None
@@ -53,7 +54,7 @@ class Background(AsyncEventLoopMixin):
 
             await self._tasks[task_id]
         except Exception:
-            self._logstash.error(
+            self._remote_logger.error(
                 "exception occured when running background task {task.func.__name__} with id {task_id}"
             )
         finally:

qena_shared_lib/exception_handlers.py

@@ -1,12 +1,11 @@
 from collections.abc import Iterable
-from typing import Any
+from typing import Any, cast
 
 from fastapi import Request, Response, status
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from pydantic_core import to_jsonable_python
 
-from .dependencies.http import get_service
 from .exceptions import (
     HTTPServiceError,
     RabbitMQServiceException,
@@ -14,194 +13,223 @@ from .exceptions import (
     Severity,
 )
 from .logging import LoggerProvider
-from .logstash._base import BaseLogstashSender
+from .remotelogging import BaseRemoteLogSender
 
 __all__ = [
-    "handle_http_service_error",
-    "handle_request_validation_error",
-    "handle_general_http_exception",
+    "AbstractHttpExceptionHandler",
+    "GeneralHttpExceptionHandler",
+    "HTTPServiceExceptionHandler",
+    "RequestValidationErrorHandler",
 ]
 
 
-def handle_http_service_error(
-    request: Request, exception: ServiceException
-) -> Response:
-    logstash = get_service(app=request.app, service_key=BaseLogstashSender)
-    logger_provider = get_service(app=request.app, service_key=LoggerProvider)
-    logger = logger_provider.get_logger("http.exception_handler")
-    exception_severity = exception.severity or Severity.LOW
-    user_agent = request.headers.get("user-agent", "__unknown__")
-    message = exception.message
-    tags = [
-        "HTTP",
-        request.method,
-        request.url.path,
-        exception.__class__.__name__,
-    ]
-    extra = {
-        "serviceType": "HTTP",
-        "method": request.method,
-        "path": request.url.path,
-        "userAgent": user_agent,
-        "exception": exception.__class__.__name__,
-    }
-    exc_info = (
-        (type(exception), exception, exception.__traceback__)
-        if exception.extract_exc_info
-        else None
-    )
-
-    match exception_severity:
-        case Severity.LOW:
-            logstash_logger_method = logstash.info
-            logger_method = logger.info
-        case Severity.MEDIUM:
-            logstash_logger_method = logstash.warning
-            logger_method = logger.warning
-        case _:
-            message = "something went wrong"
-            logstash_logger_method = logstash.error
-            logger_method = logger.error
-
-    content: dict[str, Any] = {
-        "severity": exception_severity.name,
-        "message": message,
-    }
-    status_code = _status_code_from_severity(exception.severity)
-    headers = None
-
-    match exception:
-        case HTTPServiceError() as http_service_error:
-            if http_service_error.body is not None:
-                extra_body = to_jsonable_python(http_service_error.body)
-                is_updated = False
-
-                try:
-                    if isinstance(extra_body, Iterable):
-                        content.update(extra_body)
-
-                        is_updated = True
-                except:
-                    pass
-
-                if not is_updated:
-                    content["data"] = extra_body
-
-            if http_service_error.response_code is not None:
-                content["code"] = http_service_error.response_code
-                str_response_code = str(http_service_error.response_code)
-                extra["responseCode"] = str_response_code
-
-                tags.append(str_response_code)
-
-            if http_service_error.corrective_action is not None:
-                content["correctiveAction"] = (
-                    http_service_error.corrective_action
-                )
-
-            if http_service_error.status_code is not None:
-                status_code = http_service_error.status_code
-                str_status_code = str(status_code)
-                extra["statusCode"] = str_status_code
-
-                tags.append(str_status_code)
-
-            if http_service_error.headers is not None:
-                headers = http_service_error.headers
-        case RabbitMQServiceException() as rabbitmq_service_exception:
-            str_error_code = str(rabbitmq_service_exception.code)
-            extra["code"] = str_error_code
-
-            tags.append(str_error_code)
-
-    if exception.tags:
-        tags.extend(exception.tags)
-
-    if exception.extra:
-        extra.update(exception.extra)
-
-    if exception.logstash_logging:
-        logstash_logger_method(
-            message=exception.message,
-            tags=tags,
-            extra=extra,
-            exception=exception if exception.extract_exc_info else None,
-        )
-    else:
-        logger_method(
-            "\n%s %s\n%s",
-            request.method,
-            request.url.path,
-            exception.message,
-            exc_info=exc_info,
-        )
+class AbstractHttpExceptionHandler:
+    @property
+    def exception(self) -> type[Exception]:
+        raise NotImplementedError()
 
-    return JSONResponse(
-        content=content,
-        status_code=status_code,
-        headers=headers,
-    )
 
+class HTTPServiceExceptionHandler(AbstractHttpExceptionHandler):
+    @property
+    def exception(self) -> type[Exception]:
+        return cast(type[Exception], ServiceException)
 
-def handle_request_validation_error(
-    request: Request, error: RequestValidationError
-) -> Response:
-    logger_provider = get_service(app=request.app, service_key=LoggerProvider)
-    logger = logger_provider.get_logger("http.exception_handler")
-    message = "invalid request data"
-
-    logger.warning("\n%s %s\n%s", request.method, request.url.path, message)
-
-    return JSONResponse(
-        content={
-            "severity": Severity.MEDIUM.name,
-            "message": message,
-            "code": 100,
-            "detail": to_jsonable_python(error.errors()),
-        },
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-    )
-
-
-def handle_general_http_exception(
-    request: Request, exception: Exception
-) -> Response:
-    logstash = get_service(app=request.app, service_key=BaseLogstashSender)
-    user_agent = request.get("user-agent", "__unknown__")
-
-    logstash.error(
-        message=f"something went wrong on endpoint `{request.method} {request.url.path}`",
-        tags=[
+    def __init__(
+        self,
+        remote_logger: BaseRemoteLogSender,
+        logger_provider: LoggerProvider,
+    ):
+        self._remote_logger = remote_logger
+        self._logger = logger_provider.get_logger("http.exception_handler")
+
+    def __call__(
+        self, request: Request, exception: ServiceException
+    ) -> Response:
+        exception_severity = exception.severity or Severity.LOW
+        user_agent = request.headers.get("user-agent", "__unknown__")
+        message = exception.message
+        tags = [
             "HTTP",
             request.method,
             request.url.path,
             exception.__class__.__name__,
-        ],
-        extra={
+        ]
+        extra = {
             "serviceType": "HTTP",
             "method": request.method,
             "path": request.url.path,
             "userAgent": user_agent,
             "exception": exception.__class__.__name__,
-        },
-        exception=exception,
-    )
-
-    return JSONResponse(
-        content={
-            "severity": Severity.HIGH.name,
-            "message": "something went wrong",
-        },
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-    )
-
-
-def _status_code_from_severity(severity: Severity | None) -> int:
-    if (
-        severity is None
-        or severity == Severity.LOW
-        or severity == Severity.MEDIUM
-    ):
-        return status.HTTP_400_BAD_REQUEST
+        }
+        exc_info = (
+            (type(exception), exception, exception.__traceback__)
+            if exception.extract_exc_info
+            else None
+        )
+
+        match exception_severity:
+            case Severity.LOW:
+                remote_logger_method = self._remote_logger.info
+                logger_method = self._logger.info
+            case Severity.MEDIUM:
+                remote_logger_method = self._remote_logger.warning
+                logger_method = self._logger.warning
+            case _:
+                message = "something went wrong"
+                remote_logger_method = self._remote_logger.error
+                logger_method = self._logger.error
+
+        content: dict[str, Any] = {
+            "severity": exception_severity.name,
+            "message": message,
+        }
+        status_code = self._status_code_from_severity(exception.severity)
+        headers = None
+
+        match exception:
+            case HTTPServiceError() as http_service_error:
+                if http_service_error.body is not None:
+                    extra_body = to_jsonable_python(http_service_error.body)
+                    is_updated = False
+
+                    try:
+                        if isinstance(extra_body, Iterable):
+                            content.update(extra_body)
+
+                            is_updated = True
+                    except:
+                        pass
+
+                    if not is_updated:
+                        content["data"] = extra_body
+
+                if http_service_error.response_code is not None:
+                    content["code"] = http_service_error.response_code
+                    str_response_code = str(http_service_error.response_code)
+                    extra["responseCode"] = str_response_code
+
+                    tags.append(str_response_code)
+
+                if http_service_error.corrective_action is not None:
+                    content["correctiveAction"] = (
+                        http_service_error.corrective_action
+                    )
+
+                if http_service_error.status_code is not None:
+                    status_code = http_service_error.status_code
+                    str_status_code = str(status_code)
+                    extra["statusCode"] = str_status_code
+
+                    tags.append(str_status_code)
+
+                if http_service_error.headers is not None:
+                    headers = http_service_error.headers
+            case RabbitMQServiceException() as rabbitmq_service_exception:
+                str_error_code = str(rabbitmq_service_exception.code)
+                extra["code"] = str_error_code
+
+                tags.append(str_error_code)
+
+        if exception.tags:
+            tags.extend(exception.tags)
+
+        if exception.extra:
+            extra.update(exception.extra)
+
+        if exception.remote_logging:
+            remote_logger_method(
+                message=exception.message,
+                tags=tags,
+                extra=extra,
+                exception=exception if exception.extract_exc_info else None,
+            )
+        else:
+            logger_method(
+                "\n%s %s\n%s",
+                request.method,
+                request.url.path,
+                exception.message,
+                exc_info=exc_info,
+            )
+
+        return JSONResponse(
+            content=content,
+            status_code=status_code,
+            headers=headers,
+        )
+
+    def _status_code_from_severity(self, severity: Severity | None) -> int:
+        if (
+            severity is None
+            or severity is Severity.LOW
+            or severity is Severity.MEDIUM
+        ):
+            return cast(int, status.HTTP_400_BAD_REQUEST)
 
-    return status.HTTP_500_INTERNAL_SERVER_ERROR
+        return cast(int, status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class RequestValidationErrorHandler(AbstractHttpExceptionHandler):
+    @property
+    def exception(self) -> type[Exception]:
+        return cast(type[Exception], RequestValidationError)
+
+    def __init__(self, logger_provider: LoggerProvider):
+        self._logger = logger_provider.get_logger("http.exception_handler")
+
+    def __call__(
+        self, request: Request, error: RequestValidationError
+    ) -> Response:
+        message = "invalid request data"
+
+        self._logger.warning(
+            "\n%s %s\n%s", request.method, request.url.path, message
+        )
+
+        return JSONResponse(
+            content={
+                "severity": Severity.MEDIUM.name,
+                "message": message,
+                "code": 100,
+                "detail": to_jsonable_python(error.errors()),
+            },
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        )
+
+
+class GeneralHttpExceptionHandler(AbstractHttpExceptionHandler):
+    @property
+    def exception(self) -> type[Exception]:
+        return Exception
+
+    def __init__(self, remote_logger: BaseRemoteLogSender):
+        self._remote_logger = remote_logger
+
+    def __call__(self, request: Request, exception: Exception) -> Response:
+        user_agent = request.get("user-agent", "__unknown__")
+
+        self._remote_logger.error(
+            message=f"something went wrong on endpoint `{request.method} {request.url.path}`",
+            tags=[
+                "HTTP",
+                request.method,
+                request.url.path,
+                exception.__class__.__name__,
+            ],
+            extra={
+                "serviceType": "HTTP",
+                "method": request.method,
+                "path": request.url.path,
+                "userAgent": user_agent,
+                "exception": exception.__class__.__name__,
+            },
+            exception=exception,
+        )
+
+        return JSONResponse(
+            content={
+                "severity": Severity.HIGH.name,
+                "message": "something went wrong",
+            },
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        )