zenml-nightly 0.84.0.dev20250727__tar.gz → 0.84.0.dev20250729__tar.gz

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zenml-nightly
-Version: 0.84.0.dev20250727
+Version: 0.84.0.dev20250729
 Summary: ZenML: Write production-ready ML code.
 License: Apache-2.0
 Keywords: machine learning,production,pipeline,mlops,devops

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zenml-nightly"
-version = "0.84.0.dev20250727"
+version = "0.84.0.dev20250729"
 packages = [{ include = "zenml", from = "src" }]
 description = "ZenML: Write production-ready ML code."
 authors = ["ZenML GmbH <info@zenml.io>"]

zenml_nightly-0.84.0.dev20250729/src/zenml/VERSION

@@ -0,0 +1 @@
+0.84.0.dev20250729

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/code_repositories/git/local_git_repository_context.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Implementation of the Local git repository context."""
 
-from typing import TYPE_CHECKING, Callable, Optional, cast
+from typing import TYPE_CHECKING, Callable, Optional
 
 from zenml.code_repositories import (
     LocalRepositoryContext,
@@ -25,7 +25,6 @@ from zenml.constants import (
 from zenml.logger import get_logger
 
 if TYPE_CHECKING:
-    from git.objects import Commit
     from git.remote import Remote
     from git.repo.base import Repo
 
@@ -180,7 +179,7 @@ class LocalGitRepositoryContext(LocalRepositoryContext):
             # Branch doesn't exist on remote
             return True
 
-        return cast("Commit", remote_commit_object) != local_commit_object
+        return remote_commit_object != local_commit_object
 
     @property
     def current_commit(self) -> str:
@@ -189,4 +188,4 @@ class LocalGitRepositoryContext(LocalRepositoryContext):
         Returns:
             The current commit sha.
         """
-        return cast(str, self.git_repo.head.object.hexsha)
+        return self.git_repo.head.object.hexsha

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/constants.py

@@ -181,6 +181,9 @@ ENV_ZENML_PIPELINE_RUN_API_TOKEN_EXPIRATION = (
 ENV_ZENML_CODE_REPOSITORY_IGNORE_UNTRACKED_FILES = (
     "ZENML_CODE_REPOSITORY_IGNORE_UNTRACKED_FILES"
 )
+# Environment variable that indicates whether the current environment is running
+# a step operator.
+ENV_ZENML_STEP_OPERATOR = "ZENML_STEP_OPERATOR"
 
 # Materializer environment variables
 ENV_ZENML_MATERIALIZER_ALLOW_NON_ASCII_JSON_DUMPS = (

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/integrations/azure/service_connectors/azure_service_connector.py

@@ -1490,7 +1490,8 @@ class AzureServiceConnector(ServiceConnector):
                 aks_clusters = [
                     cluster
                     for cluster in aks_clusters
-                    if self._get_resource_group(cluster.id)
+                    if cluster.id
+                    and self._get_resource_group(cluster.id)
                     == self.config.resource_group
                 ]
 
@@ -1507,7 +1508,8 @@ class AzureServiceConnector(ServiceConnector):
             clusters = [
                 (cluster.name, self._get_resource_group(cluster.id))
                 for cluster in aks_clusters
-                if cluster.name
+                if cluster.id
+                and cluster.name
                 and (not cluster_name or cluster.name == cluster_name)
             ]
 
@@ -1809,16 +1811,25 @@ class AzureServiceConnector(ServiceConnector):
             cluster_name, resource_group = clusters[0]
 
             try:
-                client = ContainerServiceClient(credential, subscription_id)
+                cs_client = ContainerServiceClient(credential, subscription_id)
 
-                creds = client.managed_clusters.list_cluster_admin_credentials(
-                    resource_group_name=resource_group,
-                    resource_name=cluster_name,
+                creds = (
+                    cs_client.managed_clusters.list_cluster_admin_credentials(
+                        resource_group_name=resource_group,
+                        resource_name=cluster_name,
+                    )
                 )
 
-                kubeconfig_yaml = creds.kubeconfigs[0].value.decode(
-                    encoding="UTF-8"
-                )
+                if creds.kubeconfigs and creds.kubeconfigs[0].value:
+                    kubeconfig_yaml = creds.kubeconfigs[0].value.decode(
+                        encoding="UTF-8"
+                    )
+                else:
+                    raise AuthorizationException(
+                        f"failed to list credentials for Azure Kubernetes "
+                        f"Service cluster '{cluster_name}' in resource group "
+                        f"'{resource_group}': no kubeconfig found"
+                    )
             except AzureError as e:
                 raise AuthorizationException(
                     f"failed to list credentials for Azure Kubernetes "

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/integrations/kubernetes/flavors/kubernetes_orchestrator_flavor.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Kubernetes orchestrator flavor."""
 
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type
 
 from pydantic import Field, NonNegativeInt, PositiveInt, field_validator
 
@@ -131,6 +131,25 @@ class KubernetesOrchestratorSettings(BaseSettings):
         "the chance of the server receiving the maximum amount of retry "
         "requests.",
     )
+    fail_on_container_waiting_reasons: Optional[List[str]] = Field(
+        default=[
+            "InvalidImageName",
+            "ErrImagePull",
+            "ImagePullBackOff",
+            "CreateContainerConfigError",
+        ],
+        description="List of container waiting reasons that should cause the "
+        "job to fail immediately. This should be set to a list of "
+        "nonrecoverable reasons, which if found in any "
+        "`pod.status.containerStatuses[*].state.waiting.reason` of a job pod, "
+        "should cause the job to fail immediately.",
+    )
+    job_monitoring_interval: int = Field(
+        default=3,
+        description="The interval in seconds to monitor the job. Each interval "
+        "is used to check for container issues and streaming logs for the "
+        "job pods.",
+    )
     pod_failure_policy: Optional[Dict[str, Any]] = Field(
         default=None,
         description="The pod failure policy to use for the job that is "

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/integrations/kubernetes/orchestrators/kube_utils.py

@@ -37,7 +37,7 @@ import json
 import re
 import time
 from collections import defaultdict
-from typing import Any, Callable, Dict, List, Optional, TypeVar, cast
+from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, cast
 
 from kubernetes import client as k8s_client
 from kubernetes import config as k8s_config
@@ -657,6 +657,50 @@ def create_job(
     )
 
 
+def get_container_status(
+    pod: k8s_client.V1Pod, container_name: str
+) -> Optional[k8s_client.V1ContainerState]:
+    """Get the status of a container.
+
+    Args:
+        pod: The pod to get the container status for.
+        container_name: The container name.
+
+    Returns:
+        The container status.
+    """
+    if not pod.status or not pod.status.container_statuses:
+        return None
+
+    for container_status in pod.status.container_statuses:
+        if container_status.name == container_name:
+            return container_status.state
+
+    return None
+
+
+def get_container_termination_reason(
+    pod: k8s_client.V1Pod, container_name: str
+) -> Optional[Tuple[int, str]]:
+    """Get the termination reason for a container.
+
+    Args:
+        pod: The pod to get the termination reason for.
+        container_name: The container name.
+
+    Returns:
+        The exit code and termination reason for the container.
+    """
+    container_state = get_container_status(pod, container_name)
+    if not container_state or not container_state.terminated:
+        return None
+
+    return (
+        container_state.terminated.exit_code,
+        container_state.terminated.reason or "Unknown",
+    )
+
+
 def wait_for_job_to_finish(
     batch_api: k8s_client.BatchV1Api,
     core_api: k8s_client.CoreV1Api,
@@ -665,8 +709,9 @@ def wait_for_job_to_finish(
     backoff_interval: float = 1,
     maximum_backoff: float = 32,
     exponential_backoff: bool = False,
-    container_name: Optional[str] = None,
+    fail_on_container_waiting_reasons: Optional[List[str]] = None,
     stream_logs: bool = True,
+    container_name: Optional[str] = None,
 ) -> None:
     """Wait for a job to finish.
 
@@ -679,6 +724,8 @@ def wait_for_job_to_finish(
         maximum_backoff: The maximum interval to wait between polling the job
             status.
         exponential_backoff: Whether to use exponential backoff.
+        fail_on_container_waiting_reasons: List of container waiting reasons
+            that will cause the job to fail.
         stream_logs: Whether to stream the job logs.
         container_name: Name of the container to stream logs from.
 
@@ -703,9 +750,39 @@ def wait_for_job_to_finish(
                         f"{condition.message}"
                     )
 
+        if fail_on_container_waiting_reasons:
+            pod_list: k8s_client.V1PodList = retry_on_api_exception(
+                core_api.list_namespaced_pod
+            )(
+                namespace=namespace,
+                label_selector=f"job-name={job_name}",
+                field_selector="status.phase=Pending",
+            )
+            for pod in pod_list.items:
+                container_state = get_container_status(
+                    pod, container_name or "main"
+                )
+
+                if (
+                    container_state
+                    and (waiting_state := container_state.waiting)
+                    and waiting_state.reason
+                    in fail_on_container_waiting_reasons
+                ):
+                    retry_on_api_exception(batch_api.delete_namespaced_job)(
+                        name=job_name,
+                        namespace=namespace,
+                        propagation_policy="Foreground",
+                    )
+                    raise RuntimeError(
+                        f"Job `{namespace}:{job_name}` failed: "
+                        f"Detected container in state "
+                        f"{waiting_state.reason}"
+                    )
+
         if stream_logs:
             try:
-                pod_list: k8s_client.V1PodList = core_api.list_namespaced_pod(
+                pod_list = core_api.list_namespaced_pod(
                     namespace=namespace,
                     label_selector=f"job-name={job_name}",
                 )

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -367,33 +367,37 @@ def main() -> None:
                     core_api=core_api,
                     namespace=namespace,
                     job_name=job_name,
+                    fail_on_container_waiting_reasons=settings.fail_on_container_waiting_reasons,
                     stream_logs=pipeline_settings.stream_step_logs,
+                    backoff_interval=settings.job_monitoring_interval,
                 )
 
                 logger.info(f"Job for step `{step_name}` completed.")
             except Exception:
-                reason = ""
+                reason = "Unknown"
                 try:
-                    pods_by_job = core_api.list_namespaced_pod(
+                    pods = core_api.list_namespaced_pod(
                         label_selector=f"job-name={job_name}",
                         namespace=namespace,
                     ).items
-                    first_pod = pods_by_job[0]
-                    if status := first_pod.status:
-                        if container_statuses := status.container_statuses:
-                            for cs in container_statuses:
-                                if cs.name == "main":
-                                    if state := cs.state:
-                                        if terminated := state.terminated:
-                                            if terminated.exit_code != 0:
-                                                reason = f"{terminated.reason}(exit_code={terminated.exit_code})"
-                                    break
+                    # Sort pods by creation timestamp, oldest first
+                    pods.sort(
+                        key=lambda pod: pod.metadata.creation_timestamp,
+                    )
+                    if pods:
+                        if (
+                            termination_reason
+                            := kube_utils.get_container_termination_reason(
+                                pods[-1], "main"
+                            )
+                        ):
+                            exit_code, reason = termination_reason
+                            if exit_code != 0:
+                                reason = f"{reason} (exit_code={exit_code})"
                 except Exception:
                     pass
                 logger.error(
                     f"Job for step `{step_name}` failed. Reason: {reason}"
-                    if reason
-                    else ""
                 )
 
                 raise

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/models/__init__.py

@@ -435,6 +435,7 @@ from zenml.models.v2.misc.info_models import (
     ServiceConnectorResourcesInfo,
     ResourcesInfo,
 )
+from zenml.models.v2.misc.exception_info import ExceptionInfo
 
 # ----------------------------- Forward References -----------------------------
 
@@ -840,4 +841,5 @@ __all__ = [
     "RunMetadataResource",
     "ProjectStatistics",
     "PipelineRunDAG",
+    "ExceptionInfo",
 ]

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/models/v2/core/step_run.py

@@ -48,6 +48,7 @@ from zenml.models.v2.base.scoped import (
 )
 from zenml.models.v2.core.artifact_version import ArtifactVersionResponse
 from zenml.models.v2.core.model_version import ModelVersionResponse
+from zenml.models.v2.misc.exception_info import ExceptionInfo
 
 if TYPE_CHECKING:
     from sqlalchemy.sql.elements import ColumnElement
@@ -143,6 +144,10 @@ class StepRunRequest(ProjectScopedRequest):
         title="Logs associated with this step run.",
         default=None,
     )
+    exception_info: Optional[ExceptionInfo] = Field(
+        default=None,
+        title="The exception information of the step run.",
+    )
 
     model_config = ConfigDict(protected_namespaces=())
 
@@ -169,6 +174,10 @@ class StepRunUpdate(BaseUpdate):
         title="The end time of the step run.",
         default=None,
     )
+    exception_info: Optional[ExceptionInfo] = Field(
+        default=None,
+        title="The exception information of the step run.",
+    )
     model_config = ConfigDict(protected_namespaces=())
 
 
@@ -237,6 +246,10 @@ class StepRunResponseMetadata(ProjectScopedResponseMetadata):
         default=None,
         max_length=TEXT_FIELD_MAX_LENGTH,
     )
+    exception_info: Optional[ExceptionInfo] = Field(
+        default=None,
+        title="The exception information of the step run.",
+    )
 
     # References
     logs: Optional["LogsResponse"] = Field(

zenml_nightly-0.84.0.dev20250729/src/zenml/models/v2/misc/exception_info.py

@@ -0,0 +1,30 @@
+#  Copyright (c) ZenML GmbH 2025. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Exception information models."""
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ExceptionInfo(BaseModel):
+    """Exception information."""
+
+    traceback: str = Field(
+        title="The traceback of the exception.",
+    )
+    step_code_line: Optional[int] = Field(
+        default=None,
+        title="The line number of the step code that raised the exception.",
+    )

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/orchestrators/publish_utils.py

@@ -13,12 +13,14 @@
 #  permissions and limitations under the License.
 """Utilities to publish pipeline and step runs."""
 
+from contextvars import ContextVar
 from datetime import datetime
 from typing import TYPE_CHECKING, Dict, List, Optional
 
 from zenml.client import Client
 from zenml.enums import ExecutionStatus, MetadataResourceTypes
 from zenml.models import (
+    ExceptionInfo,
     PipelineRunResponse,
     PipelineRunUpdate,
     RunMetadataResource,
@@ -32,6 +34,10 @@ if TYPE_CHECKING:
 
     from zenml.metadata.metadata_types import MetadataType
 
+step_exception_info: ContextVar[Optional[ExceptionInfo]] = ContextVar(
+    "step_exception_info", default=None
+)
+
 
 def publish_successful_step_run(
     step_run_id: "UUID", output_artifact_ids: Dict[str, List["UUID"]]
@@ -59,6 +65,7 @@ def publish_step_run_status_update(
     step_run_id: "UUID",
     status: "ExecutionStatus",
     end_time: Optional[datetime] = None,
+    exception_info: Optional[ExceptionInfo] = None,
 ) -> "StepRunResponse":
     """Publishes a step run update.
 
@@ -66,6 +73,7 @@ def publish_step_run_status_update(
         step_run_id: ID of the step run.
         status: New status of the step run.
         end_time: New end time of the step run.
+        exception_info: Exception information of the step run.
 
     Returns:
         The updated step run.
@@ -83,6 +91,7 @@ def publish_step_run_status_update(
         step_run_update=StepRunUpdate(
             status=status,
             end_time=end_time,
+            exception_info=exception_info,
         ),
     )
 
@@ -102,6 +111,7 @@ def publish_failed_step_run(step_run_id: "UUID") -> "StepRunResponse":
         step_run_id=step_run_id,
         status=ExecutionStatus.FAILED,
         end_time=utc_now(),
+        exception_info=step_exception_info.get(),
     )
 
 

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/orchestrators/step_launcher.py

@@ -24,6 +24,7 @@ from zenml.config.step_configurations import Step
 from zenml.config.step_run_info import StepRunInfo
 from zenml.constants import (
     ENV_ZENML_DISABLE_STEP_LOGS_STORAGE,
+    ENV_ZENML_STEP_OPERATOR,
     handle_bool_env_var,
 )
 from zenml.enums import ExecutionStatus
@@ -43,7 +44,7 @@ from zenml.orchestrators import output_utils, publish_utils, step_run_utils
 from zenml.orchestrators import utils as orchestrator_utils
 from zenml.orchestrators.step_runner import StepRunner
 from zenml.stack import Stack
-from zenml.utils import string_utils
+from zenml.utils import exception_utils, string_utils
 from zenml.utils.time_utils import utc_now
 
 if TYPE_CHECKING:
@@ -211,7 +212,9 @@ class StepLauncher:
 
         Raises:
             RunStoppedException: If the pipeline run is stopped by the user.
+            BaseException: If the step preparation or execution fails.
         """
+        publish_utils.step_exception_info.set(None)
         pipeline_run, run_was_created = self._create_or_reuse_run()
 
         # Enable or disable step logs storage
@@ -269,10 +272,13 @@ class StepLauncher:
 
             try:
                 request_factory.populate_request(request=step_run_request)
-            except:
+            except BaseException as e:
                 logger.exception(f"Failed preparing step `{self._step_name}`.")
                 step_run_request.status = ExecutionStatus.FAILED
                 step_run_request.end_time = utc_now()
+                step_run_request.exception_info = (
+                    exception_utils.collect_exception_information(e)
+                )
                 raise
             finally:
                 step_run = Client().zen_store.create_run_step(step_run_request)
@@ -453,6 +459,7 @@ class StepLauncher:
         environment = orchestrator_utils.get_config_environment_vars(
             pipeline_run_id=step_run_info.run_id,
         )
+        environment[ENV_ZENML_STEP_OPERATOR] = "True"
         logger.info(
             "Using step operator `%s` to run step `%s`.",
             step_operator.name,

{zenml_nightly-0.84.0.dev20250727 → zenml_nightly-0.84.0.dev20250729}/src/zenml/orchestrators/step_runner.py

@@ -16,6 +16,7 @@
 
 import copy
 import inspect
+import os
 from contextlib import nullcontext
 from typing import (
     TYPE_CHECKING,
@@ -34,6 +35,7 @@ from zenml.config.step_configurations import StepConfiguration
 from zenml.config.step_run_info import StepRunInfo
 from zenml.constants import (
     ENV_ZENML_DISABLE_STEP_LOGS_STORAGE,
+    ENV_ZENML_STEP_OPERATOR,
     handle_bool_env_var,
 )
 from zenml.enums import ArtifactSaveType
@@ -41,10 +43,14 @@ from zenml.exceptions import StepInterfaceError
 from zenml.logger import get_logger
 from zenml.logging.step_logging import PipelineLogsStorageContext, redirected
 from zenml.materializers.base_materializer import BaseMaterializer
-from zenml.models.v2.core.step_run import StepRunInputResponse
+from zenml.models.v2.core.step_run import (
+    StepRunInputResponse,
+    StepRunUpdate,
+)
 from zenml.orchestrators.publish_utils import (
     publish_step_run_metadata,
     publish_successful_step_run,
+    step_exception_info,
 )
 from zenml.orchestrators.utils import (
     is_setting_enabled,
@@ -56,6 +62,7 @@ from zenml.steps.utils import (
     resolve_type_annotation,
 )
 from zenml.utils import (
+    exception_utils,
     materializer_utils,
     source_utils,
     string_utils,
@@ -193,6 +200,24 @@ class StepRunner:
                 )
             except BaseException as step_exception:  # noqa: E722
                 step_failed = True
+
+                exception_info = exception_utils.collect_exception_information(
+                    step_exception, step_instance
+                )
+
+                if ENV_ZENML_STEP_OPERATOR in os.environ:
+                    # We're running in a step operator environment, so we can't
+                    # depend on the step launcher to publish the exception info
+                    Client().zen_store.update_run_step(
+                        step_run_id=step_run_info.step_run_id,
+                        step_run_update=StepRunUpdate(
+                            exception_info=exception_info,
+                        ),
+                    )
+                else:
+                    # This will be published by the step launcher
+                    step_exception_info.set(exception_info)
+
                 if not step_run.is_retriable:
                     if (
                         failure_hook_source

zenml_nightly-0.84.0.dev20250729/src/zenml/utils/exception_utils.py

@@ -0,0 +1,90 @@
+#  Copyright (c) ZenML GmbH 2025. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Exception utilities."""
+
+import inspect
+import os
+import re
+import traceback
+from typing import TYPE_CHECKING, Optional
+
+from zenml.constants import MEDIUMTEXT_MAX_LENGTH
+from zenml.logger import get_logger
+from zenml.models import (
+    ExceptionInfo,
+)
+
+if TYPE_CHECKING:
+    from zenml.steps import BaseStep
+
+logger = get_logger(__name__)
+
+
+def collect_exception_information(
+    exception: BaseException, step_instance: Optional["BaseStep"] = None
+) -> ExceptionInfo:
+    """Collects the exception information.
+
+    Args:
+        exception: The exception to collect information from.
+        step_instance: The step instance that is currently running.
+
+    Returns:
+        The exception information.
+    """
+    tb = traceback.format_tb(exception.__traceback__)
+    line_number = None
+    start_index = None
+
+    if step_instance and (
+        source_file := inspect.getsourcefile(step_instance.entrypoint)
+    ):
+        try:
+            source_file = os.path.abspath(source_file)
+
+            lines, start_line = inspect.getsourcelines(
+                step_instance.entrypoint
+            )
+            end_line = start_line + len(lines)
+
+            line_pattern = re.compile(f'File "{source_file}", line (\d+),')
+
+            for index, line in enumerate(tb):
+                match = line_pattern.search(line)
+                if match:
+                    potential_line_number = int(match.group(1))
+                    if (
+                        potential_line_number >= start_line
+                        and potential_line_number <= end_line
+                    ):
+                        line_number = potential_line_number - start_line
+                        start_index = index
+                        break
+        except Exception as e:
+            logger.debug("Failed to detect step code line: %s", e)
+
+    if start_index is not None:
+        # If the code failed while executing user code, we remove the initial
+        # part of the traceback that is happening in the ZenML code.
+        tb = tb[start_index:]
+
+    tb_bytes = "\n".join(tb).encode()
+    tb_bytes = tb_bytes[:MEDIUMTEXT_MAX_LENGTH]
+
+    return ExceptionInfo(
+        # Ignore errors when decoding in case we cut off in the middle of an
+        # encoded character.
+        traceback=tb_bytes.decode(errors="ignore"),
+        step_code_line=line_number,
+    )