dbos 1.5.0a5__tar.gz → 1.5.0a10__tar.gz

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

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

{dbos-1.5.0a5 → 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, Dict
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict
 
 from dbos._workflow_commands import garbage_collect, global_timeout
 

{dbos-1.5.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → dbos-1.5.0a10}/pyproject.toml

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

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

@@ -557,6 +557,7 @@ def test_get_workflow_by_id(dbos: DBOS) -> None:
         response.status_code == 404
     ), f"Expected status code 404, but got {response.status_code}"
 
+
 def test_admin_garbage_collect(dbos: DBOS) -> None:
 
     @DBOS.workflow()
@@ -617,11 +618,15 @@ def test_queued_workflows_endpoint(dbos: DBOS) -> None:
 
     # 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}"
+    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)}"
+    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}
@@ -630,7 +635,9 @@ def test_queued_workflows_endpoint(dbos: DBOS) -> None:
 
     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)}"
+    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"}
@@ -638,5 +645,7 @@ def test_queued_workflows_endpoint(dbos: DBOS) -> None:
     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"
+    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.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → 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.0a5 → 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"