ddeutil-workflow 0.0.73__py3-none-any.whl → 0.0.74__py3-none-any.whl

ddeutil/workflow/workflow.py

@@ -3,14 +3,25 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""Workflow module is the core module of this package. It keeps Release,
-ReleaseQueue, and Workflow models.
+"""Workflow Core Module.
 
-    This package implement timeout strategy on the workflow execution layer only
-because the main propose of this package is using Workflow to be orchestrator.
-"""
-from __future__ import annotations
+This module contains the core workflow orchestration functionality, including
+the Workflow model, release management, and workflow execution strategies.
+
+The workflow system implements timeout strategy at the workflow execution layer
+because the main purpose is to use Workflow as an orchestrator for complex
+job execution scenarios.
 
+Classes:
+    Workflow: Main workflow orchestration class
+    ReleaseType: Enumeration for different release types
+
+Constants:
+    NORMAL: Normal release execution
+    RERUN: Re-execution of failed workflows
+    EVENT: Event-triggered execution
+    FORCE: Force execution regardless of conditions
+"""
 import copy
 import time
 from concurrent.futures import (
@@ -23,20 +34,19 @@ from enum import Enum
 from pathlib import Path
 from queue import Queue
 from textwrap import dedent
-from threading import Event
-from typing import Any, Optional
+from threading import Event as ThreadEvent
+from typing import Any, Optional, Union
 from zoneinfo import ZoneInfo
 
 from pydantic import BaseModel, Field
 from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
-from . import get_status_from_error
 from .__types import DictData
-from .audits import Audit, get_audit
+from .audits import Audit, get_audit_model
 from .conf import YamlParser, dynamic
 from .errors import WorkflowCancelError, WorkflowError, WorkflowTimeoutError
-from .event import Crontab
+from .event import Event
 from .job import Job
 from .params import Param
 from .result import (
@@ -47,17 +57,31 @@ from .result import (
     WAIT,
     Result,
     Status,
+    catch,
+    get_status_from_error,
     validate_statuses,
 )
 from .reusables import has_template, param2template
+from .traces import Trace, get_trace
 from .utils import (
     gen_id,
+    get_dt_ntz_now,
     replace_sec,
 )
 
 
 class ReleaseType(str, Enum):
-    """Release Type Enum."""
+    """Release type enumeration for workflow execution modes.
+
+    This enum defines the different types of workflow releases that can be
+    triggered, each with specific behavior and use cases.
+
+    Attributes:
+        NORMAL: Standard workflow release execution
+        RERUN: Re-execution of previously failed workflow
+        EVENT: Event-triggered workflow execution
+        FORCE: Forced execution bypassing normal conditions
+    """
 
     NORMAL = "normal"
     RERUN = "rerun"
@@ -72,19 +96,43 @@ FORCE = ReleaseType.FORCE
 
 
 class Workflow(BaseModel):
-    """Workflow model that use to keep the `Job` and `Crontab` models.
-
-        This is the main future of this project because it uses to be workflow
-    data for running everywhere that you want or using it to scheduler task in
-    background. It uses lightweight coding line from Pydantic Model and enhance
-    execute method on it.
+    """Main workflow orchestration model for job and schedule management.
+
+    The Workflow class is the core component of the workflow orchestration system.
+    It manages job execution, scheduling via cron expressions, parameter handling,
+    and provides comprehensive execution capabilities for complex workflows.
+
+    This class extends Pydantic BaseModel to provide robust data validation and
+    serialization while maintaining lightweight performance characteristics.
+
+    Attributes:
+        extras (dict): Extra parameters for overriding configuration values
+        name (str): Unique workflow identifier
+        desc (str, optional): Workflow description supporting markdown content
+        params (dict[str, Param]): Parameter definitions for the workflow
+        on (list[Crontab]): Schedule definitions using cron expressions
+        jobs (dict[str, Job]): Collection of jobs within this workflow
+
+    Example:
+        Create and execute a workflow:
+
+        ```python
+        workflow = Workflow.from_conf('my-workflow')
+        result = workflow.execute({
+            'param1': 'value1',
+            'param2': 'value2'
+        })
+        ```
+
+    Note:
+        Workflows can be executed immediately or scheduled for background
+        execution using the cron-like scheduling system.
     """
 
     extras: DictData = Field(
         default_factory=dict,
         description="An extra parameters that want to override config values.",
     )
-
     name: str = Field(description="A workflow name.")
     desc: Optional[str] = Field(
         default=None,
@@ -96,14 +144,28 @@ class Workflow(BaseModel):
         default_factory=dict,
         description="A parameters that need to use on this workflow.",
     )
-    on: list[Crontab] = Field(
+    on: Event = Field(
         default_factory=list,
-        description="A list of Crontab instance for this workflow schedule.",
+        description="An events for this workflow.",
     )
     jobs: dict[str, Job] = Field(
         default_factory=dict,
         description="A mapping of job ID and job model that already loaded.",
     )
+    created_at: datetime = Field(
+        default_factory=get_dt_ntz_now,
+        description=(
+            "A created datetime of this workflow template when loading from "
+            "file."
+        ),
+    )
+    updated_dt: datetime = Field(
+        default_factory=get_dt_ntz_now,
+        description=(
+            "A updated datetime of this workflow template when loading from "
+            "file."
+        ),
+    )
 
     @classmethod
     def from_conf(
@@ -111,20 +173,38 @@ class Workflow(BaseModel):
         name: str,
         *,
         path: Optional[Path] = None,
-        extras: DictData | None = None,
+        extras: Optional[DictData] = None,
     ) -> Self:
-        """Create Workflow instance from the Loader object that only receive
-        an input workflow name. The loader object will use this workflow name to
-        searching configuration data of this workflow model in conf path.
-
-        :param name: (str) A workflow name that want to pass to Loader object.
-        :param path: (Path) An override config path.
-        :param extras: (DictData) An extra parameters that want to override core
-            config values.
-
-        :raise ValueError: If the type does not match with current object.
-
-        :rtype: Self
+        """Create Workflow instance from configuration file.
+
+        Loads workflow configuration from YAML files and creates a validated
+        Workflow instance. The configuration loader searches for workflow
+        definitions in the specified path or default configuration directories.
+
+        Args:
+            name: Workflow name to load from configuration
+            path: Optional custom configuration path to search
+            extras: Additional parameters to override configuration values
+
+        Returns:
+            Self: Validated Workflow instance loaded from configuration
+
+        Raises:
+            ValueError: If workflow type doesn't match or configuration invalid
+            FileNotFoundError: If workflow configuration file not found
+
+        Example:
+            ```python
+            # Load from default config path
+            workflow = Workflow.from_conf('data-pipeline')
+
+            # Load with custom path and extras
+            workflow = Workflow.from_conf(
+                'data-pipeline',
+                path=Path('./custom-configs'),
+                extras={'environment': 'production'}
+            )
+            ```
         """
         load: YamlParser = YamlParser(name, path=path, extras=extras, obj=cls)
 
@@ -138,105 +218,38 @@ class Workflow(BaseModel):
         if extras:
             data["extras"] = extras
 
-        cls.__bypass_on__(data, path=load.path, extras=extras)
         return cls.model_validate(obj=data)
 
-    @classmethod
-    def __bypass_on__(
-        cls,
-        data: DictData,
-        path: Path,
-        extras: DictData | None = None,
-    ) -> DictData:
-        """Bypass the on data to loaded config data.
-
-        :param data: (DictData) A data to construct to this Workflow model.
-        :param path: (Path) A config path.
-        :param extras: (DictData) An extra parameters that want to override core
-            config values.
-
-        :rtype: DictData
-        """
-        if on := data.pop("on", []):
-            if isinstance(on, str):
-                on: list[str] = [on]
-            if any(not isinstance(i, (dict, str)) for i in on):
-                raise TypeError("The `on` key should be list of str or dict")
-
-            # NOTE: Pass on value to SimLoad and keep on model object to the on
-            #   field.
-            data["on"] = [
-                (
-                    YamlParser(n, path=path, extras=extras).data
-                    if isinstance(n, str)
-                    else n
-                )
-                for n in on
-            ]
-        return data
-
-    @model_validator(mode="before")
-    def __prepare_model_before__(cls, data: Any) -> Any:
+    @field_validator(
+        "params",
+        mode="before",
+        json_schema_input_type=Union[dict[str, Param], dict[str, str]],
+    )
+    def __prepare_params(cls, data: Any) -> Any:
         """Prepare the params key in the data model before validating."""
-        if isinstance(data, dict) and (params := data.pop("params", {})):
-            data["params"] = {
-                p: (
-                    {"type": params[p]}
-                    if isinstance(params[p], str)
-                    else params[p]
-                )
-                for p in params
+        if isinstance(data, dict):
+            data = {
+                k: ({"type": v} if isinstance(v, str) else v)
+                for k, v in data.items()
             }
         return data
 
     @field_validator("desc", mode="after")
-    def __dedent_desc__(cls, value: str) -> str:
+    def __dedent_desc__(cls, data: str) -> str:
         """Prepare description string that was created on a template.
 
-        :param value: A description string value that want to dedent.
-        :rtype: str
-        """
-        return dedent(value.lstrip("\n"))
-
-    @field_validator("on", mode="after")
-    def __on_no_dup_and_reach_limit__(
-        cls,
-        value: list[Crontab],
-    ) -> list[Crontab]:
-        """Validate the on fields should not contain duplicate values and if it
-        contains the every minute value more than one value, it will remove to
-        only one value.
-
-        :raise ValueError: If it has some duplicate value.
+        Args:
+            data: A description string value that want to dedent.
 
-        :param value: A list of on object.
-
-        :rtype: list[Crontab]
+        Returns:
+            str: The de-dented description string.
         """
-        set_ons: set[str] = {str(on.cronjob) for on in value}
-        if len(set_ons) != len(value):
-            raise ValueError(
-                "The on fields should not contain duplicate on value."
-            )
+        return dedent(data.lstrip("\n"))
 
-        # WARNING:
-        # if '* * * * *' in set_ons and len(set_ons) > 1:
-        #     raise ValueError(
-        #         "If it has every minute cronjob on value, it should have "
-        #         "only one value in the on field."
-        #     )
-        set_tz: set[str] = {on.tz for on in value}
-        if len(set_tz) > 1:
-            raise ValueError(
-                f"The on fields should not contain multiple timezone, "
-                f"{list(set_tz)}."
-            )
-
-        if len(set_ons) > 10:
-            raise ValueError(
-                "The number of the on should not more than 10 crontabs."
-            )
-        return value
+    @field_validator("created_at", "updated_dt", mode="after")
+    def __convert_tz__(cls, dt: datetime) -> datetime:
+        """Replace timezone of datetime type to no timezone."""
+        return dt.replace(tzinfo=None)
 
     @model_validator(mode="after")
     def __validate_jobs_need__(self) -> Self:
@@ -277,13 +290,15 @@ class Workflow(BaseModel):
         or job's ID. This method will pass an extra parameter from this model
         to the returned Job model.
 
-        :param name: (str) A job name or ID that want to get from a mapping of
-            job models.
+        Args:
+            name: A job name or ID that want to get from a mapping of
+                job models.
 
-        :raise ValueError: If a name or ID does not exist on the jobs field.
+        Returns:
+            Job: A job model that exists on this workflow by input name.
 
-        :rtype: Job
-        :return: A job model that exists on this workflow by input name.
+        Raises:
+            ValueError: If a name or ID does not exist on the jobs field.
         """
         if name not in self.jobs:
             raise ValueError(
@@ -306,15 +321,17 @@ class Workflow(BaseModel):
             ...     "jobs": {}
             ... }
 
-        :param params: (DictData) A parameter data that receive from workflow
-            execute method.
+        Args:
+            params: A parameter data that receive from workflow
+                execute method.
 
-        :raise WorkflowError: If parameter value that want to validate does
-            not include the necessary parameter that had required flag.
+        Returns:
+            DictData: The parameter value that validate with its parameter fields and
+                adding jobs key to this parameter.
 
-        :rtype: DictData
-        :return: The parameter value that validate with its parameter fields and
-            adding jobs key to this parameter.
+        Raises:
+            WorkflowError: If parameter value that want to validate does
+                not include the necessary parameter that had required flag.
         """
         # VALIDATE: Incoming params should have keys that set on this workflow.
         check_key: list[str] = [
@@ -346,15 +363,17 @@ class Workflow(BaseModel):
         millisecond to 0 and replaced timezone to None before checking it match
         with the set `on` field.
 
-        :param dt: (datetime) A datetime object that want to validate.
+        Args:
+            dt: A datetime object that want to validate.
 
-        :rtype: datetime
+        Returns:
+            datetime: The validated release datetime.
         """
         release: datetime = replace_sec(dt.replace(tzinfo=None))
         if not self.on:
             return release
 
-        for on in self.on:
+        for on in self.on.schedule:
             if release == on.cronjob.schedule(release).next:
                 return release
         raise WorkflowError(
@@ -368,10 +387,8 @@ class Workflow(BaseModel):
         *,
         release_type: ReleaseType = NORMAL,
         run_id: Optional[str] = None,
-        parent_run_id: Optional[str] = None,
         audit: type[Audit] = None,
         override_log_name: Optional[str] = None,
-        result: Optional[Result] = None,
         timeout: int = 600,
         excluded: Optional[list[str]] = None,
     ) -> Result:
@@ -393,31 +410,28 @@ class Workflow(BaseModel):
         :param params: A workflow parameter that pass to execute method.
         :param release_type:
         :param run_id: (str) A workflow running ID.
-        :param parent_run_id: (str) A parent workflow running ID.
         :param audit: An audit class that want to save the execution result.
         :param override_log_name: (str) An override logging name that use
             instead the workflow name.
-        :param result: (Result) A result object for keeping context and status
-            data.
         :param timeout: (int) A workflow execution time out in second unit.
         :param excluded: (list[str]) A list of key that want to exclude from
             audit data.
 
         :rtype: Result
         """
-        audit: type[Audit] = audit or get_audit(extras=self.extras)
         name: str = override_log_name or self.name
-        result: Result = Result.construct_with_rs_or_id(
-            result,
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            id_logic=name,
-            extras=self.extras,
+        if run_id:
+            parent_run_id: str = run_id
+            run_id: str = gen_id(name, unique=True)
+        else:
+            run_id: str = gen_id(name, unique=True)
+            parent_run_id: str = run_id
+        context: DictData = {}
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         release: datetime = self.validate_release(dt=release)
-        result.trace.info(
-            f"[RELEASE]: Start {name!r} : {release:%Y-%m-%d %H:%M:%S}"
-        )
+        trace.info(f"[RELEASE]: Start {name!r} : {release:%Y-%m-%d %H:%M:%S}")
         tz: ZoneInfo = dynamic("tz", extras=self.extras)
         values: DictData = param2template(
             params,
@@ -425,58 +439,61 @@ class Workflow(BaseModel):
                 "release": {
                     "logical_date": release,
                     "execute_date": datetime.now(tz=tz),
-                    "run_id": result.run_id,
+                    "run_id": run_id,
                 }
             },
             extras=self.extras,
         )
         rs: Result = self.execute(
             params=values,
-            parent_run_id=result.run_id,
+            run_id=parent_run_id,
             timeout=timeout,
         )
-        result.catch(status=rs.status, context=rs.context)
-        result.trace.info(
-            f"[RELEASE]: End {name!r} : {release:%Y-%m-%d %H:%M:%S}"
-        )
-        result.trace.debug(f"[RELEASE]: Writing audit: {name!r}.")
+        catch(context, status=rs.status, updated=rs.context)
+        trace.info(f"[RELEASE]: End {name!r} : {release:%Y-%m-%d %H:%M:%S}")
+        trace.debug(f"[RELEASE]: Writing audit: {name!r}.")
         (
-            audit(
+            (audit or get_audit_model(extras=self.extras))(
                 name=name,
                 release=release,
                 type=release_type,
-                context=result.context,
-                parent_run_id=result.parent_run_id,
-                run_id=result.run_id,
-                execution_time=result.alive_time(),
+                context=context,
+                parent_run_id=parent_run_id,
+                run_id=run_id,
+                execution_time=rs.info.get("execution_time", 0),
                 extras=self.extras,
             ).save(excluded=excluded)
         )
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=rs.status,
-            context={
-                "params": params,
-                "release": {
-                    "type": release_type,
-                    "logical_date": release,
+            context=catch(
+                context,
+                status=rs.status,
+                updated={
+                    "params": params,
+                    "release": {
+                        "type": release_type,
+                        "logical_date": release,
+                    },
+                    **{"jobs": context.pop("jobs", {})},
+                    **(context["errors"] if "errors" in context else {}),
                 },
-                **{"jobs": result.context.pop("jobs", {})},
-                **(
-                    result.context["errors"]
-                    if "errors" in result.context
-                    else {}
-                ),
-            },
+            ),
+            extras=self.extras,
         )
 
     def execute_job(
         self,
         job: Job,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
-        event: Optional[Event] = None,
-    ) -> tuple[Status, Result]:
+        parent_run_id: Optional[str] = None,
+        event: Optional[ThreadEvent] = None,
+    ) -> tuple[Status, DictData]:
         """Job execution with passing dynamic parameters from the main workflow
         execution to the target job object via job's ID.
 
@@ -487,42 +504,48 @@ class Workflow(BaseModel):
             This method do not raise any error, and it will handle all exception
         from the job execution.
 
-        :param job: (Job) A job model that want to execute.
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
+        Args:
+            job: (Job) A job model that want to execute.
+            params: (DictData) A parameter data.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
 
-        :rtype: tuple[Status, Result]
+        Returns:
+            tuple[Status, DictData]: The pair of status and result context data.
         """
-        result: Result = result or Result(run_id=gen_id(self.name, unique=True))
-
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
         if event and event.is_set():
             error_msg: str = (
                 "Job execution was canceled because the event was set "
                 "before start job execution."
             )
-            return CANCEL, result.catch(
+            return CANCEL, catch(
+                context=context,
                 status=CANCEL,
-                context={
+                updated={
                     "errors": WorkflowCancelError(error_msg).to_dict(),
                 },
             )
 
-        result.trace.info(f"[WORKFLOW]: Execute Job: {job.id!r}")
+        trace.info(f"[WORKFLOW]: Execute Job: {job.id!r}")
         rs: Result = job.execute(
             params=params,
-            run_id=result.run_id,
-            parent_run_id=result.parent_run_id,
+            run_id=parent_run_id,
             event=event,
         )
         job.set_outputs(rs.context, to=params)
 
         if rs.status == FAILED:
             error_msg: str = f"Job execution, {job.id!r}, was failed."
-            return FAILED, result.catch(
+            return FAILED, catch(
+                context=context,
                 status=FAILED,
-                context={
+                updated={
                     "errors": WorkflowError(error_msg).to_dict(),
                     **params,
                 },
@@ -533,23 +556,25 @@ class Workflow(BaseModel):
                 f"Job execution, {job.id!r}, was canceled from the event after "
                 f"end job execution."
             )
-            return CANCEL, result.catch(
+            return CANCEL, catch(
+                context=context,
                 status=CANCEL,
-                context={
+                updated={
                     "errors": WorkflowCancelError(error_msg).to_dict(),
                     **params,
                 },
             )
 
-        return rs.status, result.catch(status=rs.status, context=params)
+        return rs.status, catch(
+            context=context, status=rs.status, updated=params
+        )
 
     def execute(
         self,
         params: DictData,
         *,
         run_id: Optional[str] = None,
-        parent_run_id: Optional[str] = None,
-        event: Optional[Event] = None,
+        event: Optional[ThreadEvent] = None,
         timeout: float = 3600,
         max_job_parallel: int = 2,
     ) -> Result:
@@ -598,7 +623,6 @@ class Workflow(BaseModel):
 
         :param params: A parameter data that will parameterize before execution.
         :param run_id: (Optional[str]) A workflow running ID.
-        :param parent_run_id: (Optional[str]) A parent workflow running ID.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
         :param timeout: (float) A workflow execution time out in second unit
@@ -611,24 +635,30 @@ class Workflow(BaseModel):
         :rtype: Result
         """
         ts: float = time.monotonic()
-        result: Result = Result.construct_with_rs_or_id(
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            id_logic=self.name,
-            extras=self.extras,
+        parent_run_id: Optional[str] = run_id
+        run_id: str = gen_id(self.name, extras=self.extras)
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         context: DictData = self.parameterize(params)
-        event: Event = event or Event()
+        event: ThreadEvent = event or ThreadEvent()
         max_job_parallel: int = dynamic(
             "max_job_parallel", f=max_job_parallel, extras=self.extras
         )
-        result.trace.info(
+        trace.info(
             f"[WORKFLOW]: Execute: {self.name!r} ("
             f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
         )
         if not self.jobs:
-            result.trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
-            return result.catch(status=SUCCESS, context=context)
+            trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=SUCCESS,
+                context=catch(context, status=SUCCESS),
+                info={"execution_time": time.monotonic() - ts},
+                extras=self.extras,
+            )
 
         job_queue: Queue = Queue()
         for job_id in self.jobs:
@@ -642,20 +672,30 @@ class Workflow(BaseModel):
         timeout: float = dynamic(
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
-        result.catch(status=WAIT, context=context)
+        catch(context, status=WAIT)
         if event and event.is_set():
-            return result.catch(
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
                 status=CANCEL,
-                context={
-                    "errors": WorkflowCancelError(
-                        "Execution was canceled from the event was set before "
-                        "workflow execution."
-                    ).to_dict(),
-                },
+                context=catch(
+                    context,
+                    status=CANCEL,
+                    updated={
+                        "errors": WorkflowCancelError(
+                            "Execution was canceled from the event was set "
+                            "before workflow execution."
+                        ).to_dict(),
+                    },
+                ),
+                info={"execution_time": time.monotonic() - ts},
+                extras=self.extras,
             )
 
         with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
             futures: list[Future] = []
+            backoff_sleep = 0.01  # Start with smaller sleep time
+            consecutive_waits = 0  # Track consecutive wait states
 
             while not job_queue.empty() and (
                 not_timeout_flag := ((time.monotonic() - ts) < timeout)
@@ -665,21 +705,37 @@ class Workflow(BaseModel):
                 if (check := job.check_needs(context["jobs"])) == WAIT:
                     job_queue.task_done()
                     job_queue.put(job_id)
-                    time.sleep(0.15)
+                    consecutive_waits += 1
+                    # Exponential backoff up to 0.15s max
+                    backoff_sleep = min(backoff_sleep * 1.5, 0.15)
+                    time.sleep(backoff_sleep)
                     continue
-                elif check == FAILED:  # pragma: no cov
-                    return result.catch(
+
+                # Reset backoff when we can proceed
+                consecutive_waits = 0
+                backoff_sleep = 0.01
+
+                if check == FAILED:  # pragma: no cov
+                    return Result(
+                        run_id=run_id,
+                        parent_run_id=parent_run_id,
                         status=FAILED,
-                        context={
-                            "status": FAILED,
-                            "errors": WorkflowError(
-                                f"Validate job trigger rule was failed with "
-                                f"{job.trigger_rule.value!r}."
-                            ).to_dict(),
-                        },
+                        context=catch(
+                            context,
+                            status=FAILED,
+                            updated={
+                                "status": FAILED,
+                                "errors": WorkflowError(
+                                    f"Validate job trigger rule was failed "
+                                    f"with {job.trigger_rule.value!r}."
+                                ).to_dict(),
+                            },
+                        ),
+                        info={"execution_time": time.monotonic() - ts},
+                        extras=self.extras,
                     )
                 elif check == SKIP:  # pragma: no cov
-                    result.trace.info(
+                    trace.info(
                         f"[JOB]: Skip job: {job_id!r} from trigger rule."
                     )
                     job.set_outputs(output={"status": SKIP}, to=context)
@@ -693,7 +749,9 @@ class Workflow(BaseModel):
                             self.execute_job,
                             job=job,
                             params=context,
-                            result=result,
+                            run_id=run_id,
+                            context=context,
+                            parent_run_id=parent_run_id,
                             event=event,
                         ),
                     )
@@ -706,7 +764,9 @@ class Workflow(BaseModel):
                             self.execute_job,
                             job=job,
                             params=context,
-                            result=result,
+                            run_id=run_id,
+                            context=context,
+                            parent_run_id=parent_run_id,
                             event=event,
                         )
                     )
@@ -726,7 +786,7 @@ class Workflow(BaseModel):
                 else:  # pragma: no cov
                     job_queue.put(job_id)
                     futures.insert(0, future)
-                    result.trace.warning(
+                    trace.warning(
                         f"[WORKFLOW]: ... Execution non-threading not "
                         f"handle: {future}."
                     )
@@ -749,44 +809,58 @@ class Workflow(BaseModel):
                 for i, s in enumerate(sequence_statuses, start=0):
                     statuses[total + 1 + skip_count + i] = s
 
-                return result.catch(
-                    status=validate_statuses(statuses), context=context
+                st: Status = validate_statuses(statuses)
+                return Result(
+                    run_id=run_id,
+                    parent_run_id=parent_run_id,
+                    status=st,
+                    context=catch(context, status=st),
+                    info={"execution_time": time.monotonic() - ts},
+                    extras=self.extras,
                 )
 
             event.set()
             for future in futures:
                 future.cancel()
 
-            result.trace.error(
+            trace.error(
                 f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
                 f"time more than {timeout} seconds."
             )
 
             time.sleep(0.0025)
 
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=FAILED,
-            context={
-                "errors": WorkflowTimeoutError(
-                    f"{self.name!r} was timeout because it use exec time more "
-                    f"than {timeout} seconds."
-                ).to_dict(),
-            },
+            context=catch(
+                context,
+                status=FAILED,
+                updated={
+                    "errors": WorkflowTimeoutError(
+                        f"{self.name!r} was timeout because it use exec time "
+                        f"more than {timeout} seconds."
+                    ).to_dict(),
+                },
+            ),
+            info={"execution_time": time.monotonic() - ts},
+            extras=self.extras,
         )
 
     def rerun(
         self,
         context: DictData,
         *,
-        parent_run_id: Optional[str] = None,
-        event: Optional[Event] = None,
+        run_id: Optional[str] = None,
+        event: Optional[ThreadEvent] = None,
         timeout: float = 3600,
         max_job_parallel: int = 2,
     ) -> Result:
         """Re-Execute workflow with passing the error context data.
 
         :param context: A context result that get the failed status.
-        :param parent_run_id: (Optional[str]) A parent workflow running ID.
+        :param run_id: (Optional[str]) A workflow running ID.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
         :param timeout: (float) A workflow execution time out in second unit
@@ -796,36 +870,49 @@ class Workflow(BaseModel):
         :param max_job_parallel: (int) The maximum workers that use for job
             execution in `ThreadPoolExecutor` object. (Default: 2 workers)
 
-        :rtype: Result
+        Returns
+            Result: Return Result object that create from execution context with
+                return mode.
         """
         ts: float = time.monotonic()
-
-        result: Result = Result.construct_with_rs_or_id(
-            parent_run_id=parent_run_id,
-            id_logic=self.name,
-            extras=self.extras,
+        parent_run_id: str = run_id
+        run_id: str = gen_id(self.name, extras=self.extras)
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         if context["status"] == SUCCESS:
-            result.trace.info(
+            trace.info(
                 "[WORKFLOW]: Does not rerun because it already executed with "
                 "success status."
             )
-            return result.catch(status=SUCCESS, context=context)
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=SUCCESS,
+                context=catch(context=context, status=SUCCESS),
+                extras=self.extras,
+            )
 
         err = context["errors"]
-        result.trace.info(f"[WORKFLOW]: Previous error: {err}")
+        trace.info(f"[WORKFLOW]: Previous error: {err}")
 
-        event: Event = event or Event()
+        event: ThreadEvent = event or ThreadEvent()
         max_job_parallel: int = dynamic(
             "max_job_parallel", f=max_job_parallel, extras=self.extras
         )
-        result.trace.info(
+        trace.info(
             f"[WORKFLOW]: Execute: {self.name!r} ("
             f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
         )
         if not self.jobs:
-            result.trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
-            return result.catch(status=SUCCESS, context=context)
+            trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=SUCCESS,
+                context=catch(context=context, status=SUCCESS),
+                extras=self.extras,
+            )
 
         # NOTE: Prepare the new context for rerun process.
         jobs: DictData = context.get("jobs")
@@ -845,8 +932,14 @@ class Workflow(BaseModel):
             total_job += 1
 
         if total_job == 0:
-            result.trace.warning("[WORKFLOW]: It does not have job to rerun.")
-            return result.catch(status=SUCCESS, context=context)
+            trace.warning("[WORKFLOW]: It does not have job to rerun.")
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=SUCCESS,
+                context=catch(context=context, status=SUCCESS),
+                extras=self.extras,
+            )
 
         not_timeout_flag: bool = True
         statuses: list[Status] = [WAIT] * total_job
@@ -856,20 +949,29 @@ class Workflow(BaseModel):
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
 
-        result.catch(status=WAIT, context=new_context)
+        catch(new_context, status=WAIT)
         if event and event.is_set():
-            return result.catch(
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
                 status=CANCEL,
-                context={
-                    "errors": WorkflowCancelError(
-                        "Execution was canceled from the event was set before "
-                        "workflow execution."
-                    ).to_dict(),
-                },
+                context=catch(
+                    new_context,
+                    status=CANCEL,
+                    updated={
+                        "errors": WorkflowCancelError(
+                            "Execution was canceled from the event was set "
+                            "before workflow execution."
+                        ).to_dict(),
+                    },
+                ),
+                extras=self.extras,
             )
 
         with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
             futures: list[Future] = []
+            backoff_sleep = 0.01
+            consecutive_waits = 0
 
             while not job_queue.empty() and (
                 not_timeout_flag := ((time.monotonic() - ts) < timeout)
@@ -879,21 +981,37 @@ class Workflow(BaseModel):
                 if (check := job.check_needs(new_context["jobs"])) == WAIT:
                     job_queue.task_done()
                     job_queue.put(job_id)
-                    time.sleep(0.15)
+                    consecutive_waits += 1
+
+                    # NOTE: Exponential backoff up to 0.15s max.
+                    backoff_sleep = min(backoff_sleep * 1.5, 0.15)
+                    time.sleep(backoff_sleep)
                     continue
-                elif check == FAILED:  # pragma: no cov
-                    return result.catch(
+
+                # NOTE: Reset backoff when we can proceed
+                consecutive_waits = 0
+                backoff_sleep = 0.01
+
+                if check == FAILED:  # pragma: no cov
+                    return Result(
+                        run_id=run_id,
+                        parent_run_id=parent_run_id,
                         status=FAILED,
-                        context={
-                            "status": FAILED,
-                            "errors": WorkflowError(
-                                f"Validate job trigger rule was failed with "
-                                f"{job.trigger_rule.value!r}."
-                            ).to_dict(),
-                        },
+                        context=catch(
+                            new_context,
+                            status=FAILED,
+                            updated={
+                                "status": FAILED,
+                                "errors": WorkflowError(
+                                    f"Validate job trigger rule was failed "
+                                    f"with {job.trigger_rule.value!r}."
+                                ).to_dict(),
+                            },
+                        ),
+                        extras=self.extras,
                     )
                 elif check == SKIP:  # pragma: no cov
-                    result.trace.info(
+                    trace.info(
                         f"[JOB]: Skip job: {job_id!r} from trigger rule."
                     )
                     job.set_outputs(output={"status": SKIP}, to=new_context)
@@ -907,7 +1025,9 @@ class Workflow(BaseModel):
                             self.execute_job,
                             job=job,
                             params=new_context,
-                            result=result,
+                            run_id=run_id,
+                            context=context,
+                            parent_run_id=parent_run_id,
                             event=event,
                         ),
                     )
@@ -920,7 +1040,9 @@ class Workflow(BaseModel):
                             self.execute_job,
                             job=job,
                             params=new_context,
-                            result=result,
+                            run_id=run_id,
+                            context=context,
+                            parent_run_id=parent_run_id,
                             event=event,
                         )
                     )
@@ -940,7 +1062,7 @@ class Workflow(BaseModel):
                 else:  # pragma: no cov
                     job_queue.put(job_id)
                     futures.insert(0, future)
-                    result.trace.warning(
+                    trace.warning(
                         f"[WORKFLOW]: ... Execution non-threading not "
                         f"handle: {future}."
                     )
@@ -963,27 +1085,39 @@ class Workflow(BaseModel):
                 for i, s in enumerate(sequence_statuses, start=0):
                     statuses[total + 1 + skip_count + i] = s
 
-                return result.catch(
-                    status=validate_statuses(statuses), context=new_context
+                st: Status = validate_statuses(statuses)
+                return Result(
+                    run_id=run_id,
+                    parent_run_id=parent_run_id,
+                    status=st,
+                    context=catch(new_context, status=st),
+                    extras=self.extras,
                 )
 
             event.set()
             for future in futures:
                 future.cancel()
 
-            result.trace.error(
+            trace.error(
                 f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
                 f"time more than {timeout} seconds."
             )
 
             time.sleep(0.0025)
 
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=FAILED,
-            context={
-                "errors": WorkflowTimeoutError(
-                    f"{self.name!r} was timeout because it use exec time more "
-                    f"than {timeout} seconds."
-                ).to_dict(),
-            },
+            context=catch(
+                new_context,
+                status=FAILED,
+                updated={
+                    "errors": WorkflowTimeoutError(
+                        f"{self.name!r} was timeout because it use exec time "
+                        f"more than {timeout} seconds."
+                    ).to_dict(),
+                },
+            ),
+            extras=self.extras,
         )