dbos 1.8.0a1__tar.gz → 1.8.0a3__tar.gz

{dbos-1.8.0a1 → dbos-1.8.0a3}/PKG-INFO

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

{dbos-1.8.0a1 → dbos-1.8.0a3}/dbos/_context.py

@@ -10,7 +10,7 @@ from enum import Enum
 from types import TracebackType
 from typing import List, Literal, Optional, Type, TypedDict
 
-from opentelemetry.trace import Span, Status, StatusCode
+from opentelemetry.trace import Span, Status, StatusCode, use_span
 from sqlalchemy.orm import Session
 
 from dbos._utils import GlobalParams
@@ -68,6 +68,20 @@ class StepStatus:
     max_attempts: Optional[int]
 
 
+@dataclass
+class ContextSpan:
+    """
+    A span that is used to track the context of a workflow or step execution.
+
+    Attributes:
+        span: The OpenTelemetry span object.
+        context_manager: The context manager that is used to manage the span's lifecycle.
+    """
+
+    span: Span
+    context_manager: AbstractContextManager[Span]
+
+
 class DBOSContext:
     def __init__(self) -> None:
         self.executor_id = GlobalParams.executor_id
@@ -86,7 +100,7 @@ class DBOSContext:
         self.curr_step_function_id: int = -1
         self.curr_tx_function_id: int = -1
         self.sql_session: Optional[Session] = None
-        self.spans: list[Span] = []
+        self.context_spans: list[ContextSpan] = []
 
         self.authenticated_user: Optional[str] = None
         self.authenticated_roles: Optional[List[str]] = None
@@ -202,8 +216,8 @@ class DBOSContext:
         self._end_span(exc_value)
 
     def get_current_span(self) -> Optional[Span]:
-        if len(self.spans):
-            return self.spans[-1]
+        if len(self.context_spans) > 0:
+            return self.context_spans[-1].span
         return None
 
     def _start_span(self, attributes: TracedAttributes) -> None:
@@ -218,27 +232,38 @@ class DBOSContext:
         )
         attributes["authenticatedUserAssumedRole"] = self.assumed_role
         span = dbos_tracer.start_span(
-            attributes, parent=self.spans[-1] if len(self.spans) > 0 else None
+            attributes,
+            parent=self.context_spans[-1].span if len(self.context_spans) > 0 else None,
+        )
+        # Activate the current span
+        cm = use_span(
+            span,
+            end_on_exit=False,
+            record_exception=False,
+            set_status_on_exception=False,
         )
-        self.spans.append(span)
+        self.context_spans.append(ContextSpan(span, cm))
+        cm.__enter__()
 
     def _end_span(self, exc_value: Optional[BaseException]) -> None:
+        context_span = self.context_spans.pop()
         if exc_value is None:
-            self.spans[-1].set_status(Status(StatusCode.OK))
+            context_span.span.set_status(Status(StatusCode.OK))
         else:
-            self.spans[-1].set_status(
+            context_span.span.set_status(
                 Status(StatusCode.ERROR, description=str(exc_value))
             )
-        dbos_tracer.end_span(self.spans.pop())
+        dbos_tracer.end_span(context_span.span)
+        context_span.context_manager.__exit__(None, None, None)
 
     def set_authentication(
         self, user: Optional[str], roles: Optional[List[str]]
     ) -> None:
         self.authenticated_user = user
         self.authenticated_roles = roles
-        if user is not None and len(self.spans) > 0:
-            self.spans[-1].set_attribute("authenticatedUser", user)
-            self.spans[-1].set_attribute(
+        if user is not None and len(self.context_spans) > 0:
+            self.context_spans[-1].span.set_attribute("authenticatedUser", user)
+            self.context_spans[-1].span.set_attribute(
                 "authenticatedUserRoles", json.dumps(roles) if roles is not None else ""
             )
 

{dbos-1.8.0a1 → dbos-1.8.0a3}/dbos/_error.py

@@ -126,7 +126,7 @@ class DBOSDeadLetterQueueError(DBOSException):
 
     def __init__(self, wf_id: str, max_retries: int):
         super().__init__(
-            f"Workflow {wf_id} has been moved to the dead-letter queue after exceeding the maximum of ${max_retries} retries",
+            f"Workflow {wf_id} has been moved to the dead-letter queue after exceeding the maximum of {max_retries} retries",
             dbos_error_code=DBOSErrorCode.DeadLetterQueueError.value,
         )
 

{dbos-1.8.0a1 → dbos-1.8.0a3}/dbos/_sys_db.py

@@ -437,7 +437,14 @@ class SystemDatabase:
 
         # Values to update when a row already exists for this workflow
         update_values: dict[str, Any] = {
-            "recovery_attempts": SystemSchema.workflow_status.c.recovery_attempts + 1,
+            "recovery_attempts": sa.case(
+                (
+                    SystemSchema.workflow_status.c.status
+                    != WorkflowStatusString.ENQUEUED.value,
+                    SystemSchema.workflow_status.c.recovery_attempts + 1,
+                ),
+                else_=SystemSchema.workflow_status.c.recovery_attempts,
+            ),
             "updated_at": func.extract("epoch", func.now()) * 1000,
         }
         # Don't update an existing executor ID when enqueueing a workflow.

{dbos-1.8.0a1 → dbos-1.8.0a3}/pyproject.toml

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

{dbos-1.8.0a1 → dbos-1.8.0a3}/tests/test_queue.py

@@ -1016,6 +1016,13 @@ def test_dlq_enqueued_workflows(dbos: DBOS) -> None:
     blocked_handle = queue.enqueue(blocked_workflow)
     regular_handle = queue.enqueue(regular_workflow)
 
+    # Enqueue the blocked workflow repeatedly, verify recovery attempts is not increased
+    for _ in range(max_recovery_attempts):
+        with SetWorkflowID(blocked_handle.workflow_id):
+            queue.enqueue(blocked_workflow)
+    recovery_attempts = blocked_handle.get_status().recovery_attempts
+    assert recovery_attempts is not None and recovery_attempts <= 1
+
     # Verify that the blocked workflow starts and is PENDING while the regular workflow remains ENQUEUED.
     start_event.wait()
     assert blocked_handle.get_status().status == WorkflowStatusString.PENDING.value

dbos-1.8.0a3/tests/test_spans.py

@@ -0,0 +1,272 @@
+from typing import Tuple
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.sdk import trace as tracesdk
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, InMemoryLogExporter
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from opentelemetry.trace.span import format_trace_id
+
+from dbos import DBOS, DBOSConfig
+from dbos._logger import dbos_logger
+from dbos._tracer import dbos_tracer
+from dbos._utils import GlobalParams
+
+
+def test_spans(config: DBOSConfig) -> None:
+    DBOS.destroy(destroy_registry=True)
+    config["otlp_attributes"] = {"foo": "bar"}
+    DBOS(config=config)
+    DBOS.launch()
+
+    @DBOS.workflow()
+    def test_workflow() -> None:
+        test_step()
+        current_span = DBOS.span
+        subspan = DBOS.tracer.start_span({"name": "a new span"}, parent=current_span)
+        # Note: DBOS.tracer.start_span() does not set the new span as the current span. So this log is still attached to the workflow span.
+        DBOS.logger.info("This is a test_workflow")
+        subspan.add_event("greeting_event", {"name": "a new event"})
+        DBOS.tracer.end_span(subspan)
+
+    @DBOS.step()
+    def test_step() -> None:
+        DBOS.logger.info("This is a test_step")
+        return
+
+    exporter = InMemorySpanExporter()
+    span_processor = SimpleSpanProcessor(exporter)
+    provider = tracesdk.TracerProvider()
+    provider.add_span_processor(span_processor)
+    dbos_tracer.set_provider(provider)
+
+    # Set up in-memory log exporter
+    log_exporter = InMemoryLogExporter()  # type: ignore
+    log_processor = BatchLogRecordProcessor(log_exporter)
+    log_provider = LoggerProvider()
+    log_provider.add_log_record_processor(log_processor)
+    set_logger_provider(log_provider)
+    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
+    for log in logs:
+        assert log.log_record.attributes is not None
+        assert (
+            log.log_record.attributes["applicationVersion"] == GlobalParams.app_version
+        )
+        assert log.log_record.attributes["executorID"] == GlobalParams.executor_id
+        assert log.log_record.attributes["foo"] == "bar"
+        # Make sure the log record has a span_id and trace_id
+        assert log.log_record.span_id is not None and log.log_record.span_id > 0
+        assert log.log_record.trace_id is not None and log.log_record.trace_id > 0
+        assert (
+            log.log_record.body == "This is a test_step"
+            or log.log_record.body == "This is a test_workflow"
+        )
+        assert log.log_record.attributes["traceId"] == format_trace_id(
+            log.log_record.trace_id
+        )
+
+    spans = exporter.get_finished_spans()
+
+    assert len(spans) == 5
+
+    for span in spans:
+        assert span.attributes is not None
+        assert span.attributes["applicationVersion"] == GlobalParams.app_version
+        assert span.attributes["executorID"] == GlobalParams.executor_id
+        assert span.context is not None
+        assert span.attributes["foo"] == "bar"
+        assert span.context.span_id > 0
+        assert span.context.trace_id > 0
+
+    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
+async def test_spans_async(dbos: DBOS) -> None:
+
+    @DBOS.workflow()
+    async def test_workflow() -> None:
+        await test_step()
+        current_span = DBOS.span
+        subspan = DBOS.tracer.start_span({"name": "a new span"}, parent=current_span)
+        # Note: DBOS.tracer.start_span() does not set the new span as the current span. So this log is still attached to the workflow span.
+        DBOS.logger.info("This is a test_workflow")
+        subspan.add_event("greeting_event", {"name": "a new event"})
+        DBOS.tracer.end_span(subspan)
+
+    @DBOS.step()
+    async def test_step() -> None:
+        DBOS.logger.info("This is a test_step")
+        return
+
+    exporter = InMemorySpanExporter()
+    span_processor = SimpleSpanProcessor(exporter)
+    provider = tracesdk.TracerProvider()
+    provider.add_span_processor(span_processor)
+    dbos_tracer.set_provider(provider)
+
+    # Set up in-memory log exporter
+    log_exporter = InMemoryLogExporter()  # type: ignore
+    log_processor = BatchLogRecordProcessor(log_exporter)
+    log_provider = LoggerProvider()
+    log_provider.add_log_record_processor(log_processor)
+    set_logger_provider(log_provider)
+    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
+    for log in logs:
+        assert log.log_record.attributes is not None
+        assert (
+            log.log_record.attributes["applicationVersion"] == GlobalParams.app_version
+        )
+        assert log.log_record.attributes["executorID"] == GlobalParams.executor_id
+        # Make sure the log record has a span_id and trace_id
+        assert log.log_record.span_id is not None and log.log_record.span_id > 0
+        assert log.log_record.trace_id is not None and log.log_record.trace_id > 0
+        assert (
+            log.log_record.body == "This is a test_step"
+            or log.log_record.body == "This is a test_workflow"
+        )
+        assert log.log_record.attributes["traceId"] == format_trace_id(
+            log.log_record.trace_id
+        )
+
+    spans = exporter.get_finished_spans()
+
+    assert len(spans) == 5
+
+    for span in spans:
+        assert span.attributes is not None
+        assert span.attributes["applicationVersion"] == GlobalParams.app_version
+        assert span.attributes["executorID"] == GlobalParams.executor_id
+        assert span.context is not None
+        assert span.context.span_id > 0
+        assert span.context.trace_id > 0
+
+    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:
+    dbos, app = dbos_fastapi
+
+    @app.get("/step")
+    @DBOS.step()
+    def test_step_endpoint() -> str:
+        dbos.logger.info("This is a test_step_endpoint")
+        return "test"
+
+    exporter = InMemorySpanExporter()
+    span_processor = SimpleSpanProcessor(exporter)
+    provider = tracesdk.TracerProvider()
+    provider.add_span_processor(span_processor)
+    dbos_tracer.set_provider(provider)
+
+    # Set up in-memory log exporter
+    log_exporter = InMemoryLogExporter()  # type: ignore
+    log_processor = BatchLogRecordProcessor(log_exporter)
+    log_provider = LoggerProvider()
+    log_provider.add_log_record_processor(log_processor)
+    set_logger_provider(log_provider)
+    dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
+
+    client = TestClient(app)
+    response = client.get("/step")
+    assert response.status_code == 200
+    assert response.text == '"test"'
+
+    log_processor.force_flush(timeout_millis=5000)
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 1
+    assert logs[0].log_record.attributes is not None
+    assert (
+        logs[0].log_record.attributes["applicationVersion"] == GlobalParams.app_version
+    )
+    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.attributes["traceId"] == format_trace_id(
+        logs[0].log_record.trace_id
+    )
+
+    spans = exporter.get_finished_spans()
+
+    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 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].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
+
+    # Span ID and trace ID should match the log record
+    assert spans[0].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

{dbos-1.8.0a1 → dbos-1.8.0a3}/tests/test_workflow_management.py

@@ -745,4 +745,4 @@ def test_global_timeout(dbos: DBOS) -> None:
         with pytest.raises(DBOSWorkflowCancelledError):
             handle.get_result()
     event.set()
-    final_handle.get_result() is not None
+    assert final_handle.get_result() is not None

dbos-1.8.0a1/tests/test_spans.py

@@ -1,147 +0,0 @@
-from typing import Tuple
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-from opentelemetry.sdk import trace as tracesdk
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
-
-from dbos import DBOS, DBOSConfig
-from dbos._tracer import dbos_tracer
-from dbos._utils import GlobalParams
-
-
-def test_spans(config: DBOSConfig) -> None:
-    DBOS.destroy(destroy_registry=True)
-    config["otlp_attributes"] = {"foo": "bar"}
-    DBOS(config=config)
-    DBOS.launch()
-
-    @DBOS.workflow()
-    def test_workflow() -> None:
-        test_step()
-        current_span = DBOS.span
-        subspan = DBOS.tracer.start_span({"name": "a new span"}, parent=current_span)
-        subspan.add_event("greeting_event", {"name": "a new event"})
-        DBOS.tracer.end_span(subspan)
-
-    @DBOS.step()
-    def test_step() -> None:
-        return
-
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
-
-    test_workflow()
-    test_step()
-
-    spans = exporter.get_finished_spans()
-
-    assert len(spans) == 5
-
-    for span in spans:
-        assert span.attributes is not None
-        assert span.attributes["applicationVersion"] == GlobalParams.app_version
-        assert span.attributes["executorID"] == GlobalParams.executor_id
-        assert span.context is not None
-        assert span.attributes["foo"] == "bar"
-
-    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
-
-
-@pytest.mark.asyncio
-async def test_spans_async(dbos: DBOS) -> None:
-
-    @DBOS.workflow()
-    async def test_workflow() -> None:
-        await test_step()
-        current_span = DBOS.span
-        subspan = DBOS.tracer.start_span({"name": "a new span"}, parent=current_span)
-        subspan.add_event("greeting_event", {"name": "a new event"})
-        DBOS.tracer.end_span(subspan)
-
-    @DBOS.step()
-    async def test_step() -> None:
-        return
-
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
-
-    await test_workflow()
-    await test_step()
-
-    spans = exporter.get_finished_spans()
-
-    assert len(spans) == 5
-
-    for span in spans:
-        assert span.attributes is not None
-        assert span.attributes["applicationVersion"] == GlobalParams.app_version
-        assert span.attributes["executorID"] == GlobalParams.executor_id
-        assert span.context is not 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
-
-
-def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
-    dbos, app = dbos_fastapi
-
-    @app.get("/step")
-    @DBOS.step()
-    def test_step_endpoint() -> str:
-        return "test"
-
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
-
-    client = TestClient(app)
-    response = client.get("/step")
-    assert response.status_code == 200
-    assert response.text == '"test"'
-
-    spans = exporter.get_finished_spans()
-
-    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.__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.span_id == spans[2].context.span_id  # type: ignore
-    assert spans[2].parent == None