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

hatchet_sdk/clients/admin.py

@@ -24,12 +24,6 @@ from hatchet_sdk.contracts.workflows_pb2 import (
 )
 from hatchet_sdk.contracts.workflows_pb2_grpc import WorkflowServiceStub
 from hatchet_sdk.utils.serialization import flatten
-from hatchet_sdk.utils.tracing import (
-    create_carrier,
-    create_tracer,
-    inject_carrier_into_metadata,
-    parse_carrier_from_metadata,
-)
 from hatchet_sdk.workflow_run import RunRef, WorkflowRunRef
 
 from ..loader import ClientConfig
@@ -95,7 +89,10 @@ class AdminClientBase:
                     else options["additional_metadata"]
                 )
                 if meta is not None:
-                    options["additional_metadata"] = json.dumps(meta).encode("utf-8")
+                    options = {
+                        **options,
+                        "additional_metadata": json.dumps(meta).encode("utf-8"),
+                    }
             except json.JSONDecodeError as e:
                 raise ValueError(f"Error encoding payload: {e}")
 
@@ -171,7 +168,6 @@ class AdminClientAioImpl(AdminClientBase):
         self.token = config.token
         self.listener_client = new_listener(config)
         self.namespace = config.namespace
-        self.otel_tracer = create_tracer(config=config)
 
     async def run(
         self,
@@ -190,74 +186,46 @@ class AdminClientAioImpl(AdminClientBase):
             wrr.workflow_run_id, wrr.workflow_listener, wrr.workflow_run_event_listener
         )
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     async def run_workflow(
         self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
     ) -> WorkflowRunRef:
-        ctx = parse_carrier_from_metadata(
-            (options or {}).get("additional_metadata", {})
-        )
+        try:
+            if not self.pooled_workflow_listener:
+                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        with self.otel_tracer.start_as_current_span(
-            f"hatchet.async_run_workflow.{workflow_name}", context=ctx
-        ) as span:
-            carrier = create_carrier()
+            namespace = self.namespace
 
-            try:
-                if not self.pooled_workflow_listener:
-                    self.pooled_workflow_listener = PooledWorkflowRunListener(
-                        self.config
-                    )
-
-                namespace = self.namespace
-
-                if (
-                    options is not None
-                    and "namespace" in options
-                    and options["namespace"] is not None
-                ):
-                    namespace = options.pop("namespace")
-
-                if namespace != "" and not workflow_name.startswith(self.namespace):
-                    workflow_name = f"{namespace}{workflow_name}"
-
-                if options is not None and "additional_metadata" in options:
-                    options["additional_metadata"] = inject_carrier_into_metadata(
-                        options["additional_metadata"], carrier
-                    )
-                    span.set_attributes(
-                        flatten(
-                            options["additional_metadata"], parent_key="", separator="."
-                        )
-                    )
-
-                request = self._prepare_workflow_request(workflow_name, input, options)
-
-                span.add_event(
-                    "Triggering workflow", attributes={"workflow_name": workflow_name}
-                )
+            if (
+                options is not None
+                and "namespace" in options
+                and options["namespace"] is not None
+            ):
+                namespace = options.pop("namespace")
 
-                resp: TriggerWorkflowResponse = await self.aio_client.TriggerWorkflow(
-                    request,
-                    metadata=get_metadata(self.token),
-                )
+            if namespace != "" and not workflow_name.startswith(self.namespace):
+                workflow_name = f"{namespace}{workflow_name}"
 
-                span.add_event(
-                    "Received workflow response",
-                    attributes={"workflow_name": workflow_name},
-                )
+            request = self._prepare_workflow_request(workflow_name, input, options)
 
-                return WorkflowRunRef(
-                    workflow_run_id=resp.workflow_run_id,
-                    workflow_listener=self.pooled_workflow_listener,
-                    workflow_run_event_listener=self.listener_client,
-                )
-            except (grpc.RpcError, grpc.aio.AioRpcError) as e:
-                if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                    raise DedupeViolationErr(e.details())
+            resp: TriggerWorkflowResponse = await self.aio_client.TriggerWorkflow(
+                request,
+                metadata=get_metadata(self.token),
+            )
 
-                raise e
+            return WorkflowRunRef(
+                workflow_run_id=resp.workflow_run_id,
+                workflow_listener=self.pooled_workflow_listener,
+                workflow_run_event_listener=self.listener_client,
+            )
+        except (grpc.RpcError, grpc.aio.AioRpcError) as e:
+            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
+                raise DedupeViolationErr(e.details())
+
+            raise e
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     async def run_workflows(
         self,
@@ -386,7 +354,6 @@ class AdminClient(AdminClientBase):
         self.token = config.token
         self.listener_client = new_listener(config)
         self.namespace = config.namespace
-        self.otel_tracer = create_tracer(config=config)
 
     @tenacity_retry
     def put_workflow(
@@ -456,78 +423,47 @@ class AdminClient(AdminClientBase):
 
             raise e
 
-    ## TODO: `options` is treated as a dict (wrong type hint)
-    ## TODO: `any` type hint should come from `typing`
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def run_workflow(
         self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
     ) -> WorkflowRunRef:
-        ctx = parse_carrier_from_metadata(
-            (options or {}).get("additional_metadata", {})
-        )
+        try:
+            if not self.pooled_workflow_listener:
+                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        with self.otel_tracer.start_as_current_span(
-            f"hatchet.run_workflow.{workflow_name}", context=ctx
-        ) as span:
-            carrier = create_carrier()
+            namespace = self.namespace
 
-            try:
-                if not self.pooled_workflow_listener:
-                    self.pooled_workflow_listener = PooledWorkflowRunListener(
-                        self.config
-                    )
-
-                namespace = self.namespace
-
-                ## TODO: Factor this out - it's repeated a lot of places
-                if (
-                    options is not None
-                    and "namespace" in options
-                    and options["namespace"] is not None
-                ):
-                    namespace = options.pop("namespace")
-
-                if options is not None and "additional_metadata" in options:
-                    options["additional_metadata"] = inject_carrier_into_metadata(
-                        options["additional_metadata"], carrier
-                    )
-
-                    span.set_attributes(
-                        flatten(
-                            options["additional_metadata"], parent_key="", separator="."
-                        )
-                    )
-
-                if namespace != "" and not workflow_name.startswith(self.namespace):
-                    workflow_name = f"{namespace}{workflow_name}"
-
-                request = self._prepare_workflow_request(workflow_name, input, options)
-
-                span.add_event(
-                    "Triggering workflow", attributes={"workflow_name": workflow_name}
-                )
+            ## TODO: Factor this out - it's repeated a lot of places
+            if (
+                options is not None
+                and "namespace" in options
+                and options["namespace"] is not None
+            ):
+                namespace = options.pop("namespace")
 
-                resp: TriggerWorkflowResponse = self.client.TriggerWorkflow(
-                    request,
-                    metadata=get_metadata(self.token),
-                )
+            if namespace != "" and not workflow_name.startswith(self.namespace):
+                workflow_name = f"{namespace}{workflow_name}"
 
-                span.add_event(
-                    "Received workflow response",
-                    attributes={"workflow_name": workflow_name},
-                )
+            request = self._prepare_workflow_request(workflow_name, input, options)
 
-                return WorkflowRunRef(
-                    workflow_run_id=resp.workflow_run_id,
-                    workflow_listener=self.pooled_workflow_listener,
-                    workflow_run_event_listener=self.listener_client,
-                )
-            except (grpc.RpcError, grpc.aio.AioRpcError) as e:
-                if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                    raise DedupeViolationErr(e.details())
+            resp: TriggerWorkflowResponse = self.client.TriggerWorkflow(
+                request,
+                metadata=get_metadata(self.token),
+            )
+
+            return WorkflowRunRef(
+                workflow_run_id=resp.workflow_run_id,
+                workflow_listener=self.pooled_workflow_listener,
+                workflow_run_event_listener=self.listener_client,
+            )
+        except (grpc.RpcError, grpc.aio.AioRpcError) as e:
+            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
+                raise DedupeViolationErr(e.details())
 
-                raise e
+            raise e
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def run_workflows(
         self, workflows: List[WorkflowRunDict], options: TriggerWorkflowOptions = None

hatchet_sdk/clients/dispatcher/action_listener.py

@@ -90,27 +90,24 @@ class Action:
             self.additional_metadata = {}
 
     @property
-    def otel_attributes(self) -> dict[str, Any]:
-        return flatten(
-            xs={
-                "worker_id": self.worker_id,
-                "tenant_id": self.tenant_id,
-                "workflow_run_id": self.workflow_run_id,
-                "get_group_key_run_id": self.get_group_key_run_id,
-                "job_id": self.job_id,
-                "job_name": self.job_name,
-                "job_run_id": self.job_run_id,
-                "step_id": self.step_id,
-                "step_run_id": self.step_run_id,
-                "retry_count": self.retry_count,
-                "child_workflow_index": self.child_workflow_index,
-                "child_workflow_key": self.child_workflow_key,
-                "parent_workflow_run_id": self.parent_workflow_run_id,
-                "action_payload": self.action_payload,
-            },
-            parent_key="",
-            separator=".",
-        )
+    def otel_attributes(self) -> dict[str, str | int]:
+        attrs: dict[str, str | int | None] = {
+            "hatchet.tenant_id": self.tenant_id,
+            "hatchet.worker_id": self.worker_id,
+            "hatchet.workflow_run_id": self.workflow_run_id,
+            "hatchet.step_id": self.step_id,
+            "hatchet.step_run_id": self.step_run_id,
+            "hatchet.retry_count": self.retry_count,
+            "hatchet.parent_workflow_run_id": self.parent_workflow_run_id,
+            "hatchet.child_workflow_index": self.child_workflow_index,
+            "hatchet.child_workflow_key": self.child_workflow_key,
+            "hatchet.action_payload": self.action_payload,
+            "hatchet.workflow_name": self.job_name,
+            "hatchet.action_name": self.action_id,
+            "hatchet.get_group_key_run_id": self.get_group_key_run_id,
+        }
+
+        return {k: v for k, v in attrs.items() if v}
 
 
 START_STEP_RUN = 0

hatchet_sdk/clients/events.py

@@ -17,12 +17,6 @@ from hatchet_sdk.contracts.events_pb2 import (
 )
 from hatchet_sdk.contracts.events_pb2_grpc import EventsServiceStub
 from hatchet_sdk.utils.serialization import flatten
-from hatchet_sdk.utils.tracing import (
-    create_carrier,
-    create_tracer,
-    inject_carrier_into_metadata,
-    parse_carrier_from_metadata,
-)
 
 from ..loader import ClientConfig
 from ..metadata import get_metadata
@@ -63,7 +57,6 @@ class EventClient:
         self.client = client
         self.token = config.token
         self.namespace = config.namespace
-        self.otel_tracer = create_tracer(config=config)
 
     async def async_push(
         self, event_key, payload, options: Optional[PushEventOptions] = None
@@ -79,54 +72,41 @@ class EventClient:
     ) -> List[Event]:
         return await asyncio.to_thread(self.bulk_push, events=events, options=options)
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def push(self, event_key, payload, options: PushEventOptions = None) -> Event:
-        ctx = parse_carrier_from_metadata(
-            (options or {}).get("additional_metadata", {})
-        )
-
-        with self.otel_tracer.start_as_current_span(
-            "hatchet.push", context=ctx
-        ) as span:
-            carrier = create_carrier()
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options.pop("namespace")
-
-            namespaced_event_key = namespace + event_key
-
-            try:
-                meta = inject_carrier_into_metadata(
-                    dict() if options is None else options["additional_metadata"],
-                    carrier,
-                )
-                meta_bytes = None if meta is None else json.dumps(meta).encode("utf-8")
-            except Exception as e:
-                raise ValueError(f"Error encoding meta: {e}")
+        namespace = self.namespace
 
-            span.set_attributes(flatten(meta, parent_key="", separator="."))
+        if (
+            options is not None
+            and "namespace" in options
+            and options["namespace"] is not None
+        ):
+            namespace = options.pop("namespace")
 
-            try:
-                payload_bytes = json.dumps(payload).encode("utf-8")
-            except json.UnicodeEncodeError as e:
-                raise ValueError(f"Error encoding payload: {e}")
+        namespaced_event_key = namespace + event_key
 
-            request = PushEventRequest(
-                key=namespaced_event_key,
-                payload=payload_bytes,
-                eventTimestamp=proto_timestamp_now(),
-                additionalMetadata=meta_bytes,
-            )
+        try:
+            meta = dict() if options is None else options["additional_metadata"]
+            meta_bytes = None if meta is None else json.dumps(meta).encode("utf-8")
+        except Exception as e:
+            raise ValueError(f"Error encoding meta: {e}")
 
-            span.add_event("Pushing event", attributes={"key": namespaced_event_key})
+        try:
+            payload_bytes = json.dumps(payload).encode("utf-8")
+        except json.UnicodeEncodeError as e:
+            raise ValueError(f"Error encoding payload: {e}")
+
+        request = PushEventRequest(
+            key=namespaced_event_key,
+            payload=payload_bytes,
+            eventTimestamp=proto_timestamp_now(),
+            additionalMetadata=meta_bytes,
+        )
 
-            return self.client.Push(request, metadata=get_metadata(self.token))
+        return self.client.Push(request, metadata=get_metadata(self.token))
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def bulk_push(
         self,
@@ -134,10 +114,6 @@ class EventClient:
         options: BulkPushEventOptions = None,
     ) -> List[Event]:
         namespace = self.namespace
-        bulk_push_correlation_id = uuid4()
-        ctx = parse_carrier_from_metadata(
-            (options or {}).get("additional_metadata", {})
-        )
 
         if (
             options is not None
@@ -148,43 +124,30 @@ class EventClient:
 
         bulk_events = []
         for event in events:
-            with self.otel_tracer.start_as_current_span(
-                "hatchet.bulk_push", context=ctx
-            ) as span:
-                carrier = create_carrier()
-                span.set_attribute(
-                    "bulk_push_correlation_id", str(bulk_push_correlation_id)
-                )
-
-                event_key = namespace + event["key"]
-                payload = event["payload"]
-
-                try:
-                    meta = inject_carrier_into_metadata(
-                        event.get("additional_metadata", {}), carrier
-                    )
-                    meta_bytes = json.dumps(meta).encode("utf-8") if meta else None
-                except Exception as e:
-                    raise ValueError(f"Error encoding meta: {e}")
-
-                span.set_attributes(flatten(meta, parent_key="", separator="."))
-
-                try:
-                    payload_bytes = json.dumps(payload).encode("utf-8")
-                except json.UnicodeEncodeError as e:
-                    raise ValueError(f"Error encoding payload: {e}")
-
-                request = PushEventRequest(
-                    key=event_key,
-                    payload=payload_bytes,
-                    eventTimestamp=proto_timestamp_now(),
-                    additionalMetadata=meta_bytes,
-                )
-                bulk_events.append(request)
+            event_key = namespace + event["key"]
+            payload = event["payload"]
+
+            try:
+                meta = event.get("additional_metadata", {})
+                meta_bytes = json.dumps(meta).encode("utf-8") if meta else None
+            except Exception as e:
+                raise ValueError(f"Error encoding meta: {e}")
+
+            try:
+                payload_bytes = json.dumps(payload).encode("utf-8")
+            except json.UnicodeEncodeError as e:
+                raise ValueError(f"Error encoding payload: {e}")
+
+            request = PushEventRequest(
+                key=event_key,
+                payload=payload_bytes,
+                eventTimestamp=proto_timestamp_now(),
+                additionalMetadata=meta_bytes,
+            )
+            bulk_events.append(request)
 
         bulk_request = BulkPushEventRequest(events=bulk_events)
 
-        span.add_event("Pushing bulk events")
         response = self.client.BulkPush(bulk_request, metadata=get_metadata(self.token))
 
         return response.events

hatchet_sdk/loader.py

@@ -1,7 +1,7 @@
-import json
 import os
 from logging import Logger, getLogger
 from typing import Dict, Optional
+from warnings import warn
 
 import yaml
 
@@ -39,10 +39,6 @@ class ClientConfig:
         logger: Logger = None,
         grpc_max_recv_message_length: int = 4 * 1024 * 1024,  # 4MB
         grpc_max_send_message_length: int = 4 * 1024 * 1024,  # 4MB
-        otel_exporter_oltp_endpoint: str | None = None,
-        otel_service_name: str | None = None,
-        otel_exporter_oltp_headers: dict[str, str] | None = None,
-        otel_exporter_oltp_protocol: str | None = None,
         worker_healthcheck_port: int | None = None,
         worker_healthcheck_enabled: bool | None = None,
         worker_preset_labels: dict[str, str] = {},
@@ -56,10 +52,6 @@ class ClientConfig:
         self.logInterceptor = logger
         self.grpc_max_recv_message_length = grpc_max_recv_message_length
         self.grpc_max_send_message_length = grpc_max_send_message_length
-        self.otel_exporter_oltp_endpoint = otel_exporter_oltp_endpoint
-        self.otel_service_name = otel_service_name
-        self.otel_exporter_oltp_headers = otel_exporter_oltp_headers
-        self.otel_exporter_oltp_protocol = otel_exporter_oltp_protocol
         self.worker_healthcheck_port = worker_healthcheck_port
         self.worker_healthcheck_enabled = worker_healthcheck_enabled
         self.worker_preset_labels = worker_preset_labels
@@ -142,33 +134,6 @@ class ConfigLoader:
 
         tls_config = self._load_tls_config(config_data["tls"], host_port)
 
-        otel_exporter_oltp_endpoint = get_config_value(
-            "otel_exporter_oltp_endpoint", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_ENDPOINT"
-        )
-
-        otel_service_name = get_config_value(
-            "otel_service_name", "HATCHET_CLIENT_OTEL_SERVICE_NAME"
-        )
-
-        _oltp_headers = get_config_value(
-            "otel_exporter_oltp_headers", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_HEADERS"
-        )
-
-        if _oltp_headers:
-            try:
-                otel_header_key, api_key = _oltp_headers.split("=", maxsplit=1)
-                otel_exporter_oltp_headers = {otel_header_key: api_key}
-            except ValueError:
-                raise ValueError(
-                    "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_HEADERS must be in the format `key=value`"
-                )
-        else:
-            otel_exporter_oltp_headers = None
-
-        otel_exporter_oltp_protocol = get_config_value(
-            "otel_exporter_oltp_protocol", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_PROTOCOL"
-        )
-
         worker_healthcheck_port = int(
             get_config_value(
                 "worker_healthcheck_port", "HATCHET_CLIENT_WORKER_HEALTHCHECK_PORT"
@@ -196,6 +161,19 @@ class ConfigLoader:
         if autoscaling_target:
             worker_preset_labels["hatchet-autoscaling-target"] = autoscaling_target
 
+        legacy_otlp_headers = get_config_value(
+            "otel_exporter_otlp_endpoint", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_ENDPOINT"
+        )
+
+        legacy_otlp_headers = get_config_value(
+            "otel_exporter_otlp_headers", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_HEADERS"
+        )
+
+        if legacy_otlp_headers or legacy_otlp_headers:
+            warn(
+                "The `otel_exporter_otlp_*` fields are no longer supported as of SDK version `0.46.0`. Please see the documentation on OpenTelemetry at https://docs.hatchet.run/home/features/opentelemetry for more information on how to migrate to the new `HatchetInstrumentor`."
+            )
+
         return ClientConfig(
             tenant_id=tenant_id,
             tls_config=tls_config,
@@ -207,10 +185,6 @@ class ConfigLoader:
             logger=defaults.logInterceptor,
             grpc_max_recv_message_length=grpc_max_recv_message_length,
             grpc_max_send_message_length=grpc_max_send_message_length,
-            otel_exporter_oltp_endpoint=otel_exporter_oltp_endpoint,
-            otel_service_name=otel_service_name,
-            otel_exporter_oltp_headers=otel_exporter_oltp_headers,
-            otel_exporter_oltp_protocol=otel_exporter_oltp_protocol,
             worker_healthcheck_port=worker_healthcheck_port,
             worker_healthcheck_enabled=worker_healthcheck_enabled,
             worker_preset_labels=worker_preset_labels,