dbos 1.11.0a6__tar.gz → 1.12.0a2__tar.gz

{dbos-1.11.0a6 → dbos-1.12.0a2}/PKG-INFO

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

{dbos-1.11.0a6 → dbos-1.12.0a2}/dbos/_context.py

@@ -753,3 +753,34 @@ class DBOSAssumeRole:
             assert ctx.assumed_role == self.assume_role
         ctx.assumed_role = self.prior_role
         return False  # Did not handle
+
+
+class UseLogAttributes:
+    """Temporarily set context attributes for logging"""
+
+    def __init__(self, *, workflow_id: str = "") -> None:
+        self.workflow_id = workflow_id
+        self.created_ctx = False
+
+    def __enter__(self) -> UseLogAttributes:
+        ctx = get_local_dbos_context()
+        if ctx is None:
+            self.created_ctx = True
+            _set_local_dbos_context(DBOSContext())
+        ctx = assert_current_dbos_context()
+        self.saved_workflow_id = ctx.workflow_id
+        ctx.workflow_id = self.workflow_id
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> Literal[False]:
+        ctx = assert_current_dbos_context()
+        ctx.workflow_id = self.saved_workflow_id
+        # Clean up the basic context if we created it
+        if self.created_ctx:
+            _clear_local_dbos_context()
+        return False  # Did not handle

{dbos-1.11.0a6 → dbos-1.12.0a2}/dbos/_core.py

@@ -5,7 +5,6 @@ import json
 import sys
 import threading
 import time
-import traceback
 from concurrent.futures import Future
 from functools import wraps
 from typing import (
@@ -66,7 +65,6 @@ from ._registrations import (
     get_dbos_func_name,
     get_func_info,
     get_or_create_func_info,
-    get_temp_workflow_type,
     set_dbos_func_name,
     set_func_info,
     set_temp_workflow_type,
@@ -452,7 +450,7 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
     if not wf_func:
         raise DBOSWorkflowFunctionNotFoundError(
             workflow_id,
-            f"Cannot execute workflow because {status['name']} is not a registered workflow function",
+            f"{status['name']} is not a registered workflow function",
         )
     with DBOSContextEnsure():
         # If this function belongs to a configured class, add that class instance as its first argument
@@ -463,7 +461,7 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
             if iname not in dbos._registry.instance_info_map:
                 raise DBOSWorkflowFunctionNotFoundError(
                     workflow_id,
-                    f"Cannot execute workflow because instance '{iname}' is not registered",
+                    f"configured class instance '{iname}' is not registered",
                 )
             class_instance = dbos._registry.instance_info_map[iname]
             inputs["args"] = (class_instance,) + inputs["args"]
@@ -473,7 +471,7 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
             if class_name not in dbos._registry.class_info_map:
                 raise DBOSWorkflowFunctionNotFoundError(
                     workflow_id,
-                    f"Cannot execute workflow because class '{class_name}' is not registered",
+                    f"class '{class_name}' is not registered",
                 )
             class_object = dbos._registry.class_info_map[class_name]
             inputs["args"] = (class_object,) + inputs["args"]
@@ -534,7 +532,7 @@ def start_workflow(
     if fi is None:
         raise DBOSWorkflowFunctionNotFoundError(
             "<NONE>",
-            f"start_workflow: function {func.__name__} is not registered",
+            f"{func.__name__} is not a registered workflow function",
         )
 
     func = cast("Workflow[P, R]", func.__orig_func)  # type: ignore
@@ -630,7 +628,7 @@ async def start_workflow_async(
     if fi is None:
         raise DBOSWorkflowFunctionNotFoundError(
             "<NONE>",
-            f"start_workflow: function {func.__name__} is not registered",
+            f"{func.__name__} is not a registered workflow function",
         )
 
     func = cast("Workflow[P, R]", func.__orig_func)  # type: ignore
@@ -1158,27 +1156,15 @@ def decorate_step(
 
         @wraps(func)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
-            rr: Optional[str] = check_required_roles(func, fi)
-            # Entering step is allowed:
-            #  No DBOS, just call the original function directly
-            #  In a step already, just call the original function directly.
-            #  In a workflow (that is not in a step already)
-            #  Not in a workflow (we will start the single op workflow)
-            if not dbosreg.dbos or not dbosreg.dbos._launched:
-                # Call the original function directly
-                return func(*args, **kwargs)
+            # If the step is called from a workflow, run it as a step.
+            # Otherwise, run it as a normal function.
             ctx = get_local_dbos_context()
-            if ctx and ctx.is_step():
-                # Call the original function directly
-                return func(*args, **kwargs)
-            if ctx and ctx.is_within_workflow():
-                assert ctx.is_workflow(), "Steps must be called from within workflows"
+            if ctx and ctx.is_workflow():
+                rr: Optional[str] = check_required_roles(func, fi)
                 with DBOSAssumeRole(rr):
                     return invoke_step(*args, **kwargs)
             else:
-                tempwf = dbosreg.workflow_info_map.get("<temp>." + step_name)
-                assert tempwf
-                return tempwf(*args, **kwargs)
+                return func(*args, **kwargs)
 
         wrapper = (
             _mark_coroutine(wrapper) if inspect.iscoroutinefunction(func) else wrapper  # type: ignore

{dbos-1.11.0a6 → dbos-1.12.0a2}/dbos/_dbos.py

@@ -211,6 +211,10 @@ class DBOSRegistry:
     def register_instance(self, inst: object) -> None:
         config_name = getattr(inst, "config_name")
         class_name = _class_fqn(inst.__class__)
+        if self.dbos and self.dbos._launched:
+            dbos_logger.warning(
+                f"Configured instance {config_name} of class {class_name} was registered after DBOS was launched. This may cause errors during workflow recovery. All configured instances should be instantiated before DBOS is launched."
+            )
         fn = f"{class_name}/{config_name}"
         if fn in self.instance_info_map:
             if self.instance_info_map[fn] is not inst:

{dbos-1.11.0a6 → dbos-1.12.0a2}/dbos/_error.py

@@ -106,7 +106,7 @@ class DBOSWorkflowFunctionNotFoundError(DBOSException):
 
     def __init__(self, workflow_id: str, message: Optional[str] = None):
         super().__init__(
-            f"Workflow function not found for workflow ID {workflow_id}: {message}",
+            f"Could not execute workflow {workflow_id}: {message}",
             dbos_error_code=DBOSErrorCode.WorkflowFunctionNotFound.value,
         )
 

{dbos-1.11.0a6 → dbos-1.12.0a2}/dbos/_recovery.py

@@ -2,6 +2,7 @@ import threading
 import time
 from typing import TYPE_CHECKING, Any, List
 
+from dbos._context import UseLogAttributes
 from dbos._utils import GlobalParams
 
 from ._core import execute_workflow_by_id
@@ -29,17 +30,19 @@ def startup_recovery_thread(
     stop_event = threading.Event()
     dbos.background_thread_stop_events.append(stop_event)
     while not stop_event.is_set() and len(pending_workflows) > 0:
-        try:
-            for pending_workflow in list(pending_workflows):
+        for pending_workflow in list(pending_workflows):
+            try:
                 _recover_workflow(dbos, pending_workflow)
                 pending_workflows.remove(pending_workflow)
-        except DBOSWorkflowFunctionNotFoundError:
-            time.sleep(1)
-        except Exception as e:
-            dbos.logger.error(
-                f"Exception encountered when recovering workflows:", exc_info=e
-            )
-            raise
+            except DBOSWorkflowFunctionNotFoundError:
+                time.sleep(1)
+            except Exception as e:
+                with UseLogAttributes(workflow_id=pending_workflow.workflow_uuid):
+                    dbos.logger.error(
+                        f"Exception encountered when recovering workflow {pending_workflow.workflow_uuid}:",
+                        exc_info=e,
+                    )
+                raise
 
 
 def recover_pending_workflows(
@@ -56,9 +59,11 @@ def recover_pending_workflows(
                 handle = _recover_workflow(dbos, pending_workflow)
                 workflow_handles.append(handle)
             except Exception as e:
-                dbos.logger.error(
-                    f"Exception encountered when recovering workflows:", exc_info=e
-                )
+                with UseLogAttributes(workflow_id=pending_workflow.workflow_uuid):
+                    dbos.logger.error(
+                        f"Exception encountered when recovering workflow {pending_workflow.workflow_uuid}:",
+                        exc_info=e,
+                    )
                 raise
         dbos.logger.info(
             f"Recovering {len(pending_workflows)} workflows for executor {executor_id} from version {GlobalParams.app_version}"

{dbos-1.11.0a6 → dbos-1.12.0a2}/dbos/_registrations.py

@@ -13,7 +13,7 @@ def get_dbos_func_name(f: Any) -> str:
     if hasattr(f, "dbos_function_name"):
         return str(getattr(f, "dbos_function_name"))
     raise DBOSWorkflowFunctionNotFoundError(
-        "<NONE>", f"function {f.__name__} is not registered"
+        "<NONE>", f"{f.__name__} is not a registered workflow function"
     )
 
 

{dbos-1.11.0a6 → dbos-1.12.0a2}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.11.0a6"
+version = "1.12.0a2"
 
 [project.license]
 text = "MIT"

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_async.py

@@ -329,30 +329,6 @@ def test_async_tx_raises(config: ConfigFile) -> None:
     DBOS.destroy(destroy_registry=True)
 
 
-@pytest.mark.asyncio
-async def test_async_step_temp(dbos: DBOS) -> None:
-    step_counter: int = 0
-
-    @DBOS.step()
-    async def test_step(var: str) -> str:
-        await asyncio.sleep(0.1)
-        nonlocal step_counter
-        step_counter += 1
-        DBOS.logger.info("I'm test_step")
-        return var + f"step{step_counter}"
-
-    wfuuid = f"test_async_step_temp-{time.time_ns()}"
-    with SetWorkflowID(wfuuid):
-        result = await test_step("alice")
-        assert result == "alicestep1"
-
-    with SetWorkflowID(wfuuid):
-        result = await test_step("alice")
-        assert result == "alicestep1"
-
-    assert step_counter == 1
-
-
 @pytest.mark.asyncio
 async def test_start_workflow_async(dbos: DBOS) -> None:
     wf_counter: int = 0

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_classdecorators.py

@@ -574,7 +574,7 @@ def test_step_recovery(dbos: DBOS) -> None:
     def call_step() -> None:
         with SetWorkflowID(wfid):
             nonlocal return_value
-            return_value = inst.step(input)
+            return_value = DBOS.start_workflow(inst.step, input).get_result()
 
     thread = threading.Thread(target=call_step)
     thread.start()

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_concurrency.py

@@ -59,10 +59,6 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
         res = test_step()
         return res
 
-    def test_comm_thread(id: str) -> str:
-        with SetWorkflowID(id):
-            return test_step()
-
     # Need to set isolation level to a lower one, otherwise it gets serialization error instead (we already handle it correctly by automatic retries).
     @DBOS.transaction(isolation_level="REPEATABLE READ")
     def test_transaction() -> str:
@@ -97,15 +93,6 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     assert wf_handle1.get_result() == wfuuid
     assert wf_handle2.get_result() == wfuuid
 
-    # Make sure temp workflows can handle conflicts as well.
-    wfuuid = str(uuid.uuid4())
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        future1 = executor.submit(test_comm_thread, wfuuid)
-        future2 = executor.submit(test_comm_thread, wfuuid)
-
-    assert future1.result() == wfuuid
-    assert future2.result() == wfuuid
-
     # Make sure temp transactions can handle conflicts as well.
     wfuuid = str(uuid.uuid4())
     with ThreadPoolExecutor(max_workers=2) as executor:

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_dbos.py

@@ -307,16 +307,12 @@ def test_temp_workflow(dbos: DBOS) -> None:
     assert res == "var"
 
     wfs = dbos._sys_db.get_workflows(gwi)
-    assert len(wfs) == 2
+    assert len(wfs) == 1
 
     wfi1 = dbos._sys_db.get_workflow_status(wfs[0].workflow_id)
     assert wfi1
     assert wfi1["name"].startswith("<temp>")
 
-    wfi2 = dbos._sys_db.get_workflow_status(wfs[1].workflow_id)
-    assert wfi2
-    assert wfi2["name"].startswith("<temp>")
-
     assert txn_counter == 1
     assert step_counter == 1
 
@@ -350,7 +346,7 @@ def test_temp_workflow_errors(dbos: DBOS) -> None:
     def test_retried_step(var: str) -> str:
         nonlocal retried_step_counter
         retried_step_counter += 1
-        raise Exception(var)
+        raise ValueError(var)
 
     with pytest.raises(Exception) as exc_info:
         test_transaction("tval")
@@ -360,12 +356,12 @@ def test_temp_workflow_errors(dbos: DBOS) -> None:
         test_step("cval")
     assert "cval" == str(exc_info.value)
 
-    with pytest.raises(DBOSMaxStepRetriesExceeded) as exc_info:
+    with pytest.raises(ValueError) as exc_info:
         test_retried_step("rval")
 
     assert txn_counter == 1
     assert step_counter == 1
-    assert retried_step_counter == 3
+    assert retried_step_counter == 1
 
 
 def test_recovery_workflow(dbos: DBOS) -> None:
@@ -1102,9 +1098,6 @@ def test_nonserializable_values(dbos: DBOS) -> None:
     with pytest.raises(Exception) as exc_info:
         test_ns_transaction("h")
     assert "data item should not be a function" in str(exc_info.value)
-    with pytest.raises(Exception) as exc_info:
-        test_ns_step("f")
-    assert "data item should not be a function" in str(exc_info.value)
     with pytest.raises(Exception) as exc_info:
         test_ns_wf("g")
     assert "data item should not be a function" in str(exc_info.value)
@@ -1645,22 +1638,14 @@ def test_custom_names(dbos: DBOS) -> None:
 async def test_step_without_dbos(dbos: DBOS, config: DBOSConfig) -> None:
     DBOS.destroy(destroy_registry=True)
 
-    is_dbos_active = False
-
     @DBOS.step()
     def step(x: int) -> int:
-        if is_dbos_active:
-            assert DBOS.workflow_id is not None
-        else:
-            assert DBOS.workflow_id is None
+        assert DBOS.workflow_id is None
         return x
 
     @DBOS.step()
     async def async_step(x: int) -> int:
-        if is_dbos_active:
-            assert DBOS.workflow_id is not None
-        else:
-            assert DBOS.workflow_id is None
+        assert DBOS.workflow_id is None
         return x
 
     assert step(5) == 5
@@ -1672,7 +1657,30 @@ async def test_step_without_dbos(dbos: DBOS, config: DBOSConfig) -> None:
     assert await async_step(5) == 5
 
     DBOS.launch()
-    is_dbos_active = True
 
     assert step(5) == 5
     assert await async_step(5) == 5
+
+    assert len(DBOS.list_workflows()) == 0
+
+
+def test_nested_steps(dbos: DBOS) -> None:
+
+    @DBOS.step()
+    def outer_step() -> str:
+        return inner_step()
+
+    @DBOS.step()
+    def inner_step() -> str:
+        id = DBOS.workflow_id
+        assert id is not None
+        return id
+
+    @DBOS.workflow()
+    def workflow() -> str:
+        return outer_step()
+
+    id = workflow()
+    steps = DBOS.list_workflow_steps(id)
+    assert len(steps) == 1
+    assert steps[0]["function_name"] == outer_step.__qualname__

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_failures.py

@@ -8,12 +8,14 @@ from psycopg.errors import SerializationFailure
 from sqlalchemy.exc import InvalidRequestError, OperationalError
 
 from dbos import DBOS, Queue, SetWorkflowID
+from dbos._dbos_config import DBOSConfig
 from dbos._error import (
     DBOSAwaitedWorkflowCancelledError,
     DBOSMaxStepRetriesExceeded,
     DBOSNotAuthorizedError,
     DBOSQueueDeduplicatedError,
     DBOSUnexpectedStepError,
+    DBOSWorkflowFunctionNotFoundError,
     MaxRecoveryAttemptsExceededError,
 )
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
@@ -331,15 +333,8 @@ def test_step_retries(dbos: DBOS) -> None:
     error_message = f"Step {failing_step.__qualname__} has exceeded its maximum of {max_attempts} retries"
 
     # Test calling the step directly
-    with pytest.raises(DBOSMaxStepRetriesExceeded) as excinfo:
+    with pytest.raises(Exception) as excinfo:
         failing_step()
-    assert error_message in str(excinfo.value)
-    assert step_counter == max_attempts
-    assert len(excinfo.value.errors) == max_attempts
-    for error in excinfo.value.errors:
-        assert isinstance(error, Exception)
-        assert error
-        assert "fail" in str(error)
 
     # Test calling the workflow
     step_counter = 0
@@ -347,6 +342,11 @@ def test_step_retries(dbos: DBOS) -> None:
         failing_workflow()
     assert error_message in str(excinfo.value)
     assert step_counter == max_attempts
+    assert len(excinfo.value.errors) == max_attempts
+    for error in excinfo.value.errors:
+        assert isinstance(error, Exception)
+        assert error
+        assert "fail" in str(error)
 
     # Test enqueueing the step
     step_counter = 0
@@ -397,7 +397,6 @@ def test_step_status(dbos: DBOS) -> None:
 
     assert failing_workflow() == None
     step_counter = 0
-    assert failing_step() == None
 
 
 def test_recovery_during_retries(dbos: DBOS) -> None:
@@ -499,3 +498,24 @@ def test_error_serialization() -> None:
     assert output is None
     assert isinstance(exception, str)
     assert "Message: 1, 2" in exception
+
+
+def test_unregistered_workflow(dbos: DBOS, config: DBOSConfig) -> None:
+
+    @DBOS.workflow()
+    def workflow() -> None:
+        return
+
+    wfid = str(uuid.uuid4())
+    with SetWorkflowID(wfid):
+        workflow()
+
+    dbos._sys_db.update_workflow_outcome(wfid, "PENDING")
+
+    DBOS.destroy(destroy_registry=True)
+    config["executor_id"] = str(uuid.uuid4())
+    DBOS(config=config)
+    DBOS.launch()
+
+    with pytest.raises(DBOSWorkflowFunctionNotFoundError):
+        DBOS._recover_pending_workflows()

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_queue.py

@@ -181,7 +181,8 @@ def test_queue_step(dbos: DBOS) -> None:
         handle = queue.enqueue(test_step, "abc")
     assert handle.get_result() == "abc1"
     with SetWorkflowID(wfid):
-        assert test_step("abc") == "abc1"
+        handle = queue.enqueue(test_step, "abc")
+    assert handle.get_result() == "abc1"
     assert step_counter == 1
 
 

{dbos-1.11.0a6 → dbos-1.12.0a2}/tests/test_spans.py

@@ -53,11 +53,10 @@ def test_spans(config: DBOSConfig) -> None:
     dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
 
     test_workflow()
-    test_step()
 
     log_processor.force_flush(timeout_millis=5000)
     logs = log_exporter.get_finished_logs()
-    assert len(logs) == 3
+    assert len(logs) == 2
     for log in logs:
         assert log.log_record.attributes is not None
         assert (
@@ -78,7 +77,7 @@ def test_spans(config: DBOSConfig) -> None:
 
     spans = exporter.get_finished_spans()
 
-    assert len(spans) == 5
+    assert len(spans) == 3
 
     for span in spans:
         assert span.attributes is not None
@@ -92,26 +91,19 @@ def test_spans(config: DBOSConfig) -> None:
     assert spans[0].name == test_step.__qualname__
     assert spans[1].name == "a new span"
     assert spans[2].name == test_workflow.__qualname__
-    assert spans[3].name == test_step.__qualname__
-    assert spans[4].name == f"<temp>.{test_step.__qualname__}"
 
     assert spans[0].parent.span_id == spans[2].context.span_id  # type: ignore
     assert spans[1].parent.span_id == spans[2].context.span_id  # type: ignore
     assert spans[2].parent == None
-    assert spans[3].parent.span_id == spans[4].context.span_id  # type: ignore
-    assert spans[4].parent == None
 
     # Span ID and trace ID should match the log record
     # For pyright
     assert spans[0].context is not None
     assert spans[2].context is not None
-    assert spans[3].context is not None
     assert logs[0].log_record.span_id == spans[0].context.span_id
     assert logs[0].log_record.trace_id == spans[0].context.trace_id
     assert logs[1].log_record.span_id == spans[2].context.span_id
     assert logs[1].log_record.trace_id == spans[2].context.trace_id
-    assert logs[2].log_record.span_id == spans[3].context.span_id
-    assert logs[2].log_record.trace_id == spans[3].context.trace_id
 
 
 @pytest.mark.asyncio
@@ -147,11 +139,10 @@ async def test_spans_async(dbos: DBOS) -> None:
     dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
 
     await test_workflow()
-    await test_step()
 
     log_processor.force_flush(timeout_millis=5000)
     logs = log_exporter.get_finished_logs()
-    assert len(logs) == 3
+    assert len(logs) == 2
     for log in logs:
         assert log.log_record.attributes is not None
         assert (
@@ -171,7 +162,7 @@ async def test_spans_async(dbos: DBOS) -> None:
 
     spans = exporter.get_finished_spans()
 
-    assert len(spans) == 5
+    assert len(spans) == 3
 
     for span in spans:
         assert span.attributes is not None
@@ -184,34 +175,27 @@ async def test_spans_async(dbos: DBOS) -> None:
     assert spans[0].name == test_step.__qualname__
     assert spans[1].name == "a new span"
     assert spans[2].name == test_workflow.__qualname__
-    assert spans[3].name == test_step.__qualname__
-    assert spans[4].name == f"<temp>.{test_step.__qualname__}"
 
     assert spans[0].parent.span_id == spans[2].context.span_id  # type: ignore
     assert spans[1].parent.span_id == spans[2].context.span_id  # type: ignore
     assert spans[2].parent == None
-    assert spans[3].parent.span_id == spans[4].context.span_id  # type: ignore
-    assert spans[4].parent == None
 
     # Span ID and trace ID should match the log record
     assert spans[0].context is not None
     assert spans[2].context is not None
-    assert spans[3].context is not None
     assert logs[0].log_record.span_id == spans[0].context.span_id
     assert logs[0].log_record.trace_id == spans[0].context.trace_id
     assert logs[1].log_record.span_id == spans[2].context.span_id
     assert logs[1].log_record.trace_id == spans[2].context.trace_id
-    assert logs[2].log_record.span_id == spans[3].context.span_id
-    assert logs[2].log_record.trace_id == spans[3].context.trace_id
 
 
-def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
+def test_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     dbos, app = dbos_fastapi
 
-    @app.get("/step")
-    @DBOS.step()
-    def test_step_endpoint() -> str:
-        dbos.logger.info("This is a test_step_endpoint")
+    @app.get("/wf")
+    @DBOS.workflow()
+    def test_workflow_endpoint() -> str:
+        dbos.logger.info("This is a test_workflow_endpoint")
         return "test"
 
     exporter = InMemorySpanExporter()
@@ -229,7 +213,7 @@ def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
 
     client = TestClient(app)
-    response = client.get("/step")
+    response = client.get("/wf")
     assert response.status_code == 200
     assert response.text == '"test"'
 
@@ -242,14 +226,14 @@ def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     )
     assert logs[0].log_record.span_id is not None and logs[0].log_record.span_id > 0
     assert logs[0].log_record.trace_id is not None and logs[0].log_record.trace_id > 0
-    assert logs[0].log_record.body == "This is a test_step_endpoint"
+    assert logs[0].log_record.body == "This is a test_workflow_endpoint"
     assert logs[0].log_record.attributes["traceId"] == format_trace_id(
         logs[0].log_record.trace_id
     )
 
     spans = exporter.get_finished_spans()
 
-    assert len(spans) == 3
+    assert len(spans) == 2
 
     for span in spans:
         assert span.attributes is not None
@@ -258,13 +242,11 @@ def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
         assert span.context.span_id > 0
         assert span.context.trace_id > 0
 
-    assert spans[0].name == test_step_endpoint.__qualname__
-    assert spans[1].name == f"<temp>.{test_step_endpoint.__qualname__}"
-    assert spans[2].name == "/step"
+    assert spans[0].name == test_workflow_endpoint.__qualname__
+    assert spans[1].name == "/wf"
 
     assert spans[0].parent.span_id == spans[1].context.span_id  # type: ignore
-    assert spans[1].parent.span_id == spans[2].context.span_id  # type: ignore
-    assert spans[2].parent == None
+    assert spans[1].parent == None
 
     # Span ID and trace ID should match the log record
     assert spans[0].context is not None