o i @sdZddlZddlmZddlmZddlmZddlmZddlm Z dd l m Z e e ZGd d d ZGd d d ee ZdS)a This files implements the subscribers models for ``core.dispatch_event`` and ``core.context_with_event``. Subscribers are meant to replace ``core.on()`` by automatically register hook for events registered in event_names attribute. Subscriber class automatically register hook for the name of the events stored in event_names attribute. ContextSubscriber class automatically register hooks for context.started.event_name and context.ended.event_name with event_name being the name of the events stored in event_names attribute. Subscribers also allow to compose hook capabilities: you can specialized a Subscriber by inheriting it. Finally, subscribers can listen to multiple event names to allow integration specific events that wants to trigger the same subscriber. N) TracebackType)Generic)Optional)Sequence)core) EventTypecsReZdZUdZeeed<dZeed<fddZ e ddZ e d d Z Z S) SubscriberaxBase class for event subscribers. Subclasses that define ``event_names`` automatically register themselves to handle those events. This provides a clean pattern for handling events from the Events API (Event class). The subscriber pattern automatically: - Registers the subscriber when the class is defined - Collects all ``on_event`` methods from the inheritance chain and calls them in order (parent to child) Example: @dataclass class MyEvent(Event): event_name = "my.event" data: str class MySubscriber(Subscriber): event_names = ("my.event",) @classmethod def on_event(cls, event_instance): print(f"Received: {event_instance.data}") # Subscriber is automatically registered, just dispatch: core.dispatch_event(MyEvent(data="hello")) event_names_event_handlersc svtjdi|tddt|jddD|_d|jvr(td|j dS|j D] }t j ||j |j dq+dS) Automatically register listeners at subclass definition. Handlers are registered from Base class to Children classes to allow behavior composition (a child class benefit from the parent class hook) css2|]}t|trd|jvr|tur|jVqdS)on_eventN) issubclassr __dict__r.0base_clsr r T/home/ubuntu/.local/lib/python3.10/site-packages/ddtrace/internal/core/subscriber.py Dsz/Subscriber.__init_subclass__..Nr NSubscriber class %s does not define 'event_names' and will not be registered. namer )super__init_subclass__tuplereversed__mro__r rlogdebug__name__r ron _on_eventclskwargs event_name __class__r rr=s  zSubscriber.__init_subclass__cCdS)zOverride this method in child classes to handle the event. Args: event_instance: The Event instance that was dispatched Nr )r%event_instancer r rrWzSubscriber.on_eventcC|jD]}||qdS)zIInternal handler that calls all _on_event methods from parent to childrenN)r )r%r+handlerr r rr#`  zSubscriber._on_event)r! __module__ __qualname____doc__rstr__annotations__r rr classmethodrr# __classcell__r r r(rr s     r c seZdZUdZeeed<dZeed<dZ eed<fddZ e de j efd d Ze de j ed eeeeeeeffd d Ze de j eddfddZe de j ed eeeeeeefddfddZZS)ContextSubscriberaBase class for context event subscribers. Subclasses that define ``event_names`` automatically register themselves to handle context lifecycle events: - ``context.started.{event_name}`` when the context begins - ``context.ended.{event_name}`` when the context ends Example: @dataclass class MyContextEvent(ContextEvent): event_name = "my.context" user_id: str = event_field() class MyContextSubscriber(ContextSubscriber): event_names = ("my.context",) @classmethod def on_started(cls, ctx): user_id = ctx.get_item("user_id") print(f"Context started for user {user_id}") @classmethod def on_ended(cls, ctx, exc_info): if exc_info[1]: print(f"Context ended with error: {exc_info[1]}") with core.context_with_event(MyContextEvent(url="/api", user_id="123")): pass r r _started_handlers_ended_handlersc stjd i|tddt|jddD|_tddt|jddD|_d|jvr9t d|j dS|j D]"}t j d||j|j d d t j d ||j|j d d q.Nrcsr:)on_endedN)rr7rr=rr r rrr<r rzcontext.started.z.startedrzcontext.ended.z.endedr )rrrrrr8r9rrr r!r rr"_on_context_started_on_context_endedr$r(r rrs,     z#ContextSubscriber.__init_subclass__ctxcCr*)zOverride this method in child classes to handle context start events. Args: ctx: The ExecutionContext instance Nr )r%r@r r rr;r,zContextSubscriber.on_startedexc_infocCr*)zOverride this method in child classes to handle context end events. Args: ctx: The ExecutionContext instance exc_info: Tuple of (exception_type, exception_value, traceback) or (None, None, None) Nr )r%r@rAr r rr=s zContextSubscriber.on_endedreturnNcCr-)zSInternal handler that calls all _on_context_started methods from parent to childrenN)r8)r%r@r.r r rr>r/z%ContextSubscriber._on_context_startedcCs|jD]}|||qdS)zQInternal handler that calls all _on_context_ended methods from parent to childrenN)r9)r%r@rAr.r r rr?s  z#ContextSubscriber._on_context_ended)r!r0r1r2rr3r4r8rr9rr5rExecutionContextrr;rtype BaseExceptionrr=r>r?r6r r r(rr7gs0     )  r7)r2loggingtypesrtypingrrrddtrace.internalreventsr getLoggerr!rr r7r r r rs       H