ddeutil-workflow 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

ddeutil/workflow/workflow.py

@@ -33,7 +33,7 @@ from functools import total_ordering
 from heapq import heappop, heappush
 from queue import Queue
 from textwrap import dedent
-from typing import Optional
+from typing import Any, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 from pydantic.dataclasses import dataclass
@@ -46,9 +46,10 @@ from .conf import FileLog, Loader, Log, config, get_logger
 from .exceptions import JobException, WorkflowException
 from .job import Job
 from .on import On
+from .params import Param
+from .result import Result
 from .utils import (
-    Param,
-    Result,
+    cut_id,
     delay,
     gen_id,
     get_diff_sec,
@@ -85,13 +86,16 @@ class WorkflowRelease:
         return f"{self.date:%Y-%m-%d %H:%M:%S}"
 
     @classmethod
-    def from_dt(cls, dt: datetime) -> Self:
+    def from_dt(cls, dt: datetime | str) -> Self:
         """Construct WorkflowRelease via datetime object only.
 
         :param dt: A datetime object.
 
         :rtype: Self
         """
+        if isinstance(dt, str):
+            dt: datetime = datetime.fromisoformat(dt)
+
         return cls(
             date=dt,
             offset=0,
@@ -123,12 +127,39 @@ class WorkflowRelease:
 
 @dataclass
 class WorkflowQueue:
-    """Workflow Queue object."""
+    """Workflow Queue object that is management of WorkflowRelease objects."""
 
     queue: list[WorkflowRelease] = field(default_factory=list)
     running: list[WorkflowRelease] = field(default_factory=list)
     complete: list[WorkflowRelease] = field(default_factory=list)
 
+    @classmethod
+    def from_list(
+        cls, queue: list[datetime] | list[WorkflowRelease] | None = None
+    ) -> Self:
+        """Construct WorkflowQueue object from an input queue value that passing
+        with list of datetime or list of WorkflowRelease.
+
+        :raise TypeError: If the type of an input queue does not valid.
+
+        :rtype: Self
+        """
+        if queue is None:
+            return cls()
+
+        if isinstance(queue, list):
+
+            if all(isinstance(q, datetime) for q in queue):
+                return cls(queue=[WorkflowRelease.from_dt(q) for q in queue])
+
+            if all(isinstance(q, WorkflowRelease) for q in queue):
+                return cls(queue=queue)
+
+        raise TypeError(
+            "Type of the queue does not valid with WorkflowQueue "
+            "or list of datetime or list of WorkflowRelease."
+        )
+
     @property
     def is_queued(self) -> bool:
         """Return True if it has workflow release object in the queue.
@@ -137,34 +168,35 @@ class WorkflowQueue:
         """
         return len(self.queue) > 0
 
-    def check_queue(self, data: WorkflowRelease) -> bool:
+    def check_queue(self, value: WorkflowRelease) -> bool:
         """Check a WorkflowRelease value already exists in list of tracking
         queues.
 
-        :param data: A workflow release object.
+        :param value: A WorkflowRelease object that want to check it already in
+            queues.
 
         :rtype: bool
         """
         return (
-            (data in self.queue)
-            or (data in self.running)
-            or (data in self.complete)
+            (value in self.queue)
+            or (value in self.running)
+            or (value in self.complete)
         )
 
-    def push_queue(self, data: WorkflowRelease) -> Self:
+    def push_queue(self, value: WorkflowRelease) -> Self:
         """Push data to the queue."""
-        heappush(self.queue, data)
+        heappush(self.queue, value)
         return self
 
-    def push_running(self, data: WorkflowRelease) -> Self:
+    def push_running(self, value: WorkflowRelease) -> Self:
         """Push data to the running."""
-        heappush(self.running, data)
+        heappush(self.running, value)
         return self
 
-    def remove_running(self, data: WorkflowRelease) -> Self:
+    def remove_running(self, value: WorkflowRelease) -> Self:
         """Remove data on the running if it exists."""
-        if data in self.running:
-            self.running.remove(data)
+        if value in self.running:
+            self.running.remove(value)
 
 
 class Workflow(BaseModel):
@@ -283,7 +315,7 @@ class Workflow(BaseModel):
         return dedent(value)
 
     @field_validator("on", mode="after")
-    def __on_no_dup__(cls, value: list[On]) -> list[On]:
+    def __on_no_dup_and_reach_limit__(cls, value: list[On]) -> list[On]:
         """Validate the on fields should not contain duplicate values and if it
         contain the every minute value more than one value, it will remove to
         only one value.
@@ -306,6 +338,12 @@ class Workflow(BaseModel):
         #         "If it has every minute cronjob on value, it should has only "
         #         "one value in the on field."
         #     )
+
+        if len(set_ons) > config.max_on_per_workflow:
+            raise ValueError(
+                f"The number of the on should not more than "
+                f"{config.max_on_per_workflow} crontab."
+            )
         return value
 
     @model_validator(mode="after")
@@ -404,22 +442,21 @@ class Workflow(BaseModel):
         self,
         release: datetime | WorkflowRelease,
         params: DictData,
-        run_id: str | None = None,
         *,
+        run_id: str | None = None,
         log: type[Log] = None,
-        queue: WorkflowQueue | list[datetime] | None = None,
+        queue: (
+            WorkflowQueue | list[datetime] | list[WorkflowRelease] | None
+        ) = None,
     ) -> Result:
         """Release the workflow execution with overriding parameter with the
         release templating that include logical date (release date), execution
         date, or running id to the params.
 
             This method allow workflow use log object to save the execution
-        result to log destination like file log to local `/logs` directory.
+        result to log destination like file log to the local `/logs` directory.
 
-            I will add sleep with 0.15 seconds on every step that interact with
-        the queue object.
-
-        :param release: A release datetime.
+        :param release: A release datetime or WorkflowRelease object.
         :param params: A workflow parameter that pass to execute method.
         :param queue: A list of release time that already queue.
         :param run_id: A workflow running ID for this release.
@@ -430,23 +467,23 @@ class Workflow(BaseModel):
         """
         log: type[Log] = log or FileLog
         run_id: str = run_id or gen_id(self.name, unique=True)
+        rs_release: Result = Result(run_id=run_id)
 
         # VALIDATE: Change queue value to WorkflowQueue object.
-        if queue is None:
-            queue: WorkflowQueue = WorkflowQueue()
-        elif isinstance(queue, list):
-            queue: WorkflowQueue = WorkflowQueue(queue=queue)
+        if queue is None or isinstance(queue, list):
+            queue: WorkflowQueue = WorkflowQueue.from_list(queue)
 
         # VALIDATE: Change release value to WorkflowRelease object.
         if isinstance(release, datetime):
             release: WorkflowRelease = WorkflowRelease.from_dt(release)
 
         logger.debug(
-            f"({run_id}) [RELEASE]: {self.name!r} : "
-            f"Closely to run >> {release.date:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [RELEASE]: {self.name!r} : Start release - "
+            f"{release.date:%Y-%m-%d %H:%M:%S}"
         )
 
-        # NOTE: Release parameter that use to change if params has templating.
+        # NOTE: Release parameters that use to templating on the schedule
+        #   config data.
         release_params: DictData = {
             "release": {
                 "logical_date": release.date,
@@ -456,14 +493,14 @@ class Workflow(BaseModel):
             }
         }
 
-        # WARNING: Re-create workflow object that use new running workflow ID.
+        # NOTE: Execute workflow with templating params from release mapping.
         rs: Result = self.execute(
             params=param2template(params, release_params),
             run_id=run_id,
         )
         logger.debug(
-            f"({run_id}) [RELEASE]: {self.name!r} : "
-            f"End release {release.date:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [RELEASE]: {self.name!r} : End release - "
+            f"{release.date:%Y-%m-%d %H:%M:%S}"
         )
 
         rs.set_parent_run_id(run_id)
@@ -485,16 +522,16 @@ class Workflow(BaseModel):
         queue.remove_running(release)
         heappush(queue.complete, release)
 
-        return Result(
+        context: dict[str, Any] = rs.context
+        context.pop("params")
+
+        return rs_release.catch(
             status=0,
             context={
                 "params": params,
-                "release": {
-                    "status": "success",
-                    "logical_date": release.date,
-                },
+                "release": {"status": "success", "logical_date": release.date},
+                "outputs": context,
             },
-            run_id=run_id,
         )
 
     def queue_poking(
@@ -503,14 +540,20 @@ class Workflow(BaseModel):
         end_date: datetime,
         queue: WorkflowQueue,
         log: type[Log],
+        *,
+        force_run: bool = False,
     ) -> WorkflowQueue:
         """Generate queue of datetime from the cron runner that initialize from
         the on field. with offset value.
 
-        :param offset:
-        :param end_date:
-        :param queue:
-        :param log:
+        :param offset: A offset in second unit for time travel.
+        :param end_date: An end datetime object.
+        :param queue: A workflow queue object.
+        :param log: A log class that want to making log object.
+        :param force_run: A flag that allow to release workflow if the log with
+            that release was pointed.
+
+        :rtype: WorkflowQueue
         """
         for on in self.on:
 
@@ -518,6 +561,7 @@ class Workflow(BaseModel):
                 get_dt_now(tz=config.tz, offset=offset).replace(microsecond=0)
             )
 
+            # NOTE: Skip this runner date if it more than the end date.
             if runner.date > end_date:
                 continue
 
@@ -529,8 +573,9 @@ class Workflow(BaseModel):
                 type="poking",
             )
 
-            while queue.check_queue(data=workflow_release) or (
+            while queue.check_queue(workflow_release) or (
                 log.is_pointed(name=self.name, release=workflow_release.date)
+                and not force_run
             ):
                 workflow_release = WorkflowRelease(
                     date=runner.next,
@@ -543,36 +588,50 @@ class Workflow(BaseModel):
             if runner.date > end_date:
                 continue
 
+            # NOTE: Push the WorkflowRelease object to queue.
             queue.push_queue(workflow_release)
+
         return queue
 
     def poke(
         self,
         start_date: datetime | None = None,
         params: DictData | None = None,
+        *,
         run_id: str | None = None,
         periods: int = 1,
-        *,
         log: Log | None = None,
+        force_run: bool = False,
+        timeout: int = 1800,
     ) -> list[Result]:
-        """Poke workflow with the ``on`` field with threading executor pool for
-        executing with all its schedules that was set on the `on` value.
-        This method will observe its schedule that nearing to run with the
+        """Poke this workflow with start datetime value that passing to its
+        ``on`` field with threading executor pool for executing with all its
+        schedules that was set on the `on` value.
+
+            This method will observe its schedule that nearing to run with the
         ``self.release()`` method.
 
         :param start_date: A start datetime object.
         :param params: A parameters that want to pass to the release method.
         :param run_id: A workflow running ID for this poke.
-        :param periods: A periods of minutes value to running poke.
+        :param periods: A periods in minutes value that use to run this poking.
         :param log: A log object that want to use on this poking process.
+        :param force_run: A flag that allow to release workflow if the log with
+            that release was pointed.
+        :param timeout: A second value for timeout while waiting all futures
+            run completely.
 
         :rtype: list[Result]
+        :return: A list of all results that return from ``self.release`` method.
         """
+        log: type[Log] = log or FileLog
+        run_id: str = run_id or gen_id(self.name, unique=True)
+
         # NOTE: If this workflow does not set the on schedule, it will return
         #   empty result.
         if len(self.on) == 0:
             logger.info(
-                f"({run_id}) [POKING]: {self.name!r} does not have any "
+                f"({cut_id(run_id)}) [POKING]: {self.name!r} does not have any "
                 f"schedule to run."
             )
             return []
@@ -592,82 +651,97 @@ class Workflow(BaseModel):
             start_date: datetime = current_date
             offset: float = 0
 
+        # NOTE: End date is use to stop generate queue with an input periods
+        #   value.
         end_date: datetime = start_date + timedelta(minutes=periods)
 
-        log: type[Log] = log or FileLog
-        run_id: str = run_id or gen_id(self.name, unique=True)
         logger.info(
-            f"({run_id}) [POKING]: Start Poking: {self.name!r} from "
+            f"({cut_id(run_id)}) [POKING]: Start Poking: {self.name!r} from "
             f"{start_date:%Y-%m-%d %H:%M:%S} to {end_date:%Y-%m-%d %H:%M:%S}"
         )
 
-        params: DictData = params or {}
-        workflow_queue: WorkflowQueue = WorkflowQueue()
+        params: DictData = {} if params is None else params
         results: list[Result] = []
-        futures: list[Future] = []
 
+        # NOTE: Create empty WorkflowQueue object.
+        wf_queue: WorkflowQueue = WorkflowQueue()
+
+        # NOTE: Make queue to the workflow queue object.
         self.queue_poking(
-            offset, end_date=end_date, queue=workflow_queue, log=log
+            offset,
+            end_date=end_date,
+            queue=wf_queue,
+            log=log,
+            force_run=force_run,
         )
-
-        if len(workflow_queue.queue) == 0:
+        if not wf_queue.is_queued:
             logger.info(
-                f"({run_id}) [POKING]: {self.name!r} does not have any "
-                f"queue to run."
+                f"({cut_id(run_id)}) [POKING]: {self.name!r} does not have "
+                f"any queue."
             )
             return []
 
+        # NOTE: Start create the thread pool executor for running this poke
+        #   process.
         with ThreadPoolExecutor(
             max_workers=config.max_poking_pool_worker,
-            thread_name_prefix="workflow_poking_",
+            thread_name_prefix="wf_poking_",
         ) as executor:
 
-            while workflow_queue.is_queued:
+            futures: list[Future] = []
+
+            while wf_queue.is_queued:
+
+                # NOTE: Pop the latest WorkflowRelease object from queue.
+                release: WorkflowRelease = heappop(wf_queue.queue)
 
-                wf_release: WorkflowRelease = heappop(workflow_queue.queue)
                 if (
-                    wf_release.date - get_dt_now(tz=config.tz, offset=offset)
+                    release.date - get_dt_now(tz=config.tz, offset=offset)
                 ).total_seconds() > 60:
                     logger.debug(
-                        f"({run_id}) [POKING]: Waiting because the latest "
-                        f"release has diff time more than 60 seconds "
+                        f"({cut_id(run_id)}) [POKING]: Wait because the latest "
+                        f"release has diff time more than 60 seconds ..."
                     )
-                    heappush(workflow_queue.queue, wf_release)
+                    heappush(wf_queue.queue, release)
                     delay(60)
+
+                    # WARNING: I already call queue poking again because issue
+                    #   about the every minute crontab.
                     self.queue_poking(
-                        offset, end_date, queue=workflow_queue, log=log
+                        offset,
+                        end_date,
+                        queue=wf_queue,
+                        log=log,
+                        force_run=force_run,
                     )
                     continue
 
-                # NOTE: Push the workflow release to running queue
-                workflow_queue.push_running(wf_release)
+                # NOTE: Push the latest WorkflowRelease to the running queue.
+                wf_queue.push_running(release)
 
                 futures.append(
                     executor.submit(
                         self.release,
-                        release=wf_release,
+                        release=release,
                         params=params,
                         log=log,
-                        queue=workflow_queue,
+                        queue=wf_queue,
                     )
                 )
 
                 self.queue_poking(
-                    offset, end_date, queue=workflow_queue, log=log
+                    offset,
+                    end_date,
+                    queue=wf_queue,
+                    log=log,
+                    force_run=force_run,
                 )
 
             # WARNING: This poking method does not allow to use fail-fast
             #   logic to catching parallel execution result.
-            for future in as_completed(futures):
+            for future in as_completed(futures, timeout=timeout):
                 results.append(future.result().set_parent_run_id(run_id))
 
-        while len(workflow_queue.running) > 0:  # pragma: no cov
-            logger.warning(
-                f"({run_id}) [POKING]: Running does empty when poking "
-                f"process was finishing."
-            )
-            delay(10)
-
         return results
 
     def execute_job(
@@ -685,6 +759,8 @@ class Workflow(BaseModel):
         model. It different with ``self.execute`` because this method run only
         one job and return with context of this job data.
 
+        :raise WorkflowException: If execute with not exist job's ID.
+        :raise WorkflowException: If the job execution raise JobException.
         :raise NotImplementedError: If set raise_error argument to False.
 
         :param job_id: A job ID that want to execute.
@@ -694,8 +770,11 @@ class Workflow(BaseModel):
             if it get exception from job execution.
 
         :rtype: Result
+        :return: Return the result object that receive the job execution result
+            context.
         """
         run_id: str = run_id or gen_id(self.name, unique=True)
+        rs: Result = Result(run_id=run_id)
 
         # VALIDATE: check a job ID that exists in this workflow or not.
         if job_id not in self.jobs:
@@ -704,10 +783,14 @@ class Workflow(BaseModel):
                 f"workflow."
             )
 
-        logger.info(f"({run_id}) [WORKFLOW]: Start execute job: {job_id!r}")
+        logger.info(
+            f"({cut_id(run_id)}) [WORKFLOW]: Start execute job: {job_id!r}"
+        )
 
         # IMPORTANT:
-        #   Change any job running IDs to this workflow running ID.
+        #   This execution change all job running IDs to the current workflow
+        #   execution running ID (with passing run_id to the job execution
+        #   argument).
         #
         try:
             job: Job = self.jobs[job_id]
@@ -717,7 +800,8 @@ class Workflow(BaseModel):
             )
         except JobException as err:
             logger.error(
-                f"({run_id}) [WORKFLOW]: {err.__class__.__name__}: {err}"
+                f"({cut_id(run_id)}) [WORKFLOW]: {err.__class__.__name__}: "
+                f"{err}"
             )
             if raise_error:
                 raise WorkflowException(
@@ -727,7 +811,7 @@ class Workflow(BaseModel):
                 "Handle error from the job execution does not support yet."
             ) from None
 
-        return Result(status=0, context=params).set_run_id(run_id)
+        return rs.catch(status=0, context=params)
 
     def execute(
         self,
@@ -761,7 +845,9 @@ class Workflow(BaseModel):
         :rtype: Result
         """
         run_id: str = run_id or gen_id(self.name, unique=True)
-        logger.info(f"({run_id}) [WORKFLOW]: Start Execute: {self.name!r} ...")
+        logger.info(
+            f"({cut_id(run_id)}) [WORKFLOW]: Start Execute: {self.name!r} ..."
+        )
 
         # NOTE: I use this condition because this method allow passing empty
         #   params and I do not want to create new dict object.
@@ -771,7 +857,7 @@ class Workflow(BaseModel):
         # NOTE: It should not do anything if it does not have job.
         if not self.jobs:
             logger.warning(
-                f"({run_id}) [WORKFLOW]: This workflow: {self.name!r} "
+                f"({cut_id(run_id)}) [WORKFLOW]: This workflow: {self.name!r} "
                 f"does not have any jobs"
             )
             return rs.catch(status=0, context=params)
@@ -846,14 +932,14 @@ class Workflow(BaseModel):
         not_timeout_flag: bool = True
         timeout: int = timeout or config.max_job_exec_timeout
         logger.debug(
-            f"({run_id}) [WORKFLOW]: Run {self.name} with threading executor."
+            f"({cut_id(run_id)}) [WORKFLOW]: Run {self.name!r} with threading."
         )
 
         # IMPORTANT: The job execution can run parallel and waiting by
         #   needed.
         with ThreadPoolExecutor(
             max_workers=config.max_job_parallel,
-            thread_name_prefix="workflow_exec_threading_",
+            thread_name_prefix="wf_exec_threading_",
         ) as executor:
             futures: list[Future] = []
 
@@ -863,7 +949,7 @@ class Workflow(BaseModel):
                 job_id: str = job_queue.get()
                 job: Job = self.jobs[job_id]
 
-                if any(need not in context["jobs"] for need in job.needs):
+                if not job.check_needs(context["jobs"]):
                     job_queue.task_done()
                     job_queue.put(job_id)
                     time.sleep(0.25)
@@ -872,10 +958,13 @@ class Workflow(BaseModel):
                 # NOTE: Start workflow job execution with deep copy context data
                 #   before release.
                 #
+                #   Context:
+                #   ---
                 #   {
                 #       'params': <input-params>,
-                #       'jobs': {},
+                #       'jobs': { <job's-id>: ... },
                 #   }
+                #
                 futures.append(
                     executor.submit(
                         self.execute_job,
@@ -895,8 +984,8 @@ class Workflow(BaseModel):
 
                 for future in as_completed(futures, timeout=thread_timeout):
                     if err := future.exception():
-                        logger.error(f"({run_id}) [WORKFLOW]: {err}")
-                        raise WorkflowException(f"{err}")
+                        logger.error(f"({cut_id(run_id)}) [WORKFLOW]: {err}")
+                        raise WorkflowException(str(err))
 
                     # NOTE: This getting result does not do anything.
                     future.result()
@@ -908,12 +997,10 @@ class Workflow(BaseModel):
 
         # NOTE: Raise timeout error.
         logger.warning(
-            f"({run_id}) [WORKFLOW]: Execution of workflow, {self.name!r}, "
-            f"was timeout"
-        )
-        raise WorkflowException(
-            f"Execution of workflow: {self.name} was timeout"
+            f"({cut_id(run_id)}) [WORKFLOW]: Execution: {self.name!r} "
+            f"was timeout."
         )
+        raise WorkflowException(f"Execution: {self.name!r} was timeout.")
 
     def __exec_non_threading(
         self,
@@ -940,8 +1027,8 @@ class Workflow(BaseModel):
         not_timeout_flag: bool = True
         timeout: int = timeout or config.max_job_exec_timeout
         logger.debug(
-            f"({run_id}) [WORKFLOW]: Run {self.name} with non-threading "
-            f"executor."
+            f"({cut_id(run_id)}) [WORKFLOW]: Run {self.name!r} with "
+            f"non-threading."
         )
 
         while not job_queue.empty() and (
@@ -951,7 +1038,7 @@ class Workflow(BaseModel):
             job: Job = self.jobs[job_id]
 
             # NOTE: Waiting dependency job run successful before release.
-            if any(need not in context["jobs"] for need in job.needs):
+            if not job.check_needs(context["jobs"]):
                 job_queue.task_done()
                 job_queue.put(job_id)
                 time.sleep(0.075)
@@ -980,11 +1067,10 @@ class Workflow(BaseModel):
 
         # NOTE: Raise timeout error.
         logger.warning(
-            f"({run_id}) [WORKFLOW]: Execution of workflow was timeout"
-        )
-        raise WorkflowException(
-            f"Execution of workflow: {self.name} was timeout"
+            f"({cut_id(run_id)}) [WORKFLOW]: Execution: {self.name!r} "
+            f"was timeout."
         )
+        raise WorkflowException(f"Execution: {self.name!r} was timeout.")
 
 
 @dataclass(config=ConfigDict(arbitrary_types_allowed=True))
@@ -999,7 +1085,7 @@ class WorkflowTaskData:
     alias: str
     workflow: Workflow
     runner: CronRunner
-    params: DictData
+    params: DictData = field(default_factory=dict)
 
     def release(
         self,
@@ -1009,20 +1095,24 @@ class WorkflowTaskData:
         *,
         waiting_sec: int = 60,
         sleep_interval: int = 15,
-    ) -> None:  # pragma: no cov
-        """Workflow task release that use the same logic of `workflow.release`
-        method.
+    ) -> Result:  # pragma: no cov
+        """Release the workflow task data that use the same logic of
+        `workflow.release` method but use different the queue object for
+        tracking release datetime to run.
 
-        :param queue:
+        :param queue: A mapping of alias name and list of release datetime.
         :param log: A log object for saving result logging from workflow
             execution process.
         :param run_id: A workflow running ID for this release.
         :param waiting_sec: A second period value that allow workflow execute.
         :param sleep_interval: A second value that want to waiting until time
             to execute.
+
+        :rtype: Result
         """
-        log: Log = log or FileLog
-        run_id: str = run_id or gen_id(self.workflow.name, unique=True)
+        log: type[Log] = log or FileLog
+        run_id: str = run_id or gen_id(self.alias, unique=True)
+        rs_release: Result = Result(run_id=run_id)
         runner: CronRunner = self.runner
 
         # NOTE: get next schedule time that generate from now.
@@ -1035,15 +1125,15 @@ class WorkflowTaskData:
             next_time: datetime = runner.next
 
         logger.debug(
-            f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} : "
-            f"{next_time:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+            f"{runner.cron} : {next_time:%Y-%m-%d %H:%M:%S}"
         )
         heappush(queue[self.alias], next_time)
         start_sec: float = time.monotonic()
 
         if get_diff_sec(next_time, tz=runner.tz) > waiting_sec:
             logger.debug(
-                f"({run_id}) [WORKFLOW]: {self.workflow.name!r} : "
+                f"({cut_id(run_id)}) [WORKFLOW]: {self.workflow.name!r} : "
                 f"{runner.cron} "
                 f": Does not closely >> {next_time:%Y-%m-%d %H:%M:%S}"
             )
@@ -1053,11 +1143,11 @@ class WorkflowTaskData:
             queue[self.alias].remove(next_time)
 
             time.sleep(0.2)
-            return
+            return rs_release.catch(status=0, context={})
 
         logger.debug(
-            f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} : "
-            f"Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+            f"{runner.cron} : Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
         )
 
         # NOTE: Release when the time is nearly to schedule time.
@@ -1065,8 +1155,8 @@ class WorkflowTaskData:
             sleep_interval + 5
         ):
             logger.debug(
-                f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} "
-                f": Sleep until: {duration}"
+                f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+                f"{runner.cron} : Sleep until: {duration}"
             )
             time.sleep(15)
 
@@ -1077,6 +1167,9 @@ class WorkflowTaskData:
         release_params: DictData = {
             "release": {
                 "logical_date": next_time,
+                "execute_date": datetime.now(tz=config.tz),
+                "run_id": run_id,
+                "timezone": runner.tz,
             },
         }
 
@@ -1085,8 +1178,8 @@ class WorkflowTaskData:
             params=param2template(self.params, release_params),
         )
         logger.debug(
-            f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} : "
-            f"End release - {next_time:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+            f"{runner.cron} : End release - {next_time:%Y-%m-%d %H:%M:%S}"
         )
 
         # NOTE: Set parent ID on this result.
@@ -1122,6 +1215,18 @@ class WorkflowTaskData:
         # NOTE: Queue next release date.
         logger.debug(f"[CORE]: {'-' * 100}")
 
+        context: dict[str, Any] = rs.context
+        context.pop("params")
+
+        return rs_release.catch(
+            status=0,
+            context={
+                "params": self.params,
+                "release": {"status": "success", "logical_date": next_time},
+                "outputs": context,
+            },
+        )
+
     def __eq__(self, other: WorkflowTaskData) -> bool:
         """Override equal property that will compare only the same type."""
         if isinstance(other, WorkflowTaskData):