jararaca 0.3.11a4__py3-none-any.whl → 0.3.11a5__py3-none-any.whl

jararaca/__init__.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
         retry_later,
         use_bus_message_controller,
     )
-    from jararaca.microservice import AppContext, AppInterceptor
+    from jararaca.microservice import AppInterceptor, AppTransactionContext
     from jararaca.observability.interceptor import ObservabilityInterceptor
     from jararaca.observability.providers.otel import OtelObservabilityProvider
     from jararaca.persistence.sort_filter import (
@@ -32,6 +32,17 @@ if TYPE_CHECKING:
         raises_500_on,
         raises_http_exception_on,
     )
+    from jararaca.reflect.controller_inspect import (
+        ControllerMemberReflect,
+        ControllerReflect,
+    )
+    from jararaca.reflect.metadata import (
+        SetMetadata,
+        get_all_metadata,
+        get_metadata,
+        get_metadata_value,
+        provide_metadata,
+    )
     from jararaca.rpc.http.backends.httpx import HTTPXHttpRPCAsyncBackend
     from jararaca.rpc.http.backends.otel import TracedRequestMiddleware
     from jararaca.rpc.http.decorators import Body
@@ -68,7 +79,13 @@ if TYPE_CHECKING:
     from .messagebus.message import Message, MessageOf
     from .messagebus.publisher import use_publisher
     from .messagebus.worker import MessageBusWorker
-    from .microservice import Microservice, use_app_context, use_current_container
+    from .microservice import (
+        Microservice,
+        use_app_context,
+        use_app_transaction_context,
+        use_app_tx_ctx_data,
+        use_current_container,
+    )
     from .persistence.base import T_BASEMODEL, BaseEntity
     from .persistence.interceptors.aiosqa_interceptor import (
         AIOSQAConfig,
@@ -122,6 +139,11 @@ if TYPE_CHECKING:
     from .tools.app_config.interceptor import AppConfigurationInterceptor
 
     __all__ = [
+        "SetMetadata",
+        "provide_metadata",
+        "get_metadata",
+        "get_all_metadata",
+        "get_metadata_value",
         "RedisMessageBrokerBackend",
         "FilterRuleApplier",
         "SortRuleApplier",
@@ -197,6 +219,7 @@ if TYPE_CHECKING:
         "use_session",
         "use_transaction",
         "providing_session",
+        "provide_session",
         "providing_transaction",
         "providing_new_session",
         "Post",
@@ -220,7 +243,12 @@ if TYPE_CHECKING:
         "HttpRpcClientBuilder",
         "HTTPXHttpRPCAsyncBackend",
         "use_app_context",
+        "use_app_transaction_context",
+        "use_app_tx_ctx_data",
+        "AppTransactionContext",
         "AppContext",
+        "ControllerMemberReflect",
+        "ControllerReflect",
         "AppInterceptor",
         "OtelObservabilityProvider",
     ]
@@ -228,6 +256,11 @@ if TYPE_CHECKING:
 __SPEC_PARENT__: str = __spec__.parent  # type: ignore
 # A mapping of {<member name>: (package, <module name>)} defining dynamic imports
 _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
+    "SetMetadata": (__SPEC_PARENT__, "reflect.metadata", None),
+    "provide_metadata": (__SPEC_PARENT__, "reflect.metadata", None),
+    "get_metadata": (__SPEC_PARENT__, "reflect.metadata", None),
+    "get_all_metadata": (__SPEC_PARENT__, "reflect.metadata", None),
+    "get_metadata_value": (__SPEC_PARENT__, "reflect.metadata", None),
     "RedisMessageBrokerBackend": (
         __SPEC_PARENT__,
         "broker_backend.redis_broker_backend",
@@ -353,6 +386,11 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "persistence.interceptors.aiosqa_interceptor",
         None,
     ),
+    "provide_session": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
     "providing_new_session": (
         __SPEC_PARENT__,
         "persistence.interceptors.aiosqa_interceptor",
@@ -403,8 +441,13 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "HttpRpcClientBuilder": (__SPEC_PARENT__, "rpc.http.decorators", None),
     "HTTPXHttpRPCAsyncBackend": (__SPEC_PARENT__, "rpc.http.backends.httpx", None),
     "use_app_context": (__SPEC_PARENT__, "microservice", None),
+    "use_app_transaction_context": (__SPEC_PARENT__, "microservice", None),
+    "use_app_tx_ctx_data": (__SPEC_PARENT__, "microservice", None),
     "AppContext": (__SPEC_PARENT__, "microservice", None),
     "AppInterceptor": (__SPEC_PARENT__, "microservice", None),
+    "AppTransactionContext": (__SPEC_PARENT__, "microservice", None),
+    "ControllerMemberReflect": (__SPEC_PARENT__, "reflect.controller_inspect", None),
+    "ControllerReflect": (__SPEC_PARENT__, "reflect.controller_inspect", None),
 }
 
 

jararaca/cli.py

@@ -112,7 +112,7 @@ async def declare_worker_infrastructure(
         handlers, _ = factory(instance)
 
         for handler in handlers:
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.callable.__module__}.{handler.callable.__qualname__}"
+            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
             routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
 
             queue = await channel.declare_queue(
@@ -192,7 +192,7 @@ async def declare_worker_v2_infrastructure(
 
         # Declare queues for message handlers
         for handler in handlers:
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.callable.__module__}.{handler.callable.__qualname__}"
+            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
             routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
 
             queue = await RabbitmqUtils.declare_queue(

jararaca/core/uow.py

@@ -2,13 +2,14 @@ from contextlib import asynccontextmanager
 from typing import AsyncGenerator, Sequence
 
 from jararaca.microservice import (
-    AppContext,
     AppInterceptor,
+    AppTransactionContext,
     Container,
     Microservice,
     provide_app_context,
     provide_container,
 )
+from jararaca.reflect.metadata import provide_metadata
 
 
 class ContainerInterceptor(AppInterceptor):
@@ -17,7 +18,9 @@ class ContainerInterceptor(AppInterceptor):
         self.container = container
 
     @asynccontextmanager
-    async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
+    async def intercept(
+        self, app_context: AppTransactionContext
+    ) -> AsyncGenerator[None, None]:
 
         with provide_app_context(app_context), provide_container(self.container):
             yield None
@@ -49,18 +52,20 @@ class UnitOfWorkContextProvider:
         return interceptors
 
     @asynccontextmanager
-    async def __call__(self, app_context: AppContext) -> AsyncGenerator[None, None]:
+    async def __call__(
+        self, app_context: AppTransactionContext
+    ) -> AsyncGenerator[None, None]:
 
         app_interceptors = self.factory_app_interceptors()
+        with provide_metadata(app_context.controller_member_reflect.metadata):
+            ctxs = [self.container_interceptor.intercept(app_context)] + [
+                interceptor.intercept(app_context) for interceptor in app_interceptors
+            ]
 
-        ctxs = [self.container_interceptor.intercept(app_context)] + [
-            interceptor.intercept(app_context) for interceptor in app_interceptors
-        ]
+            for ctx in ctxs:
+                await ctx.__aenter__()
 
-        for ctx in ctxs:
-            await ctx.__aenter__()
-
-        yield None
+            yield None
 
-        for ctx in reversed(ctxs):
-            await ctx.__aexit__(None, None, None)
+            for ctx in reversed(ctxs):
+                await ctx.__aexit__(None, None, None)

jararaca/messagebus/decorators.py

@@ -3,10 +3,14 @@ from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Generic, TypeVar, cast
 
 from jararaca.messagebus.message import INHERITS_MESSAGE_CO, Message, MessageOf
-from jararaca.scheduler.decorators import ScheduledAction
+from jararaca.reflect.controller_inspect import (
+    ControllerMemberReflect,
+    inspect_controller,
+)
+from jararaca.scheduler.decorators import ScheduledAction, ScheduledActionData
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
-DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
+DECORATED_T = TypeVar("DECORATED_T", bound=Any)
 
 
 class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
@@ -60,7 +64,8 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
 class MessageHandlerData:
     message_type: type[Any]
     spec: MessageHandler[Message]
-    callable: Callable[[MessageOf[Any]], Awaitable[None]]
+    instance_callable: Callable[[MessageOf[Any]], Awaitable[None]]
+    controller_member: ControllerMemberReflect
 
 
 @dataclass(frozen=True)
@@ -68,16 +73,9 @@ class ScheduleDispatchData:
     timestamp: float
 
 
-@dataclass(frozen=True)
-class ScheduledActionData:
-    spec: ScheduledAction
-    callable: Callable[
-        ..., Awaitable[None]
-    ]  # Callable[[ScheduleDispatchData], Awaitable[None]]
-
+SCHEDULED_ACTION_DATA_SET = set[ScheduledActionData]
 
 MESSAGE_HANDLER_DATA_SET = set[MessageHandlerData]
-SCHEDULED_ACTION_DATA_SET = set[ScheduledActionData]
 
 
 class MessageBusController:
@@ -93,55 +91,60 @@ class MessageBusController:
     def get_messagebus_factory(
         self,
     ) -> Callable[
-        [DECORATED_CLASS], tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]
+        [DECORATED_T], tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]
     ]:
         if self.messagebus_factory is None:
             raise Exception("MessageBus factory is not set")
         return self.messagebus_factory
 
-    def __call__(self, func: type[DECORATED_CLASS]) -> type[DECORATED_CLASS]:
+    def __call__(self, cls_t: type[DECORATED_T]) -> type[DECORATED_T]:
 
         def messagebus_factory(
-            instance: DECORATED_CLASS,
+            instance: DECORATED_T,
         ) -> tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]:
             handlers: MESSAGE_HANDLER_DATA_SET = set()
 
             schedulers: SCHEDULED_ACTION_DATA_SET = set()
 
-            members = inspect.getmembers(func, predicate=inspect.isfunction)
+            controller, members = inspect_controller(cls_t)
 
-            for name, member in members:
-                message_handler_decoration = MessageHandler.get_message_incoming(member)
+            for name, member in members.items():
+                message_handler_decoration = MessageHandler.get_message_incoming(
+                    member.member_function
+                )
                 scheduled_action_decoration = ScheduledAction.get_scheduled_action(
-                    member
+                    member.member_function
                 )
 
                 if message_handler_decoration is not None:
 
-                    if not inspect.iscoroutinefunction(member):
+                    if not inspect.iscoroutinefunction(member.member_function):
                         raise Exception(
                             "Message incoming handler '%s' from '%s.%s' must be a coroutine function"
-                            % (name, func.__module__, func.__qualname__)
+                            % (name, cls_t.__module__, cls_t.__qualname__)
                         )
 
                     handlers.add(
                         MessageHandlerData(
                             message_type=message_handler_decoration.message_type,
                             spec=message_handler_decoration,
-                            callable=getattr(instance, name),
+                            instance_callable=getattr(instance, name),
+                            controller_member=member,
                         )
                     )
                 elif scheduled_action_decoration is not None:
-                    if not inspect.iscoroutinefunction(member):
+                    if not inspect.iscoroutinefunction(member.member_function):
                         raise Exception(
                             "Scheduled action handler '%s' from '%s.%s' must be a coroutine function"
-                            % (name, func.__module__, func.__qualname__)
+                            % (name, cls_t.__module__, cls_t.__qualname__)
                         )
+                    instance_callable = getattr(instance, name)
 
                     schedulers.add(
                         ScheduledActionData(
+                            controller_member=member,
                             spec=scheduled_action_decoration,
-                            callable=getattr(instance, name),
+                            callable=instance_callable,
                         )
                     )
 
@@ -149,19 +152,17 @@ class MessageBusController:
 
         self.messagebus_factory = messagebus_factory
 
-        MessageBusController.register(func, self)
+        MessageBusController.register(cls_t, self)
 
-        return func
+        return cls_t
 
     @staticmethod
-    def register(
-        func: type[DECORATED_CLASS], messagebus: "MessageBusController"
-    ) -> None:
+    def register(func: type[DECORATED_T], messagebus: "MessageBusController") -> None:
 
         setattr(func, MessageBusController.MESSAGEBUS_ATTR, messagebus)
 
     @staticmethod
-    def get_messagebus(func: type[DECORATED_CLASS]) -> "MessageBusController | None":
+    def get_messagebus(func: type[DECORATED_T]) -> "MessageBusController | None":
         if not hasattr(func, MessageBusController.MESSAGEBUS_ATTR):
             return None
 

jararaca/messagebus/interceptors/publisher_interceptor.py

@@ -3,7 +3,7 @@ from typing import AsyncContextManager, AsyncGenerator, Protocol
 
 from jararaca.broker_backend import MessageBrokerBackend
 from jararaca.messagebus.publisher import MessagePublisher, provide_message_publisher
-from jararaca.microservice import AppContext, AppInterceptor
+from jararaca.microservice import AppInterceptor, AppTransactionContext
 
 
 class MessageBusConnectionFactory(Protocol):
@@ -24,8 +24,10 @@ class MessageBusPublisherInterceptor(AppInterceptor):
         self.message_scheduler = message_scheduler
 
     @asynccontextmanager
-    async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
-        if app_context.context_type == "websocket":
+    async def intercept(
+        self, app_context: AppTransactionContext
+    ) -> AsyncGenerator[None, None]:
+        if app_context.transaction_data.context_type == "websocket":
             yield
             return
 

jararaca/messagebus/worker.py

@@ -25,7 +25,11 @@ from jararaca.messagebus.decorators import (
     MessageHandlerData,
 )
 from jararaca.messagebus.message import Message, MessageOf
-from jararaca.microservice import MessageBusAppContext, Microservice
+from jararaca.microservice import (
+    AppTransactionContext,
+    MessageBusTransactionData,
+    Microservice,
+)
 from jararaca.utils.rabbitmq_utils import RabbitmqUtils
 
 logger = logging.getLogger(__name__)
@@ -109,7 +113,7 @@ class AioPikaMicroserviceConsumer:
 
         for handler in self.message_handler_set:
 
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.callable.__module__}.{handler.callable.__qualname__}"
+            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
             routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
 
             self.incoming_map[queue_name] = handler
@@ -219,7 +223,7 @@ class MessageHandlerCallback:
 
             return
 
-        handler = handler_data.callable
+        handler = handler_data.instance_callable
 
         sig = inspect.signature(handler)
 
@@ -263,9 +267,12 @@ class MessageHandlerCallback:
         assert incoming_message_spec is not None
 
         async with self.consumer.uow_context_provider(
-            MessageBusAppContext(
-                message=builded_message,
-                topic=routing_key,
+            AppTransactionContext(
+                controller_member_reflect=handler_data.controller_member,
+                transaction_data=MessageBusTransactionData(
+                    message=builded_message,
+                    topic=routing_key,
+                ),
             )
         ):
             ctx: AsyncContextManager[Any]

jararaca/messagebus/worker_v2.py

@@ -6,15 +6,7 @@ from abc import ABC
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from typing import (
-    Any,
-    AsyncContextManager,
-    AsyncGenerator,
-    Awaitable,
-    Callable,
-    Type,
-    get_origin,
-)
+from typing import Any, AsyncContextManager, AsyncGenerator, Type, get_origin
 from urllib.parse import parse_qs, urlparse
 
 import aio_pika
@@ -37,15 +29,16 @@ from jararaca.messagebus.decorators import (
     MessageBusController,
     MessageHandler,
     MessageHandlerData,
-    ScheduledActionData,
     ScheduleDispatchData,
 )
 from jararaca.messagebus.message import Message, MessageOf
 from jararaca.microservice import (
-    MessageBusAppContext,
+    AppTransactionContext,
+    MessageBusTransactionData,
     Microservice,
-    SchedulerAppContext,
+    SchedulerTransactionData,
 )
+from jararaca.scheduler.decorators import ScheduledActionData
 from jararaca.utils.rabbitmq_utils import RabbitmqUtils
 
 logger = logging.getLogger(__name__)
@@ -152,7 +145,7 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
         for handler in self.message_handler_set:
 
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.callable.__module__}.{handler.callable.__qualname__}"
+            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
             routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
 
             self.incoming_map[queue_name] = handler
@@ -311,7 +304,6 @@ class ScheduledMessageHandlerCallback:
 
             task = asyncio.create_task(
                 self.run_with_context(
-                    self.scheduled_action.callable,
                     self.scheduled_action,
                     (ScheduleDispatchData(int(aio_pika_message.body.decode("utf-8"))),),
                     {},
@@ -321,7 +313,6 @@ class ScheduledMessageHandlerCallback:
         elif len(sig.parameters) == 0:
             task = asyncio.create_task(
                 self.run_with_context(
-                    self.scheduled_action.callable,
                     self.scheduled_action,
                     (),
                     {},
@@ -347,21 +338,22 @@ class ScheduledMessageHandlerCallback:
 
     async def run_with_context(
         self,
-        func: Callable[..., Awaitable[None]],
         scheduled_action: ScheduledActionData,
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> None:
         async with self.consumer.uow_context_provider(
-            SchedulerAppContext(
-                action=func,
-                scheduled_to=datetime.now(UTC),
-                cron_expression=scheduled_action.spec.cron,
-                triggered_at=datetime.now(UTC),
+            AppTransactionContext(
+                controller_member_reflect=scheduled_action.controller_member,
+                transaction_data=SchedulerTransactionData(
+                    scheduled_to=datetime.now(UTC),
+                    cron_expression=scheduled_action.spec.cron,
+                    triggered_at=datetime.now(UTC),
+                ),
             )
         ):
 
-            await func(*args, **kwargs)
+            await scheduled_action.callable(*args, **kwargs)
 
 
 class MessageHandlerCallback:
@@ -427,7 +419,7 @@ class MessageHandlerCallback:
 
         handler_data = self.message_handler
 
-        handler = handler_data.callable
+        handler = handler_data.instance_callable
 
         sig = inspect.signature(handler)
 
@@ -471,9 +463,12 @@ class MessageHandlerCallback:
         assert incoming_message_spec is not None
 
         async with self.consumer.uow_context_provider(
-            MessageBusAppContext(
-                message=builded_message,
-                topic=routing_key,
+            AppTransactionContext(
+                controller_member_reflect=handler_data.controller_member,
+                transaction_data=MessageBusTransactionData(
+                    message=builded_message,
+                    topic=routing_key,
+                ),
             )
         ):
             ctx: AsyncContextManager[Any]

jararaca/microservice.py

@@ -23,64 +23,103 @@ from fastapi import Request, WebSocket
 from jararaca.core.providers import ProviderSpec, T, Token
 from jararaca.messagebus import MessageOf
 from jararaca.messagebus.message import Message
+from jararaca.reflect.controller_inspect import ControllerMemberReflect
 
 if TYPE_CHECKING:
     from typing_extensions import TypeIs
 
 
 @dataclass
-class SchedulerAppContext:
+class SchedulerTransactionData:
     triggered_at: datetime
     scheduled_to: datetime
     cron_expression: str
-    action: Callable[..., Any]
     context_type: Literal["scheduler"] = "scheduler"
 
 
 @dataclass
-class HttpAppContext:
+class HttpTransactionData:
     request: Request
     context_type: Literal["http"] = "http"
 
 
 @dataclass
-class MessageBusAppContext:
+class MessageBusTransactionData:
     topic: str
     message: MessageOf[Message]
     context_type: Literal["message_bus"] = "message_bus"
 
 
 @dataclass
-class WebSocketAppContext:
+class WebSocketTransactionData:
     websocket: WebSocket
     context_type: Literal["websocket"] = "websocket"
 
 
-AppContext = (
-    MessageBusAppContext | HttpAppContext | SchedulerAppContext | WebSocketAppContext
+TransactionData = (
+    MessageBusTransactionData
+    | HttpTransactionData
+    | SchedulerTransactionData
+    | WebSocketTransactionData
 )
 
-app_context_ctxvar = ContextVar[AppContext]("app_context")
 
+@dataclass
+class AppTransactionContext:
+    transaction_data: TransactionData
+    controller_member_reflect: ControllerMemberReflect
+
+
+AppContext = AppTransactionContext
+"""
+Alias for AppTransactionContext, used for compatibility with existing code.
+"""
+
+
+app_transaction_context_var = ContextVar[AppTransactionContext]("app_context")
+
+
+def use_app_transaction_context() -> AppTransactionContext:
+    """
+    Returns the current application transaction context.
+    This function is used to access the application transaction context in the context of an application transaction.
+    If no context is set, it raises a LookupError.
+    """
+
+    return app_transaction_context_var.get()
 
-def use_app_context() -> AppContext:
-    return app_context_ctxvar.get()
+
+def use_app_tx_ctx_data() -> TransactionData:
+    """
+    Returns the transaction data from the current app transaction context.
+    This function is used to access the transaction data in the context of an application transaction.
+    """
+
+    return use_app_transaction_context().transaction_data
+
+
+use_app_context = use_app_tx_ctx_data
+"""Alias for use_app_tx_ctx_data, used for compatibility with existing code."""
 
 
 @contextmanager
-def provide_app_context(app_context: AppContext) -> Generator[None, None, None]:
-    token = app_context_ctxvar.set(app_context)
+def provide_app_context(
+    app_context: AppTransactionContext,
+) -> Generator[None, None, None]:
+    token = app_transaction_context_var.set(app_context)
     try:
         yield
     finally:
         with suppress(ValueError):
-            app_context_ctxvar.reset(token)
+            app_transaction_context_var.reset(token)
 
 
 @runtime_checkable
 class AppInterceptor(Protocol):
 
-    def intercept(self, app_context: AppContext) -> AsyncContextManager[None]: ...
+    def intercept(
+        self, app_context: AppTransactionContext
+    ) -> AsyncContextManager[None]: ...
 
 
 class AppInterceptorWithLifecycle(Protocol):
@@ -227,17 +266,21 @@ def provide_container(container: Container) -> Generator[None, None, None]:
 
 
 __all__ = [
-    "AppContext",
+    "AppTransactionContext",
     "AppInterceptor",
     "AppInterceptorWithLifecycle",
     "Container",
     "Microservice",
-    "SchedulerAppContext",
-    "WebSocketAppContext",
-    "app_context_ctxvar",
+    "SchedulerTransactionData",
+    "WebSocketTransactionData",
+    "app_transaction_context_var",
     "current_container_ctx",
     "provide_app_context",
     "provide_container",
     "use_app_context",
     "use_current_container",
+    "HttpTransactionData",
+    "MessageBusTransactionData",
+    "is_interceptor_with_lifecycle",
+    "AppContext",
 ]

jararaca/observability/decorators.py

@@ -13,7 +13,7 @@ from typing import (
     TypeVar,
 )
 
-from jararaca.microservice import AppContext
+from jararaca.microservice import AppTransactionContext
 
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -28,9 +28,13 @@ class TracingContextProvider(Protocol):
 
 class TracingContextProviderFactory(Protocol):
 
-    def root_setup(self, app_context: AppContext) -> AsyncContextManager[None]: ...
+    def root_setup(
+        self, app_context: AppTransactionContext
+    ) -> AsyncContextManager[None]: ...
 
-    def provide_provider(self, app_context: AppContext) -> TracingContextProvider: ...
+    def provide_provider(
+        self, app_context: AppTransactionContext
+    ) -> TracingContextProvider: ...
 
 
 tracing_ctx_provider_ctxv = ContextVar[TracingContextProvider]("tracing_ctx_provider")