dbos 0.25.0a12__tar.gz → 0.25.0a14__tar.gz

{dbos-0.25.0a12 → dbos-0.25.0a14}/PKG-INFO

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

{dbos-0.25.0a12 → dbos-0.25.0a14}/dbos/_admin_server.py

@@ -7,8 +7,6 @@ from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import TYPE_CHECKING, Any, List, TypedDict
 
-import jsonpickle  # type: ignore
-
 from ._logger import dbos_logger
 from ._recovery import recover_pending_workflows
 
@@ -162,7 +160,17 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
 
     def _handle_steps(self, workflow_id: str) -> None:
         steps = self.dbos._sys_db.get_workflow_steps(workflow_id)
-        json_steps = jsonpickle.encode(steps, unpicklable=False).encode("utf-8")
+
+        updated_steps = [
+            {
+                **step,
+                "output": str(step["output"]) if step["output"] is not None else None,
+                "error": str(step["error"]) if step["error"] is not None else None,
+            }
+            for step in steps
+        ]
+
+        json_steps = json.dumps(updated_steps).encode("utf-8")
         self.send_response(200)
         self._end_headers()
         self.wfile.write(json_steps)

{dbos-0.25.0a12 → dbos-0.25.0a14}/dbos/_core.py

@@ -279,25 +279,14 @@ def _init_workflow(
             raise DBOSNonExistentWorkflowError(wfid)
         wf_status = get_status_result["status"]
     else:
-        if temp_wf_type != "transaction" or queue is not None:
-            # Synchronously record the status and inputs for workflows and single-step workflows
-            # We also have to do this for single-step workflows because of the foreign key constraint on the operation outputs table
-            # TODO: Make this transactional (and with the queue step below)
-            wf_status = dbos._sys_db.insert_workflow_status(
-                status, max_recovery_attempts=max_recovery_attempts
-            )
-
-            # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
-            dbos._sys_db.update_workflow_inputs(
-                wfid, _serialization.serialize_args(inputs)
-            )
+        # Synchronously record the status and inputs for workflows
+        # TODO: Make this transactional (and with the queue step below)
+        wf_status = dbos._sys_db.insert_workflow_status(
+            status, max_recovery_attempts=max_recovery_attempts
+        )
 
-        else:
-            # Buffer the inputs for single-transaction workflows, but don't buffer the status
-
-            dbos._sys_db.buffer_workflow_inputs(
-                wfid, _serialization.serialize_args(inputs)
-            )
+        # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
+        dbos._sys_db.update_workflow_inputs(wfid, _serialization.serialize_args(inputs))
 
         if queue is not None and wf_status == WorkflowStatusString.ENQUEUED.value:
             dbos._sys_db.enqueue(wfid, queue)
@@ -311,6 +300,18 @@ def _get_wf_invoke_func(
     status: WorkflowStatusInternal,
 ) -> Callable[[Callable[[], R]], R]:
     def persist(func: Callable[[], R]) -> R:
+        if not dbos.debug_mode and (
+            status["status"] == WorkflowStatusString.ERROR.value
+            or status["status"] == WorkflowStatusString.SUCCESS.value
+        ):
+            dbos.logger.debug(
+                f"Workflow {status['workflow_uuid']} is already completed with status {status['status']}"
+            )
+            # Directly return the result if the workflow is already completed
+            recorded_result: R = dbos._sys_db.await_workflow_result(
+                status["workflow_uuid"]
+            )
+            return recorded_result
         try:
             output = func()
             status["status"] = "SUCCESS"
@@ -319,7 +320,7 @@ def _get_wf_invoke_func(
                 if status["queue_name"] is not None:
                     queue = dbos._registry.queue_info_map[status["queue_name"]]
                     dbos._sys_db.remove_from_queue(status["workflow_uuid"], queue)
-                dbos._sys_db.buffer_workflow_status(status)
+                dbos._sys_db.update_workflow_status(status)
             return output
         except DBOSWorkflowConflictIDError:
             # Await the workflow result

{dbos-0.25.0a12 → dbos-0.25.0a14}/dbos/_dbos.py

@@ -485,14 +485,6 @@ class DBOS:
             notification_listener_thread.start()
             self._background_threads.append(notification_listener_thread)
 
-            # Start flush workflow buffers thread
-            flush_workflow_buffers_thread = threading.Thread(
-                target=self._sys_db.flush_workflow_buffers,
-                daemon=True,
-            )
-            flush_workflow_buffers_thread.start()
-            self._background_threads.append(flush_workflow_buffers_thread)
-
             # Start the queue thread
             evt = threading.Event()
             self.stop_events.append(evt)
@@ -549,7 +541,9 @@ class DBOS:
         if _dbos_global_instance is not None:
             _dbos_global_instance._reset_system_database()
         else:
-            dbos_logger.warning("reset_system_database has no effect because global DBOS object does not exist")
+            dbos_logger.warning(
+                "reset_system_database has no effect because global DBOS object does not exist"
+            )
 
     def _reset_system_database(self) -> None:
         assert (

{dbos-0.25.0a12 → dbos-0.25.0a14}/dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py

@@ -25,7 +25,7 @@ def upgrade() -> None:
             "function_name",
             sa.Text(),
             nullable=False,
-            default="",
+            server_default="",
         ),
         schema="dbos",
     )

{dbos-0.25.0a12 → dbos-0.25.0a14}/dbos/_sys_db.py

@@ -166,8 +166,6 @@ class StepInfo(TypedDict):
 
 
 _dbos_null_topic = "__null__topic__"
-_buffer_flush_batch_size = 100
-_buffer_flush_interval_secs = 1.0
 
 
 class SystemDatabase:
@@ -264,32 +262,17 @@ class SystemDatabase:
         self.notifications_map: Dict[str, threading.Condition] = {}
         self.workflow_events_map: Dict[str, threading.Condition] = {}
 
-        # Initialize the workflow status and inputs buffers
-        self._workflow_status_buffer: Dict[str, WorkflowStatusInternal] = {}
-        self._workflow_inputs_buffer: Dict[str, str] = {}
-        # Two sets for tracking which single-transaction workflows have been exported to the status table
-        self._exported_temp_txn_wf_status: Set[str] = set()
-        self._temp_txn_wf_ids: Set[str] = set()
-        self._is_flushing_status_buffer = False
-
         # Now we can run background processes
         self._run_background_processes = True
         self._debug_mode = debug_mode
 
     # Destroy the pool when finished
     def destroy(self) -> None:
-        self.wait_for_buffer_flush()
         self._run_background_processes = False
         if self.notification_conn is not None:
             self.notification_conn.close()
         self.engine.dispose()
 
-    def wait_for_buffer_flush(self) -> None:
-        # Wait until the buffers are flushed.
-        while self._is_flushing_status_buffer or not self._is_buffers_empty:
-            dbos_logger.debug("Waiting for system buffers to be exported")
-            time.sleep(1)
-
     def insert_workflow_status(
         self,
         status: WorkflowStatusInternal,
@@ -440,10 +423,6 @@ class SystemDatabase:
             with self.engine.begin() as c:
                 c.execute(cmd)
 
-        # If this is a single-transaction workflow, record that its status has been exported
-        if status["workflow_uuid"] in self._temp_txn_wf_ids:
-            self._exported_temp_txn_wf_status.add(status["workflow_uuid"])
-
     def cancel_workflow(
         self,
         workflow_id: str,
@@ -621,10 +600,7 @@ class SystemDatabase:
                     f"Workflow {workflow_uuid} has been called multiple times with different inputs"
                 )
             # TODO: actually changing the input
-        if workflow_uuid in self._temp_txn_wf_ids:
-            # Clean up the single-transaction tracking sets
-            self._exported_temp_txn_wf_status.discard(workflow_uuid)
-            self._temp_txn_wf_ids.discard(workflow_uuid)
+
         return
 
     def get_workflow_inputs(
@@ -1275,106 +1251,6 @@ class SystemDatabase:
             )
         return value
 
-    def _flush_workflow_status_buffer(self) -> None:
-        if self._debug_mode:
-            raise Exception("called _flush_workflow_status_buffer in debug mode")
-
-        """Export the workflow status buffer to the database, up to the batch size."""
-        if len(self._workflow_status_buffer) == 0:
-            return
-
-        # Record the exported status so far, and add them back on errors.
-        exported_status: Dict[str, WorkflowStatusInternal] = {}
-        with self.engine.begin() as c:
-            exported = 0
-            status_iter = iter(list(self._workflow_status_buffer))
-            wf_id: Optional[str] = None
-            while (
-                exported < _buffer_flush_batch_size
-                and (wf_id := next(status_iter, None)) is not None
-            ):
-                # Pop the first key in the buffer (FIFO)
-                status = self._workflow_status_buffer.pop(wf_id, None)
-                if status is None:
-                    continue
-                exported_status[wf_id] = status
-                try:
-                    self.update_workflow_status(status, conn=c)
-                    exported += 1
-                except Exception as e:
-                    dbos_logger.error(f"Error while flushing status buffer: {e}")
-                    c.rollback()
-                    # Add the exported status back to the buffer, so they can be retried next time
-                    self._workflow_status_buffer.update(exported_status)
-                    break
-
-    def _flush_workflow_inputs_buffer(self) -> None:
-        if self._debug_mode:
-            raise Exception("called _flush_workflow_inputs_buffer in debug mode")
-
-        """Export the workflow inputs buffer to the database, up to the batch size."""
-        if len(self._workflow_inputs_buffer) == 0:
-            return
-
-        # Record exported inputs so far, and add them back on errors.
-        exported_inputs: Dict[str, str] = {}
-        with self.engine.begin() as c:
-            exported = 0
-            input_iter = iter(list(self._workflow_inputs_buffer))
-            wf_id: Optional[str] = None
-            while (
-                exported < _buffer_flush_batch_size
-                and (wf_id := next(input_iter, None)) is not None
-            ):
-                if wf_id not in self._exported_temp_txn_wf_status:
-                    # Skip exporting inputs if the status has not been exported yet
-                    continue
-                inputs = self._workflow_inputs_buffer.pop(wf_id, None)
-                if inputs is None:
-                    continue
-                exported_inputs[wf_id] = inputs
-                try:
-                    self.update_workflow_inputs(wf_id, inputs, conn=c)
-                    exported += 1
-                except Exception as e:
-                    dbos_logger.error(f"Error while flushing inputs buffer: {e}")
-                    c.rollback()
-                    # Add the exported inputs back to the buffer, so they can be retried next time
-                    self._workflow_inputs_buffer.update(exported_inputs)
-                    break
-
-    def flush_workflow_buffers(self) -> None:
-        """Flush the workflow status and inputs buffers periodically, via a background thread."""
-        while self._run_background_processes:
-            try:
-                self._is_flushing_status_buffer = True
-                # Must flush the status buffer first, as the inputs table has a foreign key constraint on the status table.
-                self._flush_workflow_status_buffer()
-                self._flush_workflow_inputs_buffer()
-                self._is_flushing_status_buffer = False
-                if self._is_buffers_empty:
-                    # Only sleep if both buffers are empty
-                    time.sleep(_buffer_flush_interval_secs)
-            except Exception as e:
-                dbos_logger.error(f"Error while flushing buffers: {e}")
-                time.sleep(_buffer_flush_interval_secs)
-                # Will retry next time
-
-    def buffer_workflow_status(self, status: WorkflowStatusInternal) -> None:
-        self._workflow_status_buffer[status["workflow_uuid"]] = status
-
-    def buffer_workflow_inputs(self, workflow_id: str, inputs: str) -> None:
-        # inputs is a serialized WorkflowInputs string
-        self._workflow_inputs_buffer[workflow_id] = inputs
-        self._temp_txn_wf_ids.add(workflow_id)
-
-    @property
-    def _is_buffers_empty(self) -> bool:
-        return (
-            len(self._workflow_status_buffer) == 0
-            and len(self._workflow_inputs_buffer) == 0
-        )
-
     def enqueue(self, workflow_id: str, queue_name: str) -> None:
         if self._debug_mode:
             raise Exception("called enqueue in debug mode")

{dbos-0.25.0a12 → dbos-0.25.0a14}/pyproject.toml

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

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_admin_server.py

@@ -97,8 +97,6 @@ def test_admin_recovery(config: ConfigFile) -> None:
     with SetWorkflowID(wfuuid):
         assert test_workflow("bob", "bob") == "bob1bob"
 
-    dbos._sys_db.wait_for_buffer_flush()
-
     # Manually update the database to pretend the workflow comes from another executor and is pending
     with dbos._sys_db.engine.begin() as c:
         query = (
@@ -254,10 +252,9 @@ def test_admin_workflow_resume(dbos: DBOS, sys_db: SystemDatabase) -> None:
         nonlocal counter
         counter += 1
 
-    # Run the workflow and flush its results
+    # Run the workflow
     simple_workflow()
     assert counter == 1
-    dbos._sys_db.wait_for_buffer_flush()
 
     # Verify the workflow has succeeded
     output = DBOS.list_workflows()
@@ -295,7 +292,8 @@ def test_admin_workflow_resume(dbos: DBOS, sys_db: SystemDatabase) -> None:
     )
     assert response.status_code == 204
     assert event.wait(timeout=5)
-    dbos._sys_db.wait_for_buffer_flush()
+    # Wait for the workflow to finish
+    DBOS.retrieve_workflow(wfUuid).get_result()
     assert counter == 2
     info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None
@@ -307,7 +305,7 @@ def test_admin_workflow_resume(dbos: DBOS, sys_db: SystemDatabase) -> None:
         f"http://localhost:3001/workflows/{wfUuid}/resume", json=[], timeout=5
     )
     assert response.status_code == 204
-    dbos._sys_db.wait_for_buffer_flush()
+    DBOS.retrieve_workflow(wfUuid).get_result()
     info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None
     assert info.status == "SUCCESS", f"Expected status to be SUCCESS"

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_async.py

@@ -47,7 +47,6 @@ async def test_async_workflow(dbos: DBOS) -> None:
     with SetWorkflowID(wfuuid):
         result = await test_workflow("alice", "bob")
         assert result == "alicetxn11bobstep1"
-    dbos._sys_db.wait_for_buffer_flush()
 
     with SetWorkflowID(wfuuid):
         result = await test_workflow("alice", "bob")
@@ -93,7 +92,6 @@ async def test_async_step(dbos: DBOS) -> None:
     with SetWorkflowID(wfuuid):
         result = await test_workflow("alice", "bob")
         assert result == "alicetxn11bobstep1"
-    dbos._sys_db.wait_for_buffer_flush()
 
     with SetWorkflowID(wfuuid):
         result = await test_workflow("alice", "bob")
@@ -323,7 +321,6 @@ async def test_async_step_temp(dbos: DBOS) -> None:
     with SetWorkflowID(wfuuid):
         result = await test_step("alice")
         assert result == "alicestep1"
-    dbos._sys_db.wait_for_buffer_flush()
 
     with SetWorkflowID(wfuuid):
         result = await test_step("alice")
@@ -373,7 +370,7 @@ async def test_start_workflow_async(dbos: DBOS) -> None:
     result = await handle.get_result()
     assert result == "alicebobstep1"
 
-    assert wf_counter == 2
+    assert wf_counter == 1
     assert step_counter == 1
     assert wf_el_id == id(asyncio.get_running_loop())
     assert step_el_id == id(asyncio.get_running_loop())

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_classdecorators.py

@@ -413,7 +413,7 @@ def test_class_recovery(dbos: DBOS) -> None:
     # Test we can execute the workflow by uuid as recovery would do
     handle = DBOS.execute_workflow_id("run1")
     assert handle.get_result() == "ran"
-    assert exc_cnt == 2
+    assert exc_cnt == 1
 
 
 def test_inst_recovery(dbos: DBOS) -> None:
@@ -446,8 +446,9 @@ def test_inst_recovery(dbos: DBOS) -> None:
     last_inst = None
     handle = DBOS.execute_workflow_id(wfid)
     assert handle.get_result() == "ran2"
-    assert exc_cnt == 2
-    assert last_inst is inst
+    assert exc_cnt == 1
+    # Workflow has finished so last_inst should be None
+    assert last_inst is None
 
     status = DBOS.retrieve_workflow(wfid).get_status()
     assert status.class_name == "TestClass"
@@ -806,14 +807,12 @@ def test_inst_txn(dbos: DBOS) -> None:
 
     with SetWorkflowID(wfid):
         assert inst.transaction(input) == input * multiplier
-    dbos._sys_db.wait_for_buffer_flush()
     status = DBOS.retrieve_workflow(wfid).get_status()
     assert status.class_name == "TestClass"
     assert status.config_name == "test_class"
 
     handle = DBOS.start_workflow(inst.transaction, input)
     assert handle.get_result() == input * multiplier
-    dbos._sys_db.wait_for_buffer_flush()
     status = handle.get_status()
     assert status.class_name == "TestClass"
     assert status.config_name == "test_class"

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_dbos.py

@@ -33,7 +33,7 @@ def test_simple_workflow(dbos: DBOS) -> None:
         wf_counter += 1
         res = test_transaction(var2)
         res2 = test_step(var)
-        DBOS.logger.info("I'm test_workflow")
+        DBOS.logger.info("I'm test_workflow " + var + var2)
         return res + res2
 
     @DBOS.transaction(isolation_level="REPEATABLE READ")
@@ -42,7 +42,7 @@ def test_simple_workflow(dbos: DBOS) -> None:
         rows = DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
         nonlocal txn_counter
         txn_counter += 1
-        DBOS.logger.info("I'm test_transaction")
+        DBOS.logger.info("I'm test_transaction " + var2)
         return var2 + str(rows[0][0])
 
     @DBOS.step()
@@ -53,7 +53,7 @@ def test_simple_workflow(dbos: DBOS) -> None:
         assert DBOS.step_status.max_attempts is None
         nonlocal step_counter
         step_counter += 1
-        DBOS.logger.info("I'm test_step")
+        DBOS.logger.info("I'm test_step " + var)
         return var
 
     assert test_workflow("bob", "bob") == "bob1bob"
@@ -62,15 +62,17 @@ def test_simple_workflow(dbos: DBOS) -> None:
     wfuuid = str(uuid.uuid4())
     with SetWorkflowID(wfuuid):
         assert test_workflow("alice", "alice") == "alice1alice"
+    assert wf_counter == 2
     with SetWorkflowID(wfuuid):
         assert test_workflow("alice", "alice") == "alice1alice"
     assert txn_counter == 2  # Only increment once
     assert step_counter == 2  # Only increment once
+    assert wf_counter == 2  # Only increment once
 
     # Test we can execute the workflow by uuid
     handle = DBOS.execute_workflow_id(wfuuid)
     assert handle.get_result() == "alice1alice"
-    assert wf_counter == 4
+    assert wf_counter == 2
 
 
 def test_simple_workflow_attempts_counter(dbos: DBOS) -> None:
@@ -92,10 +94,7 @@ def test_simple_workflow_attempts_counter(dbos: DBOS) -> None:
             assert result is not None
             recovery_attempts, created_at, updated_at = result
             assert recovery_attempts == i + 1
-            if i == 0:
-                assert created_at == updated_at
-            else:
-                assert updated_at > created_at
+            assert updated_at > created_at
 
 
 def test_child_workflow(dbos: DBOS) -> None:
@@ -258,12 +257,11 @@ def test_exception_workflow(dbos: DBOS) -> None:
     assert bad_txn_counter == 2  # Only increment once
 
     # Test we can execute the workflow by uuid, shouldn't throw errors
-    dbos._sys_db._flush_workflow_status_buffer()
     handle = DBOS.execute_workflow_id(wfuuid)
     with pytest.raises(Exception) as exc_info:
         handle.get_result()
     assert "test error" == str(exc_info.value)
-    assert wf_counter == 3  # The workflow error is directly returned without running
+    assert wf_counter == 2  # The workflow error is directly returned without running
 
 
 def test_temp_workflow(dbos: DBOS) -> None:
@@ -298,12 +296,6 @@ def test_temp_workflow(dbos: DBOS) -> None:
     res = test_step("var")
     assert res == "var"
 
-    # Flush workflow inputs buffer shouldn't fail due to foreign key violation.
-    # It should properly skip the transaction inputs.
-    dbos._sys_db._flush_workflow_inputs_buffer()
-
-    # Wait for buffers to flush
-    dbos._sys_db.wait_for_buffer_flush()
     wfs = dbos._sys_db.get_workflows(gwi)
     assert len(wfs.workflow_uuids) == 2
 
@@ -398,7 +390,6 @@ def test_recovery_workflow(dbos: DBOS) -> None:
     with SetWorkflowID(wfuuid):
         assert test_workflow("bob", "bob") == "bob1bob"
 
-    dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
     with dbos._sys_db.engine.begin() as c:
         c.execute(
@@ -444,7 +435,6 @@ def test_recovery_workflow_step(dbos: DBOS) -> None:
     with SetWorkflowID(wfuuid):
         assert test_workflow("bob", "bob") == "bob"
 
-    dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
     with dbos._sys_db.engine.begin() as c:
         c.execute(
@@ -481,14 +471,13 @@ def test_workflow_returns_none(dbos: DBOS) -> None:
         assert test_workflow("bob", "bob") is None
     assert wf_counter == 1
 
-    dbos._sys_db.wait_for_buffer_flush()
     with SetWorkflowID(wfuuid):
         assert test_workflow("bob", "bob") is None
-    assert wf_counter == 2
+    assert wf_counter == 1
 
     handle: WorkflowHandle[None] = DBOS.retrieve_workflow(wfuuid)
     assert handle.get_result() == None
-    assert wf_counter == 2
+    assert wf_counter == 1
 
     # Change the workflow status to pending
     with dbos._sys_db.engine.begin() as c:
@@ -501,7 +490,7 @@ def test_workflow_returns_none(dbos: DBOS) -> None:
     workflow_handles = DBOS.recover_pending_workflows()
     assert len(workflow_handles) == 1
     assert workflow_handles[0].get_result() is None
-    assert wf_counter == 3
+    assert wf_counter == 2
 
     # Test that there was a recovery attempt of this
     stat = workflow_handles[0].get_status()
@@ -528,7 +517,6 @@ def test_recovery_temp_workflow(dbos: DBOS) -> None:
         res = test_transaction("bob")
         assert res == "bob1"
 
-    dbos._sys_db.wait_for_buffer_flush()
     wfs = dbos._sys_db.get_workflows(gwi)
     assert len(wfs.workflow_uuids) == 1
     assert wfs.workflow_uuids[0] == wfuuid
@@ -554,7 +542,6 @@ def test_recovery_temp_workflow(dbos: DBOS) -> None:
     assert len(wfs.workflow_uuids) == 1
     assert wfs.workflow_uuids[0] == wfuuid
 
-    dbos._sys_db.wait_for_buffer_flush()
     wfi = dbos._sys_db.get_workflow_status(wfs.workflow_uuids[0])
     assert wfi
     assert wfi["name"].startswith("<temp>")
@@ -583,7 +570,6 @@ def test_recovery_thread(config: ConfigFile) -> None:
     with SetWorkflowID(wfuuid):
         assert test_workflow(test_var) == test_var
 
-    dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
     dbos._sys_db.update_workflow_status(
         {
@@ -666,7 +652,7 @@ def test_start_workflow(dbos: DBOS) -> None:
         context = assert_current_dbos_context()
         assert not context.is_within_workflow()
     assert txn_counter == 1
-    assert wf_counter == 3
+    assert wf_counter == 1
 
 
 def test_retrieve_workflow(dbos: DBOS) -> None:
@@ -778,7 +764,6 @@ def test_retrieve_workflow_in_workflow(dbos: DBOS) -> None:
         fstat1 = wfh.get_status()
         assert fstat1
         fres = wfh.get_result()
-        dbos._sys_db.wait_for_buffer_flush()  # Wait for status to export.
         fstat2 = wfh.get_status()
         assert fstat2
         return fstat1.status + fres + fstat2.status
@@ -905,7 +890,7 @@ def test_send_recv(dbos: DBOS) -> None:
     with SetWorkflowID(send_uuid):
         res = test_send_workflow(handle.get_workflow_id(), "testtopic")
         assert res == dest_uuid
-        assert send_counter == 2
+        assert send_counter == 1
 
     with SetWorkflowID(dest_uuid):
         begin_time = time.time()
@@ -913,7 +898,7 @@ def test_send_recv(dbos: DBOS) -> None:
         duration = time.time() - begin_time
         assert duration < 3.0
         assert res == "test2-test1-test3"
-        assert recv_counter == 2
+        assert recv_counter == 1
 
     with SetWorkflowID(timeout_uuid):
         begin_time = time.time()
@@ -1142,7 +1127,9 @@ def test_multi_set_event(dbos: DBOS) -> None:
     assert DBOS.get_event(wfid, "key") == "value2"
 
 
-def test_debug_logging(dbos: DBOS, caplog: pytest.LogCaptureFixture) -> None:
+def test_debug_logging(
+    dbos: DBOS, caplog: pytest.LogCaptureFixture, config: ConfigFile
+) -> None:
     wfid = str(uuid.uuid4())
     dest_wfid = str(uuid.uuid4())
 
@@ -1196,9 +1183,27 @@ def test_debug_logging(dbos: DBOS, caplog: pytest.LogCaptureFixture) -> None:
     assert "Running recv" in caplog.text
     caplog.clear()
 
-    dbos._sys_db._flush_workflow_status_buffer()
-
     # Second run
+    with SetWorkflowID(dest_wfid):
+        dest_handle_2 = dbos.start_workflow(test_workflow_dest)
+
+    with SetWorkflowID(wfid):
+        result3 = test_workflow()
+
+    assert result3 == result1
+    assert "is already completed with status SUCCESS" in caplog.text
+
+    result4 = dest_handle_2.get_result()
+    assert result4 == result2
+    caplog.clear()
+
+    # Debug mode run
+    DBOS.destroy()
+    DBOS(config=config)
+    logging.getLogger("dbos").propagate = True
+    caplog.set_level(logging.DEBUG, "dbos")
+    DBOS.launch(debug_mode=True)
+
     with SetWorkflowID(dest_wfid):
         dest_handle_2 = dbos.start_workflow(test_workflow_dest)
 
@@ -1321,6 +1326,7 @@ def test_app_version(config: ConfigFile) -> None:
 
 def test_recovery_appversion(config: ConfigFile) -> None:
     input = 5
+    os.environ["DBOS__VMID"] = "testexecutor"
 
     DBOS.destroy(destroy_registry=True)
     dbos = DBOS(config=config)
@@ -1336,7 +1342,6 @@ def test_recovery_appversion(config: ConfigFile) -> None:
         assert test_workflow(input) == input
 
     # Change the workflow status to pending
-    dbos._sys_db.wait_for_buffer_flush()
     with dbos._sys_db.engine.begin() as c:
         c.execute(
             sa.update(SystemSchema.workflow_status)
@@ -1345,6 +1350,7 @@ def test_recovery_appversion(config: ConfigFile) -> None:
         )
 
     # Reconstruct an identical environment to simulate a restart
+    os.environ["DBOS__VMID"] = "testexecutor_another"
     DBOS.destroy(destroy_registry=True)
     dbos = DBOS(config=config)
 
@@ -1355,12 +1361,11 @@ def test_recovery_appversion(config: ConfigFile) -> None:
     DBOS.launch()
 
     # The workflow should successfully recover
-    workflow_handles = DBOS.recover_pending_workflows()
+    workflow_handles = DBOS.recover_pending_workflows(["testexecutor"])
     assert len(workflow_handles) == 1
     assert workflow_handles[0].get_result() == input
 
     # Change the workflow status to pending
-    dbos._sys_db.wait_for_buffer_flush()
     with dbos._sys_db.engine.begin() as c:
         c.execute(
             sa.update(SystemSchema.workflow_status)
@@ -1379,5 +1384,8 @@ def test_recovery_appversion(config: ConfigFile) -> None:
     DBOS.launch()
 
     # The workflow should not recover
-    workflow_handles = DBOS.recover_pending_workflows()
+    workflow_handles = DBOS.recover_pending_workflows(["testexecutor"])
     assert len(workflow_handles) == 0
+
+    # Clean up the environment variable
+    del os.environ["DBOS__VMID"]

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_failures.py

@@ -146,43 +146,6 @@ def test_notification_errors(dbos: DBOS) -> None:
     assert duration < 3.0
 
 
-def test_buffer_flush_errors(dbos: DBOS) -> None:
-    @DBOS.transaction()
-    def test_transaction(var: str) -> str:
-        rows = DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
-        return var + str(rows[0][0])
-
-    cur_time: str = datetime.datetime.now().isoformat()
-    gwi: GetWorkflowsInput = GetWorkflowsInput()
-    gwi.start_time = cur_time
-
-    res = test_transaction("bob")
-    assert res == "bob1"
-
-    dbos._sys_db.wait_for_buffer_flush()
-    wfs = dbos._sys_db.get_workflows(gwi)
-    assert len(wfs.workflow_uuids) == 1
-
-    # Crash the system database connection and make sure the buffer flush works on time.
-    backup_engine = dbos._sys_db.engine
-    dbos._sys_db.engine = sa.create_engine(
-        "postgresql+psycopg://fake:database@localhost/fake_db"
-    )
-
-    res = test_transaction("bob")
-    assert res == "bob1"
-
-    # Should see some errors in the logs
-    time.sleep(2)
-
-    # Switch back to the original good engine.
-    dbos._sys_db.engine = backup_engine
-
-    dbos._sys_db.wait_for_buffer_flush()
-    wfs = dbos._sys_db.get_workflows(gwi)
-    assert len(wfs.workflow_uuids) == 2
-
-
 def test_dead_letter_queue(dbos: DBOS) -> None:
     event = threading.Event()
     max_recovery_attempts = 20
@@ -229,7 +192,6 @@ def test_dead_letter_queue(dbos: DBOS) -> None:
     # Complete the blocked workflow
     event.set()
     assert handle.get_result() == resumed_handle.get_result() == None
-    dbos._sys_db.wait_for_buffer_flush()
     assert handle.get_status().status == WorkflowStatusString.SUCCESS.value
 
 
@@ -239,6 +201,8 @@ def test_wfstatus_invalid(dbos: DBOS) -> None:
         return "done"
 
     has_executed = False
+    event = threading.Event()
+    wfevent = threading.Event()
 
     @DBOS.workflow()
     def non_deterministic_workflow() -> None:
@@ -251,16 +215,24 @@ def test_wfstatus_invalid(dbos: DBOS) -> None:
         handle.get_status()
         res = handle.get_result()
         assert res == "done"
+        wfevent.set()
+        event.wait()
         return
 
     wfuuid = str(uuid.uuid4())
     with SetWorkflowID(wfuuid):
-        non_deterministic_workflow()
+        handle1 = dbos.start_workflow(non_deterministic_workflow)
+
+    # Make sure the first one has reached the point where it waits for the event
+    wfevent.wait()
+    with SetWorkflowID(wfuuid):
+        handle2 = dbos.start_workflow(non_deterministic_workflow)
 
     with pytest.raises(DBOSException) as exc_info:
-        with SetWorkflowID(wfuuid):
-            non_deterministic_workflow()
+        handle2.get_result()
     assert "Hint: Check if your workflow is deterministic." in str(exc_info.value)
+    event.set()
+    assert handle1.get_result() == None
 
 
 def test_step_retries(dbos: DBOS) -> None:

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_fastapi.py

@@ -134,7 +134,6 @@ def test_endpoint_recovery(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     assert response.json().get("id1") == wfuuid
     assert response.json().get("id2") != wfuuid
 
-    dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
     dbos._sys_db.update_workflow_status(
         {

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_fastapi_roles.py

@@ -132,7 +132,6 @@ def test_simple_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     assert span.attributes["authenticatedUserRoles"] == '["user", "engineer"]'
 
     # Verify that there is one workflow for this user.
-    dbos._sys_db.wait_for_buffer_flush()
     gwi = GetWorkflowsInput()
     gwi.authenticated_user = "user1"
     wfl = dbos._sys_db.get_workflows(gwi)

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_flask.py

@@ -95,7 +95,6 @@ def test_endpoint_recovery(dbos_flask: Tuple[DBOS, Flask]) -> None:
     assert response.json.get("id1") == wfuuid
     assert response.json.get("id2") != wfuuid
 
-    dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
     dbos._sys_db.update_workflow_status(
         {

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_queue.py

@@ -19,7 +19,7 @@ from dbos import (
     WorkflowHandle,
 )
 from dbos._schemas.system_database import SystemSchema
-from dbos._sys_db import WorkflowStatusString, _buffer_flush_interval_secs
+from dbos._sys_db import WorkflowStatusString
 from tests.conftest import default_config, queue_entries_are_cleaned_up
 
 
@@ -50,7 +50,7 @@ def test_simple_queue(dbos: DBOS) -> None:
     assert handle.get_result() == "abcd123"
     with SetWorkflowID(wfid):
         assert test_workflow("abc", "123") == "abcd123"
-    assert wf_counter == 2
+    assert wf_counter == 1
     assert step_counter == 1
 
 
@@ -232,7 +232,6 @@ def test_limiter(dbos: DBOS) -> None:
         assert times[limit * (wave + 1)] - times[limit * wave] < period + 0.2
 
     # Verify all workflows get the SUCCESS status eventually
-    dbos._sys_db.wait_for_buffer_flush()
     for h in handles:
         assert h.get_status().status == WorkflowStatusString.SUCCESS.value
 
@@ -300,7 +299,6 @@ def test_multiple_queues(dbos: DBOS) -> None:
         assert times[limit * (wave + 1)] - times[limit * wave] < period + 0.2
 
     # Verify all workflows get the SUCCESS status eventually
-    dbos._sys_db.wait_for_buffer_flush()
     for h in handles:
         assert h.get_status().status == WorkflowStatusString.SUCCESS.value
 
@@ -901,49 +899,6 @@ def test_resuming_queued_workflows(dbos: DBOS) -> None:
     assert queue_entries_are_cleaned_up(dbos)
 
 
-# Test a race condition between removing a task from the queue and flushing the status buffer
-def test_resuming_already_completed_queue_workflow(dbos: DBOS) -> None:
-    dbos._sys_db._run_background_processes = False  # Disable buffer flush
-
-    start_event = threading.Event()
-    counter = 0
-
-    @DBOS.workflow()
-    def test_step() -> None:
-        start_event.set()
-        nonlocal counter
-        counter += 1
-
-    queue = Queue("test_queue")
-    handle = queue.enqueue(test_step)
-    start_event.wait()
-    start_event.clear()
-    time.sleep(_buffer_flush_interval_secs)
-    assert (
-        handle.get_status().status == WorkflowStatusString.PENDING.value
-    )  # Not flushed
-    assert counter == 1  # But, really, it's completed
-    dbos._sys_db._workflow_status_buffer = (
-        {}
-    )  # Clear buffer (simulates a process restart)
-
-    # Recovery picks up on the workflow and recovers it
-    recovered_ids = DBOS.recover_pending_workflows()
-    assert len(recovered_ids) == 1
-    assert recovered_ids[0].get_workflow_id() == handle.get_workflow_id()
-    start_event.wait()
-    assert counter == 2  # The workflow ran again
-    time.sleep(
-        _buffer_flush_interval_secs
-    )  # This is actually to wait that _get_wf_invoke_func buffers the status
-    dbos._sys_db._flush_workflow_status_buffer()  # Manually flush
-    assert (
-        handle.get_status().status == WorkflowStatusString.SUCCESS.value
-    )  # Is recovered
-    assert handle.get_status().executor_id == "local"
-    assert handle.get_status().recovery_attempts == 2
-
-
 def test_dlq_enqueued_workflows(dbos: DBOS) -> None:
     start_event = threading.Event()
     blocking_event = threading.Event()
@@ -1002,7 +957,6 @@ def test_dlq_enqueued_workflows(dbos: DBOS) -> None:
     # Complete the blocked workflow
     blocking_event.set()
     assert blocked_handle.get_result() == None
-    dbos._sys_db.wait_for_buffer_flush()
     assert blocked_handle.get_status().status == WorkflowStatusString.SUCCESS.value
     with dbos._sys_db.engine.begin() as c:
         query = sa.select(SystemSchema.workflow_status.c.recovery_attempts).where(

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_scheduler.py

@@ -205,7 +205,6 @@ def test_scheduler_oaoo(dbos: DBOS) -> None:
     for event in dbos.stop_events:
         event.set()
 
-    dbos._sys_db.wait_for_buffer_flush()
     dbos._sys_db.update_workflow_status(
         {
             "workflow_uuid": workflow_id,

{dbos-0.25.0a12 → dbos-0.25.0a14}/tests/test_workflow_cmds.py

@@ -27,7 +27,6 @@ def test_list_workflow(dbos: DBOS) -> None:
     wfid = str(uuid.uuid4)
     with SetWorkflowID(wfid):
         assert simple_workflow(1) == 2
-    dbos._sys_db._flush_workflow_status_buffer()
 
     # List the workflow, then test every output
     outputs = DBOS.list_workflows()
@@ -766,8 +765,6 @@ 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()
 
-    dbos._sys_db._flush_workflow_status_buffer()
-
     wfsteps = _workflow_commands.list_workflow_steps(sys_db, wfid)
     assert len(wfsteps) == 4
     assert wfsteps[0]["function_name"] == child_workflow.__qualname__