dbos 0.24.0a6__tar.gz → 0.24.0a8__tar.gz

{dbos-0.24.0a6 → dbos-0.24.0a8}/PKG-INFO

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

{dbos-0.24.0a6 → dbos-0.24.0a8}/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.0a6 → dbos-0.24.0a8}/dbos/_conductor/conductor.py

@@ -33,7 +33,7 @@ class ConductorWebsocket(threading.Thread):
     def run(self) -> None:
         while not self.evt.is_set():
             try:
-                with connect(self.url) as websocket:
+                with connect(self.url, open_timeout=5) as websocket:
                     self.websocket = websocket
                     while not self.evt.is_set():
                         message = websocket.recv()
@@ -44,6 +44,7 @@ class ConductorWebsocket(threading.Thread):
                             continue
                         base_message = p.BaseMessage.from_json(message)
                         msg_type = base_message.type
+                        error_message = None
                         if msg_type == p.MessageType.EXECUTOR_INFO:
                             info_response = p.ExecutorInfoResponse(
                                 type=p.MessageType.EXECUTOR_INFO,
@@ -61,14 +62,14 @@ class ConductorWebsocket(threading.Thread):
                                     recovery_message.executor_ids
                                 )
                             except Exception as e:
-                                self.dbos.logger.error(
-                                    f"Exception encountered when recovering workflows: {traceback.format_exc()}"
-                                )
+                                error_message = f"Exception encountered when recovering workflows: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
                                 success = False
                             recovery_response = p.RecoveryResponse(
                                 type=p.MessageType.RECOVERY,
                                 request_id=base_message.request_id,
                                 success=success,
+                                error_message=error_message,
                             )
                             websocket.send(recovery_response.to_json())
                         elif msg_type == p.MessageType.CANCEL:
@@ -77,14 +78,14 @@ class ConductorWebsocket(threading.Thread):
                             try:
                                 self.dbos.cancel_workflow(cancel_message.workflow_id)
                             except Exception as e:
-                                self.dbos.logger.error(
-                                    f"Exception encountered when cancelling workflow {cancel_message.workflow_id}: {traceback.format_exc()}"
-                                )
+                                error_message = f"Exception encountered when cancelling workflow {cancel_message.workflow_id}: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
                                 success = False
                             cancel_response = p.CancelResponse(
                                 type=p.MessageType.CANCEL,
                                 request_id=base_message.request_id,
                                 success=success,
+                                error_message=error_message,
                             )
                             websocket.send(cancel_response.to_json())
                         elif msg_type == p.MessageType.RESUME:
@@ -93,14 +94,14 @@ class ConductorWebsocket(threading.Thread):
                             try:
                                 self.dbos.resume_workflow(resume_message.workflow_id)
                             except Exception as e:
-                                self.dbos.logger.error(
-                                    f"Exception encountered when resuming workflow {resume_message.workflow_id}: {traceback.format_exc()}"
-                                )
+                                error_message = f"Exception encountered when resuming workflow {resume_message.workflow_id}: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
                                 success = False
                             resume_response = p.ResumeResponse(
                                 type=p.MessageType.RESUME,
                                 request_id=base_message.request_id,
                                 success=success,
+                                error_message=error_message,
                             )
                             websocket.send(resume_response.to_json())
                         elif msg_type == p.MessageType.RESTART:
@@ -109,14 +110,14 @@ class ConductorWebsocket(threading.Thread):
                             try:
                                 self.dbos.restart_workflow(restart_message.workflow_id)
                             except Exception as e:
-                                self.dbos.logger.error(
-                                    f"Exception encountered when restarting workflow {restart_message.workflow_id}: {traceback.format_exc()}"
-                                )
+                                error_message = f"Exception encountered when restarting workflow {restart_message.workflow_id}: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
                                 success = False
                             restart_response = p.RestartResponse(
                                 type=p.MessageType.RESTART,
                                 request_id=base_message.request_id,
                                 success=success,
+                                error_message=error_message,
                             )
                             websocket.send(restart_response.to_json())
                         elif msg_type == p.MessageType.LIST_WORKFLOWS:
@@ -124,20 +125,26 @@ class ConductorWebsocket(threading.Thread):
                                 message
                             )
                             body = list_workflows_message.body
-                            infos = list_workflows(
-                                self.dbos._sys_db,
-                                workflow_ids=body["workflow_uuids"],
-                                user=body["authenticated_user"],
-                                start_time=body["start_time"],
-                                end_time=body["end_time"],
-                                status=body["status"],
-                                request=False,
-                                app_version=body["application_version"],
-                                name=body["workflow_name"],
-                                limit=body["limit"],
-                                offset=body["offset"],
-                                sort_desc=body["sort_desc"],
-                            )
+                            infos = []
+                            try:
+                                infos = list_workflows(
+                                    self.dbos._sys_db,
+                                    workflow_ids=body["workflow_uuids"],
+                                    user=body["authenticated_user"],
+                                    start_time=body["start_time"],
+                                    end_time=body["end_time"],
+                                    status=body["status"],
+                                    request=False,
+                                    app_version=body["application_version"],
+                                    name=body["workflow_name"],
+                                    limit=body["limit"],
+                                    offset=body["offset"],
+                                    sort_desc=body["sort_desc"],
+                                )
+                            except Exception as e:
+                                error_message = f"Exception encountered when listing workflows: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+
                             list_workflows_response = p.ListWorkflowsResponse(
                                 type=p.MessageType.LIST_WORKFLOWS,
                                 request_id=base_message.request_id,
@@ -145,6 +152,7 @@ class ConductorWebsocket(threading.Thread):
                                     p.WorkflowsOutput.from_workflow_information(i)
                                     for i in infos
                                 ],
+                                error_message=error_message,
                             )
                             websocket.send(list_workflows_response.to_json())
                         elif msg_type == p.MessageType.LIST_QUEUED_WORKFLOWS:
@@ -152,18 +160,24 @@ class ConductorWebsocket(threading.Thread):
                                 p.ListQueuedWorkflowsRequest.from_json(message)
                             )
                             q_body = list_queued_workflows_message.body
-                            infos = list_queued_workflows(
-                                self.dbos._sys_db,
-                                start_time=q_body["start_time"],
-                                end_time=q_body["end_time"],
-                                status=q_body["status"],
-                                request=False,
-                                name=q_body["workflow_name"],
-                                limit=q_body["limit"],
-                                offset=q_body["offset"],
-                                queue_name=q_body["queue_name"],
-                                sort_desc=q_body["sort_desc"],
-                            )
+                            infos = []
+                            try:
+                                infos = list_queued_workflows(
+                                    self.dbos._sys_db,
+                                    start_time=q_body["start_time"],
+                                    end_time=q_body["end_time"],
+                                    status=q_body["status"],
+                                    request=False,
+                                    name=q_body["workflow_name"],
+                                    limit=q_body["limit"],
+                                    offset=q_body["offset"],
+                                    queue_name=q_body["queue_name"],
+                                    sort_desc=q_body["sort_desc"],
+                                )
+                            except Exception as e:
+                                error_message = f"Exception encountered when listing queued workflows: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+
                             list_queued_workflows_response = (
                                 p.ListQueuedWorkflowsResponse(
                                     type=p.MessageType.LIST_QUEUED_WORKFLOWS,
@@ -172,6 +186,7 @@ class ConductorWebsocket(threading.Thread):
                                         p.WorkflowsOutput.from_workflow_information(i)
                                         for i in infos
                                     ],
+                                    error_message=error_message,
                                 )
                             )
                             websocket.send(list_queued_workflows_response.to_json())
@@ -179,11 +194,17 @@ class ConductorWebsocket(threading.Thread):
                             get_workflow_message = p.GetWorkflowRequest.from_json(
                                 message
                             )
-                            info = get_workflow(
-                                self.dbos._sys_db,
-                                get_workflow_message.workflow_id,
-                                getRequest=False,
-                            )
+                            info = None
+                            try:
+                                info = get_workflow(
+                                    self.dbos._sys_db,
+                                    get_workflow_message.workflow_id,
+                                    getRequest=False,
+                                )
+                            except Exception as e:
+                                error_message = f"Exception encountered when getting workflow {get_workflow_message.workflow_id}: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+
                             get_workflow_response = p.GetWorkflowResponse(
                                 type=p.MessageType.GET_WORKFLOW,
                                 request_id=base_message.request_id,
@@ -192,21 +213,29 @@ class ConductorWebsocket(threading.Thread):
                                     if info is not None
                                     else None
                                 ),
+                                error_message=error_message,
                             )
                             websocket.send(get_workflow_response.to_json())
                         elif msg_type == p.MessageType.EXIST_PENDING_WORKFLOWS:
                             exist_pending_workflows_message = (
                                 p.ExistPendingWorkflowsRequest.from_json(message)
                             )
-                            pending_wfs = self.dbos._sys_db.get_pending_workflows(
-                                exist_pending_workflows_message.executor_id,
-                                exist_pending_workflows_message.application_version,
-                            )
+                            pending_wfs = []
+                            try:
+                                pending_wfs = self.dbos._sys_db.get_pending_workflows(
+                                    exist_pending_workflows_message.executor_id,
+                                    exist_pending_workflows_message.application_version,
+                                )
+                            except Exception as e:
+                                error_message = f"Exception encountered when checking for pending workflows: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+
                             exist_pending_workflows_response = (
                                 p.ExistPendingWorkflowsResponse(
                                     type=p.MessageType.EXIST_PENDING_WORKFLOWS,
                                     request_id=base_message.request_id,
                                     exist=len(pending_wfs) > 0,
+                                    error_message=error_message,
                                 )
                             )
                             websocket.send(exist_pending_workflows_response.to_json())
@@ -214,6 +243,13 @@ class ConductorWebsocket(threading.Thread):
                             self.dbos.logger.warning(
                                 f"Unexpected message type: {msg_type}"
                             )
+                            unknown_message = p.BaseResponse(
+                                request_id=base_message.request_id,
+                                type=msg_type,
+                                error_message="Unknown message type",
+                            )
+                            # Still need to send a response to the conductor
+                            websocket.send(unknown_message.to_json())
             except ConnectionClosedOK:
                 self.dbos.logger.info("Conductor connection terminated")
                 break

{dbos-0.24.0a6 → dbos-0.24.0a8}/dbos/_conductor/protocol.py

@@ -45,6 +45,11 @@ class BaseMessage:
         return json.dumps(dict_data)
 
 
+@dataclass
+class BaseResponse(BaseMessage):
+    error_message: Optional[str] = None
+
+
 @dataclass
 class ExecutorInfoRequest(BaseMessage):
     pass
@@ -54,6 +59,7 @@ class ExecutorInfoRequest(BaseMessage):
 class ExecutorInfoResponse(BaseMessage):
     executor_id: str
     application_version: str
+    error_message: Optional[str] = None
 
 
 @dataclass
@@ -64,6 +70,7 @@ class RecoveryRequest(BaseMessage):
 @dataclass
 class RecoveryResponse(BaseMessage):
     success: bool
+    error_message: Optional[str] = None
 
 
 @dataclass
@@ -74,6 +81,7 @@ class CancelRequest(BaseMessage):
 @dataclass
 class CancelResponse(BaseMessage):
     success: bool
+    error_message: Optional[str] = None
 
 
 @dataclass
@@ -84,6 +92,7 @@ class ResumeRequest(BaseMessage):
 @dataclass
 class ResumeResponse(BaseMessage):
     success: bool
+    error_message: Optional[str] = None
 
 
 @dataclass
@@ -94,6 +103,7 @@ class RestartRequest(BaseMessage):
 @dataclass
 class RestartResponse(BaseMessage):
     success: bool
+    error_message: Optional[str] = None
 
 
 class ListWorkflowsBody(TypedDict):
@@ -165,6 +175,7 @@ class ListWorkflowsRequest(BaseMessage):
 @dataclass
 class ListWorkflowsResponse(BaseMessage):
     output: List[WorkflowsOutput]
+    error_message: Optional[str] = None
 
 
 class ListQueuedWorkflowsBody(TypedDict):
@@ -186,6 +197,7 @@ class ListQueuedWorkflowsRequest(BaseMessage):
 @dataclass
 class ListQueuedWorkflowsResponse(BaseMessage):
     output: List[WorkflowsOutput]
+    error_message: Optional[str] = None
 
 
 @dataclass
@@ -196,6 +208,7 @@ class GetWorkflowRequest(BaseMessage):
 @dataclass
 class GetWorkflowResponse(BaseMessage):
     output: Optional[WorkflowsOutput]
+    error_message: Optional[str] = None
 
 
 @dataclass
@@ -207,3 +220,4 @@ class ExistPendingWorkflowsRequest(BaseMessage):
 @dataclass
 class ExistPendingWorkflowsResponse(BaseMessage):
     exist: bool
+    error_message: Optional[str] = None

{dbos-0.24.0a6 → dbos-0.24.0a8}/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.0a6 → dbos-0.24.0a8}/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.0a6 → dbos-0.24.0a8}/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.0a6 → dbos-0.24.0a8}/pyproject.toml

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

{dbos-0.24.0a6 → dbos-0.24.0a8}/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()