flowtask 5.12.9__tar.gz → 5.12.12__tar.gz

{flowtask-5.12.9 → flowtask-5.12.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtask
-Version: 5.12.9
+Version: 5.12.12
 Summary: Framework for Task orchestration
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: Apache-2.0

{flowtask-5.12.9 → flowtask-5.12.12}/flowtask/components/UpdateOperationalVars.py

@@ -44,6 +44,7 @@
 
 import asyncio
 import logging
+import os
 from typing import Any
 from collections.abc import Callable
 from ..exceptions import ComponentError
@@ -154,18 +155,23 @@ class UpdateOperationalVars(DBSupport, FlowComponent):
             else:
                 program = self._program
             if hasattr(self, "name"):
-                self._environment.set(self.name, self.value)
-                value = self._environment.get(self.name)
+                # Set the variable in the process environment only (os.environ),
+                # avoiding navconfig's `config.set()` which propagates writes to
+                # the Vault backend in production.
+                os.environ[self.name] = str(self.value)
+                value = os.environ.get(self.name)
                 if value == self.value:
                     await self.set_variable(self.name, value, program)
             elif hasattr(self, "names"):
                 value = None
                 for name in self.names:
                     try:
-                        self._environment.set(name, self.value)
-                        value = self._environment.get(name)
+                        os.environ[name] = str(self.value)
+                        value = os.environ.get(name)
                     except Exception as err:
-                        print(err)
+                        self.logger.warning(
+                            f"Error setting environment variable {name}: {err}"
+                        )
                     if value == self.value:
                         await self.set_variable(name, value, program)
             return self._result

{flowtask-5.12.9 → flowtask-5.12.12}/flowtask/components/Workday/workday.py

@@ -126,6 +126,11 @@ class Workday(FlowComponent):
         )
         self.updated_from_date = kwargs.get("updated_from_date")
         self.updated_to_date = kwargs.get("updated_to_date")
+        # FEAT-192: optional recursive Cost_Center_Hierarchy chain; organization
+        # enrichment itself always runs (no opt-in flag) — this only controls
+        # whether org_hierarchy_chain is also built. Defaults to None (not
+        # forwarded) so the handler's own default (False) applies.
+        self.include_hierarchy_chain = kwargs.get("include_hierarchy_chain")
 
         # Applicant parameters
         self.applicant_id = kwargs.get("applicant_id")
@@ -503,7 +508,8 @@ class Workday(FlowComponent):
 
         if self.type == "get_cost_centers":
             for attr in ("cost_center_id", "cost_center_id_type",
-                         "updated_from_date", "updated_to_date", "include_inactive"):
+                         "updated_from_date", "updated_to_date", "include_inactive",
+                         "include_hierarchy_chain"):
                 val = getattr(self, attr, None)
                 if val is not None:
                     params[attr] = val

{flowtask-5.12.9 → flowtask-5.12.12}/flowtask/executors/qworker.py

@@ -3,6 +3,7 @@
 """Qworker job executor — dispatches tasks through the qw worker queue."""
 from __future__ import annotations
 import asyncio
+import time
 import uuid
 from typing import Any, Optional
 from flowtask.executors.base import AbstractJobExecutor
@@ -13,10 +14,20 @@ from flowtask.executors.models import (
     TaskResult,
 )
 from flowtask.executors.events import ExecutorLifecyclePublisher
-from flowtask.executors.exceptions import ExecutorError
+from flowtask.executors.exceptions import ExecutorError, ExecutorConnectionError
 from flowtask.executors.registry import register_executor
 
 DEFAULT_DISPATCH_TIMEOUT = 60
+DEFAULT_RETRY_DELAY = 10
+DEFAULT_MAX_RETRY_ELAPSED = 60
+
+_TRANSIENT_ERRORS = (
+    asyncio.TimeoutError,
+    ConnectionError,
+    ConnectionRefusedError,
+    ConnectionResetError,
+    OSError,
+)
 
 
 @register_executor("qworker")
@@ -185,6 +196,46 @@ class QworkerJobExecutor(AbstractJobExecutor):
             execution_id=execution_id,
         )
 
+    def _load_retry_config(self) -> tuple[int, int, int]:
+        """Load timeout and retry settings from project config.
+
+        Returns:
+            Tuple of (timeout, retry_delay, max_retry_elapsed) in seconds.
+        """
+        try:
+            from flowtask.conf import (
+                SCHEDULER_WORKER_TIMEOUT,
+                SCHEDULER_RETRY_ENQUEUE,
+                SCHEDULER_MAX_RETRY_ENQUEUE,
+            )
+            timeout = self._config.timeout or SCHEDULER_WORKER_TIMEOUT
+            retry_delay = SCHEDULER_RETRY_ENQUEUE
+            max_elapsed = SCHEDULER_MAX_RETRY_ENQUEUE
+        except ImportError:
+            timeout = self._config.timeout or DEFAULT_DISPATCH_TIMEOUT
+            retry_delay = DEFAULT_RETRY_DELAY
+            max_elapsed = DEFAULT_MAX_RETRY_ELAPSED
+        return timeout, retry_delay, max_elapsed
+
+    @staticmethod
+    def _classify_dispatch_error(exc: Exception) -> str:
+        """Return a human-readable reason for a dispatch failure."""
+        if isinstance(exc, asyncio.TimeoutError):
+            return "timed out waiting for worker queue — workers may be unreachable or overloaded"
+        if isinstance(exc, ConnectionRefusedError):
+            return "connection refused by worker queue broker (Redis/RabbitMQ may be down)"
+        if isinstance(exc, ConnectionResetError):
+            return "connection to worker queue broker was reset unexpectedly"
+        if isinstance(exc, (ConnectionError, OSError)):
+            return f"network/OS error connecting to worker queue broker: {exc}"
+        if isinstance(exc, asyncio.QueueFull):
+            return "worker queue is full — task discarded (non-retryable)"
+        exc_name = type(exc).__name__
+        exc_msg = str(exc)
+        if "pickle" in exc_msg.lower() or "serialize" in exc_msg.lower():
+            return f"task payload serialization failed (non-retryable): {exc_msg}"
+        return f"unexpected error ({exc_name}): {exc_msg}"
+
     async def dispatch(
         self,
         program: str,
@@ -195,7 +246,9 @@ class QworkerJobExecutor(AbstractJobExecutor):
         """Queue the task (fire-and-forget) and return immediately.
 
         Uses ``QClient.queue()`` by default, or ``QClient.publish()`` when
-        ``priority == "pub"``.
+        ``priority == "pub"``.  Retries on transient errors (timeout,
+        connection refused/reset) up to ``SCHEDULER_MAX_RETRY_ENQUEUE``
+        seconds of wall-clock time.
 
         Args:
             program: Program slug.
@@ -218,50 +271,83 @@ class QworkerJobExecutor(AbstractJobExecutor):
 
         wrapper = self._make_wrapper(program, task, execution_id, queued=True, **kwargs)
 
-        try:
-            from flowtask.conf import SCHEDULER_WORKER_TIMEOUT
-            timeout = self._config.timeout or SCHEDULER_WORKER_TIMEOUT
-        except ImportError:
-            timeout = self._config.timeout or DEFAULT_DISPATCH_TIMEOUT
-        try:
-            if priority == "pub":
-                client = self._get_client(priority=None)
-                result = await asyncio.wait_for(
-                    client.publish(wrapper), timeout=timeout
+        timeout, retry_delay, max_elapsed = self._load_retry_config()
+        start_time = time.monotonic()
+        attempt = 0
+        last_exc: Exception | None = None
+
+        while True:
+            attempt += 1
+            try:
+                if priority == "pub":
+                    client = self._get_client(priority=None)
+                    result = await asyncio.wait_for(
+                        client.publish(wrapper), timeout=timeout
+                    )
+                else:
+                    client = self._get_client(priority=priority)
+                    result = await asyncio.wait_for(
+                        client.queue(wrapper), timeout=timeout
+                    )
+                if attempt > 1:
+                    self.logger.info(
+                        "QClient dispatch for %s.%s succeeded on attempt %d",
+                        program, task, attempt,
+                    )
+                return ExecutionHandle(
+                    executor_type=ExecutorType.QWORKER,
+                    execution_id=execution_id,
+                    task_program=program,
+                    task_name=task,
+                    channel=channel,
                 )
-            else:
-                client = self._get_client(priority=priority)
-                result = await asyncio.wait_for(
-                    client.queue(wrapper), timeout=timeout
+            except _TRANSIENT_ERRORS as exc:
+                last_exc = exc
+                elapsed = time.monotonic() - start_time
+                reason = self._classify_dispatch_error(exc)
+                if elapsed >= max_elapsed:
+                    msg = (
+                        f"QClient dispatch failed for {program}.{task} "
+                        f"after {attempt} attempt(s) over {elapsed:.0f}s — "
+                        f"reason: {reason}"
+                    )
+                    self.logger.error(msg)
+                    await self._publisher.publish(
+                        "failed", program, task, execution_id, error=msg
+                    )
+                    is_conn = isinstance(exc, (ConnectionError, OSError)) and not isinstance(exc, TimeoutError)
+                    if is_conn:
+                        raise ExecutorConnectionError(msg) from exc
+                    raise ExecutorError(msg) from exc
+                self.logger.warning(
+                    "QClient dispatch attempt %d for %s.%s failed (%s). "
+                    "Retrying in %ds (%.0f/%.0fs elapsed).",
+                    attempt, program, task, reason,
+                    retry_delay, elapsed, max_elapsed,
                 )
-        except asyncio.TimeoutError as exc:
-            msg = (
-                f"QClient dispatch timed out after {timeout}s "
-                f"for {program}.{task} — workers may be unreachable"
-            )
-            self.logger.error(msg)
-            await self._publisher.publish(
-                "failed", program, task, execution_id, error=msg
-            )
-            raise ExecutorError(msg) from exc
-        except Exception as exc:
-            self.logger.error(
-                "QworkerExecutor dispatch failed for %s.%s: %s", program, task, exc
-            )
-            await self._publisher.publish(
-                "failed", program, task, execution_id, error=str(exc)
-            )
-            raise ExecutorError(
-                f"QClient dispatch failed for {program}.{task}: {exc}"
-            ) from exc
-
-        return ExecutionHandle(
-            executor_type=ExecutorType.QWORKER,
-            execution_id=execution_id,
-            task_program=program,
-            task_name=task,
-            channel=channel,
-        )
+                await asyncio.sleep(retry_delay)
+            except asyncio.QueueFull as exc:
+                reason = self._classify_dispatch_error(exc)
+                msg = (
+                    f"QClient dispatch failed for {program}.{task} — "
+                    f"reason: {reason}"
+                )
+                self.logger.error(msg)
+                await self._publisher.publish(
+                    "failed", program, task, execution_id, error=msg
+                )
+                raise ExecutorError(msg) from exc
+            except Exception as exc:
+                reason = self._classify_dispatch_error(exc)
+                msg = (
+                    f"QClient dispatch failed for {program}.{task} — "
+                    f"reason: {reason}"
+                )
+                self.logger.error(msg)
+                await self._publisher.publish(
+                    "failed", program, task, execution_id, error=msg
+                )
+                raise ExecutorError(msg) from exc
 
     async def run(
         self,
@@ -273,6 +359,8 @@ class QworkerJobExecutor(AbstractJobExecutor):
         """Run the task via QClient and wait for the result.
 
         Uses ``QClient.run()`` (or ``QClient.publish()`` for priority=pub).
+        Retries on transient connection errors up to
+        ``SCHEDULER_MAX_RETRY_ENQUEUE`` seconds of wall-clock time.
 
         Args:
             program: Program slug.
@@ -294,56 +382,82 @@ class QworkerJobExecutor(AbstractJobExecutor):
             program, task, execution_id, queued=False, **kwargs
         )
 
-        try:
-            if priority == "pub":
-                client = self._get_client(priority=None)
-                raw = await client.publish(wrapper)
-            elif priority == "direct":
-                client = self._get_client(priority="default")
-                raw = await client.run(wrapper)
-            else:
-                client = self._get_client(priority=priority)
-                raw = await client.run(wrapper)
-
-            task_result = self._parse_result(raw, execution_id)
-
-            if task_result.status == "success":
-                await self._publisher.publish(
-                    "completed", program, task, execution_id
+        _, retry_delay, max_elapsed = self._load_retry_config()
+        start_time = time.monotonic()
+        attempt = 0
+
+        while True:
+            attempt += 1
+            try:
+                if priority == "pub":
+                    client = self._get_client(priority=None)
+                    raw = await client.publish(wrapper)
+                elif priority == "direct":
+                    client = self._get_client(priority="default")
+                    raw = await client.run(wrapper)
+                else:
+                    client = self._get_client(priority=priority)
+                    raw = await client.run(wrapper)
+
+                task_result = self._parse_result(raw, execution_id)
+
+                if attempt > 1:
+                    self.logger.info(
+                        "QClient run for %s.%s succeeded on attempt %d",
+                        program, task, attempt,
+                    )
+
+                if task_result.status == "success":
+                    await self._publisher.publish(
+                        "completed", program, task, execution_id
+                    )
+                else:
+                    await self._publisher.publish(
+                        "failed", program, task, execution_id, error=task_result.error
+                    )
+
+                return task_result
+
+            except _TRANSIENT_ERRORS as exc:
+                elapsed = time.monotonic() - start_time
+                reason = self._classify_dispatch_error(exc)
+                if elapsed >= max_elapsed:
+                    msg = (
+                        f"QClient run failed for {program}.{task} "
+                        f"after {attempt} attempt(s) over {elapsed:.0f}s — "
+                        f"reason: {reason}"
+                    )
+                    self.logger.error(msg)
+                    await self._publisher.publish(
+                        "failed", program, task, execution_id, error=msg
+                    )
+                    return TaskResult(
+                        status="failed",
+                        error=msg,
+                        execution_id=execution_id,
+                    )
+                self.logger.warning(
+                    "QClient run attempt %d for %s.%s failed (%s). "
+                    "Retrying in %ds (%.0f/%.0fs elapsed).",
+                    attempt, program, task, reason,
+                    retry_delay, elapsed, max_elapsed,
                 )
-            else:
+                await asyncio.sleep(retry_delay)
+            except Exception as exc:
+                reason = self._classify_dispatch_error(exc)
+                msg = (
+                    f"QClient run failed for {program}.{task} — "
+                    f"reason: {reason}"
+                )
+                self.logger.error(msg)
                 await self._publisher.publish(
-                    "failed", program, task, execution_id, error=task_result.error
+                    "failed", program, task, execution_id, error=str(exc)
+                )
+                return TaskResult(
+                    status="failed",
+                    error=msg,
+                    execution_id=execution_id,
                 )
-
-            return task_result
-
-        except asyncio.TimeoutError as exc:
-            msg = (
-                f"QClient run timed out for {program}.{task} "
-                f"— workers may be unreachable"
-            )
-            self.logger.error(msg)
-            await self._publisher.publish(
-                "failed", program, task, execution_id, error=msg
-            )
-            return TaskResult(
-                status="failed",
-                error=msg,
-                execution_id=execution_id,
-            )
-        except Exception as exc:
-            self.logger.error(
-                "QworkerExecutor run failed for %s.%s: %s", program, task, exc
-            )
-            await self._publisher.publish(
-                "failed", program, task, execution_id, error=str(exc)
-            )
-            return TaskResult(
-                status="failed",
-                error=str(exc),
-                execution_id=execution_id,
-            )
 
     async def close(self) -> None:
         """Close the lifecycle publisher.