dbos 0.22.0a10__py3-none-any.whl → 0.23.0__py3-none-any.whl

dbos/_core.py

@@ -22,6 +22,7 @@ from typing import (
 )
 
 from dbos._outcome import Immediate, NoResult, Outcome, Pending
+from dbos._utils import GlobalParams
 
 from ._app_db import ApplicationDatabase, TransactionResultInternal
 
@@ -51,6 +52,7 @@ from ._error import (
     DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
     DBOSRecoveryError,
+    DBOSWorkflowCancelledError,
     DBOSWorkflowConflictIDError,
     DBOSWorkflowFunctionNotFoundError,
 )
@@ -163,7 +165,7 @@ def _init_workflow(
         "output": None,
         "error": None,
         "app_id": ctx.app_id,
-        "app_version": dbos.app_version,
+        "app_version": GlobalParams.app_version,
         "executor_id": ctx.executor_id,
         "request": (
             _serialization.serialize(ctx.request) if ctx.request is not None else None
@@ -175,6 +177,8 @@ def _init_workflow(
         ),
         "assumed_role": ctx.assumed_role,
         "queue_name": queue,
+        "created_at": None,
+        "updated_at": None,
     }
 
     # If we have a class name, the first arg is the instance and do not serialize
@@ -182,21 +186,31 @@ def _init_workflow(
         inputs = {"args": inputs["args"][1:], "kwargs": inputs["kwargs"]}
 
     wf_status = status["status"]
-    if temp_wf_type != "transaction" or queue is not None:
-        # Synchronously record the status and inputs for workflows and single-step workflows
-        # We also have to do this for single-step workflows because of the foreign key constraint on the operation outputs table
-        # TODO: Make this transactional (and with the queue step below)
-        wf_status = dbos._sys_db.insert_workflow_status(
-            status, max_recovery_attempts=max_recovery_attempts
-        )
-        # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
-        dbos._sys_db.update_workflow_inputs(wfid, _serialization.serialize_args(inputs))
+    if dbos.debug_mode:
+        get_status_result = dbos._sys_db.get_workflow_status(wfid)
+        if get_status_result is None:
+            raise DBOSNonExistentWorkflowError(wfid)
+        wf_status = get_status_result["status"]
     else:
-        # Buffer the inputs for single-transaction workflows, but don't buffer the status
-        dbos._sys_db.buffer_workflow_inputs(wfid, _serialization.serialize_args(inputs))
+        if temp_wf_type != "transaction" or queue is not None:
+            # Synchronously record the status and inputs for workflows and single-step workflows
+            # We also have to do this for single-step workflows because of the foreign key constraint on the operation outputs table
+            # TODO: Make this transactional (and with the queue step below)
+            wf_status = dbos._sys_db.insert_workflow_status(
+                status, max_recovery_attempts=max_recovery_attempts
+            )
+            # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
+            dbos._sys_db.update_workflow_inputs(
+                wfid, _serialization.serialize_args(inputs)
+            )
+        else:
+            # Buffer the inputs for single-transaction workflows, but don't buffer the status
+            dbos._sys_db.buffer_workflow_inputs(
+                wfid, _serialization.serialize_args(inputs)
+            )
 
-    if queue is not None and wf_status == WorkflowStatusString.ENQUEUED.value:
-        dbos._sys_db.enqueue(wfid, queue)
+        if queue is not None and wf_status == WorkflowStatusString.ENQUEUED.value:
+            dbos._sys_db.enqueue(wfid, queue)
 
     status["status"] = wf_status
     return status
@@ -211,10 +225,11 @@ def _get_wf_invoke_func(
             output = func()
             status["status"] = "SUCCESS"
             status["output"] = _serialization.serialize(output)
-            if status["queue_name"] is not None:
-                queue = dbos._registry.queue_info_map[status["queue_name"]]
-                dbos._sys_db.remove_from_queue(status["workflow_uuid"], queue)
-            dbos._sys_db.buffer_workflow_status(status)
+            if not dbos.debug_mode:
+                if status["queue_name"] is not None:
+                    queue = dbos._registry.queue_info_map[status["queue_name"]]
+                    dbos._sys_db.remove_from_queue(status["workflow_uuid"], queue)
+                dbos._sys_db.buffer_workflow_status(status)
             return output
         except DBOSWorkflowConflictIDError:
             # Retrieve the workflow handle and wait for the result.
@@ -224,13 +239,16 @@ def _get_wf_invoke_func(
             )
             output = wf_handle.get_result()
             return output
+        except DBOSWorkflowCancelledError as error:
+            raise
         except Exception as error:
             status["status"] = "ERROR"
             status["error"] = _serialization.serialize_exception(error)
-            if status["queue_name"] is not None:
-                queue = dbos._registry.queue_info_map[status["queue_name"]]
-                dbos._sys_db.remove_from_queue(status["workflow_uuid"], queue)
-            dbos._sys_db.update_workflow_status(status)
+            if not dbos.debug_mode:
+                if status["queue_name"] is not None:
+                    queue = dbos._registry.queue_info_map[status["queue_name"]]
+                    dbos._sys_db.remove_from_queue(status["workflow_uuid"], queue)
+                dbos._sys_db.update_workflow_status(status)
             raise
 
     return persist
@@ -416,10 +434,12 @@ def start_workflow(
 
     wf_status = status["status"]
 
-    if (
-        not execute_workflow
-        or wf_status == WorkflowStatusString.ERROR.value
-        or wf_status == WorkflowStatusString.SUCCESS.value
+    if not execute_workflow or (
+        not dbos.debug_mode
+        and (
+            wf_status == WorkflowStatusString.ERROR.value
+            or wf_status == WorkflowStatusString.SUCCESS.value
+        )
     ):
         dbos.logger.debug(
             f"Workflow {new_wf_id} already completed with status {wf_status}. Directly returning a workflow handle."
@@ -539,6 +559,13 @@ def decorate_transaction(
                 raise DBOSException(
                     f"Function {func.__name__} invoked before DBOS initialized"
                 )
+
+            ctx = assert_current_dbos_context()
+            if dbosreg.is_workflow_cancelled(ctx.workflow_id):
+                raise DBOSWorkflowCancelledError(
+                    f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {func.__name__}."
+                )
+
             dbos = dbosreg.dbos
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
@@ -560,6 +587,12 @@ def decorate_transaction(
                     backoff_factor = 1.5
                     max_retry_wait_seconds = 2.0
                     while True:
+
+                        if dbosreg.is_workflow_cancelled(ctx.workflow_id):
+                            raise DBOSWorkflowCancelledError(
+                                f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {func.__name__}."
+                            )
+
                         has_recorded_error = False
                         txn_error: Optional[Exception] = None
                         try:
@@ -578,6 +611,10 @@ def decorate_transaction(
                                         ctx.function_id,
                                     )
                                 )
+                                if dbos.debug_mode and recorded_output is None:
+                                    raise DBOSException(
+                                        "Transaction output not found in debug mode"
+                                    )
                                 if recorded_output:
                                     dbos.logger.debug(
                                         f"Replaying transaction, id: {ctx.function_id}, name: {attributes['name']}"
@@ -710,6 +747,13 @@ def decorate_step(
                 "operationType": OperationType.STEP.value,
             }
 
+            # Check if the workflow is cancelled
+            ctx = assert_current_dbos_context()
+            if dbosreg.is_workflow_cancelled(ctx.workflow_id):
+                raise DBOSWorkflowCancelledError(
+                    f"Workflow {ctx.workflow_id} is cancelled. Aborting step {func.__name__}."
+                )
+
             attempts = max_attempts if retries_allowed else 1
             max_retry_interval_seconds: float = 3600  # 1 Hour
 
@@ -754,6 +798,8 @@ def decorate_step(
                 recorded_output = dbos._sys_db.check_operation_execution(
                     ctx.workflow_id, ctx.function_id
                 )
+                if dbos.debug_mode and recorded_output is None:
+                    raise DBOSException("Step output not found in debug mode")
                 if recorded_output:
                     dbos.logger.debug(
                         f"Replaying step, id: {ctx.function_id}, name: {attributes['name']}"
@@ -800,6 +846,7 @@ def decorate_step(
             ctx = get_local_dbos_context()
             if ctx and ctx.is_step():
                 # Call the original function directly
+
                 return func(*args, **kwargs)
             if ctx and ctx.is_within_workflow():
                 assert ctx.is_workflow(), "Steps must be called from within workflows"

dbos/_croniter.py

@@ -5,14 +5,14 @@ Copyright (C) 2010-2012 Matsumoto Taichi.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this
 software and associated documentation files (the "Software"), to deal in the Software
-without restriction, including without limitation the rights to use, copy, modify, 
+without restriction, including without limitation the rights to use, copy, modify,
 merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
 persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

dbos/_dbos.py

@@ -9,6 +9,7 @@ import os
 import sys
 import threading
 import traceback
+import uuid
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from logging import Logger
@@ -32,6 +33,9 @@ from typing import (
 
 from opentelemetry.trace import Span
 
+from dbos._conductor.conductor import ConductorWebsocket
+from dbos._utils import GlobalParams
+
 from ._classproperty import classproperty
 from ._core import (
     TEMP_SEND_WF_NAME,
@@ -155,6 +159,7 @@ class DBOSRegistry:
         self.pollers: list[RegisteredJob] = []
         self.dbos: Optional[DBOS] = None
         self.config: Optional[ConfigFile] = None
+        self.workflow_cancelled_map: dict[str, bool] = {}
 
     def register_wf_function(self, name: str, wrapped_func: F, functype: str) -> None:
         if name in self.function_type_map:
@@ -197,6 +202,15 @@ class DBOSRegistry:
         else:
             self.instance_info_map[fn] = inst
 
+    def cancel_workflow(self, workflow_id: str) -> None:
+        self.workflow_cancelled_map[workflow_id] = True
+
+    def is_workflow_cancelled(self, workflow_id: str) -> bool:
+        return self.workflow_cancelled_map.get(workflow_id, False)
+
+    def clear_workflow_cancelled(self, workflow_id: str) -> None:
+        self.workflow_cancelled_map.pop(workflow_id, None)
+
     def compute_app_version(self) -> str:
         """
         An application's version is computed from a hash of the source of its workflows.
@@ -246,6 +260,8 @@ class DBOS:
         config: Optional[ConfigFile] = None,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
+        conductor_url: Optional[str] = None,
+        conductor_key: Optional[str] = None,
     ) -> DBOS:
         global _dbos_global_instance
         global _dbos_global_registry
@@ -261,7 +277,7 @@ class DBOS:
                 config = _dbos_global_registry.config
 
             _dbos_global_instance = super().__new__(cls)
-            _dbos_global_instance.__init__(fastapi=fastapi, config=config, flask=flask)  # type: ignore
+            _dbos_global_instance.__init__(fastapi=fastapi, config=config, flask=flask, conductor_url=conductor_url, conductor_key=conductor_key)  # type: ignore
         else:
             if (config is not None and _dbos_global_instance.config is not config) or (
                 _dbos_global_instance.fastapi is not fastapi
@@ -280,6 +296,8 @@ class DBOS:
         if destroy_registry:
             global _dbos_global_registry
             _dbos_global_registry = None
+        GlobalParams.app_version = os.environ.get("DBOS__APPVERSION", "")
+        GlobalParams.executor_id = os.environ.get("DBOS__VMID", "local")
 
     def __init__(
         self,
@@ -287,6 +305,8 @@ class DBOS:
         config: Optional[ConfigFile] = None,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
+        conductor_url: Optional[str] = None,
+        conductor_key: Optional[str] = None,
     ) -> None:
         if hasattr(self, "_initialized") and self._initialized:
             return
@@ -299,6 +319,7 @@ class DBOS:
         dbos_logger.info("Initializing DBOS")
         self.config: ConfigFile = config
         self._launched: bool = False
+        self._debug_mode: bool = False
         self._sys_db_field: Optional[SystemDatabase] = None
         self._app_db_field: Optional[ApplicationDatabase] = None
         self._registry: DBOSRegistry = _get_or_create_dbos_registry()
@@ -309,8 +330,9 @@ class DBOS:
         self.flask: Optional["Flask"] = flask
         self._executor_field: Optional[ThreadPoolExecutor] = None
         self._background_threads: List[threading.Thread] = []
-        self._executor_id: str = os.environ.get("DBOS__VMID", "local")
-        self.app_version: str = os.environ.get("DBOS__APPVERSION", "")
+        self.conductor_url: Optional[str] = conductor_url
+        self.conductor_key: Optional[str] = conductor_key
+        self.conductor_websocket: Optional[ConductorWebsocket] = None
 
         # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
@@ -368,39 +390,50 @@ class DBOS:
         rv: AdminServer = self._admin_server_field
         return rv
 
+    @property
+    def debug_mode(self) -> bool:
+        return self._debug_mode
+
     @classmethod
-    def launch(cls) -> None:
+    def launch(cls, *, debug_mode: bool = False) -> None:
         if _dbos_global_instance is not None:
-            _dbos_global_instance._launch()
+            _dbos_global_instance._launch(debug_mode=debug_mode)
 
-    def _launch(self) -> None:
+    def _launch(self, *, debug_mode: bool = False) -> None:
         try:
             if self._launched:
                 dbos_logger.warning(f"DBOS was already launched")
                 return
             self._launched = True
-            if self.app_version == "":
-                self.app_version = self._registry.compute_app_version()
-            dbos_logger.info(f"Application version: {self.app_version}")
-            dbos_tracer.app_version = self.app_version
+            self._debug_mode = debug_mode
+            if GlobalParams.app_version == "":
+                GlobalParams.app_version = self._registry.compute_app_version()
+            if self.conductor_key is not None:
+                GlobalParams.executor_id = str(uuid.uuid4())
+            dbos_logger.info(f"Executor ID: {GlobalParams.executor_id}")
+            dbos_logger.info(f"Application version: {GlobalParams.app_version}")
             self._executor_field = ThreadPoolExecutor(max_workers=64)
-            self._sys_db_field = SystemDatabase(self.config)
-            self._app_db_field = ApplicationDatabase(self.config)
+            self._sys_db_field = SystemDatabase(self.config, debug_mode=debug_mode)
+            self._app_db_field = ApplicationDatabase(self.config, debug_mode=debug_mode)
+
+            if debug_mode:
+                return
+
             admin_port = self.config["runtimeConfig"].get("admin_port")
             if admin_port is None:
                 admin_port = 3001
             self._admin_server_field = AdminServer(dbos=self, port=admin_port)
 
             workflow_ids = self._sys_db.get_pending_workflows(
-                self._executor_id, self.app_version
+                GlobalParams.executor_id, GlobalParams.app_version
             )
             if (len(workflow_ids)) > 0:
                 self.logger.info(
-                    f"Recovering {len(workflow_ids)} workflows from application version {self.app_version}"
+                    f"Recovering {len(workflow_ids)} workflows from application version {GlobalParams.app_version}"
                 )
             else:
                 self.logger.info(
-                    f"No workflows to recover from application version {self.app_version}"
+                    f"No workflows to recover from application version {GlobalParams.app_version}"
                 )
 
             self._executor.submit(startup_recovery_thread, self, workflow_ids)
@@ -430,6 +463,22 @@ class DBOS:
             bg_queue_thread.start()
             self._background_threads.append(bg_queue_thread)
 
+            # Start the conductor thread if requested
+            if self.conductor_key is not None:
+                if self.conductor_url is None:
+                    dbos_domain = os.environ.get("DBOS_DOMAIN", "cloud.dbos.dev")
+                    self.conductor_url = f"wss://{dbos_domain}/conductor/v1alpha1"
+                evt = threading.Event()
+                self.stop_events.append(evt)
+                self.conductor_websocket = ConductorWebsocket(
+                    self,
+                    conductor_url=self.conductor_url,
+                    conductor_key=self.conductor_key,
+                    evt=evt,
+                )
+                self.conductor_websocket.start()
+                self._background_threads.append(self.conductor_websocket)
+
             # Grab any pollers that were deferred and start them
             for evt, func, args, kwargs in self._registry.pollers:
                 self.stop_events.append(evt)
@@ -446,7 +495,7 @@ class DBOS:
             # to enable their export in DBOS Cloud
             for handler in dbos_logger.handlers:
                 handler.flush()
-            add_otlp_to_all_loggers(self.app_version)
+            add_otlp_to_all_loggers()
         except Exception:
             dbos_logger.error(f"DBOS failed to launch: {traceback.format_exc()}")
             raise
@@ -480,6 +529,11 @@ class DBOS:
         if self._admin_server_field is not None:
             self._admin_server_field.stop()
             self._admin_server_field = None
+        if (
+            self.conductor_websocket is not None
+            and self.conductor_websocket.websocket is not None
+        ):
+            self.conductor_websocket.websocket.close()
         # CB - This needs work, some things ought to stop before DBs are tossed out,
         #  on the other hand it hangs to move it
         if self._executor_field is not None:
@@ -843,12 +897,16 @@ class DBOS:
     @classmethod
     def cancel_workflow(cls, workflow_id: str) -> None:
         """Cancel a workflow by ID."""
+        dbos_logger.info(f"Cancelling workflow: {workflow_id}")
         _get_dbos_instance()._sys_db.cancel_workflow(workflow_id)
+        _get_or_create_dbos_registry().cancel_workflow(workflow_id)
 
     @classmethod
     def resume_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Resume a workflow by ID."""
+        dbos_logger.info(f"Resuming workflow: {workflow_id}")
         _get_dbos_instance()._sys_db.resume_workflow(workflow_id)
+        _get_or_create_dbos_registry().clear_workflow_cancelled(workflow_id)
         return execute_workflow_by_id(_get_dbos_instance(), workflow_id, False)
 
     @classproperty

dbos/_dbos_config.py

@@ -192,7 +192,11 @@ def load_config(
     data = cast(ConfigFile, data)
     db_connection = load_db_connection()
     if not silent:
-        if data["database"].get("hostname"):
+        if os.getenv("DBOS_DBHOST"):
+            print(
+                "[bold blue]Loading database connection parameters from debug environment variables[/bold blue]"
+            )
+        elif data["database"].get("hostname"):
             print(
                 "[bold blue]Loading database connection parameters from dbos-config.yaml[/bold blue]"
             )
@@ -205,32 +209,62 @@ def load_config(
                 "[bold blue]Using default database connection parameters (localhost)[/bold blue]"
             )
 
+    dbos_dbport: Optional[int] = None
+    dbport_env = os.getenv("DBOS_DBPORT")
+    if dbport_env:
+        try:
+            dbos_dbport = int(dbport_env)
+        except ValueError:
+            pass
+    dbos_dblocalsuffix: Optional[bool] = None
+    dblocalsuffix_env = os.getenv("DBOS_DBLOCALSUFFIX")
+    if dblocalsuffix_env:
+        try:
+            dbos_dblocalsuffix = dblocalsuffix_env.casefold() == "true".casefold()
+        except ValueError:
+            pass
+
     data["database"]["hostname"] = (
-        data["database"].get("hostname") or db_connection.get("hostname") or "localhost"
+        os.getenv("DBOS_DBHOST")
+        or data["database"].get("hostname")
+        or db_connection.get("hostname")
+        or "localhost"
     )
+
     data["database"]["port"] = (
-        data["database"].get("port") or db_connection.get("port") or 5432
+        dbos_dbport or data["database"].get("port") or db_connection.get("port") or 5432
     )
     data["database"]["username"] = (
-        data["database"].get("username") or db_connection.get("username") or "postgres"
+        os.getenv("DBOS_DBUSER")
+        or data["database"].get("username")
+        or db_connection.get("username")
+        or "postgres"
     )
     data["database"]["password"] = (
-        data["database"].get("password")
+        os.getenv("DBOS_DBPASSWORD")
+        or data["database"].get("password")
         or db_connection.get("password")
         or os.environ.get("PGPASSWORD")
         or "dbos"
     )
-    data["database"]["local_suffix"] = (
-        data["database"].get("local_suffix")
-        or db_connection.get("local_suffix")
-        or False
-    )
+
+    local_suffix = False
+    dbcon_local_suffix = db_connection.get("local_suffix")
+    if dbcon_local_suffix is not None:
+        local_suffix = dbcon_local_suffix
+    if data["database"].get("local_suffix") is not None:
+        local_suffix = data["database"].get("local_suffix")
+    if dbos_dblocalsuffix is not None:
+        local_suffix = dbos_dblocalsuffix
+    data["database"]["local_suffix"] = local_suffix
 
     # Configure the DBOS logger
     config_logger(data)
 
     # Check the connectivity to the database and make sure it's properly configured
-    if use_db_wizard:
+    # Note, never use db wizard if the DBOS is running in debug mode (i.e. DBOS_DEBUG_WORKFLOW_ID env var is set)
+    debugWorkflowId = os.getenv("DBOS_DEBUG_WORKFLOW_ID")
+    if use_db_wizard and debugWorkflowId is None:
         data = db_wizard(data, config_file_path)
 
     if "local_suffix" in data["database"] and data["database"]["local_suffix"]:

dbos/_debug.py

@@ -0,0 +1,45 @@
+import re
+import runpy
+import sys
+from typing import Union
+
+from dbos import DBOS
+
+
+class PythonModule:
+    def __init__(self, module_name: str):
+        self.module_name = module_name
+
+
+def debug_workflow(workflow_id: str, entrypoint: Union[str, PythonModule]) -> None:
+    # include the current directory (represented by empty string) in the search path
+    # if it not already included
+    if "" not in sys.path:
+        sys.path.insert(0, "")
+    if isinstance(entrypoint, str):
+        runpy.run_path(entrypoint)
+    elif isinstance(entrypoint, PythonModule):
+        runpy.run_module(entrypoint.module_name)
+    else:
+        raise ValueError("Invalid entrypoint type. Must be a string or PythonModule.")
+
+    DBOS.logger.info(f"Debugging workflow {workflow_id}...")
+    DBOS.launch(debug_mode=True)
+    handle = DBOS.execute_workflow_id(workflow_id)
+    handle.get_result()
+    DBOS.logger.info("Workflow Debugging complete. Exiting process.")
+
+
+def parse_start_command(command: str) -> Union[str, PythonModule]:
+    match = re.match(r"fastapi\s+run\s+(\.?[\w/]+\.py)", command)
+    if match:
+        return match.group(1)
+    match = re.match(r"python3?\s+(\.?[\w/]+\.py)", command)
+    if match:
+        return match.group(1)
+    match = re.match(r"python3?\s+-m\s+([\w\.]+)", command)
+    if match:
+        return PythonModule(match.group(1))
+    raise ValueError(
+        "Invalid command format. Must be 'fastapi run <script>' or 'python <script>' or 'python -m <module>'"
+    )

dbos/_error.py

@@ -36,6 +36,7 @@ class DBOSErrorCode(Enum):
     MaxStepRetriesExceeded = 7
     NotAuthorized = 8
     ConflictingWorkflowError = 9
+    WorkflowCancelled = 10
     ConflictingRegistrationError = 25
 
 
@@ -130,6 +131,16 @@ class DBOSMaxStepRetriesExceeded(DBOSException):
         )
 
 
+class DBOSWorkflowCancelledError(DBOSException):
+    """Exception raised when the workflow has already been cancelled."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(
+            msg,
+            dbos_error_code=DBOSErrorCode.WorkflowCancelled.value,
+        )
+
+
 class DBOSConflictingRegistrationError(DBOSException):
     """Exception raised when conflicting decorators are applied to the same function."""
 

dbos/_logger.py

@@ -8,6 +8,8 @@ from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.sdk.resources import Resource
 
+from dbos._utils import GlobalParams
+
 if TYPE_CHECKING:
     from ._dbos_config import ConfigFile
 
@@ -19,13 +21,11 @@ class DBOSLogTransformer(logging.Filter):
     def __init__(self) -> None:
         super().__init__()
         self.app_id = os.environ.get("DBOS__APPID", "")
-        self.app_version = os.environ.get("DBOS__APPVERSION", "")
-        self.executor_id = os.environ.get("DBOS__VMID", "local")
 
     def filter(self, record: Any) -> bool:
         record.applicationID = self.app_id
-        record.applicationVersion = self.app_version
-        record.executorID = self.executor_id
+        record.applicationVersion = GlobalParams.app_version
+        record.executorID = GlobalParams.executor_id
         return True
 
 
@@ -86,9 +86,8 @@ def config_logger(config: "ConfigFile") -> None:
         dbos_logger.addFilter(_otlp_transformer)
 
 
-def add_otlp_to_all_loggers(app_version: str) -> None:
+def add_otlp_to_all_loggers() -> None:
     if _otlp_handler is not None and _otlp_transformer is not None:
-        _otlp_transformer.app_version = app_version
         root = logging.root
 
         root.addHandler(_otlp_handler)

dbos/_migrations/versions/5c361fc04708_added_system_tables.py

@@ -2,7 +2,7 @@
 Add system tables.
 
 Revision ID: 5c361fc04708
-Revises: 
+Revises:
 Create Date: 2024-07-21 13:06:13.724602
 # mypy: allow-untyped-defs, allow-untyped-calls
 """

dbos/_queue.py

@@ -5,6 +5,8 @@ from typing import TYPE_CHECKING, Optional, TypedDict
 from psycopg import errors
 from sqlalchemy.exc import OperationalError
 
+from dbos._utils import GlobalParams
+
 from ._core import P, R, execute_workflow_by_id, start_workflow
 
 if TYPE_CHECKING:
@@ -71,7 +73,9 @@ def queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
             return
         for _, queue in dbos._registry.queue_info_map.items():
             try:
-                wf_ids = dbos._sys_db.start_queued_workflows(queue, dbos._executor_id)
+                wf_ids = dbos._sys_db.start_queued_workflows(
+                    queue, GlobalParams.executor_id
+                )
                 for id in wf_ids:
                     execute_workflow_by_id(dbos, id)
             except OperationalError as e: