dbos 1.4.0a1__py3-none-any.whl → 1.5.0__py3-none-any.whl

dbos/_admin_server.py

@@ -5,7 +5,9 @@ import re
 import threading
 from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import TYPE_CHECKING, Any, List, Optional, TypedDict
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict
+
+from dbos._workflow_commands import garbage_collect, global_timeout
 
 from ._context import SetWorkflowID
 from ._error import DBOSException
@@ -20,6 +22,10 @@ _health_check_path = "/dbos-healthz"
 _workflow_recovery_path = "/dbos-workflow-recovery"
 _deactivate_path = "/deactivate"
 _workflow_queues_metadata_path = "/dbos-workflow-queues-metadata"
+_garbage_collect_path = "/dbos-garbage-collect"
+_global_timeout_path = "/dbos-global-timeout"
+_queued_workflows_path = "/queues"
+_workflows_path = "/workflows"
 # /workflows/:workflow_id/cancel
 # /workflows/:workflow_id/resume
 # /workflows/:workflow_id/restart
@@ -100,10 +106,24 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             steps_match = re.match(
                 r"^/workflows/(?P<workflow_id>[^/]+)/steps$", self.path
             )
+            workflow_match = re.match(r"^/workflows/(?P<workflow_id>[^/]+)$", self.path)
 
             if steps_match:
                 workflow_id = steps_match.group("workflow_id")
                 self._handle_steps(workflow_id)
+            elif workflow_match:
+                workflow_id = workflow_match.group("workflow_id")
+                workflows = self.dbos.list_workflows(workflow_ids=[workflow_id])
+                if not workflows:
+                    self.send_response(404)
+                    self._end_headers()
+                    return
+                response_body = json.dumps(workflows[0].__dict__).encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(response_body)))
+                self._end_headers()
+                self.wfile.write(response_body)
             else:
                 self.send_response(404)
                 self._end_headers()
@@ -122,8 +142,50 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self.send_response(200)
             self._end_headers()
             self.wfile.write(json.dumps(workflow_ids).encode("utf-8"))
+        elif self.path == _workflows_path:
+            try:
+                filters = json.loads(post_data.decode("utf-8")) if post_data else {}
+                self._handle_workflows(filters)
+            except (json.JSONDecodeError, AttributeError) as e:
+                self.send_response(400)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(
+                    json.dumps({"error": f"Invalid JSON input: {str(e)}"}).encode(
+                        "utf-8"
+                    )
+                )
+        elif self.path == _queued_workflows_path:
+            try:
+                filters = json.loads(post_data.decode("utf-8")) if post_data else {}
+                self._handle_queued_workflows(filters)
+            except (json.JSONDecodeError, AttributeError) as e:
+                self.send_response(400)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(
+                    json.dumps({"error": f"Invalid JSON input: {str(e)}"}).encode(
+                        "utf-8"
+                    )
+                )
+        elif self.path == _garbage_collect_path:
+            inputs = json.loads(post_data.decode("utf-8"))
+            cutoff_epoch_timestamp_ms = inputs.get("cutoff_epoch_timestamp_ms", None)
+            rows_threshold = inputs.get("rows_threshold", None)
+            garbage_collect(
+                self.dbos,
+                cutoff_epoch_timestamp_ms=cutoff_epoch_timestamp_ms,
+                rows_threshold=rows_threshold,
+            )
+            self.send_response(204)
+            self._end_headers()
+        elif self.path == _global_timeout_path:
+            inputs = json.loads(post_data.decode("utf-8"))
+            cutoff_epoch_timestamp_ms = inputs.get("cutoff_epoch_timestamp_ms", None)
+            global_timeout(self.dbos, cutoff_epoch_timestamp_ms)
+            self.send_response(204)
+            self._end_headers()
         else:
-
             restart_match = re.match(
                 r"^/workflows/(?P<workflow_id>[^/]+)/restart$", self.path
             )
@@ -262,6 +324,50 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         self._end_headers()
         self.wfile.write(json_steps)
 
+    def _handle_workflows(self, filters: Dict[str, Any]) -> None:
+        workflows = self.dbos.list_workflows(
+            workflow_ids=filters.get("workflow_ids"),
+            name=filters.get("name"),
+            start_time=filters.get("start_time"),
+            end_time=filters.get("end_time"),
+            status=filters.get("status"),
+            app_version=filters.get("application_version"),
+            limit=filters.get("limit"),
+            offset=filters.get("offset"),
+            sort_desc=filters.get("sort_desc", False),
+            workflow_id_prefix=filters.get("workflow_id_prefix"),
+        )
+
+        response_body = json.dumps(
+            [workflow.__dict__ for workflow in workflows]
+        ).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(response_body)))
+        self._end_headers()
+        self.wfile.write(response_body)
+
+    def _handle_queued_workflows(self, filters: Dict[str, Any]) -> None:
+        workflows = self.dbos.list_queued_workflows(
+            queue_name=filters.get("queue_name"),
+            name=filters.get("name"),
+            start_time=filters.get("start_time"),
+            end_time=filters.get("end_time"),
+            status=filters.get("status"),
+            limit=filters.get("limit"),
+            offset=filters.get("offset"),
+            sort_desc=filters.get("sort_desc", False),
+        )
+
+        response_body = json.dumps(
+            [workflow.__dict__ for workflow in workflows]
+        ).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(response_body)))
+        self._end_headers()
+        self.wfile.write(response_body)
+
 
 # Be consistent with DBOS-TS response.
 class PerfUtilization(TypedDict):

dbos/_app_db.py

@@ -256,3 +256,21 @@ class ApplicationDatabase:
             )
 
             conn.execute(insert_stmt)
+
+    def garbage_collect(
+        self, cutoff_epoch_timestamp_ms: int, pending_workflow_ids: list[str]
+    ) -> None:
+        with self.engine.begin() as c:
+            delete_query = sa.delete(ApplicationSchema.transaction_outputs).where(
+                ApplicationSchema.transaction_outputs.c.created_at
+                < cutoff_epoch_timestamp_ms
+            )
+
+            if len(pending_workflow_ids) > 0:
+                delete_query = delete_query.where(
+                    ~ApplicationSchema.transaction_outputs.c.workflow_uuid.in_(
+                        pending_workflow_ids
+                    )
+                )
+
+            c.execute(delete_query)

dbos/_conductor/conductor.py

@@ -13,7 +13,9 @@ from websockets.sync.connection import Connection
 from dbos._context import SetWorkflowID
 from dbos._utils import GlobalParams
 from dbos._workflow_commands import (
+    garbage_collect,
     get_workflow,
+    global_timeout,
     list_queued_workflows,
     list_workflow_steps,
     list_workflows,
@@ -356,6 +358,41 @@ class ConductorWebsocket(threading.Thread):
                                 error_message=error_message,
                             )
                             websocket.send(list_steps_response.to_json())
+                        elif msg_type == p.MessageType.RETENTION:
+                            retention_message = p.RetentionRequest.from_json(message)
+                            success = True
+                            try:
+                                garbage_collect(
+                                    self.dbos,
+                                    cutoff_epoch_timestamp_ms=retention_message.body[
+                                        "gc_cutoff_epoch_ms"
+                                    ],
+                                    rows_threshold=retention_message.body[
+                                        "gc_rows_threshold"
+                                    ],
+                                )
+                                if (
+                                    retention_message.body["timeout_cutoff_epoch_ms"]
+                                    is not None
+                                ):
+                                    global_timeout(
+                                        self.dbos,
+                                        retention_message.body[
+                                            "timeout_cutoff_epoch_ms"
+                                        ],
+                                    )
+                            except Exception as e:
+                                error_message = f"Exception encountered during enforcing retention policy: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+                                success = False
+
+                            retention_response = p.RetentionResponse(
+                                type=p.MessageType.RETENTION,
+                                request_id=base_message.request_id,
+                                success=success,
+                                error_message=error_message,
+                            )
+                            websocket.send(retention_response.to_json())
                         else:
                             self.dbos.logger.warning(
                                 f"Unexpected message type: {msg_type}"

dbos/_conductor/protocol.py

@@ -18,6 +18,7 @@ class MessageType(str, Enum):
     EXIST_PENDING_WORKFLOWS = "exist_pending_workflows"
     LIST_STEPS = "list_steps"
     FORK_WORKFLOW = "fork_workflow"
+    RETENTION = "retention"
 
 
 T = TypeVar("T", bound="BaseMessage")
@@ -280,3 +281,20 @@ class ForkWorkflowRequest(BaseMessage):
 class ForkWorkflowResponse(BaseMessage):
     new_workflow_id: Optional[str]
     error_message: Optional[str] = None
+
+
+class RetentionBody(TypedDict):
+    gc_cutoff_epoch_ms: Optional[int]
+    gc_rows_threshold: Optional[int]
+    timeout_cutoff_epoch_ms: Optional[int]
+
+
+@dataclass
+class RetentionRequest(BaseMessage):
+    body: RetentionBody
+
+
+@dataclass
+class RetentionResponse(BaseMessage):
+    success: bool
+    error_message: Optional[str] = None

dbos/_core.py

@@ -404,9 +404,9 @@ def _execute_workflow_wthread(
                     return dbos._background_event_loop.submit_coroutine(
                         cast(Pending[R], result)()
                     )
-            except Exception:
+            except Exception as e:
                 dbos.logger.error(
-                    f"Exception encountered in asynchronous workflow: {traceback.format_exc()}"
+                    f"Exception encountered in asynchronous workflow:", exc_info=e
                 )
                 raise
 
@@ -430,9 +430,9 @@ async def _execute_workflow_async(
                     _get_wf_invoke_func(dbos, status)
                 )
                 return await result()
-            except Exception:
+            except Exception as e:
                 dbos.logger.error(
-                    f"Exception encountered in asynchronous workflow: {traceback.format_exc()}"
+                    f"Exception encountered in asynchronous workflow:", exc_info=e
                 )
                 raise
 
@@ -1123,7 +1123,7 @@ def decorate_step(
                 stepOutcome = stepOutcome.retry(
                     max_attempts,
                     on_exception,
-                    lambda i: DBOSMaxStepRetriesExceeded(func.__name__, i),
+                    lambda i, e: DBOSMaxStepRetriesExceeded(func.__name__, i, e),
                 )
 
             outcome = (

dbos/_dbos.py

@@ -521,8 +521,8 @@ class DBOS:
                 handler.flush()
             add_otlp_to_all_loggers()
             add_transformer_to_all_loggers()
-        except Exception:
-            dbos_logger.error(f"DBOS failed to launch: {traceback.format_exc()}")
+        except Exception as e:
+            dbos_logger.error(f"DBOS failed to launch:", exc_info=e)
             raise
 
     @classmethod

dbos/_dbos_config.py

@@ -31,6 +31,7 @@ class DBOSConfig(TypedDict, total=False):
         otlp_logs_endpoints: List[str]: OTLP logs endpoints
         admin_port (int): Admin port
         run_admin_server (bool): Whether to run the DBOS admin server
+        otlp_attributes (dict[str, str]): A set of custom attributes to apply OTLP-exported logs and traces
     """
 
     name: str
@@ -43,6 +44,7 @@ class DBOSConfig(TypedDict, total=False):
     otlp_logs_endpoints: Optional[List[str]]
     admin_port: Optional[int]
     run_admin_server: Optional[bool]
+    otlp_attributes: Optional[dict[str, str]]
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -84,6 +86,7 @@ class LoggerConfig(TypedDict, total=False):
 class TelemetryConfig(TypedDict, total=False):
     logs: Optional[LoggerConfig]
     OTLPExporter: Optional[OTLPExporterConfig]
+    otlp_attributes: Optional[dict[str, str]]
 
 
 class ConfigFile(TypedDict, total=False):
@@ -145,7 +148,8 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
 
     # Telemetry config
     telemetry: TelemetryConfig = {
-        "OTLPExporter": {"tracesEndpoint": [], "logsEndpoint": []}
+        "OTLPExporter": {"tracesEndpoint": [], "logsEndpoint": []},
+        "otlp_attributes": config.get("otlp_attributes", {}),
     }
     # For mypy
     assert telemetry["OTLPExporter"] is not None
@@ -431,7 +435,6 @@ def is_valid_database_url(database_url: str) -> bool:
     url = make_url(database_url)
     required_fields = [
         ("username", "Username must be specified in the connection URL"),
-        ("password", "Password must be specified in the connection URL"),
         ("host", "Host must be specified in the connection URL"),
         ("database", "Database name must be specified in the connection URL"),
     ]

dbos/_debug.py

@@ -15,11 +15,11 @@ class PythonModule:
 
 
 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):
+        # ensure the entrypoint parent directory is in sys.path
+        parent = str(Path(entrypoint).parent)
+        if parent not in sys.path:
+            sys.path.insert(0, parent)
         runpy.run_path(entrypoint)
     elif isinstance(entrypoint, PythonModule):
         runpy.run_module(entrypoint.module_name)

dbos/_error.py

@@ -150,9 +150,12 @@ class DBOSNotAuthorizedError(DBOSException):
 class DBOSMaxStepRetriesExceeded(DBOSException):
     """Exception raised when a step was retried the maximimum number of times without success."""
 
-    def __init__(self, step_name: str, max_retries: int) -> None:
+    def __init__(
+        self, step_name: str, max_retries: int, errors: list[Exception]
+    ) -> None:
         self.step_name = step_name
         self.max_retries = max_retries
+        self.errors = errors
         super().__init__(
             f"Step {step_name} has exceeded its maximum of {max_retries} retries",
             dbos_error_code=DBOSErrorCode.MaxStepRetriesExceeded.value,
@@ -160,7 +163,7 @@ class DBOSMaxStepRetriesExceeded(DBOSException):
 
     def __reduce__(self) -> Any:
         # Tell jsonpickle how to reconstruct this object
-        return (self.__class__, (self.step_name, self.max_retries))
+        return (self.__class__, (self.step_name, self.max_retries, self.errors))
 
 
 class DBOSConflictingRegistrationError(DBOSException):

dbos/_logger.py

@@ -20,14 +20,17 @@ _otlp_handler, _dbos_log_transformer = None, None
 
 
 class DBOSLogTransformer(logging.Filter):
-    def __init__(self) -> None:
+    def __init__(self, config: "ConfigFile") -> None:
         super().__init__()
         self.app_id = os.environ.get("DBOS__APPID", "")
+        self.otlp_attributes: dict[str, str] = config.get("telemetry", {}).get("otlp_attributes", {})  # type: ignore
 
     def filter(self, record: Any) -> bool:
         record.applicationID = self.app_id
         record.applicationVersion = GlobalParams.app_version
         record.executorID = GlobalParams.executor_id
+        for k, v in self.otlp_attributes.items():
+            setattr(record, k, v)
 
         # If available, decorate the log entry with Workflow ID and Trace ID
         from dbos._context import get_local_dbos_context
@@ -98,7 +101,7 @@ def config_logger(config: "ConfigFile") -> None:
 
     # Attach DBOS-specific attributes to all log entries.
     global _dbos_log_transformer
-    _dbos_log_transformer = DBOSLogTransformer()
+    _dbos_log_transformer = DBOSLogTransformer(config)
     dbos_logger.addFilter(_dbos_log_transformer)
 
 

dbos/_outcome.py

@@ -37,7 +37,7 @@ class Outcome(Protocol[T]):
         self,
         attempts: int,
         on_exception: Callable[[int, BaseException], float],
-        exceeded_retries: Callable[[int], BaseException],
+        exceeded_retries: Callable[[int, list[Exception]], Exception],
     ) -> "Outcome[T]": ...
 
     def intercept(
@@ -96,23 +96,25 @@ class Immediate(Outcome[T]):
         func: Callable[[], T],
         attempts: int,
         on_exception: Callable[[int, BaseException], float],
-        exceeded_retries: Callable[[int], BaseException],
+        exceeded_retries: Callable[[int, list[Exception]], Exception],
     ) -> T:
+        errors: list[Exception] = []
         for i in range(attempts):
             try:
                 with EnterDBOSStepRetry(i, attempts):
                     return func()
             except Exception as exp:
+                errors.append(exp)
                 wait_time = on_exception(i, exp)
                 time.sleep(wait_time)
 
-        raise exceeded_retries(attempts)
+        raise exceeded_retries(attempts, errors)
 
     def retry(
         self,
         attempts: int,
         on_exception: Callable[[int, BaseException], float],
-        exceeded_retries: Callable[[int], BaseException],
+        exceeded_retries: Callable[[int, list[Exception]], Exception],
     ) -> "Immediate[T]":
         assert attempts > 0
         return Immediate[T](
@@ -183,23 +185,25 @@ class Pending(Outcome[T]):
         func: Callable[[], Coroutine[Any, Any, T]],
         attempts: int,
         on_exception: Callable[[int, BaseException], float],
-        exceeded_retries: Callable[[int], BaseException],
+        exceeded_retries: Callable[[int, list[Exception]], Exception],
     ) -> T:
+        errors: list[Exception] = []
         for i in range(attempts):
             try:
                 with EnterDBOSStepRetry(i, attempts):
                     return await func()
             except Exception as exp:
+                errors.append(exp)
                 wait_time = on_exception(i, exp)
                 await asyncio.sleep(wait_time)
 
-        raise exceeded_retries(attempts)
+        raise exceeded_retries(attempts, errors)
 
     def retry(
         self,
         attempts: int,
         on_exception: Callable[[int, BaseException], float],
-        exceeded_retries: Callable[[int], BaseException],
+        exceeded_retries: Callable[[int, list[Exception]], Exception],
     ) -> "Pending[T]":
         assert attempts > 0
         return Pending[T](

dbos/_queue.py

@@ -1,5 +1,4 @@
 import threading
-import traceback
 from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, TypedDict
 
 from psycopg import errors

dbos/_recovery.py

@@ -1,7 +1,5 @@
-import os
 import threading
 import time
-import traceback
 from typing import TYPE_CHECKING, Any, List
 
 from dbos._utils import GlobalParams
@@ -39,9 +37,9 @@ def startup_recovery_thread(
             time.sleep(1)
         except Exception as e:
             dbos.logger.error(
-                f"Exception encountered when recovering workflows: {traceback.format_exc()}"
+                f"Exception encountered when recovering workflows:", exc_info=e
             )
-            raise e
+            raise
 
 
 def recover_pending_workflows(
@@ -59,9 +57,9 @@ def recover_pending_workflows(
                 workflow_handles.append(handle)
             except Exception as e:
                 dbos.logger.error(
-                    f"Exception encountered when recovering workflows: {traceback.format_exc()}"
+                    f"Exception encountered when recovering workflows:", exc_info=e
                 )
-                raise e
+                raise
         dbos.logger.info(
             f"Recovering {len(pending_workflows)} workflows for executor {executor_id} from version {GlobalParams.app_version}"
         )

dbos/_sys_db.py

@@ -1852,6 +1852,62 @@ class SystemDatabase:
             dbos_logger.error(f"Error connecting to the DBOS system database: {e}")
             raise
 
+    def garbage_collect(
+        self, cutoff_epoch_timestamp_ms: Optional[int], rows_threshold: Optional[int]
+    ) -> Optional[tuple[int, list[str]]]:
+        if rows_threshold is not None:
+            with self.engine.begin() as c:
+                # Get the created_at timestamp of the rows_threshold newest row
+                result = c.execute(
+                    sa.select(SystemSchema.workflow_status.c.created_at)
+                    .order_by(SystemSchema.workflow_status.c.created_at.desc())
+                    .limit(1)
+                    .offset(rows_threshold - 1)
+                ).fetchone()
+
+                if result is not None:
+                    rows_based_cutoff = result[0]
+                    # Use the more restrictive cutoff (higher timestamp = more recent = more deletion)
+                    if (
+                        cutoff_epoch_timestamp_ms is None
+                        or rows_based_cutoff > cutoff_epoch_timestamp_ms
+                    ):
+                        cutoff_epoch_timestamp_ms = rows_based_cutoff
+
+        if cutoff_epoch_timestamp_ms is None:
+            return None
+
+        with self.engine.begin() as c:
+            # Delete all workflows older than cutoff that are NOT PENDING or ENQUEUED
+            c.execute(
+                sa.delete(SystemSchema.workflow_status)
+                .where(
+                    SystemSchema.workflow_status.c.created_at
+                    < cutoff_epoch_timestamp_ms
+                )
+                .where(
+                    ~SystemSchema.workflow_status.c.status.in_(
+                        [
+                            WorkflowStatusString.PENDING.value,
+                            WorkflowStatusString.ENQUEUED.value,
+                        ]
+                    )
+                )
+            )
+
+            # Then, get the IDs of all remaining old workflows
+            pending_enqueued_result = c.execute(
+                sa.select(SystemSchema.workflow_status.c.workflow_uuid).where(
+                    SystemSchema.workflow_status.c.created_at
+                    < cutoff_epoch_timestamp_ms
+                )
+            ).fetchall()
+
+            # Return the final cutoff and workflow IDs
+            return cutoff_epoch_timestamp_ms, [
+                row[0] for row in pending_enqueued_result
+            ]
+
 
 def reset_system_database(postgres_db_url: sa.URL, sysdb_name: str) -> None:
     try:

dbos/_tracer.py

@@ -19,11 +19,14 @@ if TYPE_CHECKING:
 
 class DBOSTracer:
 
+    otlp_attributes: dict[str, str] = {}
+
     def __init__(self) -> None:
         self.app_id = os.environ.get("DBOS__APPID", None)
         self.provider: Optional[TracerProvider] = None
 
     def config(self, config: ConfigFile) -> None:
+        self.otlp_attributes = config.get("telemetry", {}).get("otlp_attributes", {})  # type: ignore
         if not isinstance(trace.get_tracer_provider(), TracerProvider):
             resource = Resource(
                 attributes={
@@ -63,6 +66,8 @@ class DBOSTracer:
         for k, v in attributes.items():
             if k != "name" and v is not None and isinstance(v, (str, bool, int, float)):
                 span.set_attribute(k, v)
+        for k, v in self.otlp_attributes.items():
+            span.set_attribute(k, v)
         return span
 
     def end_span(self, span: Span) -> None:

dbos/_workflow_commands.py

@@ -1,8 +1,9 @@
+import time
 import uuid
-from typing import List, Optional
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
 
 from dbos._context import get_local_dbos_context
-from dbos._error import DBOSException
 
 from ._app_db import ApplicationDatabase
 from ._sys_db import (
@@ -11,8 +12,12 @@ from ._sys_db import (
     StepInfo,
     SystemDatabase,
     WorkflowStatus,
+    WorkflowStatusString,
 )
 
+if TYPE_CHECKING:
+    from ._dbos import DBOS
+
 
 def list_workflows(
     sys_db: SystemDatabase,
@@ -118,3 +123,31 @@ def fork_workflow(
         application_version=application_version,
     )
     return forked_workflow_id
+
+
+def garbage_collect(
+    dbos: "DBOS",
+    cutoff_epoch_timestamp_ms: Optional[int],
+    rows_threshold: Optional[int],
+) -> None:
+    if cutoff_epoch_timestamp_ms is None and rows_threshold is None:
+        return
+    result = dbos._sys_db.garbage_collect(
+        cutoff_epoch_timestamp_ms=cutoff_epoch_timestamp_ms,
+        rows_threshold=rows_threshold,
+    )
+    if result is not None:
+        cutoff_epoch_timestamp_ms, pending_workflow_ids = result
+        dbos._app_db.garbage_collect(cutoff_epoch_timestamp_ms, pending_workflow_ids)
+
+
+def global_timeout(dbos: "DBOS", cutoff_epoch_timestamp_ms: int) -> None:
+    cutoff_iso = datetime.fromtimestamp(cutoff_epoch_timestamp_ms / 1000).isoformat()
+    for workflow in dbos.list_workflows(
+        status=WorkflowStatusString.PENDING.value, end_time=cutoff_iso
+    ):
+        dbos.cancel_workflow(workflow.workflow_id)
+    for workflow in dbos.list_workflows(
+        status=WorkflowStatusString.ENQUEUED.value, end_time=cutoff_iso
+    ):
+        dbos.cancel_workflow(workflow.workflow_id)

dbos/cli/cli.py

@@ -18,7 +18,12 @@ from dbos._debug import debug_workflow, parse_start_command
 
 from .._app_db import ApplicationDatabase
 from .._client import DBOSClient
-from .._dbos_config import _is_valid_app_name, is_valid_database_url, load_config
+from .._dbos_config import (
+    _app_name_to_db_name,
+    _is_valid_app_name,
+    is_valid_database_url,
+    load_config,
+)
 from .._docker_pg_helper import start_docker_pg, stop_docker_pg
 from .._schemas.system_database import SystemSchema
 from .._sys_db import SystemDatabase, reset_system_database
@@ -28,12 +33,36 @@ from ._template_init import copy_template, get_project_name, get_templates_direc
 
 
 def _get_db_url(db_url: Optional[str]) -> str:
+    """
+    Get the database URL to use for the DBOS application.
+    Order of precedence:
+    - If the `db_url` argument is provided, use it.
+    - If the `dbos-config.yaml` file is present, use the `database_url` from it.
+    - If the `DBOS_DATABASE_URL` environment variable is set, use it.
+
+    Otherwise fallback to the same default Postgres URL than the DBOS library.
+    Note that for the latter to be possible, a configuration file must have been found, with an application name set.
+    """
     database_url = db_url
+    _app_db_name = None
+    if database_url is None:
+        # Load from config file if present
+        try:
+            config = load_config(run_process_config=False, silent=True)
+            database_url = config.get("database_url")
+            _app_db_name = _app_name_to_db_name(config["name"])
+        except (FileNotFoundError, OSError):
+            # Config file doesn't exist, continue with other fallbacks
+            pass
     if database_url is None:
         database_url = os.getenv("DBOS_DATABASE_URL")
+    if database_url is None and _app_db_name is not None:
+        # Fallback on the same defaults than the DBOS library
+        _password = os.environ.get("PGPASSWORD", "dbos")
+        database_url = f"postgres://postgres:{_password}@localhost:5432/{_app_db_name}?connect_timeout=10&sslmode=prefer"
     if database_url is None:
         raise ValueError(
-            "Missing database URL: please set it using the --db-url flag or the DBOS_DATABASE_URL environment variable."
+            "Missing database URL: please set it using the --db-url flag, the DBOS_DATABASE_URL environment variable, or in your dbos-config.yaml file."
         )
     assert is_valid_database_url(database_url)
     return database_url

{dbos-1.4.0a1.dist-info → dbos-1.5.0.dist-info}/METADATA

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

{dbos-1.4.0a1.dist-info → dbos-1.5.0.dist-info}/RECORD

@@ -1,29 +1,29 @@
-dbos-1.4.0a1.dist-info/METADATA,sha256=Snqbd6UknvRQFKSZJUL9tBkcEvfCGnRNXGH--L4nGPc,13267
-dbos-1.4.0a1.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-1.4.0a1.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.4.0a1.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-1.5.0.dist-info/METADATA,sha256=Dn02XFDJEtFjCEZYBOqsdTHrg-qMgQ3Rd58d6HS7JRk,13265
+dbos-1.5.0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-1.5.0.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.5.0.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=NssPCubaBxdiKarOWa-wViz1hdJSkmBGcpLX_gQ4NeA,891
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
-dbos/_admin_server.py,sha256=TWXi4drrzKFpKkUmEJpJkQBZxAtOalnhtYicEn2nDK0,10618
-dbos/_app_db.py,sha256=0PKqpxJ3EbIaak3Wl0lNl3hXvhBfz4EEHaCw1bUOvIM,9937
+dbos/_admin_server.py,sha256=l46ZX4NpvBP9W8cl9gE7OqMNwUCevLMt2VztM7crBv0,15465
+dbos/_app_db.py,sha256=htblDPfqrpb_uZoFcvaud7cgQ-PDyn6Bn-cBidxdCTA,10603
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
 dbos/_client.py,sha256=cQxw1Nbh_vKZ03lONt0EmUhwXBk3B3NczZrmfXXeefY,14667
-dbos/_conductor/conductor.py,sha256=o0IaZjwnZ2TOyHeP2H4iSX6UnXLXQ4uODvWAKD9hHMs,21703
-dbos/_conductor/protocol.py,sha256=wgOFZxmS81bv0WCB9dAyg0s6QzldpzVKQDoSPeaX0Ws,6967
+dbos/_conductor/conductor.py,sha256=y_T-8kEHwKWt6W8LtcFMctB_6EvYFWsuGLxiFuuKKBU,23702
+dbos/_conductor/protocol.py,sha256=DOTprPSd7oHDcvwWSyZpnlPds_JfILtcKzHZa-qBsF4,7330
 dbos/_context.py,sha256=5ajoWAmToAfzzmMLylnJZoL4Ny9rBwZWuG05sXadMIA,24798
-dbos/_core.py,sha256=hvHKi31-3LG5yfWa-KhsnoFrXsV_eT-GeKIZFT4chx8,48533
+dbos/_core.py,sha256=eFRhljdi8vjpmBEzu-wt_feC7-uDmKqbiybz92KCRwI,48523
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=GVx3NY59tKWW6nlAtH2PvX4Ne_eOHvY012MtXVK_FQA,47265
-dbos/_dbos_config.py,sha256=2CC1YR8lP9W-_NsMUMnTnW-v-70KN4XkbJEeNJ78RlQ,20373
-dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
+dbos/_dbos.py,sha256=HHMo-PLUa6m5jFgdA-YYAwaTx2kyA1Te1VslAyd0hIw,47257
+dbos/_dbos_config.py,sha256=JUG4V1rrP0p1AYESgih4ea80qOH_13UsgoIIm8X84pw,20562
+dbos/_debug.py,sha256=99j2SChWmCPAlZoDmjsJGe77tpU2LEa8E2TtLAnnh7o,1831
 dbos/_docker_pg_helper.py,sha256=tLJXWqZ4S-ExcaPnxg_i6cVxL6ZxrYlZjaGsklY-s2I,6115
-dbos/_error.py,sha256=q0OQJZTbR8FFHV9hEpAGpz9oWBT5L509zUhmyff7FJw,8500
+dbos/_error.py,sha256=nS7KuXJHhuNXZRErxdEUGT38Hb0VPyxNwSyADiVpHcE,8581
 dbos/_event_loop.py,sha256=cvaFN9-II3MsHEOq8QoICc_8qSKrjikMlLfuhC3Y8Dk,2923
 dbos/_fastapi.py,sha256=T7YlVY77ASqyTqq0aAPclZ9YzlXdGTT0lEYSwSgt1EE,3151
 dbos/_flask.py,sha256=Npnakt-a3W5OykONFRkDRnumaDhTQmA0NPdUCGRYKXE,1652
 dbos/_kafka.py,sha256=pz0xZ9F3X9Ky1k-VSbeF3tfPhP3UPr3lUUhUfE41__U,4198
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
-dbos/_logger.py,sha256=Yde-w0MZt9xT2NBmzcKY9G3mn6OJ5aVJuC5Elm3p4p4,4390
+dbos/_logger.py,sha256=Dp6bHZKUtcm5gWwYHj_HA5Wj5OMuJGUrpl2g2i4xDZg,4620
 dbos/_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
 dbos/_migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 dbos/_migrations/versions/04ca4f231047_workflow_queues_executor_id.py,sha256=ICLPl8CN9tQXMsLDsAj8z1TsL831-Z3F8jSBvrR-wyw,736
@@ -39,9 +39,9 @@ dbos/_migrations/versions/d76646551a6c_workflow_queue.py,sha256=G942nophZ2uC2vc4
 dbos/_migrations/versions/d994145b47b6_consolidate_inputs.py,sha256=_J0jP247fuo66fzOmLlKFO9FJ_CRBXlqa2lnLrcXugQ,672
 dbos/_migrations/versions/eab0cc1d9a14_job_queue.py,sha256=uvhFOtqbBreCePhAxZfIT0qCAI7BiZTou9wt6QnbY7c,1412
 dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py,sha256=m90Lc5YH0ZISSq1MyxND6oq3RZrZKrIqEsZtwJ1jWxA,1049
-dbos/_outcome.py,sha256=EXxBg4jXCVJsByDQ1VOCIedmbeq_03S6d-p1vqQrLFU,6810
-dbos/_queue.py,sha256=Csp6wrLg6TyZJMeAWkbQAiviIDiucbP-qrBaqp2WJwY,4097
-dbos/_recovery.py,sha256=jVMexjfCCNopzyn8gVQzJCmGJaP9G3C1EFaoCQ_Nh7g,2564
+dbos/_outcome.py,sha256=Kz3aL7517q9UEFTx3Cq9zzztjWyWVOx_08fZyHo9dvg,7035
+dbos/_queue.py,sha256=Kq7aldTDLRF7cZtkXmsCy6wV2PR24enkhghEG25NtaU,4080
+dbos/_recovery.py,sha256=TBNjkmSEqBU-g5YXExsLJ9XoCe4iekqtREsskXZECEg,2507
 dbos/_registrations.py,sha256=CZt1ElqDjCT7hz6iyT-1av76Yu-iuwu_c9lozO87wvM,7303
 dbos/_roles.py,sha256=iOsgmIAf1XVzxs3gYWdGRe1B880YfOw5fpU7Jwx8_A8,2271
 dbos/_scheduler.py,sha256=SR1oRZRcVzYsj-JauV2LA8JtwTkt8mru7qf6H1AzQ1U,2027
@@ -49,7 +49,7 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
 dbos/_schemas/system_database.py,sha256=rbFKggONdvvbb45InvGz0TM6a7c-Ux9dcaL-h_7Z7pU,4438
 dbos/_serialization.py,sha256=bWuwhXSQcGmiazvhJHA5gwhrRWxtmFmcCFQSDJnqqkU,3666
-dbos/_sys_db.py,sha256=67z_K0aKH8M_oRs9c13zhp6skpT-sLAw8nYRBa3JM5w,77844
+dbos/_sys_db.py,sha256=now889o6Mlmcdopp8xF5_0LAE67KeVH9Vm-4svIqo5s,80170
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_templates/dbos-db-starter/__package/main.py.dbos,sha256=aQnBPSSQpkB8ERfhf7gB7P9tsU6OPKhZscfeh0yiaD8,2702
@@ -60,13 +60,13 @@ dbos/_templates/dbos-db-starter/migrations/env.py.dbos,sha256=IBB_gz9RjC20HPfOTG
 dbos/_templates/dbos-db-starter/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sha256=MpS7LGaJS0CpvsjhfDkp9EJqvMvVCjRPfUp4c0aE2ys,941
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
-dbos/_tracer.py,sha256=yN6GRDKu_1p-EqtQLNarMocPfga2ZuqpzStzzSPYhzo,2732
+dbos/_tracer.py,sha256=RnlcaOJEx_58hr2J9L9g6E7gjAHAeEtEGugJZmCwNfQ,2963
 dbos/_utils.py,sha256=uywq1QrjMwy17btjxW4bES49povlQwYwYbvKwMT6C2U,1575
-dbos/_workflow_commands.py,sha256=UCpHWvCEXjVZtf5FNanFvtJpgUJDSI1EFBqQP0x_2A0,3346
+dbos/_workflow_commands.py,sha256=Fi-sQxQvFkDkMlCv7EyRJIWxqk3fG6DGlgvvwkjWbS4,4485
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=7JBcpMqP1r2mfCnvWatu33z8ctEGHJarlZYKgB83cXE,2972
-dbos/cli/cli.py,sha256=EemOMqNpzSU2BQhAxV_e59pBRITDLwt49HF6W3uWBZg,20775
+dbos/cli/cli.py,sha256=IcfaX4rrSrk6f24S2jrlR33snYMyNyEIx_lNQtuVr2E,22081
 dbos/dbos-config.schema.json,sha256=CjaspeYmOkx6Ip_pcxtmfXJTn_YGdSx_0pcPBF7KZmo,6060
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-1.4.0a1.dist-info/RECORD,,
+dbos-1.5.0.dist-info/RECORD,,