dbos 0.26.0a5__tar.gz → 0.26.0a7__tar.gz

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

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

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

@@ -1,13 +1,16 @@
-from typing import Optional, TypedDict
+from typing import List, Optional, TypedDict
 
 import sqlalchemy as sa
 import sqlalchemy.dialects.postgresql as pg
+from sqlalchemy import inspect, text
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session, sessionmaker
 
+from . import _serialization
 from ._dbos_config import ConfigFile, DatabaseConfig
 from ._error import DBOSWorkflowConflictIDError
 from ._schemas.application_database import ApplicationSchema
+from ._sys_db import StepInfo
 
 
 class TransactionResultInternal(TypedDict):
@@ -18,6 +21,7 @@ class TransactionResultInternal(TypedDict):
     txn_id: Optional[str]
     txn_snapshot: str
     executor_id: Optional[str]
+    function_name: Optional[str]
 
 
 class RecordedResult(TypedDict):
@@ -87,7 +91,30 @@ class ApplicationDatabase:
                     f"CREATE SCHEMA IF NOT EXISTS {ApplicationSchema.schema}"
                 )
                 conn.execute(schema_creation_query)
-            ApplicationSchema.metadata_obj.create_all(self.engine)
+
+            inspector = inspect(self.engine)
+            if not inspector.has_table(
+                "transaction_outputs", schema=ApplicationSchema.schema
+            ):
+                ApplicationSchema.metadata_obj.create_all(self.engine)
+            else:
+                columns = inspector.get_columns(
+                    "transaction_outputs", schema=ApplicationSchema.schema
+                )
+                column_names = [col["name"] for col in columns]
+
+                if "function_name" not in column_names:
+                    # Column missing, alter table to add it
+                    with self.engine.connect() as conn:
+                        conn.execute(
+                            text(
+                                f"""
+                            ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
+                            ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
+                            """
+                            )
+                        )
+                        conn.commit()
 
     def destroy(self) -> None:
         self.engine.dispose()
@@ -108,6 +135,7 @@ class ApplicationDatabase:
                     executor_id=(
                         output["executor_id"] if output["executor_id"] else None
                     ),
+                    function_name=output["function_name"],
                 )
             )
         except DBAPIError as dbapi_error:
@@ -133,6 +161,7 @@ class ApplicationDatabase:
                         executor_id=(
                             output["executor_id"] if output["executor_id"] else None
                         ),
+                        function_name=output["function_name"],
                     )
                 )
         except DBAPIError as dbapi_error:
@@ -160,3 +189,33 @@ class ApplicationDatabase:
             "error": rows[0][1],
         }
         return result
+
+    def get_transactions(self, workflow_uuid: str) -> List[StepInfo]:
+        with self.engine.begin() as conn:
+            rows = conn.execute(
+                sa.select(
+                    ApplicationSchema.transaction_outputs.c.function_id,
+                    ApplicationSchema.transaction_outputs.c.function_name,
+                    ApplicationSchema.transaction_outputs.c.output,
+                    ApplicationSchema.transaction_outputs.c.error,
+                ).where(
+                    ApplicationSchema.transaction_outputs.c.workflow_uuid
+                    == workflow_uuid,
+                )
+            ).all()
+        return [
+            StepInfo(
+                function_id=row[0],
+                function_name=row[1],
+                output=(
+                    _serialization.deserialize(row[2]) if row[2] is not None else row[2]
+                ),
+                error=(
+                    _serialization.deserialize_exception(row[3])
+                    if row[3] is not None
+                    else row[3]
+                ),
+                child_workflow_id=None,
+            )
+            for row in rows
+        ]

{dbos-0.26.0a5 → dbos-0.26.0a7}/dbos/_conductor/conductor.py

@@ -254,6 +254,7 @@ class ConductorWebsocket(threading.Thread):
                             try:
                                 step_info = list_workflow_steps(
                                     self.dbos._sys_db,
+                                    self.dbos._app_db,
                                     list_steps_message.workflow_id,
                                 )
                             except Exception as e:

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

@@ -782,6 +782,9 @@ def decorate_transaction(
     dbosreg: "DBOSRegistry", isolation_level: "IsolationLevel" = "SERIALIZABLE"
 ) -> Callable[[F], F]:
     def decorator(func: F) -> F:
+
+        transactionName = func.__qualname__
+
         def invoke_tx(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
@@ -810,6 +813,7 @@ def decorate_transaction(
                         "txn_snapshot": "",  # TODO: add actual snapshot
                         "executor_id": None,
                         "txn_id": None,
+                        "function_name": transactionName,
                     }
                     retry_wait_seconds = 0.001
                     backoff_factor = 1.5

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

@@ -172,6 +172,12 @@ class DBOSRegistry:
         if name in self.function_type_map:
             if self.function_type_map[name] != functype:
                 raise DBOSConflictingRegistrationError(name)
+            if name != TEMP_SEND_WF_NAME:
+                # Remove the `<temp>` prefix from the function name to avoid confusion
+                truncated_name = name.replace("<temp>.", "")
+                dbos_logger.warning(
+                    f"Duplicate registration of function '{truncated_name}'. A function named '{truncated_name}' has already been registered with DBOS. All functions registered with DBOS must have unique names."
+                )
         self.function_type_map[name] = functype
         self.workflow_info_map[name] = wrapped_func
 

{dbos-0.26.0a5 → dbos-0.26.0a7}/dbos/_schemas/application_database.py

@@ -25,6 +25,7 @@ class ApplicationSchema:
         Column("txn_id", Text, nullable=True),
         Column("txn_snapshot", Text),
         Column("executor_id", Text, nullable=True),
+        Column("function_name", Text, nullable=False, server_default=""),
         Column(
             "created_at",
             BigInteger,

{dbos-0.26.0a5 → dbos-0.26.0a7}/dbos/_workflow_commands.py

@@ -2,6 +2,7 @@ import json
 from typing import Any, List, Optional
 
 from . import _serialization
+from ._app_db import ApplicationDatabase
 from ._sys_db import (
     GetQueuedWorkflowsInput,
     GetWorkflowsInput,
@@ -170,6 +171,11 @@ def get_workflow(
     return info
 
 
-def list_workflow_steps(sys_db: SystemDatabase, workflow_id: str) -> List[StepInfo]:
-    output = sys_db.get_workflow_steps(workflow_id)
-    return output
+def list_workflow_steps(
+    sys_db: SystemDatabase, app_db: ApplicationDatabase, workflow_id: str
+) -> List[StepInfo]:
+    steps = sys_db.get_workflow_steps(workflow_id)
+    transactions = app_db.get_transactions(workflow_id)
+    merged_steps = steps + transactions
+    merged_steps.sort(key=lambda step: step["function_id"])
+    return merged_steps

{dbos-0.26.0a5 → dbos-0.26.0a7}/dbos/cli/cli.py

@@ -350,8 +350,11 @@ def steps(
 ) -> None:
     config = load_config(silent=True)
     sys_db = SystemDatabase(config["database"])
+    app_db = ApplicationDatabase(config["database"])
     print(
-        jsonpickle.encode(list_workflow_steps(sys_db, workflow_id), unpicklable=False)
+        jsonpickle.encode(
+            list_workflow_steps(sys_db, app_db, workflow_id), unpicklable=False
+        )
     )
 
 

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

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

{dbos-0.26.0a5 → dbos-0.26.0a7}/tests/conftest.py

@@ -11,6 +11,7 @@ from fastapi import FastAPI
 from flask import Flask
 
 from dbos import DBOS, ConfigFile, DBOSClient
+from dbos._app_db import ApplicationDatabase
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase
 
@@ -48,6 +49,13 @@ def sys_db(config: ConfigFile) -> Generator[SystemDatabase, Any, None]:
     sys_db.destroy()
 
 
+@pytest.fixture()
+def app_db(config: ConfigFile) -> Generator[ApplicationDatabase, Any, None]:
+    app_db = ApplicationDatabase(config["database"])
+    yield app_db
+    app_db.destroy()
+
+
 @pytest.fixture(scope="session")
 def postgres_db_engine() -> sa.Engine:
     cfg = default_config()

{dbos-0.26.0a5 → dbos-0.26.0a7}/tests/test_dbos.py

@@ -1257,6 +1257,63 @@ def test_double_decoration(dbos: DBOS) -> None:
         my_function()
 
 
+def test_duplicate_registration(
+    dbos: DBOS, caplog: pytest.LogCaptureFixture, config: ConfigFile
+) -> None:
+    original_propagate = logging.getLogger("dbos").propagate
+    caplog.set_level(logging.WARNING, "dbos")
+    logging.getLogger("dbos").propagate = True
+
+    @DBOS.transaction()
+    def my_transaction() -> None:
+        pass
+
+    @DBOS.transaction()
+    def my_transaction() -> None:
+        pass
+
+    assert (
+        "Duplicate registration of function 'test_duplicate_registration.<locals>.my_transaction'"
+        in caplog.text
+    )
+
+    @DBOS.step()
+    def my_step() -> None:
+        pass
+
+    @DBOS.step()
+    def my_step() -> None:
+        pass
+
+    assert (
+        "Duplicate registration of function 'test_duplicate_registration.<locals>.my_step'"
+        in caplog.text
+    )
+
+    @DBOS.workflow()
+    def my_workflow() -> None:
+        my_step()
+        my_transaction()
+
+    @DBOS.workflow()
+    def my_workflow() -> None:
+        my_step()
+        my_transaction()
+
+    assert (
+        "Duplicate registration of function 'test_duplicate_registration.<locals>.my_workflow'"
+        in caplog.text
+    )
+
+    DBOS.destroy()
+    DBOS(config=config)
+    DBOS.launch()
+    assert "Duplicate registration of function 'temp_send_workflow'" not in caplog.text
+
+    # Reset logging
+    logging.getLogger("dbos").propagate = original_propagate
+
+
 def test_app_version(config: ConfigFile) -> None:
     def is_hex(s: str) -> bool:
         return all(c in "0123456789abcdefABCDEF" for c in s)

{dbos-0.26.0a5 → dbos-0.26.0a7}/tests/test_workflow_introspection.py

@@ -14,6 +14,7 @@ from dbos import (
     WorkflowStatusString,
     _workflow_commands,
 )
+from dbos._app_db import ApplicationDatabase
 from dbos._sys_db import SystemDatabase
 from dbos._utils import GlobalParams
 
@@ -187,7 +188,9 @@ def test_get_workflow(dbos: DBOS, config: ConfigFile, sys_db: SystemDatabase) ->
         assert info.workflow_id == wfUuid, f"Expected workflow_uuid to be {wfUuid}"
 
 
-def test_queued_workflows(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_queued_workflows(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
     queued_steps = 5
     step_events = [threading.Event() for _ in range(queued_steps)]
     event = threading.Event()
@@ -292,7 +295,7 @@ def test_queued_workflows(dbos: DBOS, sys_db: SystemDatabase) -> None:
     assert len(workflows) == 0
 
     # Test the steps are listed properly
-    steps = _workflow_commands.list_workflow_steps(sys_db, handle.workflow_id)
+    steps = _workflow_commands.list_workflow_steps(sys_db, app_db, handle.workflow_id)
     assert len(steps) == queued_steps * 2
     for i in range(queued_steps):
         # Check the enqueues
@@ -311,7 +314,7 @@ def test_queued_workflows(dbos: DBOS, sys_db: SystemDatabase) -> None:
     child_workflows = DBOS.list_workflows(name=f"<temp>.{blocking_step.__qualname__}")
     assert (len(child_workflows)) == queued_steps
     for i, c in enumerate(child_workflows):
-        steps = _workflow_commands.list_workflow_steps(sys_db, c.workflow_id)
+        steps = _workflow_commands.list_workflow_steps(sys_db, app_db, c.workflow_id)
         assert len(steps) == 1
         assert steps[0]["function_id"] == 1
         assert steps[0]["function_name"] == blocking_step.__qualname__
@@ -320,7 +323,9 @@ def test_queued_workflows(dbos: DBOS, sys_db: SystemDatabase) -> None:
         assert steps[0]["error"] is None
 
 
-def test_list_2steps_sleep(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_list_2steps_sleep(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     def simple_workflow() -> None:
@@ -341,14 +346,16 @@ def test_list_2steps_sleep(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         simple_workflow()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 3
     assert wfsteps[0]["function_name"] == stepOne.__qualname__
     assert wfsteps[1]["function_name"] == stepTwo.__qualname__
     assert wfsteps[2]["function_name"] == "DBOS.sleep"
 
 
-def test_send_recv(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_send_recv(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     def send_workflow(target: str) -> None:
@@ -367,17 +374,19 @@ def test_send_recv(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid_s):
         send_workflow(wfid_r)
 
-    wfsteps_send = _workflow_commands.list_workflow_steps(sys_db, wfid_s)
+    wfsteps_send = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid_s)
     assert len(wfsteps_send) == 1
     assert wfsteps_send[0]["function_name"] == "DBOS.send"
 
-    wfsteps_recv = _workflow_commands.list_workflow_steps(sys_db, wfid_r)
+    wfsteps_recv = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid_r)
     assert len(wfsteps_recv) == 2
-    assert wfsteps_recv[0]["function_name"] == "DBOS.sleep"
-    assert wfsteps_recv[1]["function_name"] == "DBOS.recv"
+    assert wfsteps_recv[1]["function_name"] == "DBOS.sleep"
+    assert wfsteps_recv[0]["function_name"] == "DBOS.recv"
 
 
-def test_set_get_event(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_set_get_event(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
     value = "Hello, World!"
 
     @DBOS.workflow()
@@ -395,22 +404,24 @@ def test_set_get_event(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         assert set_get_workflow() == value
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 5
     assert wfsteps[0]["function_name"] == "DBOS.setEvent"
     assert wfsteps[1]["function_name"] == stepOne.__qualname__
-    assert wfsteps[2]["function_name"] == "DBOS.sleep"
-    assert wfsteps[3]["function_name"] == "DBOS.getEvent"
-    assert wfsteps[3]["child_workflow_id"] == None
-    assert wfsteps[3]["output"] == None
-    assert wfsteps[3]["error"] == None
+    assert wfsteps[3]["function_name"] == "DBOS.sleep"
+    assert wfsteps[2]["function_name"] == "DBOS.getEvent"
+    assert wfsteps[2]["child_workflow_id"] == None
+    assert wfsteps[2]["output"] == None
+    assert wfsteps[2]["error"] == None
     assert wfsteps[4]["function_name"] == "DBOS.getEvent"
     assert wfsteps[4]["child_workflow_id"] == None
     assert wfsteps[4]["output"] == value
     assert wfsteps[4]["error"] == None
 
 
-def test_callchild_first_sync(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_callchild_first_sync(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     def parentWorkflow() -> str:
@@ -435,7 +446,7 @@ def test_callchild_first_sync(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         child_id = parentWorkflow()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 4
     assert wfsteps[0]["function_name"] == child_workflow.__qualname__
     assert wfsteps[0]["child_workflow_id"] == child_id
@@ -450,7 +461,9 @@ def test_callchild_first_sync(dbos: DBOS, sys_db: SystemDatabase) -> None:
 
 
 @pytest.mark.asyncio
-async def test_callchild_direct_asyncio(dbos: DBOS, sys_db: SystemDatabase) -> None:
+async def test_callchild_direct_asyncio(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     async def parentWorkflow() -> str:
@@ -475,7 +488,7 @@ async def test_callchild_direct_asyncio(dbos: DBOS, sys_db: SystemDatabase) -> N
     with SetWorkflowID(wfid):
         child_id = await parentWorkflow()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 4
     assert wfsteps[0]["function_name"] == child_workflow.__qualname__
     assert wfsteps[0]["child_workflow_id"] == child_id
@@ -489,7 +502,9 @@ async def test_callchild_direct_asyncio(dbos: DBOS, sys_db: SystemDatabase) -> N
     assert wfsteps[3]["function_name"] == stepTwo.__qualname__
 
 
-def test_callchild_last_sync(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_callchild_last_sync(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     def parentWorkflow() -> None:
@@ -514,7 +529,7 @@ def test_callchild_last_sync(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         parentWorkflow()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 4
     assert wfsteps[0]["function_name"] == stepOne.__qualname__
     assert wfsteps[1]["function_name"] == stepTwo.__qualname__
@@ -522,7 +537,9 @@ def test_callchild_last_sync(dbos: DBOS, sys_db: SystemDatabase) -> None:
     assert wfsteps[3]["function_name"] == "DBOS.getResult"
 
 
-def test_callchild_first_async_thread(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_callchild_first_async_thread(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     def parentWorkflow() -> None:
@@ -548,7 +565,7 @@ def test_callchild_first_async_thread(dbos: DBOS, sys_db: SystemDatabase) -> Non
     with SetWorkflowID(wfid):
         parentWorkflow()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 4
     assert wfsteps[0]["function_name"] == child_workflow.__qualname__
     assert wfsteps[1]["function_name"] == "DBOS.getStatus"
@@ -556,7 +573,9 @@ def test_callchild_first_async_thread(dbos: DBOS, sys_db: SystemDatabase) -> Non
     assert wfsteps[3]["function_name"] == stepTwo.__qualname__
 
 
-def test_list_steps_errors(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_list_steps_errors(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
     queue = Queue("test-queue")
 
     @DBOS.step()
@@ -582,7 +601,7 @@ def test_list_steps_errors(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         with pytest.raises(Exception):
             call_step()
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 1
     assert wfsteps[0]["function_name"] == failing_step.__qualname__
     assert wfsteps[0]["child_workflow_id"] == None
@@ -594,7 +613,7 @@ def test_list_steps_errors(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         with pytest.raises(Exception):
             start_step()
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 2
     assert wfsteps[0]["function_name"] == f"<temp>.{failing_step.__qualname__}"
     assert wfsteps[0]["child_workflow_id"] == f"{wfid}-1"
@@ -610,7 +629,7 @@ def test_list_steps_errors(dbos: DBOS, sys_db: SystemDatabase) -> None:
     with SetWorkflowID(wfid):
         with pytest.raises(Exception):
             enqueue_step()
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 2
     assert wfsteps[0]["function_name"] == f"<temp>.{failing_step.__qualname__}"
     assert wfsteps[0]["child_workflow_id"] == f"{wfid}-1"
@@ -623,7 +642,9 @@ def test_list_steps_errors(dbos: DBOS, sys_db: SystemDatabase) -> None:
 
 
 @pytest.mark.asyncio
-async def test_list_steps_errors_async(dbos: DBOS, sys_db: SystemDatabase) -> None:
+async def test_list_steps_errors_async(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
     queue = Queue("test-queue")
 
     @DBOS.step()
@@ -649,7 +670,7 @@ async def test_list_steps_errors_async(dbos: DBOS, sys_db: SystemDatabase) -> No
     with SetWorkflowID(wfid):
         with pytest.raises(Exception):
             await call_step()
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 1
     assert wfsteps[0]["function_name"] == failing_step.__qualname__
     assert wfsteps[0]["child_workflow_id"] == None
@@ -661,7 +682,7 @@ async def test_list_steps_errors_async(dbos: DBOS, sys_db: SystemDatabase) -> No
     with SetWorkflowID(wfid):
         with pytest.raises(Exception):
             await start_step()
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 2
     assert wfsteps[0]["function_name"] == f"<temp>.{failing_step.__qualname__}"
     assert wfsteps[0]["child_workflow_id"] == f"{wfid}-1"
@@ -677,7 +698,7 @@ async def test_list_steps_errors_async(dbos: DBOS, sys_db: SystemDatabase) -> No
     with SetWorkflowID(wfid):
         with pytest.raises(Exception):
             await enqueue_step()
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 2
     assert wfsteps[0]["function_name"] == f"<temp>.{failing_step.__qualname__}"
     assert wfsteps[0]["child_workflow_id"] == f"{wfid}-1"
@@ -689,7 +710,9 @@ async def test_list_steps_errors_async(dbos: DBOS, sys_db: SystemDatabase) -> No
     assert isinstance(wfsteps[1]["error"], Exception)
 
 
-def test_callchild_middle_async_thread(dbos: DBOS, sys_db: SystemDatabase) -> None:
+def test_callchild_middle_async_thread(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     def parentWorkflow() -> str:
@@ -716,7 +739,7 @@ def test_callchild_middle_async_thread(dbos: DBOS, sys_db: SystemDatabase) -> No
     with SetWorkflowID(wfid):
         child_id = parentWorkflow()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 5
     assert wfsteps[0]["function_name"] == stepOne.__qualname__
     assert wfsteps[0]["child_workflow_id"] == None
@@ -738,7 +761,9 @@ def test_callchild_middle_async_thread(dbos: DBOS, sys_db: SystemDatabase) -> No
 
 
 @pytest.mark.asyncio
-async def test_callchild_first_asyncio(dbos: DBOS, sys_db: SystemDatabase) -> None:
+async def test_callchild_first_asyncio(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
 
     @DBOS.workflow()
     async def parentWorkflow() -> str:
@@ -765,7 +790,7 @@ async def test_callchild_first_asyncio(dbos: DBOS, sys_db: SystemDatabase) -> No
         handle = await dbos.start_workflow_async(parentWorkflow)
         child_id = await handle.get_result()
 
-    wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
     assert len(wfsteps) == 4
     assert wfsteps[0]["function_name"] == child_workflow.__qualname__
     assert wfsteps[0]["child_workflow_id"] == child_id
@@ -856,3 +881,78 @@ async def test_callchild_rerun_asyncio(dbos: DBOS) -> None:
         res2 = await handle.get_result()
 
     assert res1 == res2
+
+
+def test_list_transaction(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
+
+    @DBOS.workflow()
+    def simple_workflow() -> None:
+        transactionOne()
+        stepTwo()
+        DBOS.sleep(1)
+        return
+
+    @DBOS.transaction()
+    def transactionOne() -> str:
+        return "a test transaction"
+
+    @DBOS.step()
+    def stepTwo() -> None:
+        return
+
+    wfid = str(uuid.uuid4())
+    with SetWorkflowID(wfid):
+        simple_workflow()
+
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
+    assert len(wfsteps) == 3
+    assert wfsteps[0]["function_name"] == transactionOne.__qualname__
+    assert wfsteps[0]["output"] == "a test transaction"
+    assert wfsteps[0]["error"] == None
+    assert wfsteps[1]["function_name"] == stepTwo.__qualname__
+    assert wfsteps[2]["function_name"] == "DBOS.sleep"
+
+
+def test_list_transaction_error(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
+
+    @DBOS.workflow()
+    def simple_workflow() -> None:
+        transactionOne()
+        stepTwo()
+        try:
+            transactionErr()
+        except Exception as e:
+            print(f"Error: {e}")
+        DBOS.sleep(1)
+        return
+
+    @DBOS.transaction()
+    def transactionOne() -> str:
+        return "a test transaction"
+
+    @DBOS.transaction()
+    def transactionErr() -> None:
+        raise Exception("a test transaction error")
+
+    @DBOS.step()
+    def stepTwo() -> None:
+        return
+
+    wfid = str(uuid.uuid4())
+    with SetWorkflowID(wfid):
+        simple_workflow()
+
+    wfsteps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
+    assert len(wfsteps) == 4
+    assert wfsteps[0]["function_name"] == transactionOne.__qualname__
+    assert wfsteps[0]["output"] == "a test transaction"
+    assert wfsteps[0]["error"] == None
+    assert wfsteps[1]["function_name"] == stepTwo.__qualname__
+    assert wfsteps[2]["function_name"] == transactionErr.__qualname__
+    assert wfsteps[2]["output"] == None
+    assert isinstance(wfsteps[2]["error"], Exception)
+    assert wfsteps[3]["function_name"] == "DBOS.sleep"