dbos 0.22.0a5__tar.gz → 0.22.0a8__tar.gz

{dbos-0.22.0a5 → dbos-0.22.0a8}/PKG-INFO

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

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_admin_server.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
 _health_check_path = "/dbos-healthz"
 _workflow_recovery_path = "/dbos-workflow-recovery"
 _deactivate_path = "/deactivate"
+_workflow_queues_metadata_path = "/dbos-workflow-queues-metadata"
 # /workflows/:workflow_id/cancel
 # /workflows/:workflow_id/resume
 # /workflows/:workflow_id/restart
@@ -64,6 +65,26 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self.send_response(200)
             self._end_headers()
             self.wfile.write("deactivated".encode("utf-8"))
+        elif self.path == _workflow_queues_metadata_path:
+            queue_metadata_array = []
+            from ._dbos import _get_or_create_dbos_registry
+
+            registry = _get_or_create_dbos_registry()
+            for queue in registry.queue_info_map.values():
+                queue_metadata = {
+                    "name": queue.name,
+                    "concurrency": queue.concurrency,
+                    "workerConcurrency": queue.worker_concurrency,
+                    "rateLimit": queue.limiter,
+                }
+                # Remove keys with None values
+                queue_metadata = {
+                    k: v for k, v in queue_metadata.items() if v is not None
+                }
+                queue_metadata_array.append(queue_metadata)
+            self.send_response(200)
+            self._end_headers()
+            self.wfile.write(json.dumps(queue_metadata_array).encode("utf-8"))
         else:
             self.send_response(404)
             self._end_headers()

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_context.py

@@ -49,7 +49,6 @@ class TracedAttributes(TypedDict, total=False):
 class DBOSContext:
     def __init__(self) -> None:
         self.executor_id = os.environ.get("DBOS__VMID", "local")
-        self.app_version = os.environ.get("DBOS__APPVERSION", "")
         self.app_id = os.environ.get("DBOS__APPID", "")
 
         self.logger = dbos_logger

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_core.py

@@ -163,7 +163,7 @@ def _init_workflow(
         "output": None,
         "error": None,
         "app_id": ctx.app_id,
-        "app_version": ctx.app_version,
+        "app_version": dbos.app_version,
         "executor_id": ctx.executor_id,
         "request": (
             _serialization.serialize(ctx.request) if ctx.request is not None else None

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_dbos.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import asyncio
 import atexit
+import hashlib
+import inspect
 import json
 import os
 import sys
@@ -186,6 +188,22 @@ class DBOSRegistry:
         else:
             self.instance_info_map[fn] = inst
 
+    def compute_app_version(self) -> str:
+        """
+        An application's version is computed from a hash of the source of its workflows.
+        This is guaranteed to be stable given identical source code because it uses an MD5 hash
+        and because it iterates through the workflows in sorted order.
+        This way, if the app's workflows are updated (which would break recovery), its version changes.
+        App version can be manually set through the DBOS__APPVERSION environment variable.
+        """
+        hasher = hashlib.md5()
+        sources = sorted(
+            [inspect.getsource(wf) for wf in self.workflow_info_map.values()]
+        )
+        for source in sources:
+            hasher.update(source.encode("utf-8"))
+        return hasher.hexdigest()
+
 
 class DBOS:
     """
@@ -283,6 +301,7 @@ class DBOS:
         self._executor_field: Optional[ThreadPoolExecutor] = None
         self._background_threads: List[threading.Thread] = []
         self._executor_id: str = os.environ.get("DBOS__VMID", "local")
+        self.app_version: str = os.environ.get("DBOS__APPVERSION", "")
 
         # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
@@ -351,6 +370,10 @@ class DBOS:
                 dbos_logger.warning(f"DBOS was already launched")
                 return
             self._launched = True
+            if self.app_version == "":
+                self.app_version = self._registry.compute_app_version()
+            dbos_logger.info(f"Application version: {self.app_version}")
+            dbos_tracer.app_version = self.app_version
             self._executor_field = ThreadPoolExecutor(max_workers=64)
             self._sys_db_field = SystemDatabase(self.config)
             self._app_db_field = ApplicationDatabase(self.config)
@@ -359,9 +382,19 @@ class DBOS:
                 admin_port = 3001
             self._admin_server_field = AdminServer(dbos=self, port=admin_port)
 
-            if not os.environ.get("DBOS__VMID"):
-                workflow_ids = self._sys_db.get_pending_workflows("local")
-                self._executor.submit(startup_recovery_thread, self, workflow_ids)
+            workflow_ids = self._sys_db.get_pending_workflows(
+                self._executor_id, self.app_version
+            )
+            if (len(workflow_ids)) > 0:
+                self.logger.info(
+                    f"Recovering {len(workflow_ids)} workflows from application version {self.app_version}"
+                )
+            else:
+                self.logger.info(
+                    f"No workflows to recover from application version {self.app_version}"
+                )
+
+            self._executor.submit(startup_recovery_thread, self, workflow_ids)
 
             # Listen to notifications
             notification_listener_thread = threading.Thread(
@@ -398,13 +431,13 @@ class DBOS:
                 self._background_threads.append(poller_thread)
             self._registry.pollers = []
 
-            dbos_logger.info("DBOS launched")
+            dbos_logger.info("DBOS launched!")
 
             # Flush handlers and add OTLP to all loggers if enabled
             # to enable their export in DBOS Cloud
             for handler in dbos_logger.handlers:
                 handler.flush()
-            add_otlp_to_all_loggers()
+            add_otlp_to_all_loggers(self.app_version)
         except Exception:
             dbos_logger.error(f"DBOS failed to launch: {traceback.format_exc()}")
             raise

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_logger.py

@@ -86,8 +86,9 @@ def config_logger(config: "ConfigFile") -> None:
         dbos_logger.addFilter(_otlp_transformer)
 
 
-def add_otlp_to_all_loggers() -> None:
+def add_otlp_to_all_loggers(app_version: str) -> None:
     if _otlp_handler is not None and _otlp_transformer is not None:
+        _otlp_transformer.app_version = app_version
         root = logging.root
 
         root.addHandler(_otlp_handler)

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_recovery.py

@@ -43,12 +43,10 @@ def recover_pending_workflows(
 ) -> List["WorkflowHandle[Any]"]:
     workflow_handles: List["WorkflowHandle[Any]"] = []
     for executor_id in executor_ids:
-        if executor_id == "local" and os.environ.get("DBOS__VMID"):
-            dbos.logger.debug(
-                f"Skip local recovery because it's running in a VM: {os.environ.get('DBOS__VMID')}"
-            )
         dbos.logger.debug(f"Recovering pending workflows for executor: {executor_id}")
-        pending_workflows = dbos._sys_db.get_pending_workflows(executor_id)
+        pending_workflows = dbos._sys_db.get_pending_workflows(
+            executor_id, dbos.app_version
+        )
         for pending_workflow in pending_workflows:
             if (
                 pending_workflow.queue_name
@@ -65,6 +63,7 @@ def recover_pending_workflows(
                 workflow_handles.append(
                     execute_workflow_by_id(dbos, pending_workflow.workflow_uuid)
                 )
-
-    dbos.logger.info("Recovered pending workflows")
+        dbos.logger.info(
+            f"Recovering {len(pending_workflows)} workflows from version {dbos.app_version}"
+        )
     return workflow_handles

{dbos-0.22.0a5 → dbos-0.22.0a8}/dbos/_sys_db.py

@@ -1,4 +1,5 @@
 import datetime
+import logging
 import os
 import re
 import threading
@@ -13,6 +14,7 @@ from typing import (
     Optional,
     Sequence,
     Set,
+    Tuple,
     TypedDict,
     cast,
 )
@@ -22,8 +24,8 @@ import sqlalchemy as sa
 import sqlalchemy.dialects.postgresql as pg
 from alembic import command
 from alembic.config import Config
-from sqlalchemy import or_
 from sqlalchemy.exc import DBAPIError
+from sqlalchemy.sql import func
 
 from . import _serialization
 from ._dbos_config import ConfigFile
@@ -191,7 +193,7 @@ class SystemDatabase:
             database="postgres",
             # fills the "application_name" column in pg_stat_activity
             query={
-                "application_name": f"dbos_transact_{os.environ.get('DBOS__VMID', 'local')}_{os.environ.get('DBOS__APPVERSION', '')}"
+                "application_name": f"dbos_transact_{os.environ.get('DBOS__VMID', 'local')}"
             },
         )
         engine = sa.create_engine(postgres_db_url)
@@ -213,7 +215,7 @@ class SystemDatabase:
             database=sysdb_name,
             # fills the "application_name" column in pg_stat_activity
             query={
-                "application_name": f"dbos_transact_{os.environ.get('DBOS__VMID', 'local')}_{os.environ.get('DBOS__APPVERSION', '')}"
+                "application_name": f"dbos_transact_{os.environ.get('DBOS__VMID', 'local')}"
             },
         )
 
@@ -228,6 +230,7 @@ class SystemDatabase:
         )
         alembic_cfg = Config()
         alembic_cfg.set_main_option("script_location", migration_dir)
+        logging.getLogger("alembic").setLevel(logging.WARNING)
         # Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
         escaped_conn_string = re.sub(
             r"%(?=[0-9A-Fa-f]{2})",
@@ -307,6 +310,7 @@ class SystemDatabase:
                     recovery_attempts=(
                         SystemSchema.workflow_status.c.recovery_attempts + 1
                     ),
+                    updated_at=func.extract("epoch", func.now()) * 1000,
                 ),
             )
         )
@@ -404,6 +408,7 @@ class SystemDatabase:
                     status=status["status"],
                     output=status["output"],
                     error=status["error"],
+                    updated_at=func.extract("epoch", func.now()) * 1000,
                 ),
             )
         )
@@ -767,7 +772,7 @@ class SystemDatabase:
         return GetWorkflowsOutput(workflow_uuids)
 
     def get_pending_workflows(
-        self, executor_id: str
+        self, executor_id: str, app_version: str
     ) -> list[GetPendingWorkflowsOutput]:
         with self.engine.begin() as c:
             rows = c.execute(
@@ -778,8 +783,10 @@ class SystemDatabase:
                     SystemSchema.workflow_status.c.status
                     == WorkflowStatusString.PENDING.value,
                     SystemSchema.workflow_status.c.executor_id == executor_id,
+                    SystemSchema.workflow_status.c.application_version == app_version,
                 )
             ).fetchall()
+
             return [
                 GetPendingWorkflowsOutput(
                     workflow_uuid=row.workflow_uuid,

{dbos-0.22.0a5 → dbos-0.22.0a8}/pyproject.toml

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

{dbos-0.22.0a5 → dbos-0.22.0a8}/tests/test_admin_server.py

@@ -5,7 +5,7 @@ import uuid
 import requests
 
 # Public API
-from dbos import DBOS, ConfigFile, SetWorkflowID, _workflow_commands
+from dbos import DBOS, ConfigFile, Queue, SetWorkflowID, _workflow_commands
 
 
 def test_admin_endpoints(dbos: DBOS) -> None:
@@ -23,6 +23,27 @@ def test_admin_endpoints(dbos: DBOS) -> None:
     assert response.status_code == 200
     assert response.json() == []
 
+    # Test GET /dbos-workflow-queues-metadata
+    Queue("q1")
+    Queue("q2", concurrency=1)
+    Queue("q3", concurrency=1, worker_concurrency=1)
+    Queue("q4", concurrency=1, worker_concurrency=1, limiter={"limit": 0, "period": 0})
+    response = requests.get(
+        "http://localhost:3001/dbos-workflow-queues-metadata", timeout=5
+    )
+    assert response.status_code == 200
+    assert response.json() == [
+        {"name": "q1"},
+        {"name": "q2", "concurrency": 1},
+        {"name": "q3", "concurrency": 1, "workerConcurrency": 1},
+        {
+            "name": "q4",
+            "concurrency": 1,
+            "workerConcurrency": 1,
+            "rateLimit": {"limit": 0, "period": 0},
+        },
+    ]
+
     # Test GET not found
     response = requests.get("http://localhost:3001/stuff", timeout=5)
     assert response.status_code == 404

{dbos-0.22.0a5 → dbos-0.22.0a8}/tests/test_dbos.py

@@ -1,5 +1,8 @@
+# mypy: disable-error-code="no-redef"
+
 import datetime
 import logging
+import os
 import threading
 import time
 import uuid
@@ -71,14 +74,22 @@ def test_simple_workflow_attempts_counter(dbos: DBOS) -> None:
 
     wfuuid = str(uuid.uuid4())
     with dbos._sys_db.engine.connect() as c:
-        stmt = sa.select(SystemSchema.workflow_status.c.recovery_attempts).where(
-            SystemSchema.workflow_status.c.workflow_uuid == wfuuid
-        )
+        stmt = sa.select(
+            SystemSchema.workflow_status.c.recovery_attempts,
+            SystemSchema.workflow_status.c.created_at,
+            SystemSchema.workflow_status.c.updated_at,
+        ).where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
         for i in range(10):
             with SetWorkflowID(wfuuid):
                 noop()
-            result = c.execute(stmt).scalar()
-            assert result == i + 1
+            result = c.execute(stmt).fetchone()
+            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
 
 
 def test_child_workflow(dbos: DBOS) -> None:
@@ -546,10 +557,13 @@ def test_recovery_temp_workflow(dbos: DBOS) -> None:
     assert txn_counter == 1
 
 
-def test_recovery_thread(config: ConfigFile, dbos: DBOS) -> None:
+def test_recovery_thread(config: ConfigFile) -> None:
     wf_counter: int = 0
     test_var = "dbos"
 
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
     @DBOS.workflow()
     def test_workflow(var: str) -> str:
         nonlocal wf_counter
@@ -557,6 +571,8 @@ def test_recovery_thread(config: ConfigFile, dbos: DBOS) -> None:
             wf_counter += 1
         return var
 
+    DBOS.launch()
+
     wfuuid = str(uuid.uuid4())
     with SetWorkflowID(wfuuid):
         assert test_workflow(test_var) == test_var
@@ -584,19 +600,19 @@ def test_recovery_thread(config: ConfigFile, dbos: DBOS) -> None:
         }
     )
 
-    dbos._destroy()  # Unusual pattern - reusing the memory
-    dbos.__init__(config=config)  # type: ignore
+    DBOS.destroy(destroy_registry=True)
+    DBOS(config=config)
 
-    @DBOS.workflow()  # type: ignore
+    @DBOS.workflow()
     def test_workflow(var: str) -> str:
         nonlocal wf_counter
         if var == test_var:
             wf_counter += 1
         return var
 
-    DBOS.launch()  # Usually the framework does this but we destroyed it above
+    DBOS.launch()
 
-    # Upon re-initialization, the background thread should recover the workflow safely.
+    # Upon re-launch, the background thread should recover the workflow safely.
     max_retries = 10
     success = False
     for i in range(max_retries):
@@ -1190,3 +1206,133 @@ def test_destroy_semantics(dbos: DBOS, config: ConfigFile) -> None:
     DBOS.launch()
 
     assert test_workflow(var) == var
+
+
+def test_app_version(config: ConfigFile) -> None:
+    def is_hex(s: str) -> bool:
+        return all(c in "0123456789abcdefABCDEF" for c in s)
+
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def workflow_one(x: int) -> int:
+        return x
+
+    @DBOS.workflow()
+    def workflow_two(y: int) -> int:
+        return y
+
+    DBOS.launch()
+
+    # Verify that app version is correctly set to a hex string
+    app_version = dbos.app_version
+    assert len(app_version) > 0
+    assert is_hex(app_version)
+
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def workflow_one(x: int) -> int:
+        return x
+
+    @DBOS.workflow()
+    def workflow_two(y: int) -> int:
+        return y
+
+    DBOS.launch()
+
+    # Verify stability--the same workflow source produces the same app version.
+    assert dbos.app_version == app_version
+
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def workflow_one(x: int) -> int:
+        return x
+
+    # Verify that changing the workflow source changes the workflow version
+    DBOS.launch()
+    assert dbos.app_version != app_version
+
+    # Verify that version can be overriden with an environment variable
+    app_version = "12345"
+    os.environ["DBOS__APPVERSION"] = app_version
+
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def workflow_one(x: int) -> int:
+        return x
+
+    DBOS.launch()
+    assert dbos.app_version == app_version
+
+    del os.environ["DBOS__APPVERSION"]
+
+
+def test_recovery_appversion(config: ConfigFile) -> None:
+    input = 5
+
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def test_workflow(x: int) -> int:
+        return x
+
+    DBOS.launch()
+
+    wfuuid = str(uuid.uuid4())
+    with SetWorkflowID(wfuuid):
+        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)
+            .values({"status": "PENDING", "name": test_workflow.__qualname__})
+            .where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
+        )
+
+    # Reconstruct an identical environment to simulate a restart
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def test_workflow(x: int) -> int:
+        return x
+
+    DBOS.launch()
+
+    # The workflow should successfully recover
+    workflow_handles = DBOS.recover_pending_workflows()
+    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)
+            .values({"status": "PENDING", "name": test_workflow.__qualname__})
+            .where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
+        )
+
+    # Now reconstruct a "modified application" with a different application version
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.workflow()
+    def test_workflow(x: int) -> int:
+        return x + 1
+
+    DBOS.launch()
+
+    # The workflow should not recover
+    workflow_handles = DBOS.recover_pending_workflows()
+    assert len(workflow_handles) == 0

{dbos-0.22.0a5 → dbos-0.22.0a8}/tests/test_spans.py

@@ -36,6 +36,7 @@ def test_spans(dbos: DBOS) -> None:
 
     for span in spans:
         assert span.attributes is not None
+        assert span.attributes["applicationVersion"] == dbos.app_version
         assert span.context is not None
 
     assert spans[0].name == test_step.__name__
@@ -73,6 +74,7 @@ async def test_spans_async(dbos: DBOS) -> None:
 
     for span in spans:
         assert span.attributes is not None
+        assert span.attributes["applicationVersion"] == dbos.app_version
         assert span.context is not None
 
     assert spans[0].name == test_step.__name__
@@ -85,7 +87,7 @@ async def test_spans_async(dbos: DBOS) -> None:
 
 
 def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
-    _, app = dbos_fastapi
+    dbos, app = dbos_fastapi
 
     @app.get("/step")
     @DBOS.step()
@@ -109,6 +111,7 @@ def test_temp_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
 
     for span in spans:
         assert span.attributes is not None
+        assert span.attributes["applicationVersion"] == dbos.app_version
         assert span.context is not None
 
     assert spans[0].name == test_step_endpoint.__name__