dbos 1.5.0a4__tar.gz → 1.5.0a10__tar.gz

{dbos-1.5.0a4 → dbos-1.5.0a10}/PKG-INFO

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

{dbos-1.5.0a4 → dbos-1.5.0a10}/dbos/_admin_server.py

@@ -5,7 +5,7 @@ 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
 
@@ -24,6 +24,8 @@ _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
@@ -104,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()
@@ -126,6 +142,32 @@ 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)
@@ -144,7 +186,6 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self.send_response(204)
             self._end_headers()
         else:
-
             restart_match = re.match(
                 r"^/workflows/(?P<workflow_id>[^/]+)/restart$", self.path
             )
@@ -283,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-1.5.0a4 → dbos-1.5.0a10}/dbos/_core.py

@@ -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-1.5.0a4 → dbos-1.5.0a10}/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-1.5.0a4 → dbos-1.5.0a10}/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-1.5.0a4 → dbos-1.5.0a10}/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-1.5.0a4 → dbos-1.5.0a10}/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-1.5.0a4 → dbos-1.5.0a10}/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-1.5.0a4 → dbos-1.5.0a10}/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.5.0a4 → dbos-1.5.0a10}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.5.0a4"
+version = "1.5.0a10"
 
 [project.license]
 text = "MIT"

{dbos-1.5.0a4 → dbos-1.5.0a10}/tests/test_admin_server.py

@@ -3,7 +3,7 @@ import socket
 import threading
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 
 import pytest
 import requests
@@ -455,6 +455,109 @@ def test_admin_workflow_fork(dbos: DBOS, sys_db: SystemDatabase) -> None:
     assert worked, "Workflow did not finish successfully"
 
 
+def test_list_workflows(dbos: DBOS) -> None:
+    # Create workflows for testing
+    @DBOS.workflow()
+    def test_workflow_1() -> None:
+        pass
+
+    @DBOS.workflow()
+    def test_workflow_2() -> None:
+        pass
+
+    # Start workflows
+    handle_1 = DBOS.start_workflow(test_workflow_1)
+    time.sleep(2)  # Sleep for 2 seconds between workflows
+    handle_2 = DBOS.start_workflow(test_workflow_2)
+
+    # Wait for workflows to complete
+    handle_1.get_result()
+    handle_2.get_result()
+
+    # List workflows and dynamically set the filter "name"
+    workflows_list = DBOS.list_workflows()
+    assert (
+        len(workflows_list) >= 2
+    ), f"Expected at least 2 workflows, but got {len(workflows_list)}"
+
+    workflow_ids = [w.workflow_id for w in workflows_list]
+
+    # Convert created_at to ISO 8601 format
+    created_at_second_workflow = workflows_list[1].created_at
+    assert (
+        created_at_second_workflow is not None
+    ), "created_at for the second workflow is None"
+    start_time_filter = datetime.fromtimestamp(
+        created_at_second_workflow / 1000, tz=timezone.utc
+    ).isoformat()
+
+    # Test POST /workflows with filters
+    filters = {
+        "workflow_ids": workflow_ids,
+        "start_time": start_time_filter,
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+
+    workflows = response.json()
+    assert len(workflows) == 1, f"Expected 1 workflows, but got {len(workflows)}"
+    assert workflows[0]["workflow_id"] == handle_2.workflow_id, "Workflow ID mismatch"
+
+    # Test POST /workflows without filters
+    response = requests.post("http://localhost:3001/workflows", json={}, timeout=5)
+    assert response.status_code == 200
+
+    workflows = response.json()
+    assert len(workflows) == len(
+        workflows_list
+    ), f"Expected {len(workflows_list)} workflows, but got {len(workflows)}"
+    for workflow in workflows:
+        assert workflow["workflow_id"] in workflow_ids, "Workflow ID mismatch"
+
+
+def test_get_workflow_by_id(dbos: DBOS) -> None:
+    # Create workflows for testing
+    @DBOS.workflow()
+    def test_workflow_1() -> None:
+        pass
+
+    @DBOS.workflow()
+    def test_workflow_2() -> None:
+        pass
+
+    # Start workflows
+    handle_1 = DBOS.start_workflow(test_workflow_1)
+    handle_2 = DBOS.start_workflow(test_workflow_2)
+
+    # Wait for workflows to complete
+    handle_1.get_result()
+    handle_2.get_result()
+
+    # Get the workflow ID of the second workflow
+    workflow_id = handle_2.workflow_id
+
+    # Test GET /workflows/:workflow_id for an existing workflow
+    response = requests.get(f"http://localhost:3001/workflows/{workflow_id}", timeout=5)
+    assert (
+        response.status_code == 200
+    ), f"Expected status code 200, but got {response.status_code}"
+
+    workflow_data = response.json()
+    assert workflow_data["workflow_id"] == workflow_id, "Workflow ID mismatch"
+    assert (
+        workflow_data["status"] == "SUCCESS"
+    ), "Expected workflow status to be SUCCESS"
+
+    # Test GET /workflows/:workflow_id for a non-existing workflow
+    non_existing_workflow_id = "non-existing-id"
+    response = requests.get(
+        f"http://localhost:3001/workflows/{non_existing_workflow_id}", timeout=5
+    )
+    assert (
+        response.status_code == 404
+    ), f"Expected status code 404, but got {response.status_code}"
+
+
 def test_admin_garbage_collect(dbos: DBOS) -> None:
 
     @DBOS.workflow()
@@ -493,3 +596,56 @@ def test_admin_global_timeout(dbos: DBOS) -> None:
     response.raise_for_status()
     with pytest.raises(DBOSWorkflowCancelledError):
         handle.get_result()
+
+
+def test_queued_workflows_endpoint(dbos: DBOS) -> None:
+    """Test the /queues endpoint with various filters and scenarios."""
+
+    # Set up a queue for testing
+    test_queue1 = Queue("test-queue-1", concurrency=1)
+    test_queue2 = Queue("test-queue-2", concurrency=1)
+
+    @DBOS.workflow()
+    def blocking_workflow() -> str:
+        while True:
+            time.sleep(0.1)
+
+    # Enqueue some workflows to create queued entries
+    handles = []
+    handles.append(test_queue1.enqueue(blocking_workflow))
+    handles.append(test_queue1.enqueue(blocking_workflow))
+    handles.append(test_queue2.enqueue(blocking_workflow))
+
+    # Test basic queued workflows endpoint
+    response = requests.post("http://localhost:3001/queues", json={}, timeout=5)
+    assert (
+        response.status_code == 200
+    ), f"Expected status 200, got {response.status_code}"
+
+    queued_workflows = response.json()
+    assert isinstance(queued_workflows, list), "Response should be a list"
+    assert (
+        len(queued_workflows) == 3
+    ), f"Expected 3 queued workflows, got {len(queued_workflows)}"
+
+    # Test with filters
+    filters = {"queue_name": "test-queue-1", "limit": 1}
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+
+    filtered_workflows = response.json()
+    assert isinstance(filtered_workflows, list), "Response should be a list"
+    assert (
+        len(filtered_workflows) == 1
+    ), f"Expected 1 workflow, got {len(filtered_workflows)}"
+
+    # Test with non-existent queue name
+    filters = {"queue_name": "non-existent-queue"}
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+
+    empty_result = response.json()
+    assert isinstance(
+        empty_result, list
+    ), "Response should be a list even for non-existent queue"
+    assert len(empty_result) == 0, "Expected no workflows for non-existent queue"

{dbos-1.5.0a4 → dbos-1.5.0a10}/tests/test_config.py

@@ -10,7 +10,7 @@ from sqlalchemy import event
 from sqlalchemy.exc import OperationalError
 
 # Public API
-from dbos import DBOS
+from dbos import DBOS, DBOSClient
 from dbos._dbos_config import (
     ConfigFile,
     DBOSConfig,
@@ -598,15 +598,6 @@ def test_process_config_with_wrong_db_url():
         process_config(data=config)
     assert "Username must be specified in the connection URL" in str(exc_info.value)
 
-    # Missing password
-    config: ConfigFile = {
-        "name": "some-app",
-        "database_url": "postgres://user:@h:1234/dbname",
-    }
-    with pytest.raises(DBOSInitializationError) as exc_info:
-        process_config(data=config)
-    assert "Password must be specified in the connection URL" in str(exc_info.value)
-
     # Missing host
     config: ConfigFile = {
         "name": "some-app",
@@ -628,6 +619,26 @@ def test_process_config_with_wrong_db_url():
     )
 
 
+def test_database_url_no_password():
+    """Test that the database URL can be provided without a password."""
+    expected_url = "postgresql://postgres@localhost:5432/dbostestpy?sslmode=disable"
+    config: DBOSConfig = {
+        "name": "some-app",
+        "database_url": expected_url,
+    }
+    processed_config = translate_dbos_config_to_config_file(config)
+    assert processed_config["name"] == "some-app"
+    assert processed_config["database_url"] == expected_url
+
+    # Make sure we can use it to construct a DBOS Client and connect to the database without a password
+    client = DBOSClient(expected_url)
+    try:
+        res = client.list_queued_workflows()
+        assert res is not None
+    finally:
+        client.destroy()
+
+
 ####################
 # TRANSLATE DBOSConfig to ConfigFile
 ####################

{dbos-1.5.0a4 → dbos-1.5.0a10}/tests/test_failures.py

@@ -332,6 +332,11 @@ def test_step_retries(dbos: DBOS) -> None:
         failing_step()
     assert error_message in str(excinfo.value)
     assert step_counter == max_attempts
+    assert len(excinfo.value.errors) == max_attempts
+    for error in excinfo.value.errors:
+        assert isinstance(error, Exception)
+        assert error
+        assert "fail" in str(error)
 
     # Test calling the workflow
     step_counter = 0
@@ -448,10 +453,11 @@ def test_error_serialization() -> None:
     # Verify that each exception that can be thrown in a workflow
     # is serializable and deserializable
     # DBOSMaxStepRetriesExceeded
-    e: Exception = DBOSMaxStepRetriesExceeded("step", 1)
+    e: Exception = DBOSMaxStepRetriesExceeded("step", 1, [Exception()])
     d = deserialize_exception(serialize_exception(e))
     assert isinstance(d, DBOSMaxStepRetriesExceeded)
     assert str(d) == str(e)
+    assert isinstance(d.errors[0], Exception)
     # DBOSNotAuthorizedError
     e = DBOSNotAuthorizedError("no")
     d = deserialize_exception(serialize_exception(e))

{dbos-1.5.0a4 → dbos-1.5.0a10}/tests/test_outcome.py

@@ -56,7 +56,7 @@ def test_immediate_retry() -> None:
         raise Exception("Error")
 
     o1 = Outcome[int].make(raiser)
-    o2 = o1.retry(3, lambda i, e: 0.1, lambda i: ExceededRetries())
+    o2 = o1.retry(3, lambda i, e: 0.1, lambda i, e: ExceededRetries())
 
     assert isinstance(o2, Immediate)
     with pytest.raises(ExceededRetries):
@@ -105,7 +105,7 @@ async def test_pending_retry() -> None:
         raise Exception("Error")
 
     o1 = Outcome[int].make(raiser)
-    o2 = o1.retry(3, lambda i, e: 0.1, lambda i: ExceededRetries())
+    o2 = o1.retry(3, lambda i, e: 0.1, lambda i, e: ExceededRetries())
 
     assert isinstance(o2, Pending)
     with pytest.raises(ExceededRetries):

{dbos-1.5.0a4 → dbos-1.5.0a10}/tests/test_queue.py

@@ -7,11 +7,12 @@ import subprocess
 import threading
 import time
 import uuid
-from typing import List
+from typing import Any, List
 from urllib.parse import quote
 
 import pytest
 import sqlalchemy as sa
+from pydantic import BaseModel
 
 from dbos import (
     DBOS,
@@ -1462,3 +1463,55 @@ def test_queue_executor_id(dbos: DBOS) -> None:
         handle = queue.enqueue(example_workflow)
         assert handle.get_result() == wfid
     assert handle.get_status().executor_id == original_executor_id
+
+
+# Non-basic types must be declared in an importable scope (so not inside a function)
+# to be serializable and deserializable
+class InnerType(BaseModel):
+    one: str
+    two: int
+
+
+class OuterType(BaseModel):
+    inner: InnerType
+
+
+def test_complex_type(dbos: DBOS) -> None:
+    queue = Queue("test_queue")
+
+    @DBOS.workflow()
+    def workflow(input: OuterType) -> OuterType:
+        return input
+
+    # Verify a workflow with non-basic inputs and outputs can be enqueued
+    inner = InnerType(one="one", two=2)
+    outer = OuterType(inner=inner)
+
+    handle = queue.enqueue(workflow, outer)
+    result = handle.get_result()
+
+    def check(result: Any) -> None:
+        assert isinstance(result, OuterType)
+        assert isinstance(result.inner, InnerType)
+        assert result.inner.one == outer.inner.one
+        assert result.inner.two == outer.inner.two
+
+    check(result)
+
+    # Verify a workflow with non-basic inputs and outputs can be recovered
+    start_event = threading.Event()
+    event = threading.Event()
+
+    @DBOS.workflow()
+    def blocked_workflow(input: OuterType) -> OuterType:
+        start_event.set()
+        event.wait()
+        return input
+
+    handle = queue.enqueue(blocked_workflow, outer)
+
+    start_event.wait()
+    recovery_handle = DBOS._recover_pending_workflows()[0]
+    event.set()
+    check(handle.get_result())
+    check(recovery_handle.get_result())

{dbos-1.5.0a4 → dbos-1.5.0a10}/tests/test_spans.py

@@ -7,12 +7,16 @@ from opentelemetry.sdk import trace as tracesdk
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
 from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
 
-from dbos import DBOS
+from dbos import DBOS, DBOSConfig
 from dbos._tracer import dbos_tracer
 from dbos._utils import GlobalParams
 
 
-def test_spans(dbos: DBOS) -> None:
+def test_spans(config: DBOSConfig) -> None:
+    DBOS.destroy(destroy_registry=True)
+    config["otlp_attributes"] = {"foo": "bar"}
+    DBOS(config=config)
+    DBOS.launch()
 
     @DBOS.workflow()
     def test_workflow() -> None:
@@ -44,6 +48,7 @@ def test_spans(dbos: DBOS) -> None:
         assert span.attributes["applicationVersion"] == GlobalParams.app_version
         assert span.attributes["executorID"] == GlobalParams.executor_id
         assert span.context is not None
+        assert span.attributes["foo"] == "bar"
 
     assert spans[0].name == test_step.__name__
     assert spans[1].name == "a new span"