hatchet-sdk 1.10.2__py3-none-any.whl → 1.11.0__py3-none-any.whl

hatchet_sdk/opentelemetry/instrumentor.py

@@ -1,6 +1,8 @@
+import json
 from importlib.metadata import version
-from typing import Any, Callable, Collection, Coroutine
+from typing import Any, Callable, Collection, Coroutine, Union, cast
 
+from hatchet_sdk.contracts import workflows_pb2 as v0_workflow_protos
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
 try:
@@ -26,20 +28,29 @@ except (RuntimeError, ImportError, ModuleNotFoundError):
         "To use the HatchetInstrumentor, you must install Hatchet's `otel` extra using (e.g.) `pip install hatchet-sdk[otel]`"
     )
 
+import inspect
+from datetime import datetime
+
+from google.protobuf import timestamp_pb2
+
 import hatchet_sdk
 from hatchet_sdk import ClientConfig
 from hatchet_sdk.clients.admin import (
     AdminClient,
+    ScheduleTriggerWorkflowOptions,
     TriggerWorkflowOptions,
     WorkflowRunTriggerConfig,
 )
 from hatchet_sdk.clients.events import (
+    BulkPushEventOptions,
     BulkPushEventWithMetadata,
     EventClient,
     PushEventOptions,
 )
 from hatchet_sdk.contracts.events_pb2 import Event
+from hatchet_sdk.logger import logger
 from hatchet_sdk.runnables.action import Action
+from hatchet_sdk.utils.opentelemetry import OTelAttribute
 from hatchet_sdk.worker.runner.runner import Runner
 from hatchet_sdk.workflow_run import WorkflowRunRef
 
@@ -51,6 +62,13 @@ OTEL_TRACEPARENT_KEY = "traceparent"
 
 
 def create_traceparent() -> str | None:
+    logger.warning(
+        "As of SDK version 1.11.0, you no longer need to call `create_traceparent` manually. The traceparent will be automatically created by the instrumentor and injected into the metadata of actions and events when appropriate. This method will be removed in a future version.",
+    )
+    return _create_traceparent()
+
+
+def _create_traceparent() -> str | None:
     """
     Creates and returns a W3C traceparent header value using OpenTelemetry's context propagation.
 
@@ -70,6 +88,16 @@ def create_traceparent() -> str | None:
 
 def parse_carrier_from_metadata(
     metadata: JSONSerializableMapping | None,
+) -> Context | None:
+    logger.warning(
+        "As of SDK version 1.11.0, you no longer need to call `parse_carrier_from_metadata` manually. This method will be removed in a future version.",
+    )
+
+    return _parse_carrier_from_metadata(metadata)
+
+
+def _parse_carrier_from_metadata(
+    metadata: JSONSerializableMapping | None,
 ) -> Context | None:
     """
     Parses OpenTelemetry trace context from a metadata dictionary.
@@ -86,7 +114,7 @@ def parse_carrier_from_metadata(
     :Example:
 
     >>> metadata = {"traceparent": "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01"}
-    >>> context = parse_carrier_from_metadata(metadata)
+    >>> context = _parse_carrier_from_metadata(metadata)
     """
 
     if not metadata:
@@ -102,6 +130,16 @@ def parse_carrier_from_metadata(
 
 def inject_traceparent_into_metadata(
     metadata: dict[str, str], traceparent: str | None = None
+) -> dict[str, str]:
+    logger.warning(
+        "As of SDK version 1.11.0, you no longer need to call `inject_traceparent_into_metadata` manually. The traceparent will automatically be injected by the instrumentor. This method will be removed in a future version.",
+    )
+
+    return _inject_traceparent_into_metadata(metadata, traceparent)
+
+
+def _inject_traceparent_into_metadata(
+    metadata: dict[str, str], traceparent: str | None = None
 ) -> dict[str, str]:
     """
     Injects OpenTelemetry `traceparent` into a metadata dictionary.
@@ -125,9 +163,8 @@ def inject_traceparent_into_metadata(
     >>> print(new_metadata)
     {"key": "value", "traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"}
     """
-
     if not traceparent:
-        traceparent = create_traceparent()
+        traceparent = _create_traceparent()
 
     if not traceparent:
         return metadata
@@ -213,6 +250,14 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             self._wrap_async_run_workflow,
         )
 
+        ## IMPORTANT: We don't need to instrument the async version of `schedule_workflow`
+        ## because it just calls the sync version internally.
+        wrap_function_wrapper(
+            hatchet_sdk,
+            "clients.admin.AdminClient.schedule_workflow",
+            self._wrap_schedule_workflow,
+        )
+
         wrap_function_wrapper(
             hatchet_sdk,
             "clients.admin.AdminClient.run_workflows",
@@ -225,6 +270,19 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             self._wrap_async_run_workflows,
         )
 
+    def extract_bound_args(
+        self,
+        wrapped_func: Callable[..., Any],
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> list[Any]:
+        sig = inspect.signature(wrapped_func)
+
+        bound_args = sig.bind(*args, **kwargs)
+        bound_args.apply_defaults()
+
+        return list(bound_args.arguments.values())
+
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     async def _wrap_handle_start_step_run(
         self,
@@ -233,8 +291,11 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         args: tuple[Action],
         kwargs: Any,
     ) -> Exception | None:
-        action = args[0]
-        traceparent = parse_carrier_from_metadata(action.additional_metadata)
+        params = self.extract_bound_args(wrapped, args, kwargs)
+
+        action = cast(Action, params[0])
+
+        traceparent = _parse_carrier_from_metadata(action.additional_metadata)
 
         with self._tracer.start_as_current_span(
             "hatchet.start_step_run",
@@ -290,66 +351,293 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
     ## 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],
+        wrapped: Callable[[str, dict[str, Any], PushEventOptions], Event],
         instance: EventClient,
         args: tuple[
             str,
             dict[str, Any],
-            PushEventOptions | None,
+            PushEventOptions,
         ],
-        kwargs: dict[str, str | dict[str, Any] | PushEventOptions | None],
+        kwargs: dict[str, str | dict[str, Any] | PushEventOptions],
     ) -> Event:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+
+        event_key = cast(str, params[0])
+        payload = cast(JSONSerializableMapping, params[1])
+        options = cast(
+            PushEventOptions,
+            params[2] if len(params) > 2 else PushEventOptions(),
+        )
+
+        attributes = {
+            OTelAttribute.EVENT_KEY: event_key,
+            OTelAttribute.ACTION_PAYLOAD: json.dumps(payload, default=str),
+            OTelAttribute.ADDITIONAL_METADATA: json.dumps(
+                options.additional_metadata, default=str
+            ),
+            OTelAttribute.NAMESPACE: options.namespace,
+            OTelAttribute.PRIORITY: options.priority,
+            OTelAttribute.FILTER_SCOPE: options.scope,
+        }
+
         with self._tracer.start_as_current_span(
             "hatchet.push_event",
+            attributes={
+                f"hatchet.{k.value}": v
+                for k, v in attributes.items()
+                if v
+                and k not in self.config.otel.excluded_attributes
+                and v != "{}"
+                and v != "[]"
+            },
         ):
-            return wrapped(*args, **kwargs)
+            options = PushEventOptions(
+                **options.model_dump(exclude={"additional_metadata"}),
+                additional_metadata=_inject_traceparent_into_metadata(
+                    dict(options.additional_metadata),
+                ),
+            )
+
+            return wrapped(event_key, dict(payload), options)
 
     ## 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]
+            [list[BulkPushEventWithMetadata], BulkPushEventOptions], list[Event]
         ],
         instance: EventClient,
         args: tuple[
             list[BulkPushEventWithMetadata],
-            PushEventOptions | None,
+            BulkPushEventOptions,
         ],
-        kwargs: dict[str, list[BulkPushEventWithMetadata] | PushEventOptions | None],
+        kwargs: dict[str, list[BulkPushEventWithMetadata] | BulkPushEventOptions],
     ) -> list[Event]:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+
+        bulk_events = cast(list[BulkPushEventWithMetadata], params[0])
+        options = cast(BulkPushEventOptions, params[1])
+
+        num_bulk_events = len(bulk_events)
+        unique_event_keys = {event.key for event in bulk_events}
+
         with self._tracer.start_as_current_span(
             "hatchet.bulk_push_event",
+            attributes={
+                "hatchet.num_events": num_bulk_events,
+                "hatchet.unique_event_keys": json.dumps(unique_event_keys, default=str),
+            },
         ):
-            return wrapped(*args, **kwargs)
+            bulk_events_with_meta = [
+                BulkPushEventWithMetadata(
+                    **event.model_dump(exclude={"additional_metadata"}),
+                    additional_metadata=_inject_traceparent_into_metadata(
+                        dict(event.additional_metadata),
+                    ),
+                )
+                for event in bulk_events
+            ]
+
+            return wrapped(
+                bulk_events_with_meta,
+                options,
+            )
 
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     def _wrap_run_workflow(
         self,
-        wrapped: Callable[[str, Any, TriggerWorkflowOptions | None], WorkflowRunRef],
+        wrapped: Callable[
+            [str, JSONSerializableMapping, TriggerWorkflowOptions],
+            WorkflowRunRef,
+        ],
         instance: AdminClient,
-        args: tuple[str, Any, TriggerWorkflowOptions | None],
-        kwargs: dict[str, str | Any | TriggerWorkflowOptions | None],
+        args: tuple[str, JSONSerializableMapping, TriggerWorkflowOptions],
+        kwargs: dict[str, str | JSONSerializableMapping | TriggerWorkflowOptions],
     ) -> WorkflowRunRef:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+
+        workflow_name = cast(str, params[0])
+        payload = cast(JSONSerializableMapping, params[1])
+        options = cast(
+            TriggerWorkflowOptions,
+            params[2] if len(params) > 2 else TriggerWorkflowOptions(),
+        )
+
+        attributes = {
+            OTelAttribute.WORKFLOW_NAME: workflow_name,
+            OTelAttribute.ACTION_PAYLOAD: json.dumps(payload, default=str),
+            OTelAttribute.PARENT_ID: options.parent_id,
+            OTelAttribute.PARENT_STEP_RUN_ID: options.parent_step_run_id,
+            OTelAttribute.CHILD_INDEX: options.child_index,
+            OTelAttribute.CHILD_KEY: options.child_key,
+            OTelAttribute.NAMESPACE: options.namespace,
+            OTelAttribute.ADDITIONAL_METADATA: json.dumps(
+                options.additional_metadata, default=str
+            ),
+            OTelAttribute.PRIORITY: options.priority,
+            OTelAttribute.DESIRED_WORKER_ID: options.desired_worker_id,
+            OTelAttribute.STICKY: options.sticky,
+            OTelAttribute.KEY: options.key,
+        }
+
         with self._tracer.start_as_current_span(
             "hatchet.run_workflow",
+            attributes={
+                f"hatchet.{k.value}": v
+                for k, v in attributes.items()
+                if v
+                and k not in self.config.otel.excluded_attributes
+                and v != "{}"
+                and v != "[]"
+            },
         ):
-            return wrapped(*args, **kwargs)
+            options = TriggerWorkflowOptions(
+                **options.model_dump(exclude={"additional_metadata"}),
+                additional_metadata=_inject_traceparent_into_metadata(
+                    dict(options.additional_metadata),
+                ),
+            )
+
+            return wrapped(workflow_name, payload, options)
 
     ## 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],
+            [str, JSONSerializableMapping, TriggerWorkflowOptions],
             Coroutine[None, None, WorkflowRunRef],
         ],
         instance: AdminClient,
-        args: tuple[str, Any, TriggerWorkflowOptions | None],
-        kwargs: dict[str, str | Any | TriggerWorkflowOptions | None],
+        args: tuple[str, JSONSerializableMapping, TriggerWorkflowOptions],
+        kwargs: dict[str, str | JSONSerializableMapping | TriggerWorkflowOptions],
     ) -> WorkflowRunRef:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+
+        workflow_name = cast(str, params[0])
+        payload = cast(JSONSerializableMapping, params[1])
+        options = cast(
+            TriggerWorkflowOptions,
+            params[2] if len(params) > 2 else TriggerWorkflowOptions(),
+        )
+
+        attributes = {
+            OTelAttribute.WORKFLOW_NAME: workflow_name,
+            OTelAttribute.ACTION_PAYLOAD: json.dumps(payload, default=str),
+            OTelAttribute.PARENT_ID: options.parent_id,
+            OTelAttribute.PARENT_STEP_RUN_ID: options.parent_step_run_id,
+            OTelAttribute.CHILD_INDEX: options.child_index,
+            OTelAttribute.CHILD_KEY: options.child_key,
+            OTelAttribute.NAMESPACE: options.namespace,
+            OTelAttribute.ADDITIONAL_METADATA: json.dumps(
+                options.additional_metadata, default=str
+            ),
+            OTelAttribute.PRIORITY: options.priority,
+            OTelAttribute.DESIRED_WORKER_ID: options.desired_worker_id,
+            OTelAttribute.STICKY: options.sticky,
+            OTelAttribute.KEY: options.key,
+        }
+
         with self._tracer.start_as_current_span(
             "hatchet.run_workflow",
+            attributes={
+                f"hatchet.{k.value}": v
+                for k, v in attributes.items()
+                if v
+                and k not in self.config.otel.excluded_attributes
+                and v != "{}"
+                and v != "[]"
+            },
         ):
-            return await wrapped(*args, **kwargs)
+            options = TriggerWorkflowOptions(
+                **options.model_dump(exclude={"additional_metadata"}),
+                additional_metadata=_inject_traceparent_into_metadata(
+                    dict(options.additional_metadata),
+                ),
+            )
+
+            return await wrapped(workflow_name, payload, options)
+
+    def _ts_to_iso(self, ts: Union[datetime, timestamp_pb2.Timestamp]) -> str:
+        if isinstance(ts, datetime):
+            return ts.isoformat()
+        elif isinstance(ts, timestamp_pb2.Timestamp):
+            return ts.ToJsonString()
+        else:
+            raise TypeError(f"Unsupported type for timestamp conversion: {type(ts)}")
+
+    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
+    def _wrap_schedule_workflow(
+        self,
+        wrapped: Callable[
+            [
+                str,
+                list[Union[datetime, timestamp_pb2.Timestamp]],
+                JSONSerializableMapping,
+                ScheduleTriggerWorkflowOptions,
+            ],
+            v0_workflow_protos.WorkflowVersion,
+        ],
+        instance: AdminClient,
+        args: tuple[
+            str,
+            list[Union[datetime, timestamp_pb2.Timestamp]],
+            JSONSerializableMapping,
+            ScheduleTriggerWorkflowOptions,
+        ],
+        kwargs: dict[
+            str,
+            str
+            | list[Union[datetime, timestamp_pb2.Timestamp]]
+            | JSONSerializableMapping
+            | ScheduleTriggerWorkflowOptions,
+        ],
+    ) -> v0_workflow_protos.WorkflowVersion:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+
+        workflow_name = cast(str, params[0])
+        schedules = cast(list[Union[datetime, timestamp_pb2.Timestamp]], params[1])
+        input = cast(JSONSerializableMapping, params[2])
+        options = cast(
+            ScheduleTriggerWorkflowOptions,
+            params[3] if len(params) > 3 else ScheduleTriggerWorkflowOptions(),
+        )
+
+        attributes = {
+            OTelAttribute.WORKFLOW_NAME: workflow_name,
+            OTelAttribute.RUN_AT_TIMESTAMPS: json.dumps(
+                [self._ts_to_iso(ts) for ts in schedules]
+            ),
+            OTelAttribute.ACTION_PAYLOAD: json.dumps(input, default=str),
+            OTelAttribute.PARENT_ID: options.parent_id,
+            OTelAttribute.PARENT_STEP_RUN_ID: options.parent_step_run_id,
+            OTelAttribute.CHILD_INDEX: options.child_index,
+            OTelAttribute.CHILD_KEY: options.child_key,
+            OTelAttribute.NAMESPACE: options.namespace,
+            OTelAttribute.ADDITIONAL_METADATA: json.dumps(
+                options.additional_metadata, default=str
+            ),
+            OTelAttribute.PRIORITY: options.priority,
+        }
+
+        with self._tracer.start_as_current_span(
+            "hatchet.schedule_workflow",
+            attributes={
+                f"hatchet.{k.value}": v
+                for k, v in attributes.items()
+                if v
+                and k not in self.config.otel.excluded_attributes
+                and v != "{}"
+                and v != "[]"
+            },
+        ):
+            options = ScheduleTriggerWorkflowOptions(
+                **options.model_dump(exclude={"additional_metadata"}),
+                additional_metadata=_inject_traceparent_into_metadata(
+                    dict(options.additional_metadata),
+                ),
+            )
+
+            return wrapped(workflow_name, schedules, input, options)
 
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     def _wrap_run_workflows(
@@ -362,10 +650,37 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         args: tuple[list[WorkflowRunTriggerConfig],],
         kwargs: dict[str, list[WorkflowRunTriggerConfig]],
     ) -> list[WorkflowRunRef]:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+        workflow_run_configs = cast(list[WorkflowRunTriggerConfig], params[0])
+
+        num_workflows = len(workflow_run_configs)
+        unique_workflow_names = {
+            config.workflow_name for config in workflow_run_configs
+        }
+
         with self._tracer.start_as_current_span(
             "hatchet.run_workflows",
+            attributes={
+                "hatchet.num_workflows": num_workflows,
+                "hatchet.unique_workflow_names": json.dumps(
+                    unique_workflow_names, default=str
+                ),
+            },
         ):
-            return wrapped(*args, **kwargs)
+            workflow_run_configs_with_meta = [
+                WorkflowRunTriggerConfig(
+                    **config.model_dump(exclude={"options"}),
+                    options=TriggerWorkflowOptions(
+                        **config.options.model_dump(exclude={"additional_metadata"}),
+                        additional_metadata=_inject_traceparent_into_metadata(
+                            dict(config.options.additional_metadata),
+                        ),
+                    ),
+                )
+                for config in workflow_run_configs
+            ]
+
+            return wrapped(workflow_run_configs_with_meta)
 
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     async def _wrap_async_run_workflows(
@@ -378,10 +693,26 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         args: tuple[list[WorkflowRunTriggerConfig],],
         kwargs: dict[str, list[WorkflowRunTriggerConfig]],
     ) -> list[WorkflowRunRef]:
+        params = self.extract_bound_args(wrapped, args, kwargs)
+        workflow_run_configs = cast(list[WorkflowRunTriggerConfig], params[0])
+
         with self._tracer.start_as_current_span(
             "hatchet.run_workflows",
         ):
-            return await wrapped(*args, **kwargs)
+            workflow_run_configs_with_meta = [
+                WorkflowRunTriggerConfig(
+                    **config.model_dump(exclude={"options"}),
+                    options=TriggerWorkflowOptions(
+                        **config.options.model_dump(exclude={"additional_metadata"}),
+                        additional_metadata=_inject_traceparent_into_metadata(
+                            dict(config.options.additional_metadata),
+                        ),
+                    ),
+                )
+                for config in workflow_run_configs
+            ]
+
+            return await wrapped(workflow_run_configs_with_meta)
 
     def _uninstrument(self, **kwargs: InstrumentKwargs) -> None:
         self.tracer_provider = NoOpTracerProvider()

hatchet_sdk/utils/opentelemetry.py

@@ -2,8 +2,18 @@ from enum import Enum
 
 
 class OTelAttribute(str, Enum):
+    ## Shared
+    NAMESPACE = "namespace"
+    ADDITIONAL_METADATA = "additional_metadata"
+    WORKFLOW_NAME = "workflow_name"
+
+    PRIORITY = "priority"
+
+    ## Unfortunately named - this corresponds to all types of payloads, not just actions
+    ACTION_PAYLOAD = "payload"
+
+    ## Action
     ACTION_NAME = "action_name"
-    ACTION_PAYLOAD = "action_payload"
     CHILD_WORKFLOW_INDEX = "child_workflow_index"
     CHILD_WORKFLOW_KEY = "child_workflow_key"
     GET_GROUP_KEY_RUN_ID = "get_group_key_run_id"
@@ -14,6 +24,21 @@ class OTelAttribute(str, Enum):
     TENANT_ID = "tenant_id"
     WORKER_ID = "worker_id"
     WORKFLOW_ID = "workflow_id"
-    WORKFLOW_NAME = "workflow_name"
     WORKFLOW_RUN_ID = "workflow_run_id"
     WORKFLOW_VERSION_ID = "workflow_version_id"
+
+    ## Push Event
+    EVENT_KEY = "event_key"
+    FILTER_SCOPE = "scope"
+
+    ## Trigger Workflow
+    PARENT_ID = "parent_id"
+    PARENT_STEP_RUN_ID = "parent_step_run_id"
+    CHILD_INDEX = "child_index"
+    CHILD_KEY = "child_key"
+    DESIRED_WORKER_ID = "desired_worker_id"
+    STICKY = "sticky"
+    KEY = "key"
+
+    ## Schedule Workflow
+    RUN_AT_TIMESTAMPS = "run_at_timestamps"

hatchet_sdk/worker/action_listener_process.py

@@ -44,10 +44,7 @@ class ActionEvent:
 STOP_LOOP_TYPE = Literal["STOP_LOOP"]
 STOP_LOOP: STOP_LOOP_TYPE = "STOP_LOOP"  # Sentinel object to stop the loop
 
-# TODO link to a block post
-BLOCKED_THREAD_WARNING = (
-    "THE TIME TO START THE STEP RUN IS TOO LONG, THE MAIN THREAD MAY BE BLOCKED"
-)
+BLOCKED_THREAD_WARNING = "THE TIME TO START THE TASK RUN IS TOO LONG, THE EVENT LOOP MAY BE BLOCKED. See https://docs.hatchet.run/blog/warning-event-loop-blocked for details and debugging help."
 
 
 class WorkerActionListenerProcess:
@@ -160,6 +157,7 @@ class WorkerActionListenerProcess:
 
             if count > 0:
                 logger.warning(f"{BLOCKED_THREAD_WARNING}: Waiting Steps {count}")
+                print(asyncio.current_task())
             await asyncio.sleep(1)
 
     async def send_event(self, event: ActionEvent, retry_attempt: int = 1) -> None:

{hatchet_sdk-1.10.2.dist-info → hatchet_sdk-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.10.2
+Version: 1.11.0
 Summary: 
 License: MIT
 Author: Alexander Belanger

{hatchet_sdk-1.10.2.dist-info → hatchet_sdk-1.11.0.dist-info}/RECORD

@@ -264,7 +264,7 @@ hatchet_sdk/hatchet.py,sha256=BVWSrKL6GCzarTNAte_r0iWsaBXntxNzrR-syR6qENI,22885
 hatchet_sdk/labels.py,sha256=nATgxWE3lFxRTnfISEpoIRLGbMfAZsHF4lZTuG4Mfic,182
 hatchet_sdk/logger.py,sha256=5uOr52T4mImSQm1QvWT8HvZFK5WfPNh3Y1cBQZRFgUQ,333
 hatchet_sdk/metadata.py,sha256=XkRbhnghJJGCdVvF-uzyGBcNaTqpeQ3uiQvNNP1wyBc,107
-hatchet_sdk/opentelemetry/instrumentor.py,sha256=TMv2cks2O6026dZ0FGLcMGswCcKNjAFv4dSkRCnqxIw,14108
+hatchet_sdk/opentelemetry/instrumentor.py,sha256=1hbZsvbK_GiuzkL88P97G6lg0BRPCvyeR7ltfQT32DM,27099
 hatchet_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatchet_sdk/rate_limit.py,sha256=TwbCuggiZaWpYuo4mjVLlE-z1OfQ2mRBiVvCSaG3lv4,3919
 hatchet_sdk/runnables/action.py,sha256=-CJ1b0SnLdXvWH9HZhhoAmKO68WJRGRn7Y7vcLNr1NU,4396
@@ -275,7 +275,7 @@ hatchet_sdk/runnables/types.py,sha256=5jf1c7_0QVUFh0bcXi4hIiaOdUiyhspU4LltoAFCwl
 hatchet_sdk/runnables/workflow.py,sha256=lgN2z9or8E4jgHf6C31Kf1KsTa8_rEtE0AwIqGpNEH8,39926
 hatchet_sdk/token.py,sha256=KjIiInwG5Kqd_FO4BSW1x_5Uc7PFbnzIVJqr50-ZldE,779
 hatchet_sdk/utils/backoff.py,sha256=6B5Rb5nLKw_TqqgpJMYjIBV1PTTtbOMRZCveisVhg_I,353
-hatchet_sdk/utils/opentelemetry.py,sha256=EadD6jy6J_kTBqDukH5ufg7kJA_VF8LLKUd-NpSZoD8,626
+hatchet_sdk/utils/opentelemetry.py,sha256=64TVwCLrUzEmcL2BUNPV_QubfiR5jajOZtVeGYLnEEA,1226
 hatchet_sdk/utils/proto_enums.py,sha256=0UybwE3s7TcqmzoQSO8YnhgAKOS8WZXsyPchB8-eksw,1247
 hatchet_sdk/utils/timedelta_to_expression.py,sha256=kwuYZ51JdDdc3h9Sw4vgBFmJBMPkgbGJA4v9uO4_NGk,660
 hatchet_sdk/utils/typing.py,sha256=P6-Nd5K_Hk-VhEkGj6LYki_9ddw05rJtzRA56qGXHag,914
@@ -512,13 +512,13 @@ hatchet_sdk/v0/workflow.py,sha256=d4o425efk7J3JgLIge34MW_A3pzwnwSRtwEOgIqM2pc,93
 hatchet_sdk/v0/workflow_run.py,sha256=jsEZprXshrSV7i_TtL5uoCL03D18zQ3NeJCq7mp97Dg,1752
 hatchet_sdk/waits.py,sha256=L2xZUcmrQX-pTVXWv1W8suMoYU_eA0uowpollauQmOM,3893
 hatchet_sdk/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hatchet_sdk/worker/action_listener_process.py,sha256=6WLtKLn8dRikzHLWwkHkoMuEf18WTKbxwNoT5WlPOBk,11874
+hatchet_sdk/worker/action_listener_process.py,sha256=vGtiCqsHf82nU1_2NqgXPY2ZIwFqWcuZeeTkYG3rRTs,11977
 hatchet_sdk/worker/runner/run_loop_manager.py,sha256=E3KD1r0-BBKUWlZJMDo9e2HHl4uAyvL8gX42-JCRLLc,3794
 hatchet_sdk/worker/runner/runner.py,sha256=9Z3Ac6hRh5rjet7-BRtpcFARlhWvy6TNrdsdj61k_yk,18822
 hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=nHRPSiDBqzhObM7i2X7t03OupVFnE7kQBdR2Ckgg-2w,2709
 hatchet_sdk/worker/worker.py,sha256=SAucu3dg8lkKLbzb3noNWvClZ09lC5tuRcBkYZtIJ-0,16088
 hatchet_sdk/workflow_run.py,sha256=ZwH0HLFGFVXz6jbiqSv4w0Om2XuR52Tzzw6LH4y65jQ,2765
-hatchet_sdk-1.10.2.dist-info/METADATA,sha256=GDuCe5FAd2VC2rWKjkVr-QZbk9LSByY0r8YuQ13E1l8,3636
-hatchet_sdk-1.10.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-hatchet_sdk-1.10.2.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
-hatchet_sdk-1.10.2.dist-info/RECORD,,
+hatchet_sdk-1.11.0.dist-info/METADATA,sha256=tSwrycIOtpPhLXcIf2udhcgTFLZCJFBilNh1szdkdfs,3636
+hatchet_sdk-1.11.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+hatchet_sdk-1.11.0.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
+hatchet_sdk-1.11.0.dist-info/RECORD,,