dbos 0.26.1__tar.gz → 0.27.0__tar.gz

{dbos-0.26.1 → dbos-0.27.0}/PKG-INFO

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

{dbos-0.26.1 → dbos-0.27.0}/dbos/__init__.py

@@ -3,10 +3,11 @@ from ._client import DBOSClient, EnqueueOptions
 from ._context import (
     DBOSContextEnsure,
     DBOSContextSetAuth,
+    SetEnqueueOptions,
     SetWorkflowID,
     SetWorkflowTimeout,
 )
-from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle
+from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowHandleAsync
 from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
@@ -25,7 +26,9 @@ __all__ = [
     "KafkaMessage",
     "SetWorkflowID",
     "SetWorkflowTimeout",
+    "SetEnqueueOptions",
     "WorkflowHandle",
+    "WorkflowHandleAsync",
     "WorkflowStatus",
     "WorkflowStatusString",
     "load_config",

{dbos-0.26.1 → dbos-0.27.0}/dbos/_admin_server.py

@@ -45,9 +45,10 @@ class AdminServer:
 
 
 class AdminRequestHandler(BaseHTTPRequestHandler):
+    is_deactivated = False
+
     def __init__(self, dbos: DBOS, *args: Any, **kwargs: Any) -> None:
         self.dbos = dbos
-        self.is_deactivated = False
         super().__init__(*args, **kwargs)
 
     def _end_headers(self) -> None:
@@ -63,11 +64,11 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self._end_headers()
             self.wfile.write("healthy".encode("utf-8"))
         elif self.path == _deactivate_path:
-            if not self.is_deactivated:
+            if not AdminRequestHandler.is_deactivated:
                 dbos_logger.info(
                     f"Deactivating DBOS executor {GlobalParams.executor_id} with version {GlobalParams.app_version}. This executor will complete existing workflows but will not start new workflows."
                 )
-                self.is_deactivated = True
+                AdminRequestHandler.is_deactivated = True
             # Stop all scheduled workflows, queues, and kafka loops
             for event in self.dbos.stop_events:
                 event.set()
@@ -209,7 +210,7 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         self._end_headers()
 
     def _handle_steps(self, workflow_id: str) -> None:
-        steps = self.dbos._sys_db.get_workflow_steps(workflow_id)
+        steps = self.dbos.list_workflow_steps(workflow_id)
 
         updated_steps = [
             {

{dbos-0.26.1 → dbos-0.27.0}/dbos/_app_db.py

@@ -7,7 +7,7 @@ from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session, sessionmaker
 
 from . import _serialization
-from ._dbos_config import ConfigFile, DatabaseConfig
+from ._dbos_config import DatabaseConfig
 from ._error import DBOSUnexpectedStepError, DBOSWorkflowConflictIDError
 from ._schemas.application_database import ApplicationSchema
 from ._sys_db import StepInfo
@@ -77,12 +77,24 @@ class ApplicationDatabase:
         pool_size = database.get("app_db_pool_size")
         if pool_size is None:
             pool_size = 20
+
+        engine_kwargs = database.get("db_engine_kwargs")
+        if engine_kwargs is None:
+            engine_kwargs = {}
+
+        # Respect user-provided values. Otherwise, set defaults.
+        if "pool_size" not in engine_kwargs:
+            engine_kwargs["pool_size"] = pool_size
+        if "max_overflow" not in engine_kwargs:
+            engine_kwargs["max_overflow"] = 0
+        if "pool_timeout" not in engine_kwargs:
+            engine_kwargs["pool_timeout"] = 30
+        if "connect_args" not in engine_kwargs:
+            engine_kwargs["connect_args"] = connect_args
+
         self.engine = sa.create_engine(
             app_db_url,
-            pool_size=pool_size,
-            max_overflow=0,
-            pool_timeout=30,
-            connect_args=connect_args,
+            **engine_kwargs,
         )
         self.sessionmaker = sessionmaker(bind=self.engine)
         self.debug_mode = debug_mode

{dbos-0.26.1 → dbos-0.27.0}/dbos/_client.py

@@ -1,9 +1,10 @@
 import asyncio
 import sys
-import time
 import uuid
 from typing import Any, Generic, List, Optional, TypedDict, TypeVar
 
+from sqlalchemy import URL
+
 from dbos._app_db import ApplicationDatabase
 
 if sys.version_info < (3, 11):
@@ -18,6 +19,7 @@ from dbos._error import DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
 from dbos._sys_db import (
+    EnqueueOptionsInternal,
     StepInfo,
     SystemDatabase,
     WorkflowStatus,
@@ -41,6 +43,7 @@ class EnqueueOptions(TypedDict):
     workflow_id: NotRequired[str]
     app_version: NotRequired[str]
     workflow_timeout: NotRequired[float]
+    deduplication_id: NotRequired[str]
 
 
 class WorkflowHandleClientPolling(Generic[R]):
@@ -57,7 +60,7 @@ class WorkflowHandleClientPolling(Generic[R]):
         return res
 
     def get_status(self) -> WorkflowStatus:
-        status = get_workflow(self._sys_db, self.workflow_id, True)
+        status = get_workflow(self._sys_db, self.workflow_id, False)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
         return status
@@ -80,7 +83,7 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
     async def get_status(self) -> WorkflowStatus:
         status = await asyncio.to_thread(
-            get_workflow, self._sys_db, self.workflow_id, True
+            get_workflow, self._sys_db, self.workflow_id, False
         )
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -94,6 +97,7 @@ class DBOSClient:
             db_config["sys_db_name"] = system_database
         self._sys_db = SystemDatabase(db_config)
         self._app_db = ApplicationDatabase(db_config)
+        self._db_url = database_url
 
     def destroy(self) -> None:
         self._sys_db.destroy()
@@ -110,6 +114,9 @@ class DBOSClient:
         if workflow_id is None:
             workflow_id = str(uuid.uuid4())
         workflow_timeout = options.get("workflow_timeout", None)
+        enqueue_options_internal: EnqueueOptionsInternal = {
+            "deduplication_id": options.get("deduplication_id"),
+        }
 
         status: WorkflowStatusInternal = {
             "workflow_uuid": workflow_id,
@@ -142,7 +149,10 @@ class DBOSClient:
         }
 
         self._sys_db.init_workflow(
-            status, _serialization.serialize_args(inputs), max_recovery_attempts=None
+            status,
+            _serialization.serialize_args(inputs),
+            max_recovery_attempts=None,
+            enqueue_options=enqueue_options_internal,
         )
         return workflow_id
 
@@ -159,13 +169,13 @@ class DBOSClient:
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
 
     def retrieve_workflow(self, workflow_id: str) -> WorkflowHandle[R]:
-        status = get_workflow(self._sys_db, workflow_id, True)
+        status = get_workflow(self._sys_db, workflow_id, False)
         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]:
-        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id, True)
+        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id, False)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
@@ -233,11 +243,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) -> None:
+    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) -> None:
+    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)
 
     def list_workflows(
         self,
@@ -351,16 +363,35 @@ class DBOSClient:
     async def list_workflow_steps_async(self, workflow_id: str) -> List[StepInfo]:
         return await asyncio.to_thread(self.list_workflow_steps, workflow_id)
 
-    def fork_workflow(self, workflow_id: str, start_step: int) -> WorkflowHandle[R]:
+    def fork_workflow(
+        self,
+        workflow_id: str,
+        start_step: int,
+        *,
+        application_version: Optional[str] = None,
+    ) -> WorkflowHandle[Any]:
         forked_workflow_id = fork_workflow(
-            self._sys_db, self._app_db, workflow_id, start_step
+            self._sys_db,
+            self._app_db,
+            workflow_id,
+            start_step,
+            application_version=application_version,
         )
-        return WorkflowHandleClientPolling[R](forked_workflow_id, self._sys_db)
+        return WorkflowHandleClientPolling[Any](forked_workflow_id, self._sys_db)
 
     async def fork_workflow_async(
-        self, workflow_id: str, start_step: int
-    ) -> WorkflowHandleAsync[R]:
+        self,
+        workflow_id: str,
+        start_step: int,
+        *,
+        application_version: Optional[str] = None,
+    ) -> WorkflowHandleAsync[Any]:
         forked_workflow_id = await asyncio.to_thread(
-            fork_workflow, self._sys_db, self._app_db, workflow_id, start_step
+            fork_workflow,
+            self._sys_db,
+            self._app_db,
+            workflow_id,
+            start_step,
+            application_version=application_version,
         )
-        return WorkflowHandleClientAsyncPolling[R](forked_workflow_id, self._sys_db)
+        return WorkflowHandleClientAsyncPolling[Any](forked_workflow_id, self._sys_db)

{dbos-0.26.1 → dbos-0.27.0}/dbos/_context.py

@@ -98,6 +98,9 @@ class DBOSContext:
         # A propagated workflow deadline.
         self.workflow_deadline_epoch_ms: Optional[int] = None
 
+        # A user-specified deduplication ID for the enqueuing workflow.
+        self.deduplication_id: Optional[str] = None
+
     def create_child(self) -> DBOSContext:
         rv = DBOSContext()
         rv.logger = self.logger
@@ -413,12 +416,53 @@ class SetWorkflowTimeout:
         return False  # Did not handle
 
 
+class SetEnqueueOptions:
+    """
+    Set the workflow enqueue options for the enclosed enqueue operation.
+
+    Usage:
+        ```
+        with SetEnqueueOptions(deduplication_id=<deduplication id>):
+            queue.enqueue(...)
+        ```
+    """
+
+    def __init__(self, *, deduplication_id: Optional[str] = None) -> None:
+        self.created_ctx = False
+        self.deduplication_id: Optional[str] = deduplication_id
+        self.saved_deduplication_id: Optional[str] = None
+
+    def __enter__(self) -> SetEnqueueOptions:
+        # Code to create a basic context
+        ctx = get_local_dbos_context()
+        if ctx is None:
+            self.created_ctx = True
+            _set_local_dbos_context(DBOSContext())
+        ctx = assert_current_dbos_context()
+        self.saved_deduplication_id = ctx.deduplication_id
+        ctx.deduplication_id = self.deduplication_id
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> Literal[False]:
+        assert_current_dbos_context().deduplication_id = self.saved_deduplication_id
+        # Code to clean up the basic context if we created it
+        if self.created_ctx:
+            _clear_local_dbos_context()
+        return False
+
+
 class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
     def __init__(self, attributes: TracedAttributes) -> None:
         self.created_ctx = False
         self.attributes = attributes
         self.is_temp_workflow = attributes["name"] == "temp_wf"
         self.saved_workflow_timeout: Optional[int] = None
+        self.saved_deduplication_id: Optional[str] = None
 
     def __enter__(self) -> DBOSContext:
         # Code to create a basic context
@@ -432,6 +476,10 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         # workflow's children (instead we propagate the deadline)
         self.saved_workflow_timeout = ctx.workflow_timeout_ms
         ctx.workflow_timeout_ms = None
+        # Unset the deduplication_id context var so it is not applied to this
+        # workflow's children
+        self.saved_deduplication_id = ctx.deduplication_id
+        ctx.deduplication_id = None
         ctx.start_workflow(
             None, self.attributes, self.is_temp_workflow
         )  # Will get from the context's next workflow ID
@@ -450,6 +498,8 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         ctx.workflow_timeout_ms = self.saved_workflow_timeout
         # Clear any propagating timeout
         ctx.workflow_deadline_epoch_ms = None
+        # Restore the saved deduplication ID
+        ctx.deduplication_id = self.saved_deduplication_id
         # Code to clean up the basic context if we created it
         if self.created_ctx:
             _clear_local_dbos_context()

{dbos-0.26.1 → dbos-0.27.0}/dbos/_core.py

@@ -71,6 +71,7 @@ from ._registrations import (
 from ._roles import check_required_roles
 from ._serialization import WorkflowInputs
 from ._sys_db import (
+    EnqueueOptionsInternal,
     GetEventWorkflowContext,
     OperationResultInternal,
     WorkflowStatus,
@@ -234,6 +235,7 @@ def _init_workflow(
     workflow_timeout_ms: Optional[int],
     workflow_deadline_epoch_ms: Optional[int],
     max_recovery_attempts: Optional[int],
+    enqueue_options: Optional[EnqueueOptionsInternal],
 ) -> WorkflowStatusInternal:
     wfid = (
         ctx.workflow_id
@@ -289,6 +291,7 @@ def _init_workflow(
         status,
         _serialization.serialize_args(inputs),
         max_recovery_attempts=max_recovery_attempts,
+        enqueue_options=enqueue_options,
     )
 
     if workflow_deadline_epoch_ms is not None:
@@ -539,6 +542,9 @@ def start_workflow(
     workflow_timeout_ms = (
         local_ctx.workflow_timeout_ms if local_ctx is not None else None
     )
+    enqueue_options = EnqueueOptionsInternal(
+        deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
+    )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
     ctx = new_wf_ctx
@@ -561,6 +567,7 @@ def start_workflow(
         workflow_timeout_ms=workflow_timeout_ms,
         workflow_deadline_epoch_ms=workflow_deadline_epoch_ms,
         max_recovery_attempts=fi.max_recovery_attempts,
+        enqueue_options=enqueue_options,
     )
 
     wf_status = status["status"]
@@ -626,6 +633,9 @@ async def start_workflow_async(
     workflow_timeout_ms, workflow_deadline_epoch_ms = _get_timeout_deadline(
         local_ctx, queue_name
     )
+    enqueue_options = EnqueueOptionsInternal(
+        deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
+    )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
     ctx = new_wf_ctx
@@ -651,6 +661,7 @@ async def start_workflow_async(
         workflow_timeout_ms=workflow_timeout_ms,
         workflow_deadline_epoch_ms=workflow_deadline_epoch_ms,
         max_recovery_attempts=fi.max_recovery_attempts,
+        enqueue_options=enqueue_options,
     )
 
     if ctx.has_parent():
@@ -727,6 +738,7 @@ def workflow_wrapper(
         workflow_timeout_ms, workflow_deadline_epoch_ms = _get_timeout_deadline(
             ctx, queue=None
         )
+
         enterWorkflowCtxMgr = (
             EnterDBOSChildWorkflow if ctx and ctx.is_workflow() else EnterDBOSWorkflow
         )
@@ -768,6 +780,7 @@ def workflow_wrapper(
                 workflow_timeout_ms=workflow_timeout_ms,
                 workflow_deadline_epoch_ms=workflow_deadline_epoch_ms,
                 max_recovery_attempts=max_recovery_attempts,
+                enqueue_options=None,
             )
 
             # TODO: maybe modify the parameters if they've been changed by `_init_workflow`

{dbos-0.26.1 → dbos-0.27.0}/dbos/_dbos.py

@@ -64,8 +64,9 @@ from ._registrations import (
 )
 from ._roles import default_required_roles, required_roles
 from ._scheduler import ScheduledWorkflow, scheduled
-from ._sys_db import StepInfo, WorkflowStatus, reset_system_database
-from ._tracer import dbos_tracer
+from ._schemas.system_database import SystemSchema
+from ._sys_db import StepInfo, SystemDatabase, WorkflowStatus, reset_system_database
+from ._tracer import DBOSTracer, dbos_tracer
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
@@ -73,14 +74,15 @@ if TYPE_CHECKING:
     from ._request import Request
     from flask import Flask
 
+from sqlalchemy import URL
 from sqlalchemy.orm import Session
 
 from ._request import Request
 
 if sys.version_info < (3, 10):
-    from typing_extensions import ParamSpec, TypeAlias
+    from typing_extensions import ParamSpec
 else:
-    from typing import ParamSpec, TypeAlias
+    from typing import ParamSpec
 
 from ._admin_server import AdminServer
 from ._app_db import ApplicationDatabase
@@ -109,7 +111,6 @@ from ._error import (
 )
 from ._event_loop import BackgroundEventLoop
 from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
-from ._sys_db import SystemDatabase
 from ._workflow_commands import get_workflow, list_workflow_steps
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
@@ -563,7 +564,22 @@ class DBOS:
         assert (
             not self._launched
         ), "The system database cannot be reset after DBOS is launched. Resetting the system database is a destructive operation that should only be used in a test environment."
-        reset_system_database(self._config)
+
+        sysdb_name = (
+            self._config["database"]["sys_db_name"]
+            if "sys_db_name" in self._config["database"]
+            and self._config["database"]["sys_db_name"]
+            else self._config["database"]["app_db_name"] + SystemSchema.sysdb_suffix
+        )
+        postgres_db_url = URL.create(
+            "postgresql+psycopg",
+            username=self._config["database"]["username"],
+            password=self._config["database"]["password"],
+            host=self._config["database"]["hostname"],
+            port=self._config["database"]["port"],
+            database="postgres",
+        )
+        reset_system_database(postgres_db_url, sysdb_name)
 
     def _destroy(self) -> None:
         self._initialized = False
@@ -962,7 +978,13 @@ class DBOS:
         return cls.fork_workflow(workflow_id, 1)
 
     @classmethod
-    def fork_workflow(cls, workflow_id: str, start_step: int) -> WorkflowHandle[Any]:
+    def fork_workflow(
+        cls,
+        workflow_id: str,
+        start_step: int,
+        *,
+        application_version: Optional[str] = None,
+    ) -> WorkflowHandle[Any]:
         """Restart a workflow with a new workflow ID from a specific step"""
 
         def fn() -> str:
@@ -972,6 +994,7 @@ class DBOS:
                 _get_dbos_instance()._app_db,
                 workflow_id,
                 start_step,
+                application_version=application_version,
             )
 
         new_id = _get_dbos_instance()._sys_db.call_function_as_step(
@@ -1166,6 +1189,11 @@ class DBOS:
         ctx.authenticated_user = authenticated_user
         ctx.authenticated_roles = authenticated_roles
 
+    @classproperty
+    def tracer(self) -> DBOSTracer:
+        """Return the DBOS OpenTelemetry tracer."""
+        return dbos_tracer
+
 
 class WorkflowHandle(Generic[R], Protocol):
     """

{dbos-0.26.1 → dbos-0.27.0}/dbos/_dbos_config.py

@@ -31,6 +31,7 @@ class DBOSConfig(TypedDict, total=False):
         app_db_pool_size (int): Application database pool size
         sys_db_name (str): System database name
         sys_db_pool_size (int): System database pool size
+        db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs (See https://docs.sqlalchemy.org/en/20/core/engines.html#sqlalchemy.create_engine)
         log_level (str): Log level
         otlp_traces_endpoints: List[str]: OTLP traces endpoints
         otlp_logs_endpoints: List[str]: OTLP logs endpoints
@@ -43,6 +44,7 @@ class DBOSConfig(TypedDict, total=False):
     app_db_pool_size: Optional[int]
     sys_db_name: Optional[str]
     sys_db_pool_size: Optional[int]
+    db_engine_kwargs: Optional[Dict[str, Any]]
     log_level: Optional[str]
     otlp_traces_endpoints: Optional[List[str]]
     otlp_logs_endpoints: Optional[List[str]]
@@ -64,6 +66,7 @@ class DatabaseConfig(TypedDict, total=False):
         app_db_pool_size (int): Application database pool size
         sys_db_name (str): System database name
         sys_db_pool_size (int): System database pool size
+        db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs
         migrate (List[str]): Migration commands to run on startup
     """
 
@@ -76,6 +79,7 @@ class DatabaseConfig(TypedDict, total=False):
     app_db_pool_size: Optional[int]
     sys_db_name: Optional[str]
     sys_db_pool_size: Optional[int]
+    db_engine_kwargs: Optional[Dict[str, Any]]
     ssl: Optional[bool]  # Will be removed in a future version
     ssl_ca: Optional[str]  # Will be removed in a future version
     migrate: Optional[List[str]]
@@ -183,6 +187,8 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
         db_config["app_db_pool_size"] = config.get("app_db_pool_size")
     if "sys_db_pool_size" in config:
         db_config["sys_db_pool_size"] = config.get("sys_db_pool_size")
+    if "db_engine_kwargs" in config:
+        db_config["db_engine_kwargs"] = config.get("db_engine_kwargs")
     if db_config:
         translated_config["database"] = db_config
 

{dbos-0.26.1 → dbos-0.27.0}/dbos/_error.py

@@ -61,6 +61,7 @@ class DBOSErrorCode(Enum):
     ConflictingWorkflowError = 9
     WorkflowCancelled = 10
     UnexpectedStep = 11
+    QueueDeduplicated = 12
     ConflictingRegistrationError = 25
 
 
@@ -133,12 +134,17 @@ class DBOSNotAuthorizedError(DBOSException):
     """Exception raised by DBOS role-based security when the user is not authorized to access a function."""
 
     def __init__(self, msg: str):
+        self.msg = msg
         super().__init__(
             msg,
             dbos_error_code=DBOSErrorCode.NotAuthorized.value,
         )
         self.status_code = 403
 
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (self.__class__, (self.msg,))
+
 
 class DBOSMaxStepRetriesExceeded(DBOSException):
     """Exception raised when a step was retried the maximimum number of times without success."""
@@ -178,6 +184,28 @@ class DBOSUnexpectedStepError(DBOSException):
         )
 
 
+class DBOSQueueDeduplicatedError(DBOSException):
+    """Exception raised when a workflow is deduplicated in the queue."""
+
+    def __init__(
+        self, workflow_id: str, queue_name: str, deduplication_id: str
+    ) -> None:
+        self.workflow_id = workflow_id
+        self.queue_name = queue_name
+        self.deduplication_id = deduplication_id
+        super().__init__(
+            f"Workflow {workflow_id} was deduplicated due to an existing workflow in queue {queue_name} with deduplication ID {deduplication_id}.",
+            dbos_error_code=DBOSErrorCode.QueueDeduplicated.value,
+        )
+
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (
+            self.__class__,
+            (self.workflow_id, self.queue_name, self.deduplication_id),
+        )
+
+
 #######################################
 ## BaseException
 #######################################

dbos-0.27.0/dbos/_migrations/versions/27ac6900c6ad_add_queue_dedup.py

@@ -0,0 +1,45 @@
+"""add queue dedup
+
+Revision ID: 27ac6900c6ad
+Revises: 83f3732ae8e7
+Create Date: 2025-04-23 16:18:48.530047
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "27ac6900c6ad"
+down_revision: Union[str, None] = "83f3732ae8e7"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "workflow_queue",
+        sa.Column(
+            "deduplication_id",
+            sa.Text(),
+            nullable=True,
+        ),
+        schema="dbos",
+    )
+
+    # Unique constraint for queue_name, deduplication_id
+    op.create_unique_constraint(
+        "uq_workflow_queue_name_dedup_id",
+        "workflow_queue",
+        ["queue_name", "deduplication_id"],
+        schema="dbos",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint(
+        "uq_workflow_queue_name_dedup_id", "workflow_queue", schema="dbos"
+    )
+    op.drop_column("workflow_queue", "deduplication_id", schema="dbos")

{dbos-0.26.1 → dbos-0.27.0}/dbos/_queue.py

@@ -99,6 +99,8 @@ def queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
                         f"Exception encountered in queue thread: {traceback.format_exc()}"
                     )
             except Exception:
-                dbos.logger.warning(
-                    f"Exception encountered in queue thread: {traceback.format_exc()}"
-                )
+                if not stop_event.is_set():
+                    # Only print the error if the thread is not stopping
+                    dbos.logger.warning(
+                        f"Exception encountered in queue thread: {traceback.format_exc()}"
+                    )

{dbos-0.26.1 → dbos-0.27.0}/dbos/_schemas/system_database.py

@@ -10,6 +10,7 @@ from sqlalchemy import (
     String,
     Table,
     Text,
+    UniqueConstraint,
     text,
 )
 
@@ -174,4 +175,12 @@ class SystemSchema:
             "completed_at_epoch_ms",
             BigInteger(),
         ),
+        Column(
+            "deduplication_id",
+            Text,
+            nullable=True,
+        ),
+        UniqueConstraint(
+            "queue_name", "deduplication_id", name="uq_workflow_queue_name_dedup_id"
+        ),
     )