dbos 1.14.0a4__tar.gz → 1.14.0a6__tar.gz

{dbos-1.14.0a4 → dbos-1.14.0a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 1.14.0a4
+Version: 1.14.0a6
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/__init__.py

@@ -9,6 +9,7 @@ from ._context import (
 )
 from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowHandleAsync
 from ._dbos_config import DBOSConfig
+from ._debouncer import Debouncer, DebouncerClient
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
 from ._sys_db import GetWorkflowsInput, WorkflowStatus, WorkflowStatusString
@@ -32,4 +33,6 @@ __all__ = [
     "WorkflowStatusString",
     "error",
     "Queue",
+    "Debouncer",
+    "DebouncerClient",
 ]

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/_client.py

@@ -3,6 +3,7 @@ import sys
 import time
 import uuid
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncGenerator,
     Generator,
@@ -24,7 +25,10 @@ else:
     from typing import NotRequired
 
 from dbos import _serialization
-from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+
+if TYPE_CHECKING:
+    from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+
 from dbos._dbos_config import (
     get_application_database_url,
     get_system_database_url,
@@ -224,23 +228,25 @@ class DBOSClient:
 
     def enqueue(
         self, options: EnqueueOptions, *args: Any, **kwargs: Any
-    ) -> WorkflowHandle[R]:
+    ) -> "WorkflowHandle[R]":
         workflow_id = self._enqueue(options, *args, **kwargs)
         return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
 
     async def enqueue_async(
         self, options: EnqueueOptions, *args: Any, **kwargs: Any
-    ) -> WorkflowHandleAsync[R]:
+    ) -> "WorkflowHandleAsync[R]":
         workflow_id = await asyncio.to_thread(self._enqueue, options, *args, **kwargs)
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
 
-    def retrieve_workflow(self, workflow_id: str) -> WorkflowHandle[R]:
+    def retrieve_workflow(self, workflow_id: str) -> "WorkflowHandle[R]":
         status = get_workflow(self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
 
-    async def retrieve_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[R]:
+    async def retrieve_workflow_async(
+        self, workflow_id: str
+    ) -> "WorkflowHandleAsync[R]":
         status = await asyncio.to_thread(get_workflow, self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
@@ -311,11 +317,13 @@ class DBOSClient:
     async def cancel_workflow_async(self, workflow_id: str) -> None:
         await asyncio.to_thread(self.cancel_workflow, workflow_id)
 
-    def resume_workflow(self, workflow_id: str) -> WorkflowHandle[Any]:
+    def resume_workflow(self, workflow_id: str) -> "WorkflowHandle[Any]":
         self._sys_db.resume_workflow(workflow_id)
         return WorkflowHandleClientPolling[Any](workflow_id, self._sys_db)
 
-    async def resume_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[Any]:
+    async def resume_workflow_async(
+        self, workflow_id: str
+    ) -> "WorkflowHandleAsync[Any]":
         await asyncio.to_thread(self.resume_workflow, workflow_id)
         return WorkflowHandleClientAsyncPolling[Any](workflow_id, self._sys_db)
 
@@ -451,7 +459,7 @@ class DBOSClient:
         start_step: int,
         *,
         application_version: Optional[str] = None,
-    ) -> WorkflowHandle[Any]:
+    ) -> "WorkflowHandle[Any]":
         forked_workflow_id = fork_workflow(
             self._sys_db,
             self._app_db,
@@ -467,7 +475,7 @@ class DBOSClient:
         start_step: int,
         *,
         application_version: Optional[str] = None,
-    ) -> WorkflowHandleAsync[Any]:
+    ) -> "WorkflowHandleAsync[Any]":
         forked_workflow_id = await asyncio.to_thread(
             fork_workflow,
             self._sys_db,

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/_context.py

@@ -215,11 +215,18 @@ class DBOSContext:
     def end_handler(self, exc_value: Optional[BaseException]) -> None:
         self._end_span(exc_value)
 
-    def get_current_span(self) -> Optional[Span]:
+    """ Return the current DBOS span if any. It must be a span created by DBOS."""
+
+    def get_current_dbos_span(self) -> Optional[Span]:
         if len(self.context_spans) > 0:
             return self.context_spans[-1].span
         return None
 
+    """ Return the current active span if any. It might not be a DBOS span."""
+
+    def get_current_active_span(self) -> Optional[Span]:
+        return dbos_tracer.get_current_span()
+
     def _start_span(self, attributes: TracedAttributes) -> None:
         if dbos_tracer.disable_otlp:
             return
@@ -235,7 +242,7 @@ class DBOSContext:
         attributes["authenticatedUserAssumedRole"] = self.assumed_role
         span = dbos_tracer.start_span(
             attributes,
-            parent=self.context_spans[-1].span if len(self.context_spans) > 0 else None,
+            parent=None,  # It'll use the current active span as the parent
         )
         # Activate the current span
         cm = use_span(
@@ -517,6 +524,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         self.saved_workflow_timeout: Optional[int] = None
         self.saved_deduplication_id: Optional[str] = None
         self.saved_priority: Optional[int] = None
+        self.saved_is_within_set_workflow_id_block: bool = False
 
     def __enter__(self) -> DBOSContext:
         # Code to create a basic context
@@ -526,6 +534,9 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
             ctx = DBOSContext()
             _set_local_dbos_context(ctx)
         assert not ctx.is_within_workflow()
+        # Unset is_within_set_workflow_id_block as the workflow is not within a block
+        self.saved_is_within_set_workflow_id_block = ctx.is_within_set_workflow_id_block
+        ctx.is_within_set_workflow_id_block = False
         # Unset the workflow_timeout_ms context var so it is not applied to this
         # workflow's children (instead we propagate the deadline)
         self.saved_workflow_timeout = ctx.workflow_timeout_ms
@@ -550,6 +561,8 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         ctx = assert_current_dbos_context()
         assert ctx.is_within_workflow()
         ctx.end_workflow(exc_value)
+        # Restore is_within_set_workflow_id_block
+        ctx.is_within_set_workflow_id_block = self.saved_is_within_set_workflow_id_block
         # Restore the saved workflow timeout
         ctx.workflow_timeout_ms = self.saved_workflow_timeout
         # Clear any propagating timeout

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/_core.py

@@ -50,6 +50,7 @@ from ._error import (
     DBOSException,
     DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
+    DBOSQueueDeduplicatedError,
     DBOSRecoveryError,
     DBOSUnexpectedStepError,
     DBOSWorkflowCancelledError,
@@ -95,6 +96,7 @@ R = TypeVar("R", covariant=True)  # A generic type for workflow return values
 F = TypeVar("F", bound=Callable[..., Any])
 
 TEMP_SEND_WF_NAME = "<temp>.temp_send_workflow"
+DEBOUNCER_WORKFLOW_NAME = "_dbos_debouncer_workflow"
 
 
 def check_is_in_coroutine() -> bool:
@@ -310,10 +312,22 @@ def _init_workflow(
     }
 
     # Synchronously record the status and inputs for workflows
-    wf_status, workflow_deadline_epoch_ms = dbos._sys_db.init_workflow(
-        status,
-        max_recovery_attempts=max_recovery_attempts,
-    )
+    try:
+        wf_status, workflow_deadline_epoch_ms = dbos._sys_db.init_workflow(
+            status,
+            max_recovery_attempts=max_recovery_attempts,
+        )
+    except DBOSQueueDeduplicatedError as e:
+        if ctx.has_parent():
+            result: OperationResultInternal = {
+                "workflow_uuid": ctx.parent_workflow_id,
+                "function_id": ctx.parent_workflow_fid,
+                "function_name": wf_name,
+                "output": None,
+                "error": _serialization.serialize_exception(e),
+            }
+            dbos._sys_db.record_operation_result(result)
+        raise
 
     if workflow_deadline_epoch_ms is not None:
         evt = threading.Event()
@@ -971,7 +985,7 @@ def decorate_transaction(
                                 dbapi_error
                             ) or dbos._app_db._is_serialization_error(dbapi_error):
                                 # Retry on serialization failure
-                                span = ctx.get_current_span()
+                                span = ctx.get_current_dbos_span()
                                 if span:
                                     span.add_event(
                                         "Transaction Failure",
@@ -1090,7 +1104,7 @@ def decorate_step(
                     exc_info=error,
                 )
                 ctx = assert_current_dbos_context()
-                span = ctx.get_current_span()
+                span = ctx.get_current_dbos_span()
                 if span:
                     span.add_event(
                         f"Step attempt {attempt} failed",

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/_dbos.py

@@ -32,12 +32,14 @@ from opentelemetry.trace import Span
 from rich import print
 
 from dbos._conductor.conductor import ConductorWebsocket
+from dbos._debouncer import debouncer_workflow
 from dbos._sys_db import SystemDatabase, WorkflowStatus
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import fork_workflow, list_queued_workflows, list_workflows
 
 from ._classproperty import classproperty
 from ._core import (
+    DEBOUNCER_WORKFLOW_NAME,
     TEMP_SEND_WF_NAME,
     WorkflowHandleAsyncPolling,
     WorkflowHandlePolling,
@@ -390,11 +392,12 @@ class DBOS:
         ) -> None:
             self.send(destination_id, message, topic)
 
-        temp_send_wf = workflow_wrapper(self._registry, send_temp_workflow)
-        set_dbos_func_name(send_temp_workflow, TEMP_SEND_WF_NAME)
-        set_dbos_func_name(temp_send_wf, TEMP_SEND_WF_NAME)
-        set_temp_workflow_type(send_temp_workflow, "send")
-        self._registry.register_wf_function(TEMP_SEND_WF_NAME, temp_send_wf, "send")
+        decorate_workflow(self._registry, TEMP_SEND_WF_NAME, None)(send_temp_workflow)
+
+        # Register the debouncer workflow
+        decorate_workflow(self._registry, DEBOUNCER_WORKFLOW_NAME, None)(
+            debouncer_workflow
+        )
 
         for handler in dbos_logger.handlers:
             handler.flush()
@@ -1297,7 +1300,7 @@ class DBOS:
     def span(cls) -> Span:
         """Return the tracing `Span` associated with the current context."""
         ctx = assert_current_dbos_context()
-        span = ctx.get_current_span()
+        span = ctx.get_current_active_span()
         assert span
         return span
 

dbos-1.14.0a6/dbos/_debouncer.py

@@ -0,0 +1,394 @@
+import asyncio
+import math
+import sys
+import time
+import types
+import uuid
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generic,
+    Optional,
+    Tuple,
+    TypedDict,
+    TypeVar,
+    Union,
+)
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+
+from dbos._client import (
+    DBOSClient,
+    EnqueueOptions,
+    WorkflowHandleClientAsyncPolling,
+    WorkflowHandleClientPolling,
+)
+from dbos._context import (
+    DBOSContextEnsure,
+    SetEnqueueOptions,
+    SetWorkflowID,
+    SetWorkflowTimeout,
+    assert_current_dbos_context,
+)
+from dbos._core import (
+    DEBOUNCER_WORKFLOW_NAME,
+    WorkflowHandleAsyncPolling,
+    WorkflowHandlePolling,
+)
+from dbos._error import DBOSQueueDeduplicatedError
+from dbos._queue import Queue
+from dbos._registrations import get_dbos_func_name
+from dbos._serialization import WorkflowInputs
+from dbos._utils import INTERNAL_QUEUE_NAME
+
+if TYPE_CHECKING:
+    from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+
+P = ParamSpec("P")  # A generic type for workflow parameters
+R = TypeVar("R", covariant=True)  # A generic type for workflow return values
+
+
+_DEBOUNCER_TOPIC = "DEBOUNCER_TOPIC"
+
+
+# Options saved from the local context to pass through to the debounced function
+class ContextOptions(TypedDict):
+    workflow_id: str
+    deduplication_id: Optional[str]
+    priority: Optional[int]
+    app_version: Optional[str]
+    workflow_timeout_sec: Optional[float]
+
+
+# Parameters for the debouncer workflow
+class DebouncerOptions(TypedDict):
+    workflow_name: str
+    debounce_timeout_sec: Optional[float]
+    queue_name: Optional[str]
+
+
+# The message sent from a debounce to the debouncer workflow
+class DebouncerMessage(TypedDict):
+    inputs: WorkflowInputs
+    message_id: str
+    debounce_period_sec: float
+
+
+def debouncer_workflow(
+    initial_debounce_period_sec: float,
+    ctx: ContextOptions,
+    options: DebouncerOptions,
+    *args: Tuple[Any, ...],
+    **kwargs: Dict[str, Any],
+) -> None:
+    from dbos._dbos import DBOS, _get_dbos_instance
+
+    dbos = _get_dbos_instance()
+
+    workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+    # Every time the debounced workflow is called, a message is sent to this workflow.
+    # It waits until debounce_period_sec have passed since the last message or until
+    # debounce_timeout_sec has elapsed.
+    debounce_deadline_epoch_sec = (
+        time.time() + options["debounce_timeout_sec"]
+        if options["debounce_timeout_sec"]
+        else math.inf
+    )
+    debounce_period_sec = initial_debounce_period_sec
+    while time.time() < debounce_deadline_epoch_sec:
+        time_until_deadline = max(debounce_deadline_epoch_sec - time.time(), 0)
+        timeout = min(debounce_period_sec, time_until_deadline)
+        message: DebouncerMessage = DBOS.recv(_DEBOUNCER_TOPIC, timeout_seconds=timeout)
+        if message is None:
+            break
+        else:
+            workflow_inputs = message["inputs"]
+            debounce_period_sec = message["debounce_period_sec"]
+            # Acknowledge receipt of the message
+            DBOS.set_event(message["message_id"], message["message_id"])
+    # After the timeout or period has elapsed, start the user workflow with the requested context parameters,
+    # either directly or on a queue.
+    with SetWorkflowID(ctx["workflow_id"]):
+        with SetWorkflowTimeout(ctx["workflow_timeout_sec"]):
+            func = dbos._registry.workflow_info_map.get(options["workflow_name"], None)
+            if not func:
+                raise Exception(
+                    f"Invalid workflow name provided to debouncer: {options['workflow_name']}"
+                )
+            if options["queue_name"]:
+                queue = dbos._registry.queue_info_map.get(options["queue_name"], None)
+                if not queue:
+                    raise Exception(
+                        f"Invalid queue name provided to debouncer: {options['queue_name']}"
+                    )
+                with SetEnqueueOptions(
+                    deduplication_id=ctx["deduplication_id"],
+                    priority=ctx["priority"],
+                    app_version=ctx["app_version"],
+                ):
+                    queue.enqueue(
+                        func, *workflow_inputs["args"], **workflow_inputs["kwargs"]
+                    )
+            else:
+                DBOS.start_workflow(
+                    func, *workflow_inputs["args"], **workflow_inputs["kwargs"]
+                )
+
+
+class Debouncer(Generic[P, R]):
+
+    def __init__(
+        self,
+        workflow_name: str,
+        *,
+        debounce_key: str,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ):
+        self.func_name = workflow_name
+        self.options: DebouncerOptions = {
+            "debounce_timeout_sec": debounce_timeout_sec,
+            "queue_name": queue.name if queue else None,
+            "workflow_name": workflow_name,
+        }
+        self.debounce_key = debounce_key
+
+    @staticmethod
+    def create(
+        workflow: Callable[P, R],
+        *,
+        debounce_key: str,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ) -> "Debouncer[P, R]":
+
+        if isinstance(workflow, (types.MethodType)):
+            raise TypeError("Only workflow functions may be debounced, not methods")
+        return Debouncer[P, R](
+            get_dbos_func_name(workflow),
+            debounce_key=debounce_key,
+            debounce_timeout_sec=debounce_timeout_sec,
+            queue=queue,
+        )
+
+    @staticmethod
+    def create_async(
+        workflow: Callable[P, Coroutine[Any, Any, R]],
+        *,
+        debounce_key: str,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ) -> "Debouncer[P, R]":
+
+        if isinstance(workflow, (types.MethodType)):
+            raise TypeError("Only workflow functions may be debounced, not methods")
+        return Debouncer[P, R](
+            get_dbos_func_name(workflow),
+            debounce_key=debounce_key,
+            debounce_timeout_sec=debounce_timeout_sec,
+            queue=queue,
+        )
+
+    def debounce(
+        self, debounce_period_sec: float, *args: P.args, **kwargs: P.kwargs
+    ) -> "WorkflowHandle[R]":
+        from dbos._dbos import DBOS, _get_dbos_instance
+
+        dbos = _get_dbos_instance()
+        internal_queue = dbos._registry.get_internal_queue()
+
+        # Read all workflow settings from context, pass them through ContextOptions
+        # into the debouncer to apply to the user workflow, then reset the context
+        # so workflow settings aren't applied to the debouncer.
+        with DBOSContextEnsure():
+            ctx = assert_current_dbos_context()
+
+            # Deterministically generate the user workflow ID and message ID
+            def assign_debounce_ids() -> tuple[str, str]:
+                return str(uuid.uuid4()), ctx.assign_workflow_id()
+
+            message_id, user_workflow_id = dbos._sys_db.call_function_as_step(
+                assign_debounce_ids, "DBOS.assign_debounce_ids"
+            )
+            ctx.id_assigned_for_next_workflow = ""
+            ctx.is_within_set_workflow_id_block = False
+            ctxOptions: ContextOptions = {
+                "workflow_id": user_workflow_id,
+                "app_version": ctx.app_version,
+                "deduplication_id": ctx.deduplication_id,
+                "priority": ctx.priority,
+                "workflow_timeout_sec": (
+                    ctx.workflow_timeout_ms / 1000.0
+                    if ctx.workflow_timeout_ms
+                    else None
+                ),
+            }
+        while True:
+            try:
+                # Attempt to enqueue a debouncer for this workflow.
+                with SetEnqueueOptions(deduplication_id=self.debounce_key):
+                    with SetWorkflowTimeout(None):
+                        internal_queue.enqueue(
+                            debouncer_workflow,
+                            debounce_period_sec,
+                            ctxOptions,
+                            self.options,
+                            *args,
+                            **kwargs,
+                        )
+                return WorkflowHandlePolling(user_workflow_id, dbos)
+            except DBOSQueueDeduplicatedError:
+                # If there is already a debouncer, send a message to it.
+                # Deterministically retrieve the ID of the debouncer
+                def get_deduplicated_workflow() -> Optional[str]:
+                    return dbos._sys_db.get_deduplicated_workflow(
+                        queue_name=internal_queue.name,
+                        deduplication_id=self.debounce_key,
+                    )
+
+                dedup_wfid = dbos._sys_db.call_function_as_step(
+                    get_deduplicated_workflow, "DBOS.get_deduplicated_workflow"
+                )
+                if dedup_wfid is None:
+                    continue
+                else:
+                    workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+                    message: DebouncerMessage = {
+                        "message_id": message_id,
+                        "inputs": workflow_inputs,
+                        "debounce_period_sec": debounce_period_sec,
+                    }
+                    DBOS.send(dedup_wfid, message, _DEBOUNCER_TOPIC)
+                    # Wait for the debouncer to acknowledge receipt of the message.
+                    # If the message is not acknowledged, this likely means the debouncer started its workflow
+                    # and exited without processing this message, so try again.
+                    if not DBOS.get_event(dedup_wfid, message_id, timeout_seconds=1):
+                        continue
+                    # Retrieve the user workflow ID from the input to the debouncer
+                    # and return a handle to it
+                    dedup_workflow_input = (
+                        DBOS.retrieve_workflow(dedup_wfid).get_status().input
+                    )
+                    assert dedup_workflow_input is not None
+                    user_workflow_id = dedup_workflow_input["args"][1]["workflow_id"]
+                    return WorkflowHandlePolling(user_workflow_id, dbos)
+
+    async def debounce_async(
+        self,
+        debounce_period_sec: float,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> "WorkflowHandleAsync[R]":
+        from dbos._dbos import _get_dbos_instance
+
+        dbos = _get_dbos_instance()
+        handle = await asyncio.to_thread(
+            self.debounce, debounce_period_sec, *args, **kwargs
+        )
+        return WorkflowHandleAsyncPolling(handle.workflow_id, dbos)
+
+
+class DebouncerClient:
+
+    def __init__(
+        self,
+        client: DBOSClient,
+        workflow_options: EnqueueOptions,
+        *,
+        debounce_key: str,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ):
+        self.workflow_options = workflow_options
+        self.debouncer_options: DebouncerOptions = {
+            "debounce_timeout_sec": debounce_timeout_sec,
+            "queue_name": queue.name if queue else None,
+            "workflow_name": workflow_options["workflow_name"],
+        }
+        self.debounce_key = debounce_key
+        self.client = client
+
+    def debounce(
+        self, debounce_period_sec: float, *args: Any, **kwargs: Any
+    ) -> "WorkflowHandle[R]":
+
+        ctxOptions: ContextOptions = {
+            "workflow_id": (
+                self.workflow_options["workflow_id"]
+                if self.workflow_options.get("workflow_id")
+                else str(uuid.uuid4())
+            ),
+            "app_version": self.workflow_options.get("app_version"),
+            "deduplication_id": self.workflow_options.get("deduplication_id"),
+            "priority": self.workflow_options.get("priority"),
+            "workflow_timeout_sec": self.workflow_options.get("workflow_timeout"),
+        }
+        message_id = str(uuid.uuid4())
+        while True:
+            try:
+                # Attempt to enqueue a debouncer for this workflow.
+                debouncer_options: EnqueueOptions = {
+                    "workflow_name": DEBOUNCER_WORKFLOW_NAME,
+                    "queue_name": INTERNAL_QUEUE_NAME,
+                    "deduplication_id": self.debounce_key,
+                }
+                self.client.enqueue(
+                    debouncer_options,
+                    debounce_period_sec,
+                    ctxOptions,
+                    self.debouncer_options,
+                    *args,
+                    **kwargs,
+                )
+                return WorkflowHandleClientPolling[R](
+                    ctxOptions["workflow_id"], self.client._sys_db
+                )
+            except DBOSQueueDeduplicatedError:
+                # If there is already a debouncer, send a message to it.
+                dedup_wfid = self.client._sys_db.get_deduplicated_workflow(
+                    queue_name=INTERNAL_QUEUE_NAME,
+                    deduplication_id=self.debounce_key,
+                )
+                if dedup_wfid is None:
+                    continue
+                else:
+                    workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+                    message: DebouncerMessage = {
+                        "message_id": message_id,
+                        "inputs": workflow_inputs,
+                        "debounce_period_sec": debounce_period_sec,
+                    }
+                    self.client.send(dedup_wfid, message, _DEBOUNCER_TOPIC)
+                    # Wait for the debouncer to acknowledge receipt of the message.
+                    # If the message is not acknowledged, this likely means the debouncer started its workflow
+                    # and exited without processing this message, so try again.
+                    if not self.client.get_event(
+                        dedup_wfid, message_id, timeout_seconds=1
+                    ):
+                        continue
+                    # Retrieve the user workflow ID from the input to the debouncer
+                    # and return a handle to it
+                    dedup_workflow_input = (
+                        self.client.retrieve_workflow(dedup_wfid).get_status().input
+                    )
+                    assert dedup_workflow_input is not None
+                    user_workflow_id = dedup_workflow_input["args"][1]["workflow_id"]
+                    return WorkflowHandleClientPolling[R](
+                        user_workflow_id, self.client._sys_db
+                    )
+
+    async def debounce_async(
+        self, debounce_period_sec: float, *args: Any, **kwargs: Any
+    ) -> "WorkflowHandleAsync[R]":
+        handle: "WorkflowHandle[R]" = await asyncio.to_thread(
+            self.debounce, debounce_period_sec, *args, **kwargs
+        )
+        return WorkflowHandleClientAsyncPolling[R](
+            handle.workflow_id, self.client._sys_db
+        )

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/_logger.py

@@ -39,7 +39,7 @@ class DBOSLogTransformer(logging.Filter):
         if ctx:
             if ctx.is_within_workflow():
                 record.operationUUID = ctx.workflow_id
-            span = ctx.get_current_span()
+            span = ctx.get_current_active_span()
             if span:
                 trace_id = format_trace_id(span.get_span_context().trace_id)
                 record.traceId = trace_id

{dbos-1.14.0a4 → dbos-1.14.0a6}/dbos/_serialization.py

@@ -12,8 +12,13 @@ class WorkflowInputs(TypedDict):
 
 
 def _validate_item(data: Any) -> None:
-    if isinstance(data, (types.FunctionType, types.MethodType)):
-        raise TypeError("Serialized data item should not be a function")
+    if isinstance(data, (types.MethodType)):
+        raise TypeError("Serialized data item should not be a class method")
+    if isinstance(data, (types.FunctionType)):
+        if jsonpickle.decode(jsonpickle.encode(data, unpicklable=True)) is None:
+            raise TypeError(
+                "Serialized function should be defined at the top level of a module"
+            )
 
 
 def serialize(data: Any) -> str: