hatchet-sdk 0.45.3__py3-none-any.whl → 0.46.0__py3-none-any.whl

hatchet_sdk/opentelemetry/instrumentor.py

@@ -0,0 +1,323 @@
+from importlib.metadata import version
+from typing import Any, Callable, Collection, Coroutine
+
+try:
+    from opentelemetry.context import Context
+    from opentelemetry.instrumentation.instrumentor import (  # type: ignore[attr-defined]
+        BaseInstrumentor,
+    )
+    from opentelemetry.instrumentation.utils import unwrap
+    from opentelemetry.metrics import MeterProvider, NoOpMeterProvider, get_meter
+    from opentelemetry.trace import (
+        NoOpTracerProvider,
+        StatusCode,
+        TracerProvider,
+        get_tracer,
+    )
+    from opentelemetry.trace.propagation.tracecontext import (
+        TraceContextTextMapPropagator,
+    )
+    from wrapt import wrap_function_wrapper  # type: ignore[import-untyped]
+except (RuntimeError, ImportError, ModuleNotFoundError):
+    raise ModuleNotFoundError(
+        "To use the HatchetInstrumentor, you must install Hatchet's `otel` extra using (e.g.) `pip install hatchet-sdk[otel]`"
+    )
+
+import hatchet_sdk
+from hatchet_sdk.clients.admin import (
+    AdminClient,
+    TriggerWorkflowOptions,
+    WorkflowRunDict,
+)
+from hatchet_sdk.clients.dispatcher.action_listener import Action
+from hatchet_sdk.clients.events import (
+    BulkPushEventWithMetadata,
+    EventClient,
+    PushEventOptions,
+)
+from hatchet_sdk.contracts.events_pb2 import Event
+from hatchet_sdk.worker.runner.runner import Runner
+from hatchet_sdk.workflow_run import WorkflowRunRef
+
+hatchet_sdk_version = version("hatchet-sdk")
+
+InstrumentKwargs = TracerProvider | MeterProvider | None
+
+
+class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
+    OTEL_TRACEPARENT_KEY = "traceparent"
+
+    def __init__(
+        self,
+        tracer_provider: TracerProvider,
+        meter_provider: MeterProvider = NoOpMeterProvider(),
+    ):
+        self.tracer_provider = tracer_provider
+        self.meter_provider = meter_provider
+
+        super().__init__()
+
+    def create_traceparent(self) -> str | None:
+        carrier: dict[str, str] = {}
+        TraceContextTextMapPropagator().inject(carrier)
+
+        return carrier.get("traceparent")
+
+    def parse_carrier_from_metadata(
+        self, metadata: dict[str, str] | None
+    ) -> Context | None:
+        if not metadata:
+            return None
+
+        traceparent = metadata.get(self.OTEL_TRACEPARENT_KEY)
+
+        if not traceparent:
+            return None
+
+        return TraceContextTextMapPropagator().extract(
+            {self.OTEL_TRACEPARENT_KEY: traceparent}
+        )
+
+    def inject_traceparent_into_metadata(
+        self, metadata: dict[str, str], traceparent: str | None
+    ) -> dict[str, str]:
+        if traceparent:
+            metadata[self.OTEL_TRACEPARENT_KEY] = traceparent
+
+        return metadata
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return tuple()
+
+    def _instrument(self, **kwargs: InstrumentKwargs) -> None:
+        self._tracer = get_tracer(__name__, hatchet_sdk_version, self.tracer_provider)
+        self._meter = get_meter(__name__, hatchet_sdk_version, self.meter_provider)
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "worker.runner.runner.Runner.handle_start_step_run",
+            self._wrap_handle_start_step_run,
+        )
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "worker.runner.runner.Runner.handle_start_group_key_run",
+            self._wrap_handle_get_group_key_run,
+        )
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "worker.runner.runner.Runner.handle_cancel_action",
+            self._wrap_handle_cancel_action,
+        )
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.events.EventClient.push",
+            self._wrap_push_event,
+        )
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.events.EventClient.bulk_push",
+            self._wrap_bulk_push_event,
+        )
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.admin.AdminClient.run_workflow",
+            self._wrap_run_workflow,
+        )
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.admin.AdminClientAioImpl.run_workflow",
+            self._wrap_async_run_workflow,
+        )
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.admin.AdminClient.run_workflows",
+            self._wrap_run_workflows,
+        )
+
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.admin.AdminClientAioImpl.run_workflows",
+            self._wrap_async_run_workflows,
+        )
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    async def _wrap_handle_start_step_run(
+        self,
+        wrapped: Callable[[Action], Coroutine[None, None, Exception | None]],
+        instance: Runner,
+        args: tuple[Action],
+        kwargs: Any,
+    ) -> Exception | None:
+        action = args[0]
+        traceparent = self.parse_carrier_from_metadata(action.additional_metadata)
+
+        with self._tracer.start_as_current_span(
+            "hatchet.start_step_run",
+            attributes=action.otel_attributes,
+            context=traceparent,
+        ) as span:
+            result = await wrapped(*args, **kwargs)
+
+            if isinstance(result, Exception):
+                span.set_status(StatusCode.ERROR, str(result))
+
+            return result
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    async def _wrap_handle_get_group_key_run(
+        self,
+        wrapped: Callable[[Action], Coroutine[None, None, Exception | None]],
+        instance: Runner,
+        args: tuple[Action],
+        kwargs: Any,
+    ) -> Exception | None:
+        action = args[0]
+
+        with self._tracer.start_as_current_span(
+            "hatchet.get_group_key_run",
+            attributes=action.otel_attributes,
+        ) as span:
+            result = await wrapped(*args, **kwargs)
+
+            if isinstance(result, Exception):
+                span.set_status(StatusCode.ERROR, str(result))
+
+            return result
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    async def _wrap_handle_cancel_action(
+        self,
+        wrapped: Callable[[str], Coroutine[None, None, Exception | None]],
+        instance: Runner,
+        args: tuple[str],
+        kwargs: Any,
+    ) -> Exception | None:
+        step_run_id = args[0]
+
+        with self._tracer.start_as_current_span(
+            "hatchet.cancel_step_run",
+            attributes={
+                "hatchet.step_run_id": step_run_id,
+            },
+        ):
+            return await wrapped(*args, **kwargs)
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    def _wrap_push_event(
+        self,
+        wrapped: Callable[[str, dict[str, Any], PushEventOptions | None], Event],
+        instance: EventClient,
+        args: tuple[
+            str,
+            dict[str, Any],
+            PushEventOptions | None,
+        ],
+        kwargs: dict[str, str | dict[str, Any] | PushEventOptions | None],
+    ) -> Event:
+        with self._tracer.start_as_current_span(
+            "hatchet.push_event",
+        ):
+            return wrapped(*args, **kwargs)
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    def _wrap_bulk_push_event(
+        self,
+        wrapped: Callable[
+            [list[BulkPushEventWithMetadata], PushEventOptions | None], list[Event]
+        ],
+        instance: EventClient,
+        args: tuple[
+            list[BulkPushEventWithMetadata],
+            PushEventOptions | None,
+        ],
+        kwargs: dict[str, list[BulkPushEventWithMetadata] | PushEventOptions | None],
+    ) -> list[Event]:
+        with self._tracer.start_as_current_span(
+            "hatchet.bulk_push_event",
+        ):
+            return wrapped(*args, **kwargs)
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    def _wrap_run_workflow(
+        self,
+        wrapped: Callable[[str, Any, TriggerWorkflowOptions | None], WorkflowRunRef],
+        instance: AdminClient,
+        args: tuple[str, Any, TriggerWorkflowOptions | None],
+        kwargs: dict[str, str | Any | TriggerWorkflowOptions | None],
+    ) -> WorkflowRunRef:
+        with self._tracer.start_as_current_span(
+            "hatchet.run_workflow",
+        ):
+            return wrapped(*args, **kwargs)
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    async def _wrap_async_run_workflow(
+        self,
+        wrapped: Callable[
+            [str, Any, TriggerWorkflowOptions | None],
+            Coroutine[None, None, WorkflowRunRef],
+        ],
+        instance: AdminClient,
+        args: tuple[str, Any, TriggerWorkflowOptions | None],
+        kwargs: dict[str, str | Any | TriggerWorkflowOptions | None],
+    ) -> WorkflowRunRef:
+        with self._tracer.start_as_current_span(
+            "hatchet.run_workflow",
+        ):
+            return await wrapped(*args, **kwargs)
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    def _wrap_run_workflows(
+        self,
+        wrapped: Callable[
+            [list[WorkflowRunDict], TriggerWorkflowOptions | None], list[WorkflowRunRef]
+        ],
+        instance: AdminClient,
+        args: tuple[
+            list[WorkflowRunDict],
+            TriggerWorkflowOptions | None,
+        ],
+        kwargs: dict[str, list[WorkflowRunDict] | TriggerWorkflowOptions | None],
+    ) -> list[WorkflowRunRef]:
+        with self._tracer.start_as_current_span(
+            "hatchet.run_workflows",
+        ):
+            return wrapped(*args, **kwargs)
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    async def _wrap_async_run_workflows(
+        self,
+        wrapped: Callable[
+            [list[WorkflowRunDict], TriggerWorkflowOptions | None],
+            Coroutine[None, None, list[WorkflowRunRef]],
+        ],
+        instance: AdminClient,
+        args: tuple[
+            list[WorkflowRunDict],
+            TriggerWorkflowOptions | None,
+        ],
+        kwargs: dict[str, list[WorkflowRunDict] | TriggerWorkflowOptions | None],
+    ) -> list[WorkflowRunRef]:
+        with self._tracer.start_as_current_span(
+            "hatchet.run_workflows",
+        ):
+            return await wrapped(*args, **kwargs)
+
+    def _uninstrument(self, **kwargs: InstrumentKwargs) -> None:
+        self.tracer_provider = NoOpTracerProvider()
+        self.meter_provider = NoOpMeterProvider()
+
+        unwrap(hatchet_sdk, "worker.runner.runner.Runner.handle_start_step_run")
+        unwrap(hatchet_sdk, "worker.runner.runner.Runner.handle_start_group_key_run")
+        unwrap(hatchet_sdk, "worker.runner.runner.Runner.handle_cancel_action")
+        unwrap(hatchet_sdk, "clients.events.EventClient.push")
+        unwrap(hatchet_sdk, "clients.events.EventClient.bulk_push")
+        unwrap(hatchet_sdk, "clients.admin.AdminClient.run_workflow")
+        unwrap(hatchet_sdk, "clients.admin.AdminClientAioImpl.run_workflow")
+        unwrap(hatchet_sdk, "clients.admin.AdminClient.run_workflows")
+        unwrap(hatchet_sdk, "clients.admin.AdminClientAioImpl.run_workflows")

hatchet_sdk/worker/runner/runner.py

@@ -10,7 +10,6 @@ from multiprocessing import Queue
 from threading import Thread, current_thread
 from typing import Any, Callable, Dict, Literal, Type, TypeVar, cast, overload
 
-from opentelemetry.trace import StatusCode
 from pydantic import BaseModel
 
 from hatchet_sdk.client import new_client_raw
@@ -32,7 +31,6 @@ from hatchet_sdk.contracts.dispatcher_pb2 import (
 )
 from hatchet_sdk.loader import ClientConfig
 from hatchet_sdk.logger import logger
-from hatchet_sdk.utils.tracing import create_tracer, parse_carrier_from_metadata
 from hatchet_sdk.utils.types import WorkflowValidator
 from hatchet_sdk.v2.callable import DurableContext
 from hatchet_sdk.worker.action_listener_process import ActionEvent
@@ -88,43 +86,29 @@ class Runner:
             labels=labels, client=new_client_raw(config).dispatcher
         )
 
-        self.otel_tracer = create_tracer(config=config)
-
     def create_workflow_run_url(self, action: Action) -> str:
         return f"{self.config.server_url}/workflow-runs/{action.workflow_run_id}?tenant={action.tenant_id}"
 
     def run(self, action: Action) -> None:
-        ctx = parse_carrier_from_metadata(action.additional_metadata)
-
-        with self.otel_tracer.start_as_current_span(
-            f"hatchet.worker.run.{action.step_id}", context=ctx
-        ) as span:
-            if self.worker_context.id() is None:
-                self.worker_context._worker_id = action.worker_id
-
-            span.set_attributes(action.otel_attributes)
-            span.set_attribute("workflow_run_url", self.create_workflow_run_url(action))
-
-            match action.action_type:
-                case ActionType.START_STEP_RUN:
-                    log = f"run: start step: {action.action_id}/{action.step_run_id}"
-                    span.add_event(log)
-                    logger.info(log)
-                    asyncio.create_task(self.handle_start_step_run(action))
-                case ActionType.CANCEL_STEP_RUN:
-                    log = f"cancel: step run:  {action.action_id}/{action.step_run_id}"
-                    span.add_event(log)
-                    logger.info(log)
-                    asyncio.create_task(self.handle_cancel_action(action.step_run_id))
-                case ActionType.START_GET_GROUP_KEY:
-                    log = f"run: get group key:  {action.action_id}/{action.get_group_key_run_id}"
-                    span.add_event(log)
-                    logger.info(log)
-                    asyncio.create_task(self.handle_start_group_key_run(action))
-                case _:
-                    log = f"unknown action type: {action.action_type}"
-                    span.add_event(log)
-                    logger.error(log)
+        if self.worker_context.id() is None:
+            self.worker_context._worker_id = action.worker_id
+
+        match action.action_type:
+            case ActionType.START_STEP_RUN:
+                log = f"run: start step: {action.action_id}/{action.step_run_id}"
+                logger.info(log)
+                asyncio.create_task(self.handle_start_step_run(action))
+            case ActionType.CANCEL_STEP_RUN:
+                log = f"cancel: step run:  {action.action_id}/{action.step_run_id}"
+                logger.info(log)
+                asyncio.create_task(self.handle_cancel_action(action.step_run_id))
+            case ActionType.START_GET_GROUP_KEY:
+                log = f"run: get group key:  {action.action_id}/{action.get_group_key_run_id}"
+                logger.info(log)
+                asyncio.create_task(self.handle_start_group_key_run(action))
+            case _:
+                log = f"unknown action type: {action.action_type}"
+                logger.error(log)
 
     def step_run_callback(self, action: Action) -> Callable[[asyncio.Task[Any]], None]:
         def inner_callback(task: asyncio.Task[Any]) -> None:
@@ -306,101 +290,87 @@ class Runner:
             validator_registry=self.validator_registry,
         )
 
-    async def handle_start_step_run(self, action: Action) -> None:
-        with self.otel_tracer.start_as_current_span(
-            f"hatchet.worker.handle_start_step_run.{action.step_id}",
-        ) as span:
-            span.add_event("Starting step run")
-            span.set_attributes(action.otel_attributes)
-
-            action_name = action.action_id
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
+    async def handle_start_step_run(self, action: Action) -> None | Exception:
+        action_name = action.action_id
 
-            # Find the corresponding action function from the registry
-            action_func = self.action_registry.get(action_name)
+        # Find the corresponding action function from the registry
+        action_func = self.action_registry.get(action_name)
 
-            context = self.create_context(action, action_func)
+        context = self.create_context(action, action_func)
 
-            self.contexts[action.step_run_id] = context
+        self.contexts[action.step_run_id] = context
 
-            if action_func:
-                self.event_queue.put(
-                    ActionEvent(
-                        action=action,
-                        type=STEP_EVENT_TYPE_STARTED,
-                    )
+        if action_func:
+            self.event_queue.put(
+                ActionEvent(
+                    action=action,
+                    type=STEP_EVENT_TYPE_STARTED,
                 )
+            )
 
-                loop = asyncio.get_event_loop()
-                task = loop.create_task(
-                    self.async_wrapped_action_func(
-                        context, action_func, action, action.step_run_id
-                    )
+            loop = asyncio.get_event_loop()
+            task = loop.create_task(
+                self.async_wrapped_action_func(
+                    context, action_func, action, action.step_run_id
                 )
-
-                task.add_done_callback(self.step_run_callback(action))
-                self.tasks[action.step_run_id] = task
-
-                try:
-                    await task
-                    span.set_status(StatusCode.OK)
-                except Exception as e:
-                    # do nothing, this should be caught in the callback
-                    span.set_status(StatusCode.ERROR)
-                    span.record_exception(e)
-
-            span.add_event("Finished step run")
-
-    async def handle_start_group_key_run(self, action: Action) -> None:
-        with self.otel_tracer.start_as_current_span(
-            f"hatchet.worker.handle_start_step_run.{action.step_id}"
-        ) as span:
-            span.add_event("Starting group key run")
-            action_name = action.action_id
-            context = Context(
-                action,
-                self.dispatcher_client,
-                self.admin_client,
-                self.client.event,
-                self.client.rest,
-                self.client.workflow_listener,
-                self.workflow_run_event_listener,
-                self.worker_context,
-                self.client.config.namespace,
             )
 
-            self.contexts[action.get_group_key_run_id] = context
+            task.add_done_callback(self.step_run_callback(action))
+            self.tasks[action.step_run_id] = task
 
-            # Find the corresponding action function from the registry
-            action_func = self.action_registry.get(action_name)
+            try:
+                await task
+            except Exception as e:
+                return e
 
-            if action_func:
-                # send an event that the group key run has started
-                self.event_queue.put(
-                    ActionEvent(
-                        action=action,
-                        type=GROUP_KEY_EVENT_TYPE_STARTED,
-                    )
+        return None
+
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
+    async def handle_start_group_key_run(self, action: Action) -> Exception | None:
+        action_name = action.action_id
+        context = Context(
+            action,
+            self.dispatcher_client,
+            self.admin_client,
+            self.client.event,
+            self.client.rest,
+            self.client.workflow_listener,
+            self.workflow_run_event_listener,
+            self.worker_context,
+            self.client.config.namespace,
+        )
+
+        self.contexts[action.get_group_key_run_id] = context
+
+        # Find the corresponding action function from the registry
+        action_func = self.action_registry.get(action_name)
+
+        if action_func:
+            # send an event that the group key run has started
+            self.event_queue.put(
+                ActionEvent(
+                    action=action,
+                    type=GROUP_KEY_EVENT_TYPE_STARTED,
                 )
+            )
 
-                loop = asyncio.get_event_loop()
-                task = loop.create_task(
-                    self.async_wrapped_action_func(
-                        context, action_func, action, action.get_group_key_run_id
-                    )
+            loop = asyncio.get_event_loop()
+            task = loop.create_task(
+                self.async_wrapped_action_func(
+                    context, action_func, action, action.get_group_key_run_id
                 )
+            )
 
-                task.add_done_callback(self.group_key_run_callback(action))
-                self.tasks[action.get_group_key_run_id] = task
+            task.add_done_callback(self.group_key_run_callback(action))
+            self.tasks[action.get_group_key_run_id] = task
 
-                try:
-                    await task
-                    span.set_status(StatusCode.OK)
-                except Exception as e:
-                    # do nothing, this should be caught in the callback
-                    span.set_status(StatusCode.ERROR)
-                    span.record_exception(e)
+            try:
+                await task
+            except Exception as e:
+                return e
 
-            span.add_event("Finished group key run")
+        return None
 
     def force_kill_thread(self, thread: Thread) -> None:
         """Terminate a python threading.Thread."""
@@ -431,39 +401,31 @@ class Runner:
         except Exception as e:
             logger.exception(f"Failed to terminate thread: {e}")
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     async def handle_cancel_action(self, run_id: str) -> None:
-        with self.otel_tracer.start_as_current_span(
-            "hatchet.worker.handle_cancel_action"
-        ) as span:
-            span.add_event(f"Cancelling run id: {run_id}")
-            span.set_attribute("run_id", run_id)
-
-            try:
-                # call cancel to signal the context to stop
-                if run_id in self.contexts:
-                    context = self.contexts.get(run_id)
-
-                    if context:
-                        context.cancel()
+        try:
+            # call cancel to signal the context to stop
+            if run_id in self.contexts:
+                context = self.contexts.get(run_id)
 
-                await asyncio.sleep(1)
+                if context:
+                    context.cancel()
 
-                if run_id in self.tasks:
-                    future = self.tasks.get(run_id)
+            await asyncio.sleep(1)
 
-                    if future:
-                        future.cancel()
+            if run_id in self.tasks:
+                future = self.tasks.get(run_id)
 
-                # check if thread is still running, if so, print a warning
-                if run_id in self.threads:
-                    logger.warning(
-                        f"Thread {self.threads[run_id].ident} with run id {run_id} is still running after cancellation. This could cause the thread pool to get blocked and prevent new tasks from running."
-                    )
+                if future:
+                    future.cancel()
 
-                span.set_status(StatusCode.OK)
-            finally:
-                self.cleanup_run_id(run_id)
-                span.add_event(f"Finished cancelling run id: {run_id}")
+            # check if thread is still running, if so, print a warning
+            if run_id in self.threads:
+                logger.warning(
+                    f"Thread {self.threads[run_id].ident} with run id {run_id} is still running after cancellation. This could cause the thread pool to get blocked and prevent new tasks from running."
+                )
+        finally:
+            self.cleanup_run_id(run_id)
 
     def serialize_output(self, output: Any) -> str:
 

{hatchet_sdk-0.45.3.dist-info → hatchet_sdk-0.46.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 0.45.3
+Version: 0.46.0
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run
@@ -9,6 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: otel
 Requires-Dist: aiohttp (>=3.10.5,<4.0.0)
 Requires-Dist: aiohttp-retry (>=2.8.3,<3.0.0)
 Requires-Dist: aiostream (>=0.5.2,<0.6.0)
@@ -17,14 +18,13 @@ Requires-Dist: grpcio (>=1.64.1,!=1.68.*) ; python_version < "3.13"
 Requires-Dist: grpcio (>=1.69.0) ; python_version >= "3.13"
 Requires-Dist: grpcio-tools (>=1.64.1,!=1.68.*) ; python_version < "3.13"
 Requires-Dist: grpcio-tools (>=1.69.0) ; python_version >= "3.13"
-Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
-Requires-Dist: opentelemetry-api (>=1.28.0,<2.0.0)
-Requires-Dist: opentelemetry-distro (>=0.49b0)
-Requires-Dist: opentelemetry-exporter-otlp (>=1.28.0,<2.0.0)
-Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.28.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (>=0.49b0)
-Requires-Dist: opentelemetry-sdk (>=1.28.0,<2.0.0)
+Requires-Dist: opentelemetry-api (>=1.28.0,<2.0.0) ; extra == "otel"
+Requires-Dist: opentelemetry-distro (>=0.49b0) ; extra == "otel"
+Requires-Dist: opentelemetry-exporter-otlp (>=1.28.0,<2.0.0) ; extra == "otel"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.28.0,<2.0.0) ; extra == "otel"
+Requires-Dist: opentelemetry-instrumentation (>=0.49b0) ; extra == "otel"
+Requires-Dist: opentelemetry-sdk (>=1.28.0,<2.0.0) ; extra == "otel"
 Requires-Dist: prometheus-client (>=0.21.1,<0.22.0)
 Requires-Dist: protobuf (>=5.29.1,<6.0.0)
 Requires-Dist: pydantic (>=2.6.3,<3.0.0)