dbos 0.22.0a7__tar.gz → 0.22.0a8__tar.gz

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

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

{dbos-0.22.0a7 → 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.0a7 → 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.0a7 → 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.0a7 → 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.0a7 → 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.0a7 → 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,
 )
@@ -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})",
@@ -769,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(
@@ -780,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.0a7 → dbos-0.22.0a8}/pyproject.toml

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

{dbos-0.22.0a7 → 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
@@ -554,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
@@ -565,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
@@ -592,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):
@@ -1198,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.0a7 → 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__