qena-shared-lib 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

qena_shared_lib/application.py

@@ -9,8 +9,8 @@ from starlette.types import Lifespan
 
 from .exception_handlers import (
     handle_general_http_exception,
+    handle_http_service_error,
     handle_request_validation_error,
-    handle_service_exception,
 )
 from .exceptions import ServiceException
 from .http import ControllerBase
@@ -153,7 +153,7 @@ class Builder:
         )
         app.state.container = self._container
 
-        app.exception_handler(ServiceException)(handle_service_exception)
+        app.exception_handler(ServiceException)(handle_http_service_error)
         app.exception_handler(RequestValidationError)(
             handle_request_validation_error
         )

qena_shared_lib/exception_handlers.py

@@ -7,18 +7,23 @@ from fastapi.responses import JSONResponse
 from pydantic_core import to_jsonable_python
 
 from .dependencies.http import get_service
-from .exceptions import ServiceException, Severity
+from .exceptions import (
+    HTTPServiceError,
+    RabbitMQServiceException,
+    ServiceException,
+    Severity,
+)
 from .logging import LoggerProvider
 from .logstash._base import BaseLogstashSender
 
 __all__ = [
-    "handle_service_exception",
+    "handle_http_service_error",
     "handle_request_validation_error",
     "handle_general_http_exception",
 ]
 
 
-def handle_service_exception(
+def handle_http_service_error(
     request: Request, exception: ServiceException
 ) -> Response:
     logstash = get_service(app=request.app, service_key=BaseLogstashSender)
@@ -32,20 +37,12 @@ def handle_service_exception(
         request.url.path,
         exception.__class__.__name__,
     ]
-
-    if exception.tags:
-        exception.tags.extend(tags)
-
     extra = {
         "serviceType": "HTTP",
         "method": request.method,
         "path": request.url.path,
         "exception": exception.__class__.__name__,
     }
-
-    if exception.extra:
-        exception.extra.update(extra)
-
     exc_info = (
         (type(exception), exception, exception.__traceback__)
         if exception.extract_exc_info
@@ -64,6 +61,63 @@ def handle_service_exception(
             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,
@@ -80,39 +134,10 @@ def handle_service_exception(
             exc_info=exc_info,
         )
 
-    content: dict[str, Any] = {
-        "severity": exception_severity.name
-        if exception_severity
-        else Severity.LOW.name,
-        "message": message,
-    }
-
-    if exception.response_code is not None:
-        content["code"] = exception.response_code
-
-    if exception.corrective_action is not None:
-        content["correctiveAction"] = exception.corrective_action
-
-    if exception.body is not None:
-        extra_body = to_jsonable_python(exception.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
-
     return JSONResponse(
         content=content,
-        status_code=exception.status_code
-        or _status_code_from_severity(exception.severity),
-        headers=exception.headers,
+        status_code=status_code,
+        headers=headers,
     )
 
 

qena_shared_lib/exceptions.py

@@ -2,50 +2,56 @@ from enum import Enum
 from typing import Any
 
 __all__ = [
-    "Severity",
-    "ServiceException",
-    "ClientError",
+    "BadGateway",
     "BadRequest",
-    "Unauthorized",
-    "PaymentRequired",
-    "Forbidden",
-    "NotFound",
-    "MethodNotAllowed",
-    "NotAcceptable",
-    "ProxyAuthenticationRequired",
-    "RequestTimeout",
+    "ClientError",
     "Conflict",
-    "Gone",
-    "LengthRequired",
-    "PreconditionFailed",
-    "PayloadTooLarge",
-    "URITooLong",
-    "UnsupportedMediaType",
-    "RangeNotSatisfiable",
     "ExpectationFailed",
+    "FailedDependency",
+    "Forbidden",
+    "GatewayTimeout",
+    "Gone",
+    "HTTPServiceError",
+    "HTTPVersionNotSupported",
     "IAmATeapot",
-    "MisdirectedRequest",
-    "UnprocessableEntity",
+    "InsufficientStorage",
+    "InternalServerError",
+    "LengthRequired",
     "Locked",
-    "FailedDependency",
-    "TooEarly",
-    "UpgradeRequired",
+    "LoopDetected",
+    "MethodNotAllowed",
+    "MisdirectedRequest",
+    "NetworkAuthenticationRequired",
+    "NotAcceptable",
+    "NotExtended",
+    "NotFound",
+    "NotImplemented",
+    "PayloadTooLarge",
+    "PaymentRequired",
+    "PreconditionFailed",
     "PreconditionRequired",
-    "TooManyRequests",
+    "ProxyAuthenticationRequired",
+    "RabbitMQBlockedError",
+    "RabbitMQConnectionUnhealthyError",
+    "RabbitMQRpcRequestPendingError",
+    "RabbitMQRpcRequestTimeoutError",
+    "RabbitMQServiceException",
+    "RangeNotSatisfiable",
     "RequestHeaderFieldsTooLarge",
-    "UnavailableForLegalReasons",
+    "RequestTimeout",
     "ServerError",
-    "InternalServerError",
-    "NotImplemented",
-    "BadGateway",
+    "ServiceException",
     "ServiceUnavailable",
-    "GatewayTimeout",
-    "HTTPVersionNotSupported",
+    "Severity",
+    "TooEarly",
+    "TooManyRequests",
+    "Unauthorized",
+    "UnavailableForLegalReasons",
+    "UnprocessableEntity",
+    "UnsupportedMediaType",
+    "UpgradeRequired",
+    "URITooLong",
     "VariantAlsoNegotiates",
-    "InsufficientStorage",
-    "LoopDetected",
-    "NotExtended",
-    "NetworkAuthenticationRequired",
 ]
 
 
@@ -56,100 +62,134 @@ class Severity(Enum):
 
 
 class ServiceException(Exception):
-    _GENERAL_EXTRACT_EXC_INFO = None
     _GENERAL_SEVERITY = None
-    _GENERAL_STATUS_CODE = None
+    _GENERAL_EXTRACT_EXC_INFO = None
 
     def __init__(
         self,
         message: str,
-        body: Any | None = None,
-        corrective_action: str | None = None,
         severity: Severity | None = None,
-        status_code: int | None = None,
-        response_code: int | None = None,
         tags: list[str] | None = None,
         extra: dict[str, str] | None = None,
-        headers: dict[str, str] | None = None,
-        logstash_logging: bool = True,
-        extract_exc_info: bool = True,
+        logstash_logging: bool | None = None,
+        extract_exc_info: bool | None = None,
     ):
         self._message = message
-        self._body = body
-        self._corrective_action = corrective_action
-        self._response_code = response_code
+
+        if severity is not None:
+            self._severity = severity
+        else:
+            self._severity = self._GENERAL_SEVERITY
+
         self._tags = tags
         self._extra = extra
-        self._headers = headers
-        self._logstash_logging = (
-            logstash_logging if logstash_logging is not None else True
-        )
-        self._extract_exc_info = (
-            extract_exc_info
-            if extract_exc_info is not None
-            else self._GENERAL_EXTRACT_EXC_INFO
-        )
-        self._severity = (
-            severity if severity is not None else self._GENERAL_SEVERITY
-        )
-        self._status_code = (
-            status_code
-            if status_code is not None
-            else self._GENERAL_STATUS_CODE
-        )
+
+        if logstash_logging is not None:
+            self._logstash_logging = logstash_logging
+        else:
+            self._logstash_logging = True
+
+        if extract_exc_info is not None:
+            self._extract_exc_info = extract_exc_info
+        else:
+            self._extract_exc_info = self._GENERAL_EXTRACT_EXC_INFO
 
     @property
     def message(self) -> str:
         return self._message
 
     @property
-    def body(self) -> Any | None:
-        return self._body
+    def severity(self) -> Severity | None:
+        return self._severity
 
     @property
-    def corrective_action(self) -> str | None:
-        return self._corrective_action
+    def tags(self) -> list[str] | None:
+        return self._tags
 
     @property
-    def severity(self) -> Severity | None:
-        return self._severity
+    def extra(self) -> dict[str, str] | None:
+        return self._extra
 
     @property
-    def status_code(self) -> int | None:
-        return self._status_code
+    def logstash_logging(self) -> bool | None:
+        return self._logstash_logging
 
     @property
-    def response_code(self) -> int | None:
-        return self._response_code
+    def extract_exc_info(self) -> bool | None:
+        return self._extract_exc_info
+
+    def __str__(self) -> str:
+        return f"message `{self._message}`, tags {self._tags or []}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__} ( message: `{self._message}`, tags: {self._tags or []}, extra: {self._extra or {}} )"
+
+
+class HTTPServiceError(ServiceException):
+    _GENERAL_STATUS_CODE = None
+
+    def __init__(
+        self,
+        message: str,
+        body: Any | None = None,
+        status_code: int | None = None,
+        headers: dict[str, str] | None = None,
+        response_code: int | None = None,
+        corrective_action: str | None = None,
+        severity: Severity | None = None,
+        tags: list[str] | None = None,
+        extra: dict[str, str] | None = None,
+        logstash_logging: bool = True,
+        extract_exc_info: bool = True,
+    ):
+        super().__init__(
+            message=message,
+            severity=severity,
+            tags=tags,
+            extra=extra,
+            logstash_logging=logstash_logging,
+            extract_exc_info=extract_exc_info,
+        )
+
+        self._body = body
+
+        if status_code is not None:
+            self._status_code = status_code
+        else:
+            self._status_code = self._GENERAL_STATUS_CODE
+
+        self._headers = headers
+        self._response_code = response_code
+        self._corrective_action = corrective_action
 
     @property
-    def tags(self) -> list[str] | None:
-        return self._tags
+    def body(self) -> Any | None:
+        return self._body
 
     @property
-    def extra(self) -> dict[str, str] | None:
-        return self._extra
+    def status_code(self) -> int | None:
+        return self._status_code
 
     @property
     def headers(self) -> dict[str, str] | None:
         return self._headers
 
     @property
-    def logstash_logging(self) -> bool | None:
-        return self._logstash_logging
+    def response_code(self) -> int | None:
+        return self._response_code
 
     @property
-    def extract_exc_info(self) -> bool | None:
-        return self._extract_exc_info
+    def corrective_action(self) -> str | None:
+        return self._corrective_action
 
     def __str__(self) -> str:
-        return f"message `{self._message}`, tags `{self._tags or []}`"
+        return f"message `{self._message}`, status_code {self._status_code or 500}, response_code {self._response_code or 0}"
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__} ( message = `{self._message}`, tags = `{self._tags or []}`, extra = `{self._extra or {}}` )"
+        return f"{self.__class__.__name__} ( message: `{self._message}`, status_code: {self._status_code or 500}, response_code: {self._response_code or 0} )"
 
 
-class ClientError(ServiceException):
+class ClientError(HTTPServiceError):
     _GENERAL_EXTRACT_EXC_INFO = False
     _GENERAL_SEVERITY = Severity.MEDIUM
 
@@ -270,7 +310,7 @@ class UnavailableForLegalReasons(ClientError):
     _GENERAL_STATUS_CODE = 451
 
 
-class ServerError(ServiceException):
+class ServerError(HTTPServiceError):
     _GENERAL_EXTRACT_EXC_INFO = True
     _GENERAL_SEVERITY = Severity.HIGH
 
@@ -317,3 +357,65 @@ class NotExtended(ServerError):
 
 class NetworkAuthenticationRequired(ServerError):
     _GENERAL_STATUS_CODE = 511
+
+
+class RabbitMQServiceException(ServiceException):
+    _GENERAL_SEVERITY = Severity.HIGH
+    _GENERAL_CODE = None
+
+    def __init__(
+        self,
+        message: str,
+        code: int | None = None,
+        data: Any | None = None,
+        severity: Severity | None = None,
+        tags: list[str] | None = None,
+        extra: dict[str, str] | None = None,
+        logstash_logging: bool | None = None,
+        extract_exc_info: bool | None = None,
+    ):
+        super().__init__(
+            message=message,
+            severity=severity,
+            tags=tags,
+            extra=extra,
+            logstash_logging=logstash_logging,
+            extract_exc_info=extract_exc_info,
+        )
+
+        if code is not None:
+            self._code = code
+        else:
+            self._code = self._GENERAL_CODE or 0
+
+        self._data = data
+
+    @property
+    def code(self) -> int:
+        return self._code
+
+    @property
+    def data(self) -> Any | None:
+        return self._data
+
+    def __str__(self) -> str:
+        return f"message `{self.message}`, code {self.code}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__} ( message: `{self._message}`, code: {self._code} )"
+
+
+class RabbitMQBlockedError(Exception):
+    pass
+
+
+class RabbitMQRpcRequestTimeoutError(Exception):
+    pass
+
+
+class RabbitMQRpcRequestPendingError(Exception):
+    pass
+
+
+class RabbitMQConnectionUnhealthyError(Exception):
+    pass

qena_shared_lib/http.py

@@ -9,6 +9,7 @@ from fastapi.responses import JSONResponse
 from fastapi.types import IncEx
 
 __all__ = [
+    "api_controller",
     "ApiController",
     "ControllerBase",
     "delete",
@@ -41,7 +42,7 @@ class HTTPMethods(Enum):
 class RouteHandlerMeta:
     method: HTTPMethods
     path: str | None = None
-    response_model: Any | None = Default(None)
+    response_model: Any | None = None
     status_code: int | None = None
     tags: list[str | Enum] | None = None
     dependencies: Sequence[Depends] | None = None
@@ -57,7 +58,7 @@ class RouteHandlerMeta:
     response_model_exclude_defaults: bool = False
     response_model_exclude_none: bool = False
     include_in_schema: bool = True
-    response_class: type[Response] = Default(JSONResponse)
+    response_class: type[Response] = JSONResponse
     name: str | None = None
     openapi_extra: dict[str, Any] | None = None
 
@@ -69,7 +70,7 @@ class ApiController:
         *,
         tags: list[str | Enum] | None = None,
         dependencies: Sequence[Depends] | None = None,
-        default_response_class: type[Response] = Default(JSONResponse),
+        default_response_class: type[Response] = JSONResponse,
         responses: dict[int | str, dict[str, Any]] | None = None,
         redirect_slashes: bool = True,
         deprecated: bool | None = None,
@@ -92,6 +93,29 @@ class ApiController:
         return controller
 
 
+def api_controller(
+    prefix: str | None = None,
+    *,
+    tags: list[str | Enum] | None = None,
+    dependencies: Sequence[Depends] | None = None,
+    default_response_class: type[Response] = JSONResponse,
+    responses: dict[int | str, dict[str, Any]] | None = None,
+    redirect_slashes: bool = True,
+    deprecated: bool | None = None,
+    include_in_schema: bool = True,
+) -> ApiController:
+    return ApiController(
+        prefix=prefix,
+        tags=tags,
+        dependencies=dependencies,
+        default_response_class=default_response_class,
+        responses=responses,
+        redirect_slashes=redirect_slashes,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+    )
+
+
 def get(
     path: str | None = None,
     *,

qena_shared_lib/logstash/_base.py

@@ -102,13 +102,13 @@ class LogstashLogRecord:
         self, exception: BaseException
     ) -> dict[str, str]:
         causes = {}
-        cause = exception.__cause__
+        cause = exception.__cause__ or exception.__context__
         cause_depth = 0
 
         while cause is not None:
             cause_depth += 1
             causes[self._depth_to_cause(cause_depth)] = cause.__class__.__name__
-            cause = cause.__cause__
+            cause = cause.__cause__ or cause.__context__
 
         return causes
 
@@ -228,7 +228,6 @@ class BaseLogstashSender(AsyncEventLoopMixin):
         self._max_log_retry = max_log_retry
         self._started = False
         self._closed = False
-        self._close_future = self.loop.create_future()
         self._log_queue: Queue[LogstashLogRecord | EndOfLogMarker] = Queue(
             log_queue_size
         )
@@ -246,6 +245,7 @@ class BaseLogstashSender(AsyncEventLoopMixin):
 
         self._started = True
         self._closed = False
+        self._close_future = self.loop.create_future()
         _, _ = await gather(
             self.loop.run_in_executor(executor=None, func=self._hook_on_start),
             self._hook_on_start_async(),

qena_shared_lib/rabbitmq/__init__.py

@@ -2,11 +2,9 @@ from ._base import AbstractRabbitMQService, RabbitMqManager
 from ._channel import BaseChannel
 from ._exception_handlers import (
     handle_general_mq_exception,
-    handle_microservice_exception,
-    handle_rabbitmq_exception,
+    handle_rabbit_mq_service_exception,
     handle_validation_error,
 )
-from ._exceptions import RabbitMQException
 from ._listener import (
     CONSUMER_ATTRIBUTE,
     LISTENER_ATTRIBUTE,
@@ -20,7 +18,9 @@ from ._listener import (
     RetryPolicy,
     RpcWorker,
     consume,
+    consumer,
     execute,
+    rpc_worker,
 )
 from ._publisher import Publisher
 from ._rpc_client import RpcClient
@@ -31,22 +31,22 @@ __all__ = [
     "BaseChannel",
     "consume",
     "CONSUMER_ATTRIBUTE",
+    "consumer",
     "Consumer",
     "execute",
     "FixedRetryDelay",
     "handle_general_mq_exception",
-    "handle_microservice_exception",
-    "handle_rabbitmq_exception",
+    "handle_rabbit_mq_service_exception",
     "handle_validation_error",
     "LISTENER_ATTRIBUTE",
     "ListenerBase",
     "ListenerContext",
     "Publisher",
-    "RabbitMQException",
     "RabbitMqManager",
     "RetryDelayJitter",
     "RetryPolicy",
     "RPC_WORKER_ATTRIBUTE",
+    "rpc_worker",
     "RpcClient",
     "RpcWorker",
 ]