jararaca 0.3.18__tar.gz → 0.3.19__tar.gz

{jararaca-0.3.18 → jararaca-0.3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jararaca
-Version: 0.3.18
+Version: 0.3.19
 Summary: A simple and fast API framework for Python
 Home-page: https://github.com/LuscasLeo/jararaca
 Author: Lucas S
@@ -18,11 +18,11 @@ Requires-Dist: croniter (>=3.0.3,<4.0.0)
 Requires-Dist: fastapi (>=0.113.0,<0.114.0)
 Requires-Dist: frozendict (>=2.4.6,<3.0.0)
 Requires-Dist: mako (>=1.3.5,<2.0.0)
-Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
-Requires-Dist: opentelemetry-distro (>=0.49b2,<0.50) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-api (>=1.38.0,<2.0.0) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-distro (>=0.59b0,<0.60) ; extra == "opentelemetry"
 Requires-Dist: opentelemetry-exporter-otlp (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
-Requires-Dist: opentelemetry-sdk (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-sdk (>=1.38.0,<2.0.0) ; extra == "opentelemetry"
 Requires-Dist: redis (>=5.0.8,<6.0.0)
 Requires-Dist: sqlalchemy (>=2.0.34,<3.0.0)
 Requires-Dist: types-croniter (>=3.0.3.20240731,<4.0.0.0)

{jararaca-0.3.18 → jararaca-0.3.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.3.18"
+version = "0.3.19"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"
@@ -20,9 +20,9 @@ croniter = "^3.0.3"
 redis = "^5.0.8"
 websockets = "^13.0.1"
 opentelemetry-exporter-otlp-proto-http = { version = "^1.27.0", optional = true }
-opentelemetry-api = { version = "^1.27.0", optional = true }
-opentelemetry-sdk = { version = "^1.27.0", optional = true }
-opentelemetry-distro = { version = "^0.49b2", optional = true }
+opentelemetry-api = "^1.38.0"
+opentelemetry-sdk = "^1.38.0"
+opentelemetry-distro = "^0.59b0"
 opentelemetry-exporter-otlp = { version = "^1.27.0", optional = true }
 types-croniter = "^3.0.3.20240731"
 types-redis = "^4.6.0.20240903"

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/__init__.py

@@ -17,6 +17,8 @@ if TYPE_CHECKING:
         AppTransactionContext,
         use_app_type,
     )
+    from jararaca.observability.decorators import TracedClass, TracedFunc, traced_class
+    from jararaca.observability.hooks import spawn_trace
     from jararaca.observability.interceptor import ObservabilityInterceptor
     from jararaca.observability.providers.otel import OtelObservabilityProvider
     from jararaca.persistence.sort_filter import (
@@ -222,6 +224,10 @@ if TYPE_CHECKING:
         "HttpPut",
         "HttpDelete",
         "ObservabilityInterceptor",
+        "TracedFunc",
+        "TracedClass",
+        "traced_class",
+        "spawn_trace",
         "QueryInjector",
         "HttpMicroservice",
         "use_current_container",
@@ -392,6 +398,10 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "HttpPut": (__SPEC_PARENT__, "rpc.http.decorators", "Put"),
     "HttpDelete": (__SPEC_PARENT__, "rpc.http.decorators", "Delete"),
     "ObservabilityInterceptor": (__SPEC_PARENT__, "observability.interceptor", None),
+    "TracedFunc": (__SPEC_PARENT__, "observability.decorators", None),
+    "TracedClass": (__SPEC_PARENT__, "observability.decorators", None),
+    "traced_class": (__SPEC_PARENT__, "observability.decorators", None),
+    "spawn_trace": (__SPEC_PARENT__, "observability.hooks", None),
     "QueryInjector": (__SPEC_PARENT__, "persistence.utilities", None),
     "HttpMicroservice": (__SPEC_PARENT__, "presentation.http_microservice", None),
     "use_current_container": (__SPEC_PARENT__, "microservice", None),

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/core/uow.py

@@ -33,7 +33,6 @@ class UnitOfWorkContextProvider:
         self.container = container
         self.container_interceptor = ContainerInterceptor(container)
 
-    # TODO: Guarantee that the context is closed whenever an exception is raised
     # TODO: Guarantee a unit of work workflow for the whole request, including all the interceptors
 
     def factory_app_interceptors(self) -> Sequence[AppInterceptor]:
@@ -65,7 +64,36 @@ class UnitOfWorkContextProvider:
             for ctx in ctxs:
                 await ctx.__aenter__()
 
-            yield None
-
-            for ctx in reversed(ctxs):
-                await ctx.__aexit__(None, None, None)
+            exc_type = None
+            exc_value = None
+            exc_traceback = None
+
+            try:
+                yield None
+            except BaseException as e:
+                exc_type = type(e)
+                exc_value = e
+                exc_traceback = e.__traceback__
+                raise
+            finally:
+                # Exit interceptors in reverse order, propagating exception info
+                for ctx in reversed(ctxs):
+                    try:
+                        suppressed = await ctx.__aexit__(
+                            exc_type, exc_value, exc_traceback
+                        )
+                        # If an interceptor returns True, it suppresses the exception
+                        if suppressed and exc_type is not None:
+                            exc_type = None
+                            exc_value = None
+                            exc_traceback = None
+                    except BaseException as exit_exc:
+                        # If an interceptor raises an exception during cleanup,
+                        # replace the original exception with the new one
+                        exc_type = type(exit_exc)
+                        exc_value = exit_exc
+                        exc_traceback = exit_exc.__traceback__
+
+                # Re-raise the exception if it wasn't suppressed
+                if exc_type is not None and exc_value is not None:
+                    raise exc_value.with_traceback(exc_traceback)

jararaca-0.3.19/src/jararaca/messagebus/implicit_headers.py

@@ -0,0 +1,45 @@
+import datetime
+import decimal
+import typing
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Generator
+
+FieldArray = list["FieldValue"]
+"""A data structure for holding an array of field values."""
+
+FieldTable = typing.Dict[str, "FieldValue"]
+FieldValue = (
+    bool
+    | bytes
+    | bytearray
+    | decimal.Decimal
+    | FieldArray
+    | FieldTable
+    | float
+    | int
+    | None
+    | str
+    | datetime.datetime
+)
+
+ImplicitHeaders = Dict[str, FieldValue]
+
+implicit_headers_ctx = ContextVar[ImplicitHeaders | None](
+    "implicit_headers_ctx", default=None
+)
+
+
+def use_implicit_headers() -> ImplicitHeaders | None:
+    return implicit_headers_ctx.get()
+
+
+@contextmanager
+def provide_implicit_headers(
+    implicit_headers: ImplicitHeaders,
+) -> Generator[None, Any, None]:
+    token = implicit_headers_ctx.set(implicit_headers)
+    try:
+        yield
+    finally:
+        implicit_headers_ctx.reset(token)

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py

@@ -9,6 +9,7 @@ from aio_pika.abc import AbstractConnection
 from pydantic import BaseModel
 
 from jararaca.broker_backend import MessageBrokerBackend
+from jararaca.messagebus import implicit_headers
 from jararaca.messagebus.interceptors.publisher_interceptor import (
     MessageBusConnectionFactory,
 )
@@ -42,8 +43,12 @@ class AIOPikaMessagePublisher(MessagePublisher):
             logging.warning(f"Exchange {self.exchange_name} not found")
             return
         routing_key = f"{topic}."
+
+        implicit_headers_data = implicit_headers.use_implicit_headers()
         await exchange.publish(
-            aio_pika.Message(body=message.model_dump_json().encode()),
+            aio_pika.Message(
+                body=message.model_dump_json().encode(), headers=implicit_headers_data
+            ),
             routing_key=routing_key,
         )
 

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/messagebus/worker.py

@@ -50,6 +50,7 @@ from jararaca.messagebus.decorators import (
     MessageHandlerData,
     ScheduleDispatchData,
 )
+from jararaca.messagebus.implicit_headers import provide_implicit_headers
 from jararaca.messagebus.message import Message, MessageOf
 from jararaca.microservice import (
     AppTransactionContext,
@@ -1130,6 +1131,8 @@ class ScheduledMessageHandlerCallback:
                 AppTransactionContext(
                     controller_member_reflect=scheduled_action.controller_member,
                     transaction_data=SchedulerTransactionData(
+                        task_name=scheduled_action.spec.name
+                        or scheduled_action.callable.__qualname__,
                         scheduled_to=datetime.now(UTC),
                         cron_expression=scheduled_action.spec.cron,
                         triggered_at=datetime.now(UTC),
@@ -1469,7 +1472,9 @@ class MessageHandlerCallback:
         incoming_message_spec = MessageHandler.get_message_incoming(handler)
         assert incoming_message_spec is not None
 
-        with provide_shutdown_state(self.consumer.shutdown_state):
+        with provide_implicit_headers(aio_pika_message.headers), provide_shutdown_state(
+            self.consumer.shutdown_state
+        ):
             async with self.consumer.uow_context_provider(
                 AppTransactionContext(
                     controller_member_reflect=handler_data.controller_member,

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/microservice.py

@@ -19,7 +19,7 @@ from typing import (
     runtime_checkable,
 )
 
-from fastapi import Request, WebSocket
+from fastapi import Request, Response, WebSocket
 
 from jararaca.core.providers import ProviderSpec, T, Token
 from jararaca.messagebus import MessageOf
@@ -34,6 +34,7 @@ if TYPE_CHECKING:
 
 @dataclass
 class SchedulerTransactionData:
+    task_name: str
     triggered_at: datetime
     scheduled_to: datetime
     cron_expression: str
@@ -43,6 +44,7 @@ class SchedulerTransactionData:
 @dataclass
 class HttpTransactionData:
     request: Request
+    response: Response
     context_type: Literal["http"] = "http"
 
 

jararaca-0.3.19/src/jararaca/observability/decorators.py

@@ -0,0 +1,213 @@
+import inspect
+from contextlib import contextmanager, suppress
+from contextvars import ContextVar
+from functools import wraps
+from typing import (
+    Any,
+    AsyncContextManager,
+    Awaitable,
+    Callable,
+    ContextManager,
+    Generator,
+    Mapping,
+    Protocol,
+    Sequence,
+    TypeVar,
+    Union,
+)
+
+from jararaca.microservice import AppTransactionContext
+
+F = TypeVar("F", bound=Callable[..., Awaitable[Any]])
+
+AttributeValue = Union[
+    str,
+    bool,
+    int,
+    float,
+    Sequence[str],
+    Sequence[bool],
+    Sequence[int],
+    Sequence[float],
+]
+
+AttributeMap = Mapping[str, AttributeValue]
+
+
+class TracingContextProvider(Protocol):
+
+    def __call__(
+        self, trace_name: str, context_attributes: AttributeMap | None
+    ) -> ContextManager[Any]: ...
+
+
+class TracingContextProviderFactory(Protocol):
+
+    def root_setup(
+        self, app_context: AppTransactionContext
+    ) -> AsyncContextManager[None]: ...
+
+    def provide_provider(
+        self, app_context: AppTransactionContext
+    ) -> TracingContextProvider: ...
+
+
+tracing_ctx_provider_ctxv = ContextVar[TracingContextProvider]("tracing_ctx_provider")
+
+
+@contextmanager
+def provide_tracing_ctx_provider(
+    ctx_provider: TracingContextProvider,
+) -> Generator[None, None, None]:
+
+    token = tracing_ctx_provider_ctxv.set(ctx_provider)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            tracing_ctx_provider_ctxv.reset(token)
+
+
+def get_tracing_ctx_provider() -> TracingContextProvider | None:
+    return tracing_ctx_provider_ctxv.get(None)
+
+
+def default_trace_mapper(*args: Any, **kwargs: Any) -> dict[str, str]:
+    return {
+        "args": str(args),
+        "kwargs": str(kwargs),
+    }
+
+
+class TracedFunc:
+
+    def __init__(
+        self,
+        trace_name: str,
+        trace_mapper: Callable[..., dict[str, str]] = default_trace_mapper,
+    ):
+        self.trace_name = trace_name
+        self.trace_mapper = trace_mapper
+
+    def __call__(
+        self,
+        decorated: F,
+    ) -> F:
+
+        @wraps(decorated)
+        async def wrapper(
+            *args: Any,
+            **kwargs: Any,
+        ) -> Any:
+
+            if ctx_provider := get_tracing_ctx_provider():
+                with ctx_provider(
+                    self.trace_name,
+                    self.trace_mapper(*args, **kwargs),
+                ):
+                    return await decorated(*args, **kwargs)
+
+            return await decorated(*args, **kwargs)
+
+        return wrapper  # type: ignore[return-value]
+
+
+C = TypeVar("C", bound=type)
+
+
+class TracedClass:
+    """
+    Class decorator that automatically applies tracing to all async methods in a class.
+
+    Usage:
+        @TracedClass()
+        class MyService:
+            async def method1(self) -> str:
+                return "hello"
+
+            async def method2(self, x: int) -> int:
+                return x * 2
+
+            def sync_method(self) -> str:  # Not traced
+                return "sync"
+    """
+
+    def __init__(
+        self,
+        trace_name_prefix: str | None = None,
+        trace_mapper: Callable[..., dict[str, str]] = default_trace_mapper,
+        include_private: bool = False,
+        exclude_methods: set[str] | None = None,
+    ):
+        """
+        Initialize the TracedClass decorator.
+
+        Args:
+            trace_name_prefix: Prefix for trace names. If None, uses class name.
+            trace_mapper: Function to map method arguments to trace attributes.
+            include_private: Whether to trace private methods (starting with _).
+            exclude_methods: Set of method names to exclude from tracing.
+        """
+        self.trace_name_prefix = trace_name_prefix
+        self.trace_mapper = trace_mapper
+        self.include_private = include_private
+        self.exclude_methods = exclude_methods or set()
+
+    def __call__(self, cls: C) -> C:
+        """Apply tracing to all async methods in the class."""
+
+        # Use class name as prefix if not provided
+        trace_prefix = self.trace_name_prefix or cls.__name__
+
+        # Get all methods in the class
+        for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+            # Skip if method should be excluded
+            if name in self.exclude_methods:
+                continue
+
+            # Skip private methods unless explicitly included
+            if name.startswith("_") and not self.include_private:
+                continue
+
+            # Only trace async methods
+            if inspect.iscoroutinefunction(method):
+                trace_name = f"{trace_prefix}.{name}"
+                traced_method = TracedFunc(trace_name, self.trace_mapper)(method)
+                setattr(cls, name, traced_method)
+
+        return cls
+
+
+def traced_class(
+    trace_name_prefix: str | None = None,
+    trace_mapper: Callable[..., dict[str, str]] = default_trace_mapper,
+    include_private: bool = False,
+    exclude_methods: set[str] | None = None,
+) -> Callable[[C], C]:
+    """
+    Functional interface for TracedClass decorator.
+
+    Usage:
+        @traced_class(trace_name_prefix="MyService")
+        class MyService:
+            async def method1(self) -> str:
+                return "hello"
+    """
+    return TracedClass(
+        trace_name_prefix=trace_name_prefix,
+        trace_mapper=trace_mapper,
+        include_private=include_private,
+        exclude_methods=exclude_methods,
+    )
+
+
+__all__ = [
+    "TracingContextProvider",
+    "TracingContextProviderFactory",
+    "provide_tracing_ctx_provider",
+    "get_tracing_ctx_provider",
+    "default_trace_mapper",
+    "TracedFunc",
+    "TracedClass",
+    "traced_class",
+]

jararaca-0.3.19/src/jararaca/observability/hooks.py

@@ -0,0 +1,20 @@
+from contextlib import contextmanager
+from typing import Any, Generator
+
+from jararaca.observability.decorators import AttributeMap, get_tracing_ctx_provider
+
+
+@contextmanager
+def spawn_trace(
+    name: str,
+    attributes: AttributeMap | None = None,
+) -> Generator[None, Any, None]:
+
+    if trace_context_provider := get_tracing_ctx_provider():
+        with trace_context_provider(trace_name=name, context_attributes=attributes):
+            yield
+    else:
+        yield
+
+
+spawn_trace

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/observability/providers/otel.py

@@ -1,6 +1,6 @@
 import logging
 from contextlib import asynccontextmanager, contextmanager
-from typing import AsyncGenerator, Generator, Protocol
+from typing import Any, AsyncGenerator, Generator, Protocol
 
 from opentelemetry import metrics, trace
 from opentelemetry._logs import set_logger_provider
@@ -23,11 +23,21 @@ from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
-from jararaca.microservice import AppTransactionContext, Container, Microservice
+from jararaca.messagebus.implicit_headers import (
+    ImplicitHeaders,
+    provide_implicit_headers,
+    use_implicit_headers,
+)
+from jararaca.microservice import (
+    AppTransactionContext,
+    Container,
+    Microservice,
+    use_app_transaction_context,
+)
 from jararaca.observability.decorators import (
+    AttributeMap,
     TracingContextProvider,
     TracingContextProviderFactory,
-    get_tracing_ctx_provider,
 )
 from jararaca.observability.interceptor import ObservabilityProvider
 
@@ -43,7 +53,7 @@ class OtelTracingContextProvider(TracingContextProvider):
     def __call__(
         self,
         trace_name: str,
-        context_attributes: dict[str, str],
+        context_attributes: AttributeMap | None,
     ) -> Generator[None, None, None]:
 
         with tracer.start_as_current_span(trace_name, attributes=context_attributes):
@@ -63,7 +73,7 @@ class OtelTracingContextProviderFactory(TracingContextProviderFactory):
     ) -> AsyncGenerator[None, None]:
 
         title: str = "Unmapped App Context Execution"
-        headers = {}
+        headers: dict[str, Any] = {}
         tx_data = app_tx_ctx.transaction_data
         if tx_data.context_type == "http":
 
@@ -72,6 +82,19 @@ class OtelTracingContextProviderFactory(TracingContextProviderFactory):
 
         elif tx_data.context_type == "message_bus":
             title = f"Message Bus {tx_data.topic}"
+            headers = use_implicit_headers() or {}
+
+        elif tx_data.context_type == "websocket":
+            headers = dict(tx_data.websocket.headers)
+            title = f"WebSocket {tx_data.websocket.url}"
+
+        elif tx_data.context_type == "scheduler":
+            title = f"Scheduler Task {tx_data.task_name}"
+            headers = {
+                "scheduled_to": tx_data.scheduled_to.isoformat(),
+                "cron_expression": tx_data.cron_expression,
+                "triggered_at": tx_data.triggered_at.isoformat(),
+            }
 
         carrier = {
             key: value
@@ -90,8 +113,23 @@ class OtelTracingContextProviderFactory(TracingContextProviderFactory):
 
         ctx2 = W3CBaggagePropagator().extract(b2, context=ctx)
 
-        with tracer.start_as_current_span(name=title, context=ctx2):
-            yield
+        with tracer.start_as_current_span(
+            name=title,
+            context=ctx2,
+            attributes={
+                "app.context_type": tx_data.context_type,
+            },
+        ) as root_span:
+            cx = root_span.get_span_context()
+            if app_tx_ctx.transaction_data.context_type == "http":
+                app_tx_ctx.transaction_data.response.headers["traceparent"] = hex(
+                    cx.trace_id
+                )[2:].rjust(32, "0")
+            tracing_headers: ImplicitHeaders = {}
+            TraceContextTextMapPropagator().inject(tracing_headers)
+            W3CBaggagePropagator().inject(tracing_headers)
+            with provide_implicit_headers(tracing_headers):
+                yield
 
 
 class LoggerHandlerCallback(Protocol):
@@ -99,6 +137,21 @@ class LoggerHandlerCallback(Protocol):
     def __call__(self, logger_handler: logging.Handler) -> None: ...
 
 
+class CustomLoggingHandler(LoggingHandler):
+
+    def _translate(self, record: logging.LogRecord) -> dict[str, Any]:
+        try:
+            ctx = use_app_transaction_context()
+            return {
+                **super()._translate(record),
+                "attributes": {
+                    "context_type": ctx.transaction_data.context_type,
+                },
+            }
+        except LookupError:
+            return super()._translate(record)
+
+
 class OtelObservabilityProvider(ObservabilityProvider):
 
     def __init__(
@@ -143,11 +196,11 @@ class OtelObservabilityProvider(ObservabilityProvider):
             BatchLogRecordProcessor(self.logs_exporter)
         )
 
-        logging_handler = LoggingHandler(
+        logging_handler = CustomLoggingHandler(
             level=logging.DEBUG, logger_provider=logger_provider
         )
 
-        logging_handler.addFilter(lambda _: get_tracing_ctx_provider() is not None)
+        # logging_handler.addFilter(lambda _: get_tracing_ctx_provider() is not None)
 
         self.logging_handler_callback(logging_handler)
 

{jararaca-0.3.18 → jararaca-0.3.19}/src/jararaca/presentation/server.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import signal
 import threading
@@ -5,7 +6,7 @@ from contextlib import asynccontextmanager
 from signal import SIGINT, SIGTERM
 from typing import Any, AsyncGenerator
 
-from fastapi import Depends, FastAPI, Request, WebSocket
+from fastapi import Depends, FastAPI, HTTPException, Request, Response, WebSocket
 from starlette.types import ASGIApp
 
 from jararaca.core.uow import UnitOfWorkContextProvider
@@ -23,6 +24,8 @@ from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
 from jararaca.reflect.controller_inspect import ControllerMemberReflect
 
+logger = logging.getLogger(__name__)
+
 
 class HttpAppLifecycle:
 
@@ -109,7 +112,7 @@ class HttpUowContextProviderDependency:
         self.shutdown_state.setup_signal_handlers()
 
     async def __call__(
-        self, websocket: WebSocket = None, request: Request = None  # type: ignore
+        self, websocket: WebSocket = None, request: Request = None, response: Response = None  # type: ignore
     ) -> AsyncGenerator[None, None]:
         if request:
             endpoint = request.scope["endpoint"]
@@ -133,13 +136,34 @@ class HttpUowContextProviderDependency:
                 AppTransactionContext(
                     controller_member_reflect=member,
                     transaction_data=(
-                        HttpTransactionData(request=request)
+                        HttpTransactionData(request=request, response=response)
                         if request
                         else WebSocketTransactionData(websocket=websocket)
                     ),
                 )
             ):
-                yield
+                try:
+                    yield
+                except HTTPException:
+                    raise
+                except Exception as e:
+                    logger.exception("Unhandled exception in request handling.")
+                    raise HTTPException(
+                        status_code=500,
+                        detail={
+                            "message": "Internal server error occurred.",
+                            "x-traceparentid": (
+                                response.headers.get("traceparent")
+                                if response
+                                else None
+                            ),
+                        },
+                        headers=(
+                            {k: str(v) for k, v in response.headers.items()}
+                            if response
+                            else {}
+                        ),
+                    ) from e
 
 
 def create_http_server(

jararaca-0.3.18/src/jararaca/observability/decorators.py

@@ -1,97 +0,0 @@
-from contextlib import contextmanager, suppress
-from contextvars import ContextVar
-from functools import wraps
-from typing import (
-    Any,
-    AsyncContextManager,
-    Awaitable,
-    Callable,
-    ContextManager,
-    Generator,
-    ParamSpec,
-    Protocol,
-    TypeVar,
-)
-
-from jararaca.microservice import AppTransactionContext
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-class TracingContextProvider(Protocol):
-
-    def __call__(
-        self, trace_name: str, context_attributes: dict[str, str]
-    ) -> ContextManager[Any]: ...
-
-
-class TracingContextProviderFactory(Protocol):
-
-    def root_setup(
-        self, app_context: AppTransactionContext
-    ) -> AsyncContextManager[None]: ...
-
-    def provide_provider(
-        self, app_context: AppTransactionContext
-    ) -> TracingContextProvider: ...
-
-
-tracing_ctx_provider_ctxv = ContextVar[TracingContextProvider]("tracing_ctx_provider")
-
-
-@contextmanager
-def provide_tracing_ctx_provider(
-    ctx_provider: TracingContextProvider,
-) -> Generator[None, None, None]:
-
-    token = tracing_ctx_provider_ctxv.set(ctx_provider)
-    try:
-        yield
-    finally:
-        with suppress(ValueError):
-            tracing_ctx_provider_ctxv.reset(token)
-
-
-def get_tracing_ctx_provider() -> TracingContextProvider | None:
-    return tracing_ctx_provider_ctxv.get(None)
-
-
-def default_trace_mapper(*args: Any, **kwargs: Any) -> dict[str, str]:
-    return {
-        "args": str(args),
-        "kwargs": str(kwargs),
-    }
-
-
-class TracedFunc:
-
-    def __init__(
-        self,
-        trace_name: str,
-        trace_mapper: Callable[..., dict[str, str]] = default_trace_mapper,
-    ):
-        self.trace_name = trace_name
-        self.trace_mapper = trace_mapper
-
-    def __call__(
-        self,
-        decorated: Callable[P, Awaitable[R]],
-    ) -> Callable[P, Awaitable[R]]:
-
-        @wraps(decorated)
-        async def wrapper(
-            *args: P.args,
-            **kwargs: P.kwargs,
-        ) -> R:
-
-            if ctx_provider := get_tracing_ctx_provider():
-                with ctx_provider(
-                    self.trace_name,
-                    self.trace_mapper(**kwargs),
-                ):
-                    return await decorated(*args, **kwargs)
-
-            return await decorated(*args, **kwargs)
-
-        return wrapper