dbos 1.6.0a3__tar.gz → 1.6.0a4__tar.gz

{dbos-1.6.0a3 → dbos-1.6.0a4}/PKG-INFO

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

{dbos-1.6.0a3 → dbos-1.6.0a4}/dbos/_core.py

@@ -392,7 +392,7 @@ def _execute_workflow_wthread(
     **kwargs: Any,
 ) -> R:
     attributes: TracedAttributes = {
-        "name": func.__name__,
+        "name": get_dbos_func_name(func),
         "operationType": OperationType.WORKFLOW.value,
     }
     with DBOSContextSwap(ctx):
@@ -425,7 +425,7 @@ async def _execute_workflow_async(
     **kwargs: Any,
 ) -> R:
     attributes: TracedAttributes = {
-        "name": func.__name__,
+        "name": get_dbos_func_name(func),
         "operationType": OperationType.WORKFLOW.value,
     }
     with DBOSContextSwap(ctx):
@@ -532,7 +532,8 @@ def start_workflow(
     fi = get_func_info(func)
     if fi is None:
         raise DBOSWorkflowFunctionNotFoundError(
-            "<NONE>", f"start_workflow: function {func.__name__} is not registered"
+            "<NONE>",
+            f"start_workflow: function {func.__name__} is not registered",
         )
 
     func = cast("Workflow[P, R]", func.__orig_func)  # type: ignore
@@ -627,7 +628,8 @@ async def start_workflow_async(
     fi = get_func_info(func)
     if fi is None:
         raise DBOSWorkflowFunctionNotFoundError(
-            "<NONE>", f"start_workflow: function {func.__name__} is not registered"
+            "<NONE>",
+            f"start_workflow: function {func.__name__} is not registered",
         )
 
     func = cast("Workflow[P, R]", func.__orig_func)  # type: ignore
@@ -731,13 +733,13 @@ def workflow_wrapper(
         assert fi is not None
         if dbosreg.dbos is None:
             raise DBOSException(
-                f"Function {func.__name__} invoked before DBOS initialized"
+                f"Function {get_dbos_func_name(func)} invoked before DBOS initialized"
             )
         dbos = dbosreg.dbos
 
         rr: Optional[str] = check_required_roles(func, fi)
         attributes: TracedAttributes = {
-            "name": func.__name__,
+            "name": get_dbos_func_name(func),
             "operationType": OperationType.WORKFLOW.value,
         }
         inputs: WorkflowInputs = {
@@ -837,27 +839,30 @@ def workflow_wrapper(
 
 
 def decorate_workflow(
-    reg: "DBOSRegistry", max_recovery_attempts: Optional[int]
+    reg: "DBOSRegistry", name: Optional[str], max_recovery_attempts: Optional[int]
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def _workflow_decorator(func: Callable[P, R]) -> Callable[P, R]:
         wrapped_func = workflow_wrapper(reg, func, max_recovery_attempts)
-        reg.register_wf_function(func.__qualname__, wrapped_func, "workflow")
+        func_name = name if name is not None else func.__qualname__
+        set_dbos_func_name(func, func_name)
+        set_dbos_func_name(wrapped_func, func_name)
+        reg.register_wf_function(func_name, wrapped_func, "workflow")
         return wrapped_func
 
     return _workflow_decorator
 
 
 def decorate_transaction(
-    dbosreg: "DBOSRegistry", isolation_level: "IsolationLevel" = "SERIALIZABLE"
+    dbosreg: "DBOSRegistry", name: Optional[str], isolation_level: "IsolationLevel"
 ) -> Callable[[F], F]:
     def decorator(func: F) -> F:
 
-        transaction_name = func.__qualname__
+        transaction_name = name if name is not None else func.__qualname__
 
         def invoke_tx(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
-                    f"Function {func.__name__} invoked before DBOS initialized"
+                    f"Function {transaction_name} invoked before DBOS initialized"
                 )
 
             dbos = dbosreg.dbos
@@ -865,12 +870,12 @@ def decorate_transaction(
             status = dbos._sys_db.get_workflow_status(ctx.workflow_id)
             if status and status["status"] == WorkflowStatusString.CANCELLED.value:
                 raise DBOSWorkflowCancelledError(
-                    f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {func.__name__}."
+                    f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {transaction_name}."
                 )
 
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
-                    "name": func.__name__,
+                    "name": transaction_name,
                     "operationType": OperationType.TRANSACTION.value,
                 }
                 with EnterDBOSTransaction(session, attributes=attributes):
@@ -971,7 +976,7 @@ def decorate_transaction(
                             raise
                         except InvalidRequestError as invalid_request_error:
                             dbos.logger.error(
-                                f"InvalidRequestError in transaction {func.__qualname__} \033[1m Hint: Do not call commit() or rollback() within a DBOS transaction.\033[0m"
+                                f"InvalidRequestError in transaction {transaction_name} \033[1m Hint: Do not call commit() or rollback() within a DBOS transaction.\033[0m"
                             )
                             txn_error = invalid_request_error
                             raise
@@ -991,7 +996,7 @@ def decorate_transaction(
 
         if inspect.iscoroutinefunction(func):
             raise DBOSException(
-                f"Function {func.__name__} is a coroutine function, but DBOS.transaction does not support coroutine functions"
+                f"Function {transaction_name} is a coroutine function, but DBOS.transaction does not support coroutine functions"
             )
 
         fi = get_or_create_func_info(func)
@@ -1010,15 +1015,19 @@ def decorate_transaction(
                 with DBOSAssumeRole(rr):
                     return invoke_tx(*args, **kwargs)
             else:
-                tempwf = dbosreg.workflow_info_map.get("<temp>." + func.__qualname__)
+                tempwf = dbosreg.workflow_info_map.get("<temp>." + transaction_name)
                 assert tempwf
                 return tempwf(*args, **kwargs)
 
+        set_dbos_func_name(func, transaction_name)
+        set_dbos_func_name(wrapper, transaction_name)
+
         def temp_wf(*args: Any, **kwargs: Any) -> Any:
             return wrapper(*args, **kwargs)
 
         wrapped_wf = workflow_wrapper(dbosreg, temp_wf)
-        set_dbos_func_name(temp_wf, "<temp>." + func.__qualname__)
+        set_dbos_func_name(temp_wf, "<temp>." + transaction_name)
+        set_dbos_func_name(wrapped_wf, "<temp>." + transaction_name)
         set_temp_workflow_type(temp_wf, "transaction")
         dbosreg.register_wf_function(
             get_dbos_func_name(temp_wf), wrapped_wf, "transaction"
@@ -1035,24 +1044,25 @@ def decorate_transaction(
 def decorate_step(
     dbosreg: "DBOSRegistry",
     *,
-    retries_allowed: bool = False,
-    interval_seconds: float = 1.0,
-    max_attempts: int = 3,
-    backoff_rate: float = 2.0,
+    name: Optional[str],
+    retries_allowed: bool,
+    interval_seconds: float,
+    max_attempts: int,
+    backoff_rate: float,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorator(func: Callable[P, R]) -> Callable[P, R]:
 
-        step_name = func.__qualname__
+        step_name = name if name is not None else func.__qualname__
 
         def invoke_step(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
-                    f"Function {func.__name__} invoked before DBOS initialized"
+                    f"Function {step_name} invoked before DBOS initialized"
                 )
             dbos = dbosreg.dbos
 
             attributes: TracedAttributes = {
-                "name": func.__name__,
+                "name": step_name,
                 "operationType": OperationType.STEP.value,
             }
 
@@ -1131,7 +1141,7 @@ def decorate_step(
                 stepOutcome = stepOutcome.retry(
                     max_attempts,
                     on_exception,
-                    lambda i, e: DBOSMaxStepRetriesExceeded(func.__name__, i, e),
+                    lambda i, e: DBOSMaxStepRetriesExceeded(step_name, i, e),
                 )
 
             outcome = (
@@ -1160,7 +1170,7 @@ def decorate_step(
                 with DBOSAssumeRole(rr):
                     return invoke_step(*args, **kwargs)
             else:
-                tempwf = dbosreg.workflow_info_map.get("<temp>." + func.__qualname__)
+                tempwf = dbosreg.workflow_info_map.get("<temp>." + step_name)
                 assert tempwf
                 return tempwf(*args, **kwargs)
 
@@ -1168,6 +1178,9 @@ def decorate_step(
             _mark_coroutine(wrapper) if inspect.iscoroutinefunction(func) else wrapper  # type: ignore
         )
 
+        set_dbos_func_name(func, step_name)
+        set_dbos_func_name(wrapper, step_name)
+
         def temp_wf_sync(*args: Any, **kwargs: Any) -> Any:
             return wrapper(*args, **kwargs)
 
@@ -1181,7 +1194,8 @@ def decorate_step(
 
         temp_wf = temp_wf_async if inspect.iscoroutinefunction(func) else temp_wf_sync
         wrapped_wf = workflow_wrapper(dbosreg, temp_wf)
-        set_dbos_func_name(temp_wf, "<temp>." + func.__qualname__)
+        set_dbos_func_name(temp_wf, "<temp>." + step_name)
+        set_dbos_func_name(wrapped_wf, "<temp>." + step_name)
         set_temp_workflow_type(temp_wf, "step")
         dbosreg.register_wf_function(get_dbos_func_name(temp_wf), wrapped_wf, "step")
         wrapper.__orig_func = temp_wf  # type: ignore

{dbos-1.6.0a3 → dbos-1.6.0a4}/dbos/_dbos.py

@@ -360,6 +360,7 @@ class DBOS:
 
         temp_send_wf = workflow_wrapper(self._registry, send_temp_workflow)
         set_dbos_func_name(send_temp_workflow, TEMP_SEND_WF_NAME)
+        set_dbos_func_name(temp_send_wf, TEMP_SEND_WF_NAME)
         set_temp_workflow_type(send_temp_workflow, "send")
         self._registry.register_wf_function(TEMP_SEND_WF_NAME, temp_send_wf, "send")
 
@@ -589,14 +590,22 @@ class DBOS:
     # Decorators for DBOS functionality
     @classmethod
     def workflow(
-        cls, *, max_recovery_attempts: Optional[int] = DEFAULT_MAX_RECOVERY_ATTEMPTS
+        cls,
+        *,
+        name: Optional[str] = None,
+        max_recovery_attempts: Optional[int] = DEFAULT_MAX_RECOVERY_ATTEMPTS,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """Decorate a function for use as a DBOS workflow."""
-        return decorate_workflow(_get_or_create_dbos_registry(), max_recovery_attempts)
+        return decorate_workflow(
+            _get_or_create_dbos_registry(), name, max_recovery_attempts
+        )
 
     @classmethod
     def transaction(
-        cls, isolation_level: IsolationLevel = "SERIALIZABLE"
+        cls,
+        isolation_level: IsolationLevel = "SERIALIZABLE",
+        *,
+        name: Optional[str] = None,
     ) -> Callable[[F], F]:
         """
         Decorate a function for use as a DBOS transaction.
@@ -605,12 +614,15 @@ class DBOS:
             isolation_level(IsolationLevel): Transaction isolation level
 
         """
-        return decorate_transaction(_get_or_create_dbos_registry(), isolation_level)
+        return decorate_transaction(
+            _get_or_create_dbos_registry(), name, isolation_level
+        )
 
     @classmethod
     def step(
         cls,
         *,
+        name: Optional[str] = None,
         retries_allowed: bool = False,
         interval_seconds: float = 1.0,
         max_attempts: int = 3,
@@ -629,6 +641,7 @@ class DBOS:
 
         return decorate_step(
             _get_or_create_dbos_registry(),
+            name=name,
             retries_allowed=retries_allowed,
             interval_seconds=interval_seconds,
             max_attempts=max_attempts,

{dbos-1.6.0a3 → dbos-1.6.0a4}/dbos/_kafka.py

@@ -13,6 +13,7 @@ from ._context import SetWorkflowID
 from ._error import DBOSInitializationError
 from ._kafka_message import KafkaMessage
 from ._logger import dbos_logger
+from ._registrations import get_dbos_func_name
 
 _KafkaConsumerWorkflow = Callable[[KafkaMessage], None]
 
@@ -44,7 +45,7 @@ def _kafka_consumer_loop(
         config["auto.offset.reset"] = "earliest"
 
     if config.get("group.id") is None:
-        config["group.id"] = safe_group_name(func.__qualname__, topics)
+        config["group.id"] = safe_group_name(get_dbos_func_name(func), topics)
         dbos_logger.warning(
             f"Consumer group ID not found. Using generated group.id {config['group.id']}"
         )

{dbos-1.6.0a3 → dbos-1.6.0a4}/dbos/_registrations.py

@@ -4,15 +4,17 @@ from enum import Enum
 from types import FunctionType
 from typing import Any, Callable, List, Literal, Optional, Tuple, Type, cast
 
+from dbos._error import DBOSWorkflowFunctionNotFoundError
+
 DEFAULT_MAX_RECOVERY_ATTEMPTS = 100
 
 
 def get_dbos_func_name(f: Any) -> str:
     if hasattr(f, "dbos_function_name"):
         return str(getattr(f, "dbos_function_name"))
-    if hasattr(f, "__qualname__"):
-        return str(getattr(f, "__qualname__"))
-    return "<unknown>"
+    raise DBOSWorkflowFunctionNotFoundError(
+        "<NONE>", f"function {f.__name__} is not registered"
+    )
 
 
 def set_dbos_func_name(f: Any, name: str) -> None:

{dbos-1.6.0a3 → dbos-1.6.0a4}/dbos/_roles.py

@@ -10,6 +10,7 @@ from ._context import DBOSAssumeRole, get_local_dbos_context
 from ._registrations import (
     DBOSFuncInfo,
     get_class_info_for_func,
+    get_dbos_func_name,
     get_or_create_class_info,
     get_or_create_func_info,
 )
@@ -36,7 +37,7 @@ def check_required_roles(
     ctx = get_local_dbos_context()
     if ctx is None or ctx.authenticated_roles is None:
         raise DBOSNotAuthorizedError(
-            f"Function {func.__name__} requires a role, but was called in a context without authentication information"
+            f"Function {get_dbos_func_name(func)} requires a role, but was called in a context without authentication information"
         )
 
     for r in required_roles:
@@ -44,7 +45,7 @@ def check_required_roles(
             return r
 
     raise DBOSNotAuthorizedError(
-        f"Function {func.__name__} has required roles, but user is not authenticated for any of them"
+        f"Function {get_dbos_func_name(func)} has required roles, but user is not authenticated for any of them"
     )
 
 

{dbos-1.6.0a3 → dbos-1.6.0a4}/dbos/_scheduler.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
 
 from ._context import SetWorkflowID
 from ._croniter import croniter  # type: ignore
+from ._registrations import get_dbos_func_name
 
 ScheduledWorkflow = Callable[[datetime, datetime], None]
 
@@ -24,20 +25,22 @@ def scheduler_loop(
         iter = croniter(cron, datetime.now(timezone.utc), second_at_beginning=True)
     except Exception as e:
         dbos_logger.error(
-            f'Cannot run scheduled function {func.__name__}. Invalid crontab "{cron}"'
+            f'Cannot run scheduled function {get_dbos_func_name(func)}. Invalid crontab "{cron}"'
         )
     while not stop_event.is_set():
         nextExecTime = iter.get_next(datetime)
         sleepTime = nextExecTime - datetime.now(timezone.utc)
         if stop_event.wait(timeout=sleepTime.total_seconds()):
             return
-        with SetWorkflowID(f"sched-{func.__qualname__}-{nextExecTime.isoformat()}"):
-            try:
+        try:
+            with SetWorkflowID(
+                f"sched-{get_dbos_func_name(func)}-{nextExecTime.isoformat()}"
+            ):
                 scheduler_queue.enqueue(func, nextExecTime, datetime.now(timezone.utc))
-            except Exception:
-                dbos_logger.warning(
-                    f"Exception encountered in scheduler thread: {traceback.format_exc()})"
-                )
+        except Exception:
+            dbos_logger.warning(
+                f"Exception encountered in scheduler thread: {traceback.format_exc()})"
+            )
 
 
 def scheduled(
@@ -48,7 +51,7 @@ def scheduled(
             croniter(cron, datetime.now(timezone.utc), second_at_beginning=True)
         except Exception as e:
             raise ValueError(
-                f'Invalid crontab "{cron}" for scheduled function function {func.__name__}.'
+                f'Invalid crontab "{cron}" for scheduled function function {get_dbos_func_name(func)}.'
             )
 
         global scheduler_queue

{dbos-1.6.0a3 → dbos-1.6.0a4}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.6.0a3"
+version = "1.6.0a4"
 
 [project.license]
 text = "MIT"

{dbos-1.6.0a3 → dbos-1.6.0a4}/tests/test_classdecorators.py

@@ -15,6 +15,7 @@ from tests.conftest import queue_entries_are_cleaned_up
 
 def test_required_roles(dbos: DBOS) -> None:
     @DBOS.required_roles(["user"])
+    @DBOS.workflow(name="tfunc")
     def tfunc(var: str) -> str:
         assert assert_current_dbos_context().assumed_role == "user"
         return var

{dbos-1.6.0a3 → dbos-1.6.0a4}/tests/test_dbos.py

@@ -15,6 +15,7 @@ import sqlalchemy as sa
 from dbos import (
     DBOS,
     DBOSConfig,
+    Queue,
     SetWorkflowID,
     SetWorkflowTimeout,
     WorkflowHandle,
@@ -1190,10 +1191,13 @@ def test_debug_logging(
         result1 = test_workflow()
 
     assert result1 == "Step: Hello, Transaction: World"
-    assert "Running step" in caplog.text and "name: step_function" in caplog.text
+    assert (
+        "Running step" in caplog.text
+        and f"name: {step_function.__qualname__}" in caplog.text
+    )
     assert (
         "Running transaction" in caplog.text
-        and "name: transaction_function" in caplog.text
+        and f"name: {transaction_function.__qualname__}" in caplog.text
     )
     assert "Running sleep" in caplog.text
     assert "Running set_event" in caplog.text
@@ -1233,10 +1237,13 @@ def test_debug_logging(
         result3 = test_workflow()
 
     assert result3 == result1
-    assert "Replaying step" in caplog.text and "name: step_function" in caplog.text
+    assert (
+        "Replaying step" in caplog.text
+        and f"name: {step_function.__qualname__}" in caplog.text
+    )
     assert (
         "Replaying transaction" in caplog.text
-        and "name: transaction_function" in caplog.text
+        and f"name: {transaction_function.__qualname__}" in caplog.text in caplog.text
     )
     assert "Replaying sleep" in caplog.text
     assert "Replaying set_event" in caplog.text
@@ -1556,3 +1563,48 @@ def test_workflow_timeout(dbos: DBOS) -> None:
             assert assert_current_dbos_context().workflow_timeout_ms is None
         assert assert_current_dbos_context().workflow_timeout_ms == 1000
     assert get_local_dbos_context() is None
+
+
+def test_custom_names(dbos: DBOS) -> None:
+    workflow_name = "workflow_name"
+    step_name = "step_name"
+    txn_name = "txn_name"
+    queue = Queue("test-queue")
+
+    @DBOS.workflow(name=workflow_name)
+    def workflow() -> str:
+        return DBOS.workflow_id
+
+    handle = queue.enqueue(workflow)
+    assert handle.get_status().name == workflow_name
+    assert handle.get_result() == handle.workflow_id
+
+    @DBOS.step(name=step_name)
+    def step() -> str:
+        return DBOS.workflow_id
+
+    handle = queue.enqueue(step)
+    assert handle.get_status().name == f"<temp>.{step_name}"
+    assert handle.get_result() == handle.workflow_id
+
+    @DBOS.transaction(name=txn_name)
+    def txn() -> str:
+        return DBOS.workflow_id
+
+    handle = queue.enqueue(txn)
+    assert handle.get_status().name == f"<temp>.{txn_name}"
+    assert handle.get_result() == handle.workflow_id
+
+    # Verify we can declare another workflow with the same function name
+    # but a different custom name
+
+    another_workflow = "another_workflow"
+
+    @DBOS.workflow(name=another_workflow)
+    def workflow(x: int) -> int:
+        return x
+
+    value = 5
+    handle = DBOS.start_workflow(workflow, value)  # type: ignore
+    assert handle.get_status().name == another_workflow
+    assert handle.get_result() == value  # type: ignore

{dbos-1.6.0a3 → dbos-1.6.0a4}/tests/test_failures.py

@@ -325,7 +325,7 @@ def test_step_retries(dbos: DBOS) -> None:
     def enqueue_failing_step() -> None:
         queue.enqueue(failing_step).get_result()
 
-    error_message = f"Step {failing_step.__name__} has exceeded its maximum of {max_attempts} retries"
+    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:

{dbos-1.6.0a3 → dbos-1.6.0a4}/tests/test_fastapi_roles.py

@@ -123,7 +123,7 @@ def test_simple_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     assert span.attributes is not None
 
     span = spans[0]
-    assert span.name == "test_user_endpoint"
+    assert span.name == test_user_endpoint.__qualname__
     assert span.parent is not None
     assert span.parent.span_id == spans[1].context.span_id
     assert span.attributes is not None
@@ -171,7 +171,7 @@ def test_simple_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     assert response.status_code == 403
     assert (
         response.text
-        == '{"message":"Function test_admin_endpoint has required roles, but user is not authenticated for any of them","dbos_error_code":"8","dbos_error":"DBOSNotAuthorizedError"}'
+        == '{"message":"Function test_simple_endpoint.<locals>.test_admin_endpoint has required roles, but user is not authenticated for any of them","dbos_error_code":"8","dbos_error":"DBOSNotAuthorizedError"}'
     )
 
 
@@ -293,7 +293,7 @@ def test_jwt_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     assert response.status_code == 403
     assert (
         response.text
-        == '{"message":"Function test_admin_endpoint has required roles, but user is not authenticated for any of them","dbos_error_code":"8","dbos_error":"DBOSNotAuthorizedError"}'
+        == '{"message":"Function test_jwt_endpoint.<locals>.test_admin_endpoint has required roles, but user is not authenticated for any of them","dbos_error_code":"8","dbos_error":"DBOSNotAuthorizedError"}'
     )
 
 

{dbos-1.6.0a3 → dbos-1.6.0a4}/tests/test_scheduler.py

@@ -7,6 +7,7 @@ from sqlalchemy.engine import Engine
 
 # Public API
 from dbos import DBOS
+from dbos._error import DBOSWorkflowFunctionNotFoundError
 
 
 def simulate_db_restart(engine: Engine, downtime: float) -> None:
@@ -155,6 +156,19 @@ def test_scheduled_transaction(dbos: DBOS) -> None:
     assert txn_counter > 2 and txn_counter <= 4
 
 
+def test_scheduled_step(dbos: DBOS) -> None:
+    step_counter: int = 0
+
+    @DBOS.scheduled("* * * * * *")
+    @DBOS.step()
+    def test_step(scheduled: datetime, actual: datetime) -> None:
+        nonlocal step_counter
+        step_counter += 1
+
+    time.sleep(4)
+    assert step_counter > 2 and step_counter <= 4
+
+
 def test_scheduled_workflow_exception(dbos: DBOS) -> None:
     wf_counter: int = 0
 
@@ -240,5 +254,5 @@ def my_function():
     pass
 """
     # Use exec to run the code and catch the expected exception
-    with pytest.raises(ValueError, match="Invalid crontab"):
+    with pytest.raises(DBOSWorkflowFunctionNotFoundError) as excinfo:
         exec(code)

{dbos-1.6.0a3 → dbos-1.6.0a4}/tests/test_spans.py

@@ -41,7 +41,7 @@ def test_spans(config: DBOSConfig) -> None:
 
     spans = exporter.get_finished_spans()
 
-    assert len(spans) == 4
+    assert len(spans) == 5
 
     for span in spans:
         assert span.attributes is not None
@@ -50,15 +50,17 @@ def test_spans(config: DBOSConfig) -> None:
         assert span.context is not None
         assert span.attributes["foo"] == "bar"
 
-    assert spans[0].name == test_step.__name__
+    assert spans[0].name == test_step.__qualname__
     assert spans[1].name == "a new span"
-    assert spans[2].name == test_workflow.__name__
-    assert spans[3].name == test_step.__name__
+    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 == None
+    assert spans[3].parent.span_id == spans[4].context.span_id  # type: ignore
+    assert spans[4].parent == None
 
 
 @pytest.mark.asyncio
@@ -87,7 +89,7 @@ async def test_spans_async(dbos: DBOS) -> None:
 
     spans = exporter.get_finished_spans()
 
-    assert len(spans) == 4
+    assert len(spans) == 5
 
     for span in spans:
         assert span.attributes is not None
@@ -95,15 +97,17 @@ async def test_spans_async(dbos: DBOS) -> None:
         assert span.attributes["executorID"] == GlobalParams.executor_id
         assert span.context is not None
 
-    assert spans[0].name == test_step.__name__
+    assert spans[0].name == test_step.__qualname__
     assert spans[1].name == "a new span"
-    assert spans[2].name == test_workflow.__name__
-    assert spans[3].name == test_step.__name__
+    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 == None
+    assert spans[3].parent.span_id == spans[4].context.span_id  # type: ignore
+    assert spans[4].parent == None
 
 
 def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
@@ -127,15 +131,17 @@ def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
 
     spans = exporter.get_finished_spans()
 
-    assert len(spans) == 2
+    assert len(spans) == 3
 
     for span in spans:
         assert span.attributes is not None
         assert span.attributes["applicationVersion"] == GlobalParams.app_version
         assert span.context is not None
 
-    assert spans[0].name == test_step_endpoint.__name__
-    assert spans[1].name == "/step"
+    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].parent.span_id == spans[1].context.span_id  # type:ignore
-    assert spans[1].parent == None
+    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