hatchet-sdk 1.19.0__py3-none-any.whl → 1.20.1__py3-none-any.whl

hatchet_sdk/clients/rest/models/update_cron_workflow_trigger_request.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, StrictBool
+from typing_extensions import Self
+
+
+class UpdateCronWorkflowTriggerRequest(BaseModel):
+    """
+    UpdateCronWorkflowTriggerRequest
+    """  # noqa: E501
+
+    enabled: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["enabled"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UpdateCronWorkflowTriggerRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateCronWorkflowTriggerRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"enabled": obj.get("enabled")})
+        return _obj

hatchet_sdk/clients/rest/models/update_tenant_member_request.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
+
+from hatchet_sdk.clients.rest.models.tenant_member_role import TenantMemberRole
+
+
+class UpdateTenantMemberRequest(BaseModel):
+    """
+    UpdateTenantMemberRequest
+    """  # noqa: E501
+
+    role: TenantMemberRole = Field(description="The role of the user in the tenant.")
+    __properties: ClassVar[List[str]] = ["role"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UpdateTenantMemberRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateTenantMemberRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"role": obj.get("role")})
+        return _obj

hatchet_sdk/clients/rest/models/v1_filter.py

@@ -19,7 +19,7 @@ import pprint
 import re  # noqa: F401
 from typing import Any, ClassVar, Dict, List, Optional, Set
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing_extensions import Annotated, Self
 
 from hatchet_sdk.clients.rest.models.api_resource_meta import APIResourceMeta
@@ -50,6 +50,11 @@ class V1Filter(BaseModel):
     payload: Dict[str, Any] = Field(
         description="Additional payload data associated with the filter"
     )
+    is_declarative: Optional[StrictBool] = Field(
+        default=None,
+        description="Whether the filter is declarative (true) or programmatic (false)",
+        alias="isDeclarative",
+    )
     __properties: ClassVar[List[str]] = [
         "metadata",
         "tenantId",
@@ -57,6 +62,7 @@ class V1Filter(BaseModel):
         "scope",
         "expression",
         "payload",
+        "isDeclarative",
     ]
 
     model_config = ConfigDict(
@@ -122,6 +128,7 @@ class V1Filter(BaseModel):
                 "scope": obj.get("scope"),
                 "expression": obj.get("expression"),
                 "payload": obj.get("payload"),
+                "isDeclarative": obj.get("isDeclarative"),
             }
         )
         return _obj

hatchet_sdk/clients/rest/models/v1_update_webhook_request.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing_extensions import Self
+
+
+class V1UpdateWebhookRequest(BaseModel):
+    """
+    V1UpdateWebhookRequest
+    """  # noqa: E501
+
+    event_key_expression: StrictStr = Field(
+        description="The CEL expression to use for the event key. This is used to create the event key from the webhook payload.",
+        alias="eventKeyExpression",
+    )
+    __properties: ClassVar[List[str]] = ["eventKeyExpression"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1UpdateWebhookRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1UpdateWebhookRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"eventKeyExpression": obj.get("eventKeyExpression")})
+        return _obj

hatchet_sdk/clients/rest/models/v1_webhook_source_name.py

@@ -31,6 +31,8 @@ class V1WebhookSourceName(str, Enum):
     GENERIC = "GENERIC"
     GITHUB = "GITHUB"
     STRIPE = "STRIPE"
+    SLACK = "SLACK"
+    LINEAR = "LINEAR"
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:

hatchet_sdk/clients/rest/models/worker.py

@@ -25,6 +25,7 @@ from typing_extensions import Annotated, Self
 
 from hatchet_sdk.clients.rest.models.api_resource_meta import APIResourceMeta
 from hatchet_sdk.clients.rest.models.recent_step_runs import RecentStepRuns
+from hatchet_sdk.clients.rest.models.registered_workflow import RegisteredWorkflow
 from hatchet_sdk.clients.rest.models.semaphore_slots import SemaphoreSlots
 from hatchet_sdk.clients.rest.models.worker_label import WorkerLabel
 from hatchet_sdk.clients.rest.models.worker_runtime_info import WorkerRuntimeInfo
@@ -52,6 +53,11 @@ class Worker(BaseModel):
     actions: Optional[List[StrictStr]] = Field(
         default=None, description="The actions this worker can perform."
     )
+    registered_workflows: Optional[List[RegisteredWorkflow]] = Field(
+        default=None,
+        description="The workflow ids registered on this worker.",
+        alias="registeredWorkflows",
+    )
     slots: Optional[List[SemaphoreSlots]] = Field(
         default=None, description="The semaphore slot state for the worker."
     )
@@ -97,6 +103,7 @@ class Worker(BaseModel):
         "lastHeartbeatAt",
         "lastListenerEstablished",
         "actions",
+        "registeredWorkflows",
         "slots",
         "recentStepRuns",
         "status",
@@ -161,6 +168,13 @@ class Worker(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of metadata
         if self.metadata:
             _dict["metadata"] = self.metadata.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in registered_workflows (list)
+        _items = []
+        if self.registered_workflows:
+            for _item_registered_workflows in self.registered_workflows:
+                if _item_registered_workflows:
+                    _items.append(_item_registered_workflows.to_dict())
+            _dict["registeredWorkflows"] = _items
         # override the default output from pydantic by calling `to_dict()` of each item in slots (list)
         _items = []
         if self.slots:
@@ -208,6 +222,14 @@ class Worker(BaseModel):
                 "lastHeartbeatAt": obj.get("lastHeartbeatAt"),
                 "lastListenerEstablished": obj.get("lastListenerEstablished"),
                 "actions": obj.get("actions"),
+                "registeredWorkflows": (
+                    [
+                        RegisteredWorkflow.from_dict(_item)
+                        for _item in obj["registeredWorkflows"]
+                    ]
+                    if obj.get("registeredWorkflows") is not None
+                    else None
+                ),
                 "slots": (
                     [SemaphoreSlots.from_dict(_item) for _item in obj["slots"]]
                     if obj.get("slots") is not None

hatchet_sdk/features/runs.py

@@ -1,4 +1,5 @@
 import asyncio
+import time
 from collections.abc import AsyncIterator
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Literal, overload
@@ -32,6 +33,7 @@ from hatchet_sdk.clients.v1.api_client import (
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.utils.aio import gather_max_concurrency
 from hatchet_sdk.utils.datetimes import partition_date_range
+from hatchet_sdk.utils.iterables import create_chunks
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
 if TYPE_CHECKING:
@@ -179,6 +181,216 @@ class RunsClient(BaseRestClient):
         """
         return await asyncio.to_thread(self.get_status, workflow_run_id)
 
+    def _perform_action_with_pagination(
+        self,
+        action: Literal["cancel", "replay"],
+        statuses: list[V1TaskStatus],
+        sleep_time: int = 3,
+        chunk_size: int = 500,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+    ) -> None:
+        """
+        Perform a bulk action (cancel or replay) on runs matching the specified filters in chunks.
+
+        The motivation for this method is to provide an easy way to perform bulk operations by filters over a larger number of runs than
+        the API would normally be able to handle, with automatic pagination and chunking to help limit the pressure on the API.
+
+        This method first pulls the IDs of the runs from the API, and then feeds them back to the API in chunks.
+
+        :param action: The action to perform, either "cancel" or "replay".
+        :param statuses: The statuses to filter runs by.
+        :param sleep_time: The time to sleep between processing chunks, in seconds.
+        :param chunk_size: The maximum number of run IDs to process in each chunk.
+        :param since: The start time for filtering runs.
+        :param until: The end time for filtering runs.
+        :param additional_metadata: Additional metadata to filter runs by.
+        :param workflow_ids: The workflow IDs to filter runs by.
+        """
+        until = until or datetime.now(tz=timezone.utc)
+        since = since or (until - timedelta(days=1))
+
+        with self.client() as client:
+            external_ids = self._wra(client).v1_workflow_run_external_ids_list(
+                tenant=self.client_config.tenant_id,
+                since=since,
+                until=until,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                statuses=statuses,
+                workflow_ids=workflow_ids,
+            )
+
+        chunks = list(create_chunks(external_ids, chunk_size))
+        func = self.bulk_cancel if action == "cancel" else self.bulk_replay
+
+        for ix, chunk in enumerate(chunks):
+            self.client_config.logger.info(
+                f"processing chunk {ix + 1}/{len(chunks)} of {len(chunk)} ids"  # noqa: G004
+            )
+
+            opts = BulkCancelReplayOpts(ids=chunk)
+            func(opts=opts)
+
+            time.sleep(sleep_time)
+
+    def bulk_replay_by_filters_with_pagination(
+        self,
+        sleep_time: int = 3,
+        chunk_size: int = 500,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+    ) -> None:
+        """
+        Replay runs matching the specified filters in chunks.
+
+        The motivation for this method is to provide an easy way to perform bulk operations by filters over a larger number of runs than
+        the API would normally be able to handle, with automatic pagination and chunking to help limit the pressure on the API.
+
+        This method first pulls the IDs of the runs from the API, and then feeds them back to the API in chunks.
+
+        :param sleep_time: The time to sleep between processing chunks, in seconds.
+        :param chunk_size: The maximum number of run IDs to process in each chunk.
+        :param since: The start time for filtering runs.
+        :param until: The end time for filtering runs.
+        :param statuses: The statuses to filter runs by.
+        :param additional_metadata: Additional metadata to filter runs by.
+        :param workflow_ids: The workflow IDs to filter runs by.
+        """
+
+        self._perform_action_with_pagination(
+            since=since,
+            action="replay",
+            sleep_time=sleep_time,
+            chunk_size=chunk_size,
+            until=until,
+            statuses=statuses or [V1TaskStatus.FAILED, V1TaskStatus.CANCELLED],
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+        )
+
+    def bulk_cancel_by_filters_with_pagination(
+        self,
+        sleep_time: int = 3,
+        chunk_size: int = 500,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+    ) -> None:
+        """
+        Cancel runs matching the specified filters in chunks.
+
+        The motivation for this method is to provide an easy way to perform bulk operations by filters over a larger number of runs than
+        the API would normally be able to handle, with automatic pagination and chunking to help limit the pressure on the API.
+
+        This method first pulls the IDs of the runs from the API, and then feeds them back to the API in chunks.
+
+        :param sleep_time: The time to sleep between processing chunks, in seconds.
+        :param chunk_size: The maximum number of run IDs to process in each chunk.
+        :param since: The start time for filtering runs.
+        :param until: The end time for filtering runs.
+        :param statuses: The statuses to filter runs by.
+        :param additional_metadata: Additional metadata to filter runs by.
+        :param workflow_ids: The workflow IDs to filter runs by.
+        """
+
+        self._perform_action_with_pagination(
+            since=since,
+            action="cancel",
+            sleep_time=sleep_time,
+            chunk_size=chunk_size,
+            until=until,
+            statuses=statuses or [V1TaskStatus.RUNNING, V1TaskStatus.QUEUED],
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+        )
+
+    async def aio_bulk_replay_by_filters_with_pagination(
+        self,
+        sleep_time: int = 3,
+        chunk_size: int = 500,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+    ) -> None:
+        """
+        Replay runs matching the specified filters in chunks.
+
+        The motivation for this method is to provide an easy way to perform bulk operations by filters over a larger number of runs than
+        the API would normally be able to handle, with automatic pagination and chunking to help limit the pressure on the API.
+
+        This method first pulls the IDs of the runs from the API, and then feeds them back to the API in chunks.
+
+        :param sleep_time: The time to sleep between processing chunks, in seconds.
+        :param chunk_size: The maximum number of run IDs to process in each chunk.
+        :param since: The start time for filtering runs.
+        :param until: The end time for filtering runs.
+        :param statuses: The statuses to filter runs by.
+        :param additional_metadata: Additional metadata to filter runs by.
+        :param workflow_ids: The workflow IDs to filter runs by.
+        """
+
+        await asyncio.to_thread(
+            self._perform_action_with_pagination,
+            since=since,
+            action="replay",
+            sleep_time=sleep_time,
+            chunk_size=chunk_size,
+            until=until,
+            statuses=statuses or [V1TaskStatus.FAILED, V1TaskStatus.CANCELLED],
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+        )
+
+    async def aio_bulk_cancel_by_filters_with_pagination(
+        self,
+        sleep_time: int = 3,
+        chunk_size: int = 500,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+    ) -> None:
+        """
+        Cancel runs matching the specified filters in chunks.
+
+        The motivation for this method is to provide an easy way to perform bulk operations by filters over a larger number of runs than
+        the API would normally be able to handle, with automatic pagination and chunking to help limit the pressure on the API.
+
+        This method first pulls the IDs of the runs from the API, and then feeds them back to the API in chunks.
+
+        :param sleep_time: The time to sleep between processing chunks, in seconds.
+        :param chunk_size: The maximum number of run IDs to process in each chunk.
+        :param since: The start time for filtering runs.
+        :param until: The end time for filtering runs.
+        :param statuses: The statuses to filter runs by.
+        :param additional_metadata: Additional metadata to filter runs by.
+        :param workflow_ids: The workflow IDs to filter runs by.
+        """
+
+        await asyncio.to_thread(
+            self._perform_action_with_pagination,
+            since=since,
+            action="cancel",
+            sleep_time=sleep_time,
+            chunk_size=chunk_size,
+            until=until,
+            statuses=statuses or [V1TaskStatus.RUNNING, V1TaskStatus.QUEUED],
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+        )
+
     @retry
     def list_with_pagination(
         self,

hatchet_sdk/hatchet.py

@@ -2,7 +2,6 @@ import asyncio
 import logging
 from collections.abc import Callable
 from datetime import timedelta
-from functools import cached_property
 from typing import Any, Concatenate, ParamSpec, cast, overload
 
 from hatchet_sdk import Context, DurableContext
@@ -10,7 +9,6 @@ from hatchet_sdk.client import Client
 from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
 from hatchet_sdk.clients.events import EventClient
 from hatchet_sdk.clients.listeners.run_event_listener import RunEventListenerClient
-from hatchet_sdk.clients.rest.models.tenant_version import TenantVersion
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.features.cel import CELClient
 from hatchet_sdk.features.cron import CronClient
@@ -65,11 +63,6 @@ class Hatchet:
             client if client else Client(config=config or ClientConfig(), debug=debug)
         )
 
-        if self.tenant_engine_version != TenantVersion.V1:
-            logger.warning(
-                "🚨⚠️‼️ YOU ARE USING A V0 ENGINE WITH A V1 SDK, WHICH IS NOT SUPPORTED. PLEASE UPGRADE YOUR ENGINE TO V1.🚨⚠️‼️"
-            )
-
     @property
     def cel(self) -> CELClient:
         """
@@ -179,19 +172,6 @@ class Hatchet:
         """
         return self._client.config.namespace
 
-    @cached_property
-    def tenant_engine_version(self) -> TenantVersion:
-        """
-        Get the version of the Hatchet engine running in your tenant.
-        """
-        try:
-            return self._client.tenant.get().version
-        except Exception:
-            ## Nothing we can do here - if this fails, it's probably
-            ## because they don't have this endpoint yet, so we need to just
-            ## assume V1 to swallow the warning.
-            return TenantVersion.V1
-
     def worker(
         self,
         name: str,

hatchet_sdk/opentelemetry/instrumentor.py

@@ -216,11 +216,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             "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",
@@ -310,27 +306,6 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
 
             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.get_otel_attributes(self.config),
-        ) 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,
@@ -719,7 +694,6 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         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")