dbos 0.24.0a5__tar.gz → 0.24.0a7__tar.gz

{dbos-0.24.0a5 → dbos-0.24.0a7}/PKG-INFO

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

{dbos-0.24.0a5 → dbos-0.24.0a7}/dbos/_app_db.py

@@ -5,7 +5,7 @@ import sqlalchemy.dialects.postgresql as pg
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session, sessionmaker
 
-from ._dbos_config import ConfigFile
+from ._dbos_config import ConfigFile, DatabaseConfig
 from ._error import DBOSWorkflowConflictIDError
 from ._schemas.application_database import ApplicationSchema
 
@@ -61,8 +61,22 @@ class ApplicationDatabase:
             port=config["database"]["port"],
             database=app_db_name,
         )
+
+        connect_args = {}
+        if (
+            "connectionTimeoutMillis" in config["database"]
+            and config["database"]["connectionTimeoutMillis"]
+        ):
+            connect_args["connect_timeout"] = int(
+                config["database"]["connectionTimeoutMillis"] / 1000
+            )
+
         self.engine = sa.create_engine(
-            app_db_url, pool_size=20, max_overflow=5, pool_timeout=30
+            app_db_url,
+            pool_size=config["database"]["app_db_pool_size"],
+            max_overflow=0,
+            pool_timeout=30,
+            connect_args=connect_args,
         )
         self.sessionmaker = sessionmaker(bind=self.engine)
         self.debug_mode = debug_mode

{dbos-0.24.0a5 → dbos-0.24.0a7}/dbos/_core.py

@@ -824,7 +824,9 @@ def decorate_step(
             stepOutcome = Outcome[R].make(functools.partial(func, *args, **kwargs))
             if retries_allowed:
                 stepOutcome = stepOutcome.retry(
-                    max_attempts, on_exception, lambda i: DBOSMaxStepRetriesExceeded()
+                    max_attempts,
+                    on_exception,
+                    lambda i: DBOSMaxStepRetriesExceeded(func.__name__, i),
                 )
 
             outcome = (

{dbos-0.24.0a5 → dbos-0.24.0a7}/dbos/_dbos.py

@@ -457,7 +457,14 @@ class DBOS:
             admin_port = self.config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:
                 admin_port = 3001
-            self._admin_server_field = AdminServer(dbos=self, port=admin_port)
+            run_admin_server = self.config.get("runtimeConfig", {}).get(
+                "run_admin_server"
+            )
+            if run_admin_server:
+                try:
+                    self._admin_server_field = AdminServer(dbos=self, port=admin_port)
+                except Exception as e:
+                    dbos_logger.warning(f"Failed to start admin server: {e}")
 
             workflow_ids = self._sys_db.get_pending_workflows(
                 GlobalParams.executor_id, GlobalParams.app_version

{dbos-0.24.0a5 → dbos-0.24.0a7}/dbos/_dbos_config.py

@@ -22,30 +22,38 @@ from ._logger import dbos_logger
 DBOS_CONFIG_PATH = "dbos-config.yaml"
 
 
-class DBOSConfig(TypedDict):
+class DBOSConfig(TypedDict, total=False):
     """
     Data structure containing the DBOS library configuration.
 
     Attributes:
         name (str): Application name
         database_url (str): Database connection string
+        app_db_pool_size (int): Application database pool size
         sys_db_name (str): System database name
+        sys_db_pool_size (int): System database pool size
         log_level (str): Log level
         otlp_traces_endpoints: List[str]: OTLP traces endpoints
+        admin_port (int): Admin port
+        run_admin_server (bool): Whether to run the DBOS admin server
     """
 
     name: str
     database_url: Optional[str]
+    app_db_pool_size: Optional[int]
     sys_db_name: Optional[str]
+    sys_db_pool_size: Optional[int]
     log_level: Optional[str]
     otlp_traces_endpoints: Optional[List[str]]
     admin_port: Optional[int]
+    run_admin_server: Optional[bool]
 
 
 class RuntimeConfig(TypedDict, total=False):
     start: List[str]
     setup: Optional[List[str]]
     admin_port: Optional[int]
+    run_admin_server: Optional[bool]
 
 
 class DatabaseConfig(TypedDict, total=False):
@@ -55,7 +63,9 @@ class DatabaseConfig(TypedDict, total=False):
     password: str
     connectionTimeoutMillis: Optional[int]
     app_db_name: str
+    app_db_pool_size: Optional[int]
     sys_db_name: Optional[str]
+    sys_db_pool_size: Optional[int]
     ssl: Optional[bool]
     ssl_ca: Optional[str]
     local_suffix: Optional[bool]
@@ -160,12 +170,21 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
         db_config = parse_database_url_to_dbconfig(database_url)
     if "sys_db_name" in config:
         db_config["sys_db_name"] = config.get("sys_db_name")
+    if "app_db_pool_size" in config:
+        db_config["app_db_pool_size"] = config.get("app_db_pool_size")
+    if "sys_db_pool_size" in config:
+        db_config["sys_db_pool_size"] = config.get("sys_db_pool_size")
     if db_config:
         translated_config["database"] = db_config
 
-    # Admin port
+    # Runtime config
+    translated_config["runtimeConfig"] = {"run_admin_server": True}
     if "admin_port" in config:
-        translated_config["runtimeConfig"] = {"admin_port": config["admin_port"]}
+        translated_config["runtimeConfig"]["admin_port"] = config["admin_port"]
+    if "run_admin_server" in config:
+        translated_config["runtimeConfig"]["run_admin_server"] = config[
+            "run_admin_server"
+        ]
 
     # Telemetry config
     telemetry = {}
@@ -289,6 +308,15 @@ def process_config(
             f'Invalid app name {data["name"]}.  App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores.'
         )
 
+    if data.get("telemetry") is None:
+        data["telemetry"] = {}
+    telemetry = cast(TelemetryConfig, data["telemetry"])
+    if telemetry.get("logs") is None:
+        telemetry["logs"] = {}
+    logs = cast(LoggerConfig, telemetry["logs"])
+    if logs.get("logLevel") is None:
+        logs["logLevel"] = "INFO"
+
     if "database" not in data:
         data["database"] = {}
 
@@ -379,6 +407,20 @@ def process_config(
         local_suffix = dbos_dblocalsuffix
     data["database"]["local_suffix"] = local_suffix
 
+    if not data["database"].get("app_db_pool_size"):
+        data["database"]["app_db_pool_size"] = 20
+    if not data["database"].get("sys_db_pool_size"):
+        data["database"]["sys_db_pool_size"] = 20
+    if not data["database"].get("connectionTimeoutMillis"):
+        data["database"]["connectionTimeoutMillis"] = 10000
+
+    if not data.get("runtimeConfig"):
+        data["runtimeConfig"] = {
+            "run_admin_server": True,
+        }
+    elif "run_admin_server" not in data["runtimeConfig"]:
+        data["runtimeConfig"]["run_admin_server"] = True
+
     # Check the connectivity to the database and make sure it's properly configured
     # 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")
@@ -475,13 +517,13 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
                 otlp_exporter["logsEndpoint"] = logsEndpoint
 
     # Runtime config
-    if (
-        "runtimeConfig" in provided_config
-        and "admin_port" in provided_config["runtimeConfig"]
-    ):
-        del provided_config["runtimeConfig"][
-            "admin_port"
-        ]  # Admin port is expected to be 3001 (the default in dbos/_admin_server.py::__init__ ) by DBOS Cloud
+    if "runtimeConfig" in provided_config:
+        if "admin_port" in provided_config["runtimeConfig"]:
+            del provided_config["runtimeConfig"][
+                "admin_port"
+            ]  # Admin port is expected to be 3001 (the default in dbos/_admin_server.py::__init__ ) by DBOS Cloud
+        if "run_admin_server" in provided_config["runtimeConfig"]:
+            del provided_config["runtimeConfig"]["run_admin_server"]
 
     # Env should be set from the hosting provider (e.g., DBOS Cloud)
     if "env" in provided_config:

{dbos-0.24.0a5 → dbos-0.24.0a7}/dbos/_error.py

@@ -1,7 +1,7 @@
 """Errors thrown by DBOS."""
 
 from enum import Enum
-from typing import Optional
+from typing import Any, Optional
 
 
 class DBOSException(Exception):
@@ -124,12 +124,18 @@ class DBOSNotAuthorizedError(DBOSException):
 class DBOSMaxStepRetriesExceeded(DBOSException):
     """Exception raised when a step was retried the maximimum number of times without success."""
 
-    def __init__(self) -> None:
+    def __init__(self, step_name: str, max_retries: int) -> None:
+        self.step_name = step_name
+        self.max_retries = max_retries
         super().__init__(
-            "Step reached maximum retries.",
+            f"Step {step_name} has exceeded its maximum of {max_retries} retries",
             dbos_error_code=DBOSErrorCode.MaxStepRetriesExceeded.value,
         )
 
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (self.__class__, (self.step_name, self.max_retries))
+
 
 class DBOSWorkflowCancelledError(DBOSException):
     """Exception raised when the workflow has already been cancelled."""

{dbos-0.24.0a5 → dbos-0.24.0a7}/dbos/_sys_db.py

@@ -203,8 +203,8 @@ class SystemDatabase:
         # Create a connection pool for the system database
         self.engine = sa.create_engine(
             system_db_url,
-            pool_size=20,
-            max_overflow=5,
+            pool_size=config["database"]["sys_db_pool_size"],
+            max_overflow=0,
             pool_timeout=30,
             connect_args={"connect_timeout": 10},
         )

{dbos-0.24.0a5 → dbos-0.24.0a7}/pyproject.toml

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

{dbos-0.24.0a5 → dbos-0.24.0a7}/tests/test_admin_server.py

@@ -1,13 +1,16 @@
 import os
+import socket
 import threading
 import time
 import uuid
 
+import pytest
 import requests
 import sqlalchemy as sa
+from requests.exceptions import ConnectionError
 
 # Public API
-from dbos import DBOS, ConfigFile, Queue, SetWorkflowID, _workflow_commands
+from dbos import DBOS, ConfigFile, DBOSConfig, Queue, SetWorkflowID, _workflow_commands
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase, WorkflowStatusString
 from dbos._utils import GlobalParams
@@ -172,6 +175,75 @@ runtimeConfig:
         os.remove("dbos-config.yaml")
 
 
+def test_disable_admin_server(cleanup_test_databases: None) -> None:
+    # Initialize singleton
+    DBOS.destroy()  # In case of other tests leaving it
+
+    config: DBOSConfig = {
+        "name": "test-app",
+        "run_admin_server": False,
+    }
+    try:
+        DBOS(config=config)
+        DBOS.launch()
+
+        with pytest.raises(ConnectionError):
+            requests.get("http://localhost:3001/dbos-healthz", timeout=1)
+    finally:
+        # Clean up after the test
+        DBOS.destroy()
+
+
+def test_busy_admin_server_port_does_not_throw() -> None:
+    # Initialize singleton
+    DBOS.destroy()  # In case of other tests leaving it
+
+    config: DBOSConfig = {
+        "name": "test-app",
+    }
+    server_thread = None
+    stop_event = threading.Event()
+    try:
+
+        def start_dummy_server(port: int, stop_event: threading.Event) -> None:
+            """Starts a simple TCP server on the given port."""
+            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            server_socket.bind(("0.0.0.0", port))
+            server_socket.listen(1)
+            # We need to call accept for the port to be considered busy by the OS...
+            while not stop_event.is_set():
+                try:
+                    server_socket.settimeout(
+                        1
+                    )  # Timeout for accept in case the thread is stopped.
+                    client_socket, _ = server_socket.accept()
+                    client_socket.close()
+                except socket.timeout:
+                    pass
+            server_socket.close()
+
+        port_to_block = 3001
+        server_thread = threading.Thread(
+            target=start_dummy_server, args=(port_to_block, stop_event)
+        )
+        server_thread.daemon = (
+            True  # Allows the thread to be terminated when the main thread exits
+        )
+        server_thread.start()
+
+        DBOS(config=config)
+        DBOS.launch()
+    finally:
+        # Clean up after the test
+        DBOS.destroy()
+        if server_thread and server_thread.is_alive():
+            stop_event.set()
+            server_thread.join(2)
+            if server_thread.is_alive():
+                print("Warning: Server thread did not terminate gracefully.")
+
+
 def test_admin_workflow_resume(dbos: DBOS, sys_db: SystemDatabase) -> None:
     counter: int = 0
     event = threading.Event()

{dbos-0.24.0a5 → dbos-0.24.0a7}/tests/test_config.py

@@ -5,6 +5,7 @@ from unittest.mock import mock_open
 
 import pytest
 import pytest_mock
+from sqlalchemy import event
 
 # Public API
 from dbos import DBOS, load_config
@@ -313,7 +314,9 @@ def test_process_config_full():
             "password": "password",
             "connectionTimeoutMillis": 3000,
             "app_db_name": "example_db",
+            "app_db_pool_size": 45,
             "sys_db_name": "sys_db",
+            "sys_db_pool_size": 27,
             "ssl": True,
             "ssl_ca": "ca.pem",
             "local_suffix": False,
@@ -323,6 +326,7 @@ def test_process_config_full():
         "runtimeConfig": {
             "start": ["python3 main.py"],
             "admin_port": 8001,
+            "run_admin_server": False,
             "setup": ["echo 'hello'"],
         },
         "telemetry": {
@@ -353,8 +357,11 @@ def test_process_config_full():
     assert configFile["database"]["local_suffix"] == False
     assert configFile["database"]["migrate"] == ["alembic upgrade head"]
     assert configFile["database"]["rollback"] == ["alembic downgrade base"]
+    assert configFile["database"]["app_db_pool_size"] == 45
+    assert configFile["database"]["sys_db_pool_size"] == 27
     assert configFile["runtimeConfig"]["start"] == ["python3 main.py"]
     assert configFile["runtimeConfig"]["admin_port"] == 8001
+    assert configFile["runtimeConfig"]["run_admin_server"] == False
     assert configFile["runtimeConfig"]["setup"] == ["echo 'hello'"]
     assert configFile["telemetry"]["logs"]["logLevel"] == "DEBUG"
     assert configFile["telemetry"]["OTLPExporter"]["logsEndpoint"] == "thelogsendpoint"
@@ -380,8 +387,11 @@ def test_process_config_with_db_url():
     assert processed_config["database"]["ssl"] == True
     assert processed_config["database"]["ssl_ca"] == "ca.pem"
     assert processed_config["database"]["local_suffix"] == False
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
     assert "rollback" not in processed_config["database"]
     assert "migrate" not in processed_config["database"]
+    assert processed_config["runtimeConfig"]["run_admin_server"] == True
 
 
 def test_process_config_with_db_url_taking_precedence_over_database():
@@ -413,9 +423,12 @@ def test_process_config_with_db_url_taking_precedence_over_database():
     assert processed_config["database"]["migrate"] == ["alembic upgrade head"]
     assert processed_config["database"]["rollback"] == ["alembic downgrade base"]
     assert processed_config["database"]["local_suffix"] == True
-    assert "connectionTimeoutMillis" not in processed_config["database"]
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
+    assert processed_config["database"]["connectionTimeoutMillis"] == 10000
     assert "ssl" not in processed_config["database"]
     assert "ssl_ca" not in processed_config["database"]
+    assert processed_config["runtimeConfig"]["run_admin_server"] == True
 
 
 # Note this exercise going through the db wizard
@@ -432,6 +445,11 @@ def test_process_config_load_defaults():
     assert processed_config["database"]["password"] == os.environ.get(
         "PGPASSWORD", "dbos"
     )
+    assert processed_config["database"]["connectionTimeoutMillis"] == 10000
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
+    assert processed_config["telemetry"]["logs"]["logLevel"] == "INFO"
+    assert processed_config["runtimeConfig"]["run_admin_server"] == True
 
 
 def test_process_config_load_default_with_None_database_url():
@@ -448,6 +466,9 @@ def test_process_config_load_default_with_None_database_url():
     assert processed_config["database"]["password"] == os.environ.get(
         "PGPASSWORD", "dbos"
     )
+    assert processed_config["database"]["connectionTimeoutMillis"] == 10000
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
 
 
 def test_process_config_with_None_app_db_name():
@@ -467,6 +488,9 @@ def test_process_config_with_None_app_db_name():
     assert processed_config["database"]["password"] == os.environ.get(
         "PGPASSWORD", "dbos"
     )
+    assert processed_config["database"]["connectionTimeoutMillis"] == 10000
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
 
 
 def test_process_config_with_empty_app_db_name():
@@ -486,6 +510,9 @@ def test_process_config_with_empty_app_db_name():
     assert processed_config["database"]["password"] == os.environ.get(
         "PGPASSWORD", "dbos"
     )
+    assert processed_config["database"]["connectionTimeoutMillis"] == 10000
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
 
 
 def test_config_missing_name():
@@ -534,6 +561,9 @@ def test_load_config_load_db_connection(mocker):
     assert configFile["database"]["password"] == "password"
     assert configFile["database"]["local_suffix"] == True
     assert configFile["database"]["app_db_name"] == "some_app_local"
+    assert configFile["database"]["app_db_pool_size"] == 20
+    assert configFile["database"]["sys_db_pool_size"] == 20
+    assert configFile["database"]["connectionTimeoutMillis"] == 10000
 
 
 def test_config_mixed_params():
@@ -543,6 +573,7 @@ def test_config_mixed_params():
             "port": 1234,
             "username": "some user",
             "password": "abc123",
+            "app_db_pool_size": 3,
         },
     }
 
@@ -552,6 +583,9 @@ def test_config_mixed_params():
     assert configFile["database"]["port"] == 1234
     assert configFile["database"]["username"] == "some user"
     assert configFile["database"]["password"] == "abc123"
+    assert configFile["database"]["app_db_pool_size"] == 3
+    assert configFile["database"]["sys_db_pool_size"] == 20
+    assert configFile["database"]["connectionTimeoutMillis"] == 10000
 
 
 def test_debug_override(mocker: pytest_mock.MockFixture):
@@ -575,6 +609,9 @@ def test_debug_override(mocker: pytest_mock.MockFixture):
     assert configFile["database"]["username"] == "fakeuser"
     assert configFile["database"]["password"] == "fakepassword"
     assert configFile["database"]["local_suffix"] == False
+    assert configFile["database"]["app_db_pool_size"] == 20
+    assert configFile["database"]["sys_db_pool_size"] == 20
+    assert configFile["database"]["connectionTimeoutMillis"] == 10000
 
 
 def test_local_config():
@@ -600,6 +637,8 @@ def test_local_config():
     assert processed_config["database"]["password"] == os.environ["PGPASSWORD"]
     assert processed_config["database"]["app_db_name"] == "some_db_local"
     assert processed_config["database"]["connectionTimeoutMillis"] == 3000
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
 
 
 def test_local_config_without_name(mocker):
@@ -624,6 +663,8 @@ def test_local_config_without_name(mocker):
     assert processed_config["database"]["password"] == os.environ["PGPASSWORD"]
     assert processed_config["database"]["app_db_name"] == "some_app_local"
     assert processed_config["database"]["connectionTimeoutMillis"] == 3000
+    assert processed_config["database"]["app_db_pool_size"] == 20
+    assert processed_config["database"]["sys_db_pool_size"] == 20
 
 
 ####################
@@ -676,9 +717,9 @@ def test_query_parameters():
     """Test processing of various query parameters."""
 
     # Test connect_timeout conversion
-    database_url = "postgresql://user:password@localhost:5432/dbname?connect_timeout=10"
+    database_url = "postgresql://user:password@localhost:5432/dbname?connect_timeout=7"
     db_config = parse_database_url_to_dbconfig(database_url)
-    assert db_config["connectionTimeoutMillis"] == 10000
+    assert db_config["connectionTimeoutMillis"] == 7000
 
     # Test sslmode=require (should set ssl=True)
     database_url = "postgresql://user:password@localhost:5432/dbname?sslmode=require"
@@ -701,9 +742,9 @@ def test_query_parameters():
     assert db_config["ssl_ca"] == "ca.pem"
 
     # Test multiple parameters together
-    database_url = "postgresql://user:password@localhost:5432/dbname?connect_timeout=10&sslmode=require&sslrootcert=ca.pem&application_name=myapp"
+    database_url = "postgresql://user:password@localhost:5432/dbname?connect_timeout=8&sslmode=require&sslrootcert=ca.pem&application_name=myapp"
     db_config = parse_database_url_to_dbconfig(database_url)
-    assert db_config["connectionTimeoutMillis"] == 10000
+    assert db_config["connectionTimeoutMillis"] == 8000
     assert db_config["ssl"] == True
     assert db_config["ssl_ca"] == "ca.pem"
 
@@ -739,10 +780,13 @@ def test_translate_dbosconfig_full_input():
     config: DBOSConfig = {
         "name": "test-app",
         "database_url": "postgresql://user:password@localhost:5432/dbname?connect_timeout=10&sslmode=require&sslrootcert=ca.pem",
+        "app_db_pool_size": 45,
         "sys_db_name": "sysdb",
+        "sys_db_pool_size": 27,
         "log_level": "DEBUG",
         "otlp_traces_endpoints": ["http://otel:7777", "notused"],
         "admin_port": 8001,
+        "run_admin_server": False,
     }
 
     translated_config = translate_dbos_config_to_config_file(config)
@@ -757,6 +801,8 @@ def test_translate_dbosconfig_full_input():
     assert translated_config["database"]["connectionTimeoutMillis"] == 10000
     assert translated_config["database"]["app_db_name"] == "dbname"
     assert translated_config["database"]["sys_db_name"] == "sysdb"
+    assert translated_config["database"]["app_db_pool_size"] == 45
+    assert translated_config["database"]["sys_db_pool_size"] == 27
     assert "database_url" not in translated_config
     assert translated_config["telemetry"]["logs"]["logLevel"] == "DEBUG"
     assert (
@@ -765,6 +811,7 @@ def test_translate_dbosconfig_full_input():
     )
     assert "logsEndpoint" not in translated_config["telemetry"]["OTLPExporter"]
     assert translated_config["runtimeConfig"]["admin_port"] == 8001
+    assert translated_config["runtimeConfig"]["run_admin_server"] == False
     assert "start" not in translated_config["runtimeConfig"]
     assert "setup" not in translated_config["runtimeConfig"]
     assert "env" not in translated_config
@@ -778,9 +825,10 @@ def test_translate_dbosconfig_minimal_input():
 
     assert translated_config["name"] == "test-app"
     assert translated_config["telemetry"]["logs"]["logLevel"] == "INFO"
+    assert translated_config["runtimeConfig"]["run_admin_server"] == True
+    assert "admin_port" not in translated_config["runtimeConfig"]
     assert "database" not in translated_config
     assert "env" not in translated_config
-    assert "runtimeConfig" not in translated_config
 
 
 def test_translate_dbosconfig_just_sys_db_name():
@@ -790,11 +838,66 @@ def test_translate_dbosconfig_just_sys_db_name():
     }
     translated_config = translate_dbos_config_to_config_file(config)
 
+    assert translated_config["database"]["sys_db_name"] == "sysdb"
+    assert "app_db_pool_size" not in translated_config["database"]
+    assert "sys_db_pool_size" not in translated_config["database"]
+    assert "env" not in translated_config
+    assert "admin_port" not in translated_config["runtimeConfig"]
+
+
+def test_translate_dbosconfig_just_app_db_pool_size():
+    config: DBOSConfig = {
+        "name": "test-app",
+        "app_db_pool_size": 45,
+    }
+    translated_config = translate_dbos_config_to_config_file(config)
+
+    assert translated_config["database"]["app_db_pool_size"] == 45
+    assert "sys_db_name" not in translated_config["database"]
+    assert "sys_db_pool_size" not in translated_config["database"]
+    assert "env" not in translated_config
+    assert "admin_port" not in translated_config["runtimeConfig"]
+
+
+def test_translate_dbosconfig_just_sys_db_pool_size():
+    config: DBOSConfig = {
+        "name": "test-app",
+        "sys_db_pool_size": 27,
+    }
+    translated_config = translate_dbos_config_to_config_file(config)
+
+    assert translated_config["database"]["sys_db_pool_size"] == 27
+    assert "app_db_pool_size" not in translated_config["database"]
+    assert "sys_db_name" not in translated_config["database"]
+    assert "env" not in translated_config
+
+
+def test_translate_dbosconfig_just_admin_port():
+    config: DBOSConfig = {
+        "name": "test-app",
+        "admin_port": 8001,
+    }
+    translated_config = translate_dbos_config_to_config_file(config)
+
+    assert translated_config["runtimeConfig"]["admin_port"] == 8001
+    assert translated_config["runtimeConfig"]["run_admin_server"] == True
+    assert "env" not in translated_config
+    assert "database" not in translated_config
+
+
+def test_translate_dbosconfig_just_run_admin_server():
+    config: DBOSConfig = {
+        "name": "test-app",
+        "run_admin_server": True,
+    }
+    translated_config = translate_dbos_config_to_config_file(config)
+
     assert translated_config["name"] == "test-app"
     assert translated_config["telemetry"]["logs"]["logLevel"] == "INFO"
-    assert translated_config["database"]["sys_db_name"] == "sysdb"
+    assert translated_config["runtimeConfig"]["run_admin_server"] == True
+    assert "admin_port" not in translated_config["runtimeConfig"]
     assert "env" not in translated_config
-    assert "runtimeConfig" not in translated_config
+    assert "database" not in translated_config
 
 
 def test_translate_empty_otlp_traces_endpoints():
@@ -875,6 +978,7 @@ def test_overwrite_config(mocker):
             "app_db_name": "dbostestpy",
             "sys_db_name": "sysdb",
             "connectionTimeoutMillis": 10000,
+            "app_db_pool_size": 10,
         },
         "telemetry": {
             "OTLPExporter": {
@@ -887,6 +991,7 @@ def test_overwrite_config(mocker):
         },
         "runtimeConfig": {
             "admin_port": 8001,
+            "run_admin_server": True,
         },
         "env": {
             "FOO": "BAR",
@@ -904,10 +1009,13 @@ def test_overwrite_config(mocker):
     assert config["database"]["ssl"] == True
     assert config["database"]["ssl_ca"] == "cert.pem"
     assert config["database"]["connectionTimeoutMillis"] == 10000
+    assert config["database"]["app_db_pool_size"] == 10
+    assert "sys_db_pool_size" not in config["database"]
     assert config["telemetry"]["logs"]["logLevel"] == "DEBUG"
     assert config["telemetry"]["OTLPExporter"]["tracesEndpoint"] == "thetracesendpoint"
     assert config["telemetry"]["OTLPExporter"]["logsEndpoint"] == "thelogsendpoint"
     assert "admin_port" not in config["runtimeConfig"]
+    assert "run_admin_server" not in config["runtimeConfig"]
     assert "env" not in config
 
 
@@ -1185,3 +1293,71 @@ def test_name_does_no_match(mocker):
 def test_no_config_file():
     # Handles FileNotFoundError
     check_config_consistency(name="stock-prices")
+
+
+####################
+# DATABASES CONNECTION POOLS
+####################
+
+
+def test_configured_pool_sizes():
+    config: DBOSConfig = {
+        "name": "test-app",
+        "app_db_pool_size": 42,
+        "sys_db_pool_size": 43,
+    }
+
+    dbos = DBOS(config=config)
+    dbos.launch()
+    assert dbos._app_db.engine.pool._pool.maxsize == 42
+    assert dbos._sys_db.engine.pool._pool.maxsize == 43
+    dbos.destroy()
+
+
+def test_default_pool_params():
+    config: DBOSConfig = {
+        "name": "test-app",
+    }
+
+    dbos = DBOS(config=config)
+    dbos.launch()
+    app_db_engine = dbos._app_db.engine
+    assert app_db_engine.pool._pool.maxsize == 20
+
+    # force the release of connections so we can intercept on connect.
+    app_db_engine.dispose()
+
+    @event.listens_for(app_db_engine, "connect")
+    def inspect_connection(dbapi_connection, connection_record):
+        connect_timeout = dbapi_connection.info.get_parameters()["connect_timeout"]
+        assert connect_timeout == "10"
+
+    with app_db_engine.connect() as conn:
+        pass
+
+    assert dbos._sys_db.engine.pool._pool.maxsize == 20
+    dbos.destroy()
+
+
+def test_configured_app_db_connect_timeout():
+    config: DBOSConfig = {
+        "name": "test-app",
+        "database_url": f"postgresql://postgres:@localhost:5432/dbname?connect_timeout=7",
+    }
+
+    dbos = DBOS(config=config)
+    dbos.launch()
+    app_db_engine = dbos._app_db.engine
+
+    # force the release of connections so we can intercept on connect.
+    app_db_engine.dispose()
+
+    @event.listens_for(app_db_engine, "connect")
+    def inspect_connection(dbapi_connection, connection_record):
+        connect_timeout = dbapi_connection.info.get_parameters()["connect_timeout"]
+        assert connect_timeout == "7"
+
+    with app_db_engine.connect() as conn:
+        pass
+
+    dbos.destroy()

{dbos-0.24.0a5 → dbos-0.24.0a7}/tests/test_failures.py

@@ -8,11 +8,16 @@ import sqlalchemy as sa
 from psycopg.errors import SerializationFailure
 from sqlalchemy.exc import InvalidRequestError, OperationalError
 
-# Public API
-from dbos import DBOS, GetWorkflowsInput, SetWorkflowID
-from dbos._error import DBOSDeadLetterQueueError, DBOSException
+from dbos import DBOS, GetWorkflowsInput, Queue, SetWorkflowID
+from dbos._error import (
+    DBOSDeadLetterQueueError,
+    DBOSException,
+    DBOSMaxStepRetriesExceeded,
+)
 from dbos._sys_db import WorkflowStatusString
 
+from .conftest import queue_entries_are_cleaned_up
+
 
 def test_transaction_errors(dbos: DBOS) -> None:
     retry_counter: int = 0
@@ -258,3 +263,64 @@ def test_wfstatus_invalid(dbos: DBOS) -> None:
         with SetWorkflowID(wfuuid):
             non_deterministic_worklow()
     assert "Hint: Check if your workflow is deterministic." in str(exc_info.value)
+
+
+def test_step_retries(dbos: DBOS) -> None:
+    step_counter = 0
+
+    queue = Queue("test-queue")
+    max_attempts = 2
+
+    @DBOS.step(retries_allowed=True, interval_seconds=0, max_attempts=max_attempts)
+    def failing_step() -> None:
+        nonlocal step_counter
+        step_counter += 1
+        raise Exception("fail")
+
+    @DBOS.workflow()
+    def failing_workflow() -> None:
+        failing_step()
+
+    @DBOS.workflow()
+    def enqueue_failing_step() -> None:
+        queue.enqueue(failing_step).get_result()
+
+    error_message = f"Step {failing_step.__name__} has exceeded its maximum of {max_attempts} retries"
+
+    # Test calling the step directly
+    with pytest.raises(DBOSMaxStepRetriesExceeded) as excinfo:
+        failing_step()
+    assert error_message in str(excinfo.value)
+    assert step_counter == max_attempts
+
+    # Test calling the workflow
+    step_counter = 0
+    with pytest.raises(DBOSMaxStepRetriesExceeded) as excinfo:
+        failing_workflow()
+    assert error_message in str(excinfo.value)
+    assert step_counter == max_attempts
+
+    # Test enqueueing the step
+    step_counter = 0
+    handle = queue.enqueue(failing_step)
+    with pytest.raises(DBOSMaxStepRetriesExceeded) as excinfo:
+        handle.get_result()
+    assert error_message in str(excinfo.value)
+    assert step_counter == max_attempts
+
+    # Test enqueuing the workflow
+    step_counter = 0
+    handle = queue.enqueue(failing_workflow)
+    with pytest.raises(DBOSMaxStepRetriesExceeded) as excinfo:
+        handle.get_result()
+    assert error_message in str(excinfo.value)
+    assert step_counter == max_attempts
+
+    # Test enqueuing the step from a workflow
+    step_counter = 0
+    with pytest.raises(DBOSMaxStepRetriesExceeded) as excinfo:
+        enqueue_failing_step()
+    assert error_message in str(excinfo.value)
+    assert step_counter == max_attempts
+
+    assert queue_entries_are_cleaned_up(dbos)