durable-workflow 2.12.2__tar.gz → 2.12.3__tar.gz

{durable_workflow-2.12.2/src/durable_workflow.egg-info → durable_workflow-2.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.12.2
+Version: 2.12.3
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.12.2"
+version = "2.12.3"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -79,8 +79,8 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.12.2"
-registry-version = "2.12.2"
+product-train = "2.12.3"
+registry-version = "2.12.3"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/src/durable_workflow/_activity_process.py

@@ -24,6 +24,7 @@ from multiprocessing.process import BaseProcess
 from pathlib import Path
 from typing import Any, cast
 
+from ._failure_reporting import exception_message
 from .activity import ActivityContext, ActivityInfo, _set_context
 from .errors import ActivityCancelled, NonRetryableError
 from .interceptors import ActivityInterceptorContext, WorkerInterceptor
@@ -139,7 +140,7 @@ def _callback(directory: str, channel: socket.socket) -> None:
         except BaseException as error:
             code = getattr(error, "code", None)
             _write_payload(directory, "outcome", CallbackOutcome(failure=CallbackFailure(
-                message=str(error), failure_type=type(error).__name__,
+                message=exception_message(error), failure_type=type(error).__name__,
                 failure_class=f"{type(error).__module__}.{type(error).__qualname__}",
                 failure_code=code if isinstance(code, int) and not isinstance(code, bool) else None,
                 stack_trace=traceback.format_exc(), non_retryable=isinstance(error, NonRetryableError),

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/src/durable_workflow/_failure_reporting.py

@@ -26,6 +26,12 @@ _EXCEPTION_IDENTITY = frozenset({
 })
 
 
+def exception_message(error: BaseException, *, fallback: str | None = None) -> str:
+    """Keep useful diagnostic text; blank exceptions still need a valid report."""
+    message = str(error)
+    return message if message.strip() else fallback or type(error).__name__
+
+
 def encoded_json(value: Any) -> bytes:
     """Use HTTPX's actual JSON settings, including escaping and NaN refusal."""
     return httpx.Request("POST", "https://failure.invalid", json=value).content

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/src/durable_workflow/invocable.py

@@ -12,6 +12,7 @@ from datetime import datetime, timezone
 from typing import Any, cast
 
 from . import serializer
+from ._failure_reporting import exception_message
 from .errors import ActivityCancelled, NonRetryableError
 from .external_storage import ExternalPayloadCache, ExternalStorageDriver
 from .external_task_input import ExternalTaskInput, parse_external_task_input
@@ -105,7 +106,7 @@ class InvocableActivityHandler:
                 started,
                 kind="application",
                 classification="application_error",
-                message=str(exc),
+                message=exception_message(exc),
                 failure_type=type(exc).__name__,
                 stack_trace=traceback.format_exc(),
                 retryable=False,
@@ -116,7 +117,7 @@ class InvocableActivityHandler:
                 started,
                 kind="timeout",
                 classification="deadline_exceeded",
-                message=str(exc) or "Invocable activity handler exceeded its deadline.",
+                message=exception_message(exc, fallback="Invocable activity handler exceeded its deadline."),
                 failure_type=type(exc).__name__,
                 stack_trace=traceback.format_exc(),
                 timeout_type="deadline_exceeded",
@@ -140,7 +141,7 @@ class InvocableActivityHandler:
                 started,
                 kind="application",
                 classification="application_error",
-                message=str(exc),
+                message=exception_message(exc),
                 failure_type=type(exc).__name__,
                 stack_trace=traceback.format_exc(),
                 retryable=True,

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/src/durable_workflow/worker.py

@@ -44,7 +44,7 @@ from ._activity_lease import activity_lease_renewal_supported, current_activity_
 from ._activity_process import CallbackFailure, CallbackInvocation, CallbackProcessLost, SupervisedCallback
 from ._cancellation_scope_history import CancellationScopeBudget, CancellationScopeDeliveryReceipt
 from ._cooperative_cancellation import CancellationRequest, read_cancellation_history
-from ._failure_reporting import REQUEST_BYTES, normalize_local_failure
+from ._failure_reporting import REQUEST_BYTES, exception_message, normalize_local_failure
 from ._prepared_local_activity import PreparedAttempt, PreparedCancellationObserved, PreparedLocalRunner
 from ._query_task_authority import QueryTaskAuthority, current_query_authority
 from ._sticky_workflow_cache import CacheKey, StickyWorkflowCache, complete_history
@@ -3240,7 +3240,7 @@ class Worker:
         except NonRetryableError as e:
             log.exception("activity failed (non-retryable)")
             await self._report_activity_task_failure(
-                task_id, attempt_id, "activity failure", message=str(e), failure_type=type(e).__name__,
+                task_id, attempt_id, "activity failure", message=exception_message(e), failure_type=type(e).__name__,
                 failure_class=_exception_class_name(e), failure_code=_exception_code(e),
                 stack_trace=traceback.format_exc(), non_retryable=True,
             )
@@ -3271,7 +3271,8 @@ class Worker:
             raise error
         log.error("activity failed", exc_info=(type(error), error, error.__traceback__))
         await self._report_activity_task_failure(
-            task_id, attempt_id, "activity failure", message=str(error), failure_type=type(error).__name__,
+            task_id, attempt_id, "activity failure", message=exception_message(error),
+            failure_type=type(error).__name__,
             failure_class=_exception_class_name(error), failure_code=_exception_code(error),
             stack_trace="".join(traceback.format_exception(type(error), error, error.__traceback__)),
         )
@@ -3573,7 +3574,7 @@ class Worker:
             )
             return "failed"
         except QueryFailed as e:
-            message = str(e)
+            message = exception_message(e)
             if "unknown query" in message:
                 reason = "rejected_unknown_query"
             elif message.startswith("workflow replay failed before query:"):
@@ -3594,7 +3595,7 @@ class Worker:
             await self._fail_query_task(
                 query_task_id,
                 attempt,
-                str(e) or "query execution failed",
+                exception_message(e, fallback="query execution failed"),
                 reason="query_rejected",
                 failure_type=type(e).__name__,
                 stack_trace=traceback.format_exc(),
@@ -3631,7 +3632,7 @@ class Worker:
             await self._fail_query_task(
                 query_task_id,
                 attempt,
-                str(e) or "query result completion was rejected by the server",
+                exception_message(e, fallback="query result completion was rejected by the server"),
                 reason=server_reason if server_reason else "query_result_completion_failed",
                 failure_type=type(e).__name__,
                 stack_trace=traceback.format_exc(),
@@ -3667,7 +3668,7 @@ class Worker:
             await self._fail_query_task(
                 query_task_id,
                 attempt,
-                str(e) or "query result completion failed",
+                exception_message(e, fallback="query result completion failed"),
                 reason="query_result_completion_failed",
                 failure_type=type(e).__name__,
                 stack_trace=traceback.format_exc(),
@@ -4075,7 +4076,7 @@ class Worker:
             return await self._reject_update_validation_task(
                 task_id,
                 attempt,
-                str(exc) or "update validator rejected the request",
+                exception_message(exc, fallback="update validator rejected the request"),
                 reason="update_validator_rejected",
                 failure_type=exc.exception_type or type(exc).__name__,
                 validation_errors=exc.validation_errors,
@@ -4085,7 +4086,7 @@ class Worker:
             return await self._reject_update_validation_task(
                 task_id,
                 attempt,
-                str(exc),
+                exception_message(exc),
                 reason="update_validation_worker_failed",
                 failure_type=type(exc).__name__,
                 stack_trace=traceback.format_exc(),
@@ -4094,7 +4095,7 @@ class Worker:
             return await self._reject_update_validation_task(
                 task_id,
                 attempt,
-                str(exc) or "update validator rejected the request",
+                exception_message(exc, fallback="update validator rejected the request"),
                 reason="update_validator_rejected",
                 failure_type=type(exc).__name__,
                 stack_trace=traceback.format_exc(),

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/src/durable_workflow/workflow.py

@@ -43,6 +43,7 @@ from ._cancellation_scope_history import (
     ScopeBoundary,
 )
 from ._cooperative_cancellation import CancellationDelivery, read_cancellation_history
+from ._failure_reporting import exception_message
 from .cancellation import (
     CancellationContext,
     CancellationPolicy,
@@ -3292,7 +3293,7 @@ def _prepare_query_state(
             raise
         except Exception as exc:
             state.outcome.close()
-            raise QueryFailed(str(exc) or f"query {query_name!r} failed") from exc
+            raise QueryFailed(exception_message(exc, fallback=f"query {query_name!r} failed")) from exc
         except BaseException:
             state.outcome.close()
             raise
@@ -3594,7 +3595,7 @@ def _invoke_update_validator(
     except Exception as exc:
         errors = exc.errors if isinstance(exc, InvalidArgument) else None
         raise UpdateRejected(
-            str(exc) or f"update validator {update_name!r} rejected the request",
+            exception_message(exc, fallback=f"update validator {update_name!r} rejected the request"),
             exception_type=type(exc).__name__,
             validation_errors=errors,
         ) from exc
@@ -3614,7 +3615,7 @@ def _accepted_update_payload(
 
 
 def _fail_update_from_exception(update_id: str, prefix: str, exc: Exception) -> FailUpdate:
-    message = str(exc) or type(exc).__name__
+    message = exception_message(exc)
     return FailUpdate(
         update_id=update_id,
         message=f"{prefix}: {message}",
@@ -3628,7 +3629,7 @@ def _exception_class_name(exc: BaseException) -> str:
 
 
 def _fail_workflow_from_exception(exc: BaseException, *, prefix: str | None = None) -> FailWorkflow:
-    message = str(exc) or type(exc).__name__
+    message = exception_message(exc)
     if prefix:
         message = f"{prefix}: {message}"
 
@@ -3645,12 +3646,12 @@ def _fail_workflow_from_exception(exc: BaseException, *, prefix: str | None = No
             "initiating_failure": {
                 "type": type(initiating).__name__,
                 "class": _exception_class_name(initiating),
-                "message": str(initiating) or type(initiating).__name__,
+                "message": exception_message(initiating),
             },
             "compensation_failure": {
                 "type": type(compensation).__name__,
                 "class": _exception_class_name(compensation),
-                "message": str(compensation) or type(compensation).__name__,
+                "message": exception_message(compensation),
                 "activity_type": exc.compensation_activity_type,
                 "registration_order": exc.compensation_registration_order,
             },

{durable_workflow-2.12.2 → durable_workflow-2.12.3/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.12.2
+Version: 2.12.3
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/src/durable_workflow.egg-info/SOURCES.txt

@@ -83,6 +83,7 @@ tests/test_cooperative_cancellation_worker.py
 tests/test_cooperative_remote_worker.py
 tests/test_docstring_cross_references.py
 tests/test_durable_selection.py
+tests/test_empty_callback_failure.py
 tests/test_errors.py
 tests/test_external_storage.py
 tests/test_external_task_input.py

durable_workflow-2.12.3/tests/test_empty_callback_failure.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import AsyncMock
+
+import pytest
+
+from durable_workflow import serializer, workflow
+from durable_workflow.client import Client
+from durable_workflow.errors import NonRetryableError
+from durable_workflow.external_task_result import parse_external_task_result
+from durable_workflow.invocable import handle_invocable_activity
+from durable_workflow.worker import Worker
+from durable_workflow.workflow import _fail_update_from_exception, _fail_workflow_from_exception
+from tests.query_task_helpers import leased_query_task
+from tests.test_cooperative_remote_worker import make_owner, task
+from tests.test_invocable import activity_input
+from tests.test_worker import mock_client  # noqa: F401  (shared fixture)
+
+
+async def application_failure(kind: str, message: str) -> None:
+    if kind == "NonRetryableError":
+        raise NonRetryableError(message)
+    raise AssertionError(message)
+
+
+@pytest.mark.parametrize("message", ["", " \t\n", "  original failure  "])
+@pytest.mark.parametrize("kind", ["AssertionError", "NonRetryableError"])
+@pytest.mark.parametrize("supervised", [False, True])
+async def test_callback_failure_reports_a_nonempty_message_with_original_authority(
+    monkeypatch: pytest.MonkeyPatch, message: str, kind: str, supervised: bool,
+) -> None:
+    if supervised:
+        worker, client = await make_owner(monkeypatch)
+    else:
+        client = AsyncMock(spec=Client)
+        worker = Worker(client, task_queue="queue", worker_id="owner")
+    worker.activities["remote"] = application_failure
+    try:
+        outcome = await worker._run_activity_task(task(kind, message))
+        assert outcome == ("failed_non_retryable" if kind == "NonRetryableError" else "failed")
+        client.fail_activity_task.assert_awaited_once()
+        report = client.fail_activity_task.await_args.kwargs
+        assert report["message"] == (message if message.strip() else kind)
+        assert report["failure_type"] == kind
+        assert report["failure_class"].endswith("." + kind)
+        assert report.get("non_retryable", False) is (kind == "NonRetryableError")
+        assert report["task_id"] == "remote-task"
+        assert report["activity_attempt_id"] == "attempt"
+        assert report["lease_owner"] == "owner"
+        assert "application_failure" in report["stack_trace"]
+        client.complete_activity_task.assert_not_awaited()
+    finally:
+        await worker.stop()
+
+
+@pytest.mark.parametrize("message", ["", " \t\n", "  original failure  "])
+@pytest.mark.parametrize("kind", ["AssertionError", "NonRetryableError"])
+async def test_invocable_failure_keeps_a_valid_typed_envelope(message: str, kind: str) -> None:
+    output = await handle_invocable_activity(
+        activity_input(kind, message), {"billing.charge-card": application_failure},
+    )
+    failure: Any = parse_external_task_result(output).failure
+    assert failure.message == (message if message.strip() else kind)
+    assert failure.type == kind
+    assert "application_failure" in failure.stack_trace
+
+
+@pytest.mark.parametrize("message", ["", " \t\n", "  original failure  "])
+def test_workflow_and_update_failures_have_useful_messages(message: str) -> None:
+    error = AssertionError(message)
+    expected = message if message.strip() else "AssertionError"
+    failed = _fail_workflow_from_exception(error)
+    assert failed.message == expected
+    assert failed.exception_type == "AssertionError"
+    update = _fail_update_from_exception("update", "update rejected", error)
+    assert update.message == "update rejected: " + expected
+    assert update.exception_type == "AssertionError"
+
+
+@workflow.defn(name="tests.blank-query-and-validator")
+class BlankQueryAndValidatorWorkflow:
+    message = ""
+
+    @workflow.query("status")
+    def status(self) -> str:
+        raise AssertionError(type(self).message)
+
+    @workflow.update("approve")
+    def approve(self) -> None:
+        return None
+
+    @approve.validator  # type: ignore[attr-defined]
+    def validate_approve(self) -> None:
+        raise AssertionError(type(self).message)
+
+    def run(self, ctx: Any) -> str:
+        return "waiting"
+
+
+def blank_workflow_task(**fields: Any) -> dict[str, Any]:
+    return {
+        "workflow_type": "tests.blank-query-and-validator",
+        "history_events": [],
+        "workflow_arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+        **fields,
+    }
+
+
+@pytest.mark.parametrize("message", ["", " \t\n", "  original failure  "])
+async def test_query_failure_reports_a_nonempty_message(
+    mock_client: AsyncMock, message: str, monkeypatch: pytest.MonkeyPatch,  # noqa: F811
+) -> None:
+    monkeypatch.setattr(BlankQueryAndValidatorWorkflow, "message", message)
+    worker = Worker(mock_client, task_queue="q1", workflows=[BlankQueryAndValidatorWorkflow])
+    query = blank_workflow_task(
+        query_task_id="qt-blank", query_task_attempt=3, query_name="status",
+        query_arguments=serializer.envelope([], codec="avro"),
+    )
+
+    assert await worker._run_query_task(leased_query_task(worker, query)) == "failed"
+
+    report = mock_client.fail_query_task.await_args.kwargs
+    assert report["message"] == (message if message.strip() else "query 'status' failed")
+    assert report["reason"] == "query_rejected"
+    assert report["query_task_id"] == "qt-blank"
+    assert report["query_task_attempt"] == 3
+    mock_client.complete_query_task.assert_not_awaited()
+
+
+@pytest.mark.parametrize("message", ["", " \t\n", "  original failure  "])
+async def test_update_validator_rejection_reports_a_nonempty_message(
+    mock_client: AsyncMock, message: str, monkeypatch: pytest.MonkeyPatch,  # noqa: F811
+) -> None:
+    monkeypatch.setattr(BlankQueryAndValidatorWorkflow, "message", message)
+    worker = Worker(
+        mock_client, task_queue="q1", workflows=[BlankQueryAndValidatorWorkflow], worker_id="validator",
+    )
+    validation = blank_workflow_task(
+        task_kind="update_validation", update_validation_task_id="uv-blank", update_validation_attempt=2,
+        update_name="approve", update_arguments=serializer.envelope([], codec="avro"),
+        workflow_id="wf", run_id="run",
+    )
+
+    assert await worker._run_update_validation_task(validation) == "rejected"
+
+    rejection = mock_client.reject_update_validation_task.await_args.kwargs
+    expected = message if message.strip() else "update validator 'approve' rejected the request"
+    assert expected in rejection["message"]
+    assert rejection["message"].strip()
+    assert rejection["reason"] == "update_validator_rejected"
+    assert rejection["failure_type"] == "AssertionError"
+    assert rejection["update_validation_task_id"] == "uv-blank"
+    assert rejection["update_validation_attempt"] == 2
+    mock_client.approve_update_validation_task.assert_not_awaited()

{durable_workflow-2.12.2 → durable_workflow-2.12.3}/tests/test_replay_regression_corpus.py

@@ -344,8 +344,15 @@ class NexusCooperativeDeliveryWorkflow:
             return error.request_id
 
 
+@workflow.defn(name="tests.replay.blank-failure")
+class BlankFailureWorkflow:
+    def run(self, ctx: WorkflowContext, message: str) -> None:
+        raise AssertionError(message)
+
+
 WORKFLOWS = [
     PendingFinally,
+    BlankFailureWorkflow,
     IdentityAcrossReplay,
     IdentityContinueAsNew,
     PersistedClockWorkflow,