dbos 1.12.0a3__tar.gz → 1.13.0a3__tar.gz

{dbos-1.12.0a3 → dbos-1.13.0a3}/PKG-INFO

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

dbos-1.13.0a3/dbos/_alembic_migrations/versions/471b60d64126_dbos_migrations.py

@@ -0,0 +1,35 @@
+"""dbos_migrations
+
+Revision ID: 471b60d64126
+Revises: 01ce9f07bd10
+Create Date: 2025-08-21 14:22:31.455266
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "471b60d64126"
+down_revision: Union[str, None] = "01ce9f07bd10"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Create dbos_migrations table
+    op.create_table(
+        "dbos_migrations",
+        sa.Column("version", sa.BigInteger(), nullable=False),
+        sa.PrimaryKeyConstraint("version"),
+        schema="dbos",
+    )
+
+    # Insert initial version 1
+    op.execute("INSERT INTO dbos.dbos_migrations (version) VALUES (1)")
+
+
+def downgrade() -> None:
+    op.drop_table("dbos_migrations", schema="dbos")

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_context.py

@@ -221,6 +221,8 @@ class DBOSContext:
         return None
 
     def _start_span(self, attributes: TracedAttributes) -> None:
+        if dbos_tracer.disable_otlp:
+            return
         attributes["operationUUID"] = (
             self.workflow_id if len(self.workflow_id) > 0 else None
         )
@@ -246,6 +248,8 @@ class DBOSContext:
         cm.__enter__()
 
     def _end_span(self, exc_value: Optional[BaseException]) -> None:
+        if dbos_tracer.disable_otlp:
+            return
         context_span = self.context_spans.pop()
         if exc_value is None:
             context_span.span.set_status(Status(StatusCode.OK))

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_core.py

@@ -356,6 +356,7 @@ def _get_wf_invoke_func(
             )
             return recorded_result
         try:
+            dbos._active_workflows_set.add(status["workflow_uuid"])
             output = func()
             if not dbos.debug_mode:
                 dbos._sys_db.update_workflow_outcome(
@@ -378,6 +379,8 @@ def _get_wf_invoke_func(
                     error=_serialization.serialize_exception(error),
                 )
             raise
+        finally:
+            dbos._active_workflows_set.discard(status["workflow_uuid"])
 
     return persist
 

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_dbos.py

@@ -293,16 +293,24 @@ class DBOS:
         return _dbos_global_instance
 
     @classmethod
-    def destroy(cls, *, destroy_registry: bool = False) -> None:
+    def destroy(
+        cls,
+        *,
+        destroy_registry: bool = False,
+        workflow_completion_timeout_sec: int = 0,
+    ) -> None:
         global _dbos_global_instance
         if _dbos_global_instance is not None:
-            _dbos_global_instance._destroy()
+            _dbos_global_instance._destroy(
+                workflow_completion_timeout_sec=workflow_completion_timeout_sec,
+            )
         _dbos_global_instance = None
         if destroy_registry:
             global _dbos_global_registry
             _dbos_global_registry = None
         GlobalParams.app_version = os.environ.get("DBOS__APPVERSION", "")
         GlobalParams.executor_id = os.environ.get("DBOS__VMID", "local")
+        dbos_logger.info("DBOS successfully shut down")
 
     def __init__(
         self,
@@ -337,6 +345,7 @@ class DBOS:
         self.conductor_key: Optional[str] = conductor_key
         self.conductor_websocket: Optional[ConductorWebsocket] = None
         self._background_event_loop: BackgroundEventLoop = BackgroundEventLoop()
+        self._active_workflows_set: set[str] = set()
 
         # Globally set the application version and executor ID.
         # In DBOS Cloud, instead use the values supplied through environment variables.
@@ -588,12 +597,23 @@ class DBOS:
 
         reset_system_database(pg_db_url, sysdb_name)
 
-    def _destroy(self) -> None:
+    def _destroy(self, *, workflow_completion_timeout_sec: int) -> None:
         self._initialized = False
         for event in self.poller_stop_events:
             event.set()
         for event in self.background_thread_stop_events:
             event.set()
+        if workflow_completion_timeout_sec > 0:
+            deadline = time.time() + workflow_completion_timeout_sec
+            while time.time() < deadline:
+                time.sleep(1)
+                active_workflows = len(self._active_workflows_set)
+                if active_workflows > 0:
+                    dbos_logger.info(
+                        f"Attempting to shut down DBOS. {active_workflows} workflows remain active. IDs: {self._active_workflows_set}"
+                    )
+                else:
+                    break
         self._background_event_loop.stop()
         if self._sys_db_field is not None:
             self._sys_db_field.destroy()
@@ -609,10 +629,8 @@ class DBOS:
             and self.conductor_websocket.websocket is not None
         ):
             self.conductor_websocket.websocket.close()
-        # CB - This needs work, some things ought to stop before DBs are tossed out,
-        #  on the other hand it hangs to move it
         if self._executor_field is not None:
-            self._executor_field.shutdown(cancel_futures=True)
+            self._executor_field.shutdown(wait=False, cancel_futures=True)
             self._executor_field = None
         for bg_thread in self._background_threads:
             bg_thread.join()

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_dbos_config.py

@@ -33,6 +33,9 @@ class DBOSConfig(TypedDict, total=False):
         admin_port (int): Admin port
         run_admin_server (bool): Whether to run the DBOS admin server
         otlp_attributes (dict[str, str]): A set of custom attributes to apply OTLP-exported logs and traces
+        application_version (str): Application version
+        executor_id (str): Executor ID, used to identify the application instance in distributed environments
+        disable_otlp (bool): If True, disables OTLP tracing and logging. Defaults to False.
     """
 
     name: str
@@ -49,6 +52,7 @@ class DBOSConfig(TypedDict, total=False):
     otlp_attributes: Optional[dict[str, str]]
     application_version: Optional[str]
     executor_id: Optional[str]
+    disable_otlp: Optional[bool]
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -91,6 +95,7 @@ class TelemetryConfig(TypedDict, total=False):
     logs: Optional[LoggerConfig]
     OTLPExporter: Optional[OTLPExporterConfig]
     otlp_attributes: Optional[dict[str, str]]
+    disable_otlp: Optional[bool]
 
 
 class ConfigFile(TypedDict, total=False):
@@ -157,6 +162,7 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
     telemetry: TelemetryConfig = {
         "OTLPExporter": {"tracesEndpoint": [], "logsEndpoint": []},
         "otlp_attributes": config.get("otlp_attributes", {}),
+        "disable_otlp": config.get("disable_otlp", False),
     }
     # For mypy
     assert telemetry["OTLPExporter"] is not None

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_fastapi.py

@@ -49,7 +49,7 @@ class LifespanMiddleware:
                     if not self.dbos._launched:
                         self.dbos._launch()
                 elif message["type"] == "lifespan.shutdown.complete":
-                    self.dbos._destroy()
+                    self.dbos.destroy()
                 await send(message)
 
             # Call the original app with our wrapped functions

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_logger.py

@@ -77,7 +77,9 @@ def config_logger(config: "ConfigFile") -> None:
     otlp_logs_endpoints = (
         config.get("telemetry", {}).get("OTLPExporter", {}).get("logsEndpoint")  # type: ignore
     )
-    if otlp_logs_endpoints:
+    disable_otlp = config.get("telemetry", {}).get("disable_otlp", False)  # type: ignore
+
+    if not disable_otlp and otlp_logs_endpoints:
         log_provider = PatchedOTLPLoggerProvider(
             Resource.create(
                 attributes={

dbos-1.13.0a3/dbos/_migration.py

@@ -0,0 +1,233 @@
+import logging
+import os
+import re
+
+import sqlalchemy as sa
+from alembic import command
+from alembic.config import Config
+
+from ._logger import dbos_logger
+
+
+def ensure_dbos_schema(engine: sa.Engine) -> bool:
+    """
+    True if using DBOS migrations (DBOS schema and migrations table already exist or were created)
+    False if using Alembic migrations (DBOS schema exists, but dbos_migrations table doesn't)
+    """
+    with engine.begin() as conn:
+        # Check if dbos schema exists
+        schema_result = conn.execute(
+            sa.text(
+                "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'dbos'"
+            )
+        )
+        schema_existed = schema_result.fetchone() is not None
+
+        # Create schema if it doesn't exist
+        if not schema_existed:
+            conn.execute(sa.text("CREATE SCHEMA dbos"))
+
+        # Check if dbos_migrations table exists
+        table_result = conn.execute(
+            sa.text(
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'dbos' AND table_name = 'dbos_migrations'"
+            )
+        )
+        table_exists = table_result.fetchone() is not None
+
+        if table_exists:
+            return True
+        elif schema_existed:
+            return False
+        else:
+            conn.execute(
+                sa.text(
+                    "CREATE TABLE dbos.dbos_migrations (version BIGINT NOT NULL PRIMARY KEY)"
+                )
+            )
+            return True
+
+
+def run_alembic_migrations(engine: sa.Engine) -> None:
+    """Run system database schema migrations with Alembic.
+    This is DEPRECATED in favor of DBOS-managed migrations.
+    It is retained only for backwards compatibility and
+    will be removed in the next major version."""
+    # Run a schema migration for the system database
+    migration_dir = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)), "_alembic_migrations"
+    )
+    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})",
+        "%%",
+        engine.url.render_as_string(hide_password=False),
+    )
+    alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
+    try:
+        command.upgrade(alembic_cfg, "head")
+    except Exception as e:
+        dbos_logger.warning(
+            f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
+        )
+
+
+def run_dbos_migrations(engine: sa.Engine) -> None:
+    """Run DBOS-managed migrations by executing each SQL command in dbos_migrations."""
+    with engine.begin() as conn:
+        # Get current migration version
+        result = conn.execute(sa.text("SELECT version FROM dbos.dbos_migrations"))
+        current_version = result.fetchone()
+        last_applied = current_version[0] if current_version else 0
+
+        # Apply migrations starting from the next version
+        for i, migration_sql in enumerate(dbos_migrations, 1):
+            if i <= last_applied:
+                continue
+
+            # Execute the migration
+            dbos_logger.info(f"Applying DBOS system database schema migration {i}")
+            conn.execute(sa.text(migration_sql))
+
+            # Update the single row with the new version
+            if last_applied == 0:
+                conn.execute(
+                    sa.text(
+                        "INSERT INTO dbos.dbos_migrations (version) VALUES (:version)"
+                    ),
+                    {"version": i},
+                )
+            else:
+                conn.execute(
+                    sa.text("UPDATE dbos.dbos_migrations SET version = :version"),
+                    {"version": i},
+                )
+            last_applied = i
+
+
+dbos_migration_one = """
+-- Enable uuid extension for generating UUIDs
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE dbos.workflow_status (
+    workflow_uuid TEXT PRIMARY KEY,
+    status TEXT,
+    name TEXT,
+    authenticated_user TEXT,
+    assumed_role TEXT,
+    authenticated_roles TEXT,
+    request TEXT,
+    output TEXT,
+    error TEXT,
+    executor_id TEXT,
+    created_at BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
+    updated_at BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
+    application_version TEXT,
+    application_id TEXT,
+    class_name VARCHAR(255) DEFAULT NULL,
+    config_name VARCHAR(255) DEFAULT NULL,
+    recovery_attempts BIGINT DEFAULT 0,
+    queue_name TEXT,
+    workflow_timeout_ms BIGINT,
+    workflow_deadline_epoch_ms BIGINT,
+    inputs TEXT,
+    started_at_epoch_ms BIGINT,
+    deduplication_id TEXT,
+    priority INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX workflow_status_created_at_index ON dbos.workflow_status (created_at);
+CREATE INDEX workflow_status_executor_id_index ON dbos.workflow_status (executor_id);
+CREATE INDEX workflow_status_status_index ON dbos.workflow_status (status);
+
+ALTER TABLE dbos.workflow_status 
+ADD CONSTRAINT uq_workflow_status_queue_name_dedup_id 
+UNIQUE (queue_name, deduplication_id);
+
+CREATE TABLE dbos.operation_outputs (
+    workflow_uuid TEXT NOT NULL,
+    function_id INTEGER NOT NULL,
+    function_name TEXT NOT NULL DEFAULT '',
+    output TEXT,
+    error TEXT,
+    child_workflow_id TEXT,
+    PRIMARY KEY (workflow_uuid, function_id),
+    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE dbos.notifications (
+    destination_uuid TEXT NOT NULL,
+    topic TEXT,
+    message TEXT NOT NULL,
+    created_at_epoch_ms BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
+    message_uuid TEXT NOT NULL DEFAULT gen_random_uuid(), -- Built-in function
+    FOREIGN KEY (destination_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX idx_workflow_topic ON dbos.notifications (destination_uuid, topic);
+
+-- Create notification function
+CREATE OR REPLACE FUNCTION dbos.notifications_function() RETURNS TRIGGER AS $$
+DECLARE
+    payload text := NEW.destination_uuid || '::' || NEW.topic;
+BEGIN
+    PERFORM pg_notify('dbos_notifications_channel', payload);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create notification trigger
+CREATE TRIGGER dbos_notifications_trigger
+AFTER INSERT ON dbos.notifications
+FOR EACH ROW EXECUTE FUNCTION dbos.notifications_function();
+
+CREATE TABLE dbos.workflow_events (
+    workflow_uuid TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    PRIMARY KEY (workflow_uuid, key),
+    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+-- Create events function
+CREATE OR REPLACE FUNCTION dbos.workflow_events_function() RETURNS TRIGGER AS $$
+DECLARE
+    payload text := NEW.workflow_uuid || '::' || NEW.key;
+BEGIN
+    PERFORM pg_notify('dbos_workflow_events_channel', payload);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create events trigger
+CREATE TRIGGER dbos_workflow_events_trigger
+AFTER INSERT ON dbos.workflow_events
+FOR EACH ROW EXECUTE FUNCTION dbos.workflow_events_function();
+
+CREATE TABLE dbos.streams (
+    workflow_uuid TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    "offset" INTEGER NOT NULL,
+    PRIMARY KEY (workflow_uuid, key, "offset"),
+    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE dbos.event_dispatch_kv (
+    service_name TEXT NOT NULL,
+    workflow_fn_name TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT,
+    update_seq NUMERIC(38,0),
+    update_time NUMERIC(38,15),
+    PRIMARY KEY (service_name, workflow_fn_name, key)
+);
+"""
+
+dbos_migrations = [dbos_migration_one]

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_sys_db.py

@@ -1,10 +1,7 @@
 import datetime
 import functools
 import json
-import logging
-import os
 import random
-import re
 import threading
 import time
 from enum import Enum
@@ -25,11 +22,14 @@ from typing import (
 import psycopg
 import sqlalchemy as sa
 import sqlalchemy.dialects.postgresql as pg
-from alembic import command
-from alembic.config import Config
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.sql import func
 
+from dbos._migration import (
+    ensure_dbos_schema,
+    run_alembic_migrations,
+    run_dbos_migrations,
+)
 from dbos._utils import INTERNAL_QUEUE_NAME, retriable_postgres_exception
 
 from . import _serialization
@@ -386,41 +386,11 @@ class SystemDatabase:
                 conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
         engine.dispose()
 
-        # Run a schema migration for the system database
-        migration_dir = os.path.join(
-            os.path.dirname(os.path.realpath(__file__)), "_migrations"
-        )
-        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})",
-            "%%",
-            self.engine.url.render_as_string(hide_password=False),
-        )
-        alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
-        try:
-            command.upgrade(alembic_cfg, "head")
-        except Exception as e:
-            dbos_logger.warning(
-                f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
-            )
-            alembic_cfg = Config()
-            alembic_cfg.set_main_option("script_location", migration_dir)
-            # Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
-            escaped_conn_string = re.sub(
-                r"%(?=[0-9A-Fa-f]{2})",
-                "%%",
-                self.engine.url.render_as_string(hide_password=False),
-            )
-            alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
-            try:
-                command.upgrade(alembic_cfg, "head")
-            except Exception as e:
-                dbos_logger.warning(
-                    f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
-                )
+        using_dbos_migrations = ensure_dbos_schema(self.engine)
+        if not using_dbos_migrations:
+            # Complete the Alembic migrations, create the dbos_migrations table
+            run_alembic_migrations(self.engine)
+        run_dbos_migrations(self.engine)
 
     # Destroy the pool when finished
     def destroy(self) -> None:

{dbos-1.12.0a3 → dbos-1.13.0a3}/dbos/_tracer.py

@@ -24,10 +24,14 @@ class DBOSTracer:
     def __init__(self) -> None:
         self.app_id = os.environ.get("DBOS__APPID", None)
         self.provider: Optional[TracerProvider] = None
+        self.disable_otlp: bool = False
 
     def config(self, config: ConfigFile) -> None:
         self.otlp_attributes = config.get("telemetry", {}).get("otlp_attributes", {})  # type: ignore
-        if not isinstance(trace.get_tracer_provider(), TracerProvider):
+        self.disable_otlp = config.get("telemetry", {}).get("disable_otlp", False)  # type: ignore
+        if not self.disable_otlp and not isinstance(
+            trace.get_tracer_provider(), TracerProvider
+        ):
             resource = Resource(
                 attributes={
                     ResourceAttributes.SERVICE_NAME: config["name"],

{dbos-1.12.0a3 → dbos-1.13.0a3}/pyproject.toml

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

{dbos-1.12.0a3 → dbos-1.13.0a3}/tests/test_dbos.py

@@ -27,7 +27,7 @@ from dbos._context import assert_current_dbos_context, get_local_dbos_context
 from dbos._error import (
     DBOSAwaitedWorkflowCancelledError,
     DBOSConflictingRegistrationError,
-    DBOSMaxStepRetriesExceeded,
+    DBOSException,
 )
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import GetWorkflowsInput
@@ -1684,3 +1684,36 @@ def test_nested_steps(dbos: DBOS) -> None:
     steps = DBOS.list_workflow_steps(id)
     assert len(steps) == 1
     assert steps[0]["function_name"] == outer_step.__qualname__
+
+
+def test_destroy(dbos: DBOS, config: DBOSConfig) -> None:
+
+    @DBOS.workflow()
+    def unblocked_workflow() -> None:
+        return
+
+    blocking_event = threading.Event()
+
+    @DBOS.workflow()
+    def blocked_workflow() -> None:
+        blocking_event.wait()
+
+    unblocked_workflow()
+
+    # Destroy DBOS with no active workflows, verify it is destroyed immediately
+    start = time.time()
+    DBOS.destroy(workflow_completion_timeout_sec=60)
+    assert time.time() - start < 5
+
+    DBOS(config=config)
+    DBOS.launch()
+
+    handle = DBOS.start_workflow(blocked_workflow)
+
+    # Destroy DBOS with an active workflow, verify it waits out the timeout
+    start = time.time()
+    DBOS.destroy(workflow_completion_timeout_sec=3)
+    assert time.time() - start > 3
+    blocking_event.set()
+    with pytest.raises(DBOSException):
+        handle.get_result()

{dbos-1.12.0a3 → dbos-1.13.0a3}/tests/test_schema_migration.py

@@ -1,16 +1,13 @@
-import os
-import re
-
 import pytest
 import sqlalchemy as sa
-from alembic import command
-from alembic.config import Config
 
 # Public API
 from dbos import DBOS, DBOSConfig
+from dbos._migration import dbos_migrations, run_alembic_migrations
 
 # Private API because this is a unit test
 from dbos._schemas.system_database import SystemSchema
+from dbos._sys_db import SystemDatabase
 
 
 def test_systemdb_migration(dbos: DBOS) -> None:
@@ -32,16 +29,61 @@ def test_systemdb_migration(dbos: DBOS) -> None:
         result = connection.execute(sql)
         assert result.fetchall() == []
 
-    # Test migrating down
-    rollback_system_db(
-        sysdb_url=dbos._sys_db.engine.url.render_as_string(hide_password=False)
-    )
+        # Check dbos_migrations table exists, has one row, and has the right version
+        migrations_result = connection.execute(
+            sa.text("SELECT version FROM dbos.dbos_migrations")
+        )
+        migrations_rows = migrations_result.fetchall()
+        assert len(migrations_rows) == 1
+        assert migrations_rows[0][0] == len(dbos_migrations)
+
+
+def test_alembic_migrations_compatibility(
+    config: DBOSConfig, postgres_db_engine: sa.Engine
+) -> None:
+    system_database_url = f"{config['database_url']}_dbos_sys"
+    sysdb_name = sa.make_url(system_database_url).database
 
+    # Drop and recreate the system database
+    with postgres_db_engine.connect() as connection:
+        connection.execution_options(isolation_level="AUTOCOMMIT")
+        connection.execute(sa.text(f'DROP DATABASE IF EXISTS "{sysdb_name}"'))
+        connection.execute(sa.text(f'CREATE DATABASE "{sysdb_name}"'))
+
+    sys_db = SystemDatabase(system_database_url=system_database_url, engine_kwargs={})
+    # Run the deprecated Alembic migrations
+    run_alembic_migrations(sys_db.engine)
+    # Then, run the new migrations to verify they work from a system database
+    # that started in Alembic.
+    dbos = DBOS(config=config)
+    DBOS.launch()
+    # Make sure all tables exist
     with dbos._sys_db.engine.connect() as connection:
-        with pytest.raises(sa.exc.ProgrammingError) as exc_info:
-            sql = SystemSchema.workflow_status.select()
-            result = connection.execute(sql)
-        assert "does not exist" in str(exc_info.value)
+        sql = SystemSchema.workflow_status.select()
+        result = connection.execute(sql)
+        assert result.fetchall() == []
+
+        sql = SystemSchema.operation_outputs.select()
+        result = connection.execute(sql)
+        assert result.fetchall() == []
+
+        sql = SystemSchema.workflow_events.select()
+        result = connection.execute(sql)
+        assert result.fetchall() == []
+
+        sql = SystemSchema.notifications.select()
+        result = connection.execute(sql)
+        assert result.fetchall() == []
+
+        # Check dbos_migrations table exists, has one row, and has the right version
+        migrations_result = connection.execute(
+            sa.text("SELECT version FROM dbos.dbos_migrations")
+        )
+        migrations_rows = migrations_result.fetchall()
+        assert len(migrations_rows) == 1
+        assert migrations_rows[0][0] == len(dbos_migrations)
+
+    assert DBOS.list_workflows() == []
 
 
 def test_custom_sysdb_name_migration(
@@ -66,36 +108,9 @@ def test_custom_sysdb_name_migration(
         result = connection.execute(sql)
         assert result.fetchall() == []
 
-    # Test migrating down
-    rollback_system_db(
-        sysdb_url=dbos._sys_db.engine.url.render_as_string(hide_password=False)
-    )
-
-    with dbos._sys_db.engine.connect() as connection:
-        with pytest.raises(sa.exc.ProgrammingError) as exc_info:
-            sql = SystemSchema.workflow_status.select()
-            result = connection.execute(sql)
-        assert "does not exist" in str(exc_info.value)
     DBOS.destroy()
 
 
-def rollback_system_db(sysdb_url: str) -> None:
-    migration_dir = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
-        "dbos",
-        "_migrations",
-    )
-    alembic_cfg = Config()
-    alembic_cfg.set_main_option("script_location", migration_dir)
-    escaped_conn_string = re.sub(
-        r"%(?=[0-9A-Fa-f]{2})",
-        "%%",
-        sysdb_url,
-    )
-    alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
-    command.downgrade(alembic_cfg, "base")  # Rollback all migrations
-
-
 def test_reset(config: DBOSConfig, postgres_db_engine: sa.Engine) -> None:
     DBOS.destroy()
     dbos = DBOS(config=config)

{dbos-1.12.0a3 → dbos-1.13.0a3}/tests/test_spans.py

@@ -254,3 +254,61 @@ def test_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     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
+
+
+def test_disable_otlp_no_spans(config: DBOSConfig) -> None:
+    DBOS.destroy(destroy_registry=True)
+    config["otlp_attributes"] = {"foo": "bar"}
+    config["disable_otlp"] = True
+    DBOS(config=config)
+    DBOS.launch()
+
+    @DBOS.workflow()
+    def test_workflow() -> None:
+        test_step()
+        DBOS.logger.info("This is a test_workflow")
+
+    @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()
+
+    log_processor.force_flush(timeout_millis=5000)
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 2
+    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"
+        # We disable OTLP, so no span_id or trace_id should be present
+        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.get("traceId") is None
+
+    spans = exporter.get_finished_spans()
+
+    # No spans should be created since OTLP is disabled
+    assert len(spans) == 0