dbos 2.4.0a3__py3-none-any.whl → 2.6.0a8__py3-none-any.whl

dbos/_core.py

@@ -91,6 +91,7 @@ F = TypeVar("F", bound=Callable[..., Any])
 
 TEMP_SEND_WF_NAME = "<temp>.temp_send_workflow"
 DEBOUNCER_WORKFLOW_NAME = "_dbos_debouncer_workflow"
+DEFAULT_POLLING_INTERVAL = 1.0
 
 
 class WorkflowHandleFuture(Generic[R]):
@@ -103,7 +104,9 @@ class WorkflowHandleFuture(Generic[R]):
     def get_workflow_id(self) -> str:
         return self.workflow_id
 
-    def get_result(self) -> R:
+    def get_result(
+        self, *, polling_interval_sec: float = DEFAULT_POLLING_INTERVAL
+    ) -> R:
         try:
             r = self.future.result()
         except Exception as e:
@@ -130,9 +133,13 @@ class WorkflowHandlePolling(Generic[R]):
     def get_workflow_id(self) -> str:
         return self.workflow_id
 
-    def get_result(self) -> R:
+    def get_result(
+        self, *, polling_interval_sec: float = DEFAULT_POLLING_INTERVAL
+    ) -> R:
         try:
-            r: R = self.dbos._sys_db.await_workflow_result(self.workflow_id)
+            r: R = self.dbos._sys_db.await_workflow_result(
+                self.workflow_id, polling_interval_sec
+            )
         except Exception as e:
             serialized_e = self.dbos._serializer.serialize(e)
             self.dbos._sys_db.record_get_result(self.workflow_id, None, serialized_e)
@@ -158,7 +165,9 @@ class WorkflowHandleAsyncTask(Generic[R]):
     def get_workflow_id(self) -> str:
         return self.workflow_id
 
-    async def get_result(self) -> R:
+    async def get_result(
+        self, *, polling_interval_sec: float = DEFAULT_POLLING_INTERVAL
+    ) -> R:
         try:
             r = await self.task
         except Exception as e:
@@ -192,10 +201,14 @@ class WorkflowHandleAsyncPolling(Generic[R]):
     def get_workflow_id(self) -> str:
         return self.workflow_id
 
-    async def get_result(self) -> R:
+    async def get_result(
+        self, *, polling_interval_sec: float = DEFAULT_POLLING_INTERVAL
+    ) -> R:
         try:
             r: R = await asyncio.to_thread(
-                self.dbos._sys_db.await_workflow_result, self.workflow_id
+                self.dbos._sys_db.await_workflow_result,
+                self.workflow_id,
+                polling_interval_sec,
             )
         except Exception as e:
             serialized_e = self.dbos._serializer.serialize(e)
@@ -366,7 +379,7 @@ def _get_wf_invoke_func(
             )
             # Directly return the result if the workflow is already completed
             recorded_result: R = dbos._sys_db.await_workflow_result(
-                status["workflow_uuid"]
+                status["workflow_uuid"], polling_interval=DEFAULT_POLLING_INTERVAL
             )
             return recorded_result
         try:
@@ -381,7 +394,9 @@ def _get_wf_invoke_func(
             return output
         except DBOSWorkflowConflictIDError:
             # Await the workflow result
-            r: R = dbos._sys_db.await_workflow_result(status["workflow_uuid"])
+            r: R = dbos._sys_db.await_workflow_result(
+                status["workflow_uuid"], polling_interval=DEFAULT_POLLING_INTERVAL
+            )
             return r
         except DBOSWorkflowCancelledError as error:
             raise DBOSAwaitedWorkflowCancelledError(status["workflow_uuid"])
@@ -579,11 +594,14 @@ def start_workflow(
     ctx = new_wf_ctx
     new_child_workflow_id = ctx.id_assigned_for_next_workflow
     if ctx.has_parent():
-        child_workflow_id = dbos._sys_db.check_child_workflow(
-            ctx.parent_workflow_id, ctx.parent_workflow_fid
+        recorded_result = dbos._sys_db.check_operation_execution(
+            ctx.parent_workflow_id, ctx.parent_workflow_fid, get_dbos_func_name(func)
         )
-        if child_workflow_id is not None:
-            return WorkflowHandlePolling(child_workflow_id, dbos)
+        if recorded_result and recorded_result["error"]:
+            e: Exception = dbos._sys_db.serializer.deserialize(recorded_result["error"])
+            raise e
+        elif recorded_result and recorded_result["child_workflow_id"]:
+            return WorkflowHandlePolling(recorded_result["child_workflow_id"], dbos)
 
     status = _init_workflow(
         dbos,
@@ -675,13 +693,19 @@ async def start_workflow_async(
     ctx = new_wf_ctx
     new_child_workflow_id = ctx.id_assigned_for_next_workflow
     if ctx.has_parent():
-        child_workflow_id = await asyncio.to_thread(
-            dbos._sys_db.check_child_workflow,
+        recorded_result = await asyncio.to_thread(
+            dbos._sys_db.check_operation_execution,
             ctx.parent_workflow_id,
             ctx.parent_workflow_fid,
+            get_dbos_func_name(func),
         )
-        if child_workflow_id is not None:
-            return WorkflowHandleAsyncPolling(child_workflow_id, dbos)
+        if recorded_result and recorded_result["error"]:
+            e: Exception = dbos._sys_db.serializer.deserialize(recorded_result["error"])
+            raise e
+        elif recorded_result and recorded_result["child_workflow_id"]:
+            return WorkflowHandleAsyncPolling(
+                recorded_result["child_workflow_id"], dbos
+            )
 
     status = await asyncio.to_thread(
         _init_workflow,
@@ -788,7 +812,9 @@ def workflow_wrapper(
                 c_wfid: str, dbos: "DBOS"
             ) -> Callable[[Callable[[], R]], R]:
                 def recorded_result_inner(func: Callable[[], R]) -> R:
-                    r: R = dbos._sys_db.await_workflow_result(c_wfid)
+                    r: R = dbos._sys_db.await_workflow_result(
+                        c_wfid, polling_interval=DEFAULT_POLLING_INTERVAL
+                    )
                     return r
 
                 return recorded_result_inner
@@ -798,11 +824,16 @@ def workflow_wrapper(
             workflow_id = ctx.workflow_id
 
             if ctx.has_parent():
-                child_workflow_id = dbos._sys_db.check_child_workflow(
-                    ctx.parent_workflow_id, ctx.parent_workflow_fid
+                r = dbos._sys_db.check_operation_execution(
+                    ctx.parent_workflow_id,
+                    ctx.parent_workflow_fid,
+                    get_dbos_func_name(func),
                 )
-                if child_workflow_id is not None:
-                    return recorded_result(child_workflow_id, dbos)
+                if r and r["error"]:
+                    e: Exception = dbos._sys_db.serializer.deserialize(r["error"])
+                    raise e
+                elif r and r["child_workflow_id"]:
+                    return recorded_result(r["child_workflow_id"], dbos)
 
             status = _init_workflow(
                 dbos,
@@ -889,12 +920,6 @@ def decorate_transaction(
                 )
 
             dbos = dbosreg.dbos
-            ctx = assert_current_dbos_context()
-            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 {transaction_name}."
-                )
             assert (
                 dbos._app_db
             ), "Transactions can only be used if DBOS is configured with an application_database_url"
@@ -905,6 +930,26 @@ def decorate_transaction(
                 }
                 with EnterDBOSTransaction(session, attributes=attributes):
                     ctx = assert_current_dbos_context()
+                    # Check if the step record for this transaction exists
+                    recorded_step_output = dbos._sys_db.check_operation_execution(
+                        ctx.workflow_id, ctx.function_id, transaction_name
+                    )
+                    if recorded_step_output:
+                        dbos.logger.debug(
+                            f"Replaying transaction, id: {ctx.function_id}, name: {attributes['name']}"
+                        )
+                        if recorded_step_output["error"]:
+                            step_error: Exception = dbos._serializer.deserialize(
+                                recorded_step_output["error"]
+                            )
+                            raise step_error
+                        elif recorded_step_output["output"]:
+                            return dbos._serializer.deserialize(
+                                recorded_step_output["output"]
+                            )
+                        else:
+                            raise Exception("Output and error are both None")
+
                     txn_output: TransactionResultInternal = {
                         "workflow_uuid": ctx.workflow_id,
                         "function_id": ctx.function_id,
@@ -915,6 +960,14 @@ def decorate_transaction(
                         "txn_id": None,
                         "function_name": transaction_name,
                     }
+                    step_output: OperationResultInternal = {
+                        "workflow_uuid": ctx.workflow_id,
+                        "function_id": ctx.function_id,
+                        "function_name": transaction_name,
+                        "output": None,
+                        "error": None,
+                        "started_at_epoch_ms": int(time.time() * 1000),
+                    }
                     retry_wait_seconds = 0.001
                     backoff_factor = 1.5
                     max_retry_wait_seconds = 2.0
@@ -953,8 +1006,18 @@ def decorate_transaction(
                                             )
                                         )
                                         has_recorded_error = True
+                                        step_output["error"] = recorded_output["error"]
+                                        dbos._sys_db.record_operation_result(
+                                            step_output
+                                        )
                                         raise deserialized_error
                                     elif recorded_output["output"]:
+                                        step_output["output"] = recorded_output[
+                                            "output"
+                                        ]
+                                        dbos._sys_db.record_operation_result(
+                                            step_output
+                                        )
                                         return dbos._serializer.deserialize(
                                             recorded_output["output"]
                                         )
@@ -1011,10 +1074,13 @@ def decorate_transaction(
                         finally:
                             # Don't record the error if it was already recorded
                             if txn_error and not has_recorded_error:
-                                txn_output["error"] = dbos._serializer.serialize(
-                                    txn_error
+                                step_output["error"] = txn_output["error"] = (
+                                    dbos._serializer.serialize(txn_error)
                                 )
                                 dbos._app_db.record_transaction_error(txn_output)
+                                dbos._sys_db.record_operation_result(step_output)
+            step_output["output"] = dbos._serializer.serialize(output)
+            dbos._sys_db.record_operation_result(step_output)
             return output
 
         if inspect.iscoroutinefunction(func):
@@ -1283,7 +1349,9 @@ def set_event(dbos: "DBOS", key: str, value: Any) -> None:
                     ctx.workflow_id, ctx.curr_step_function_id, key, value
                 )
         elif cur_ctx.is_step():
-            dbos._sys_db.set_event_from_step(cur_ctx.workflow_id, key, value)
+            dbos._sys_db.set_event_from_step(
+                cur_ctx.workflow_id, cur_ctx.curr_step_function_id, key, value
+            )
         else:
             raise DBOSException(
                 "set_event() must be called from within a workflow or step"

dbos/_dbos.py

@@ -7,7 +7,6 @@ import os
 import sys
 import threading
 import time
-import uuid
 from concurrent.futures import ThreadPoolExecutor
 from logging import Logger
 from typing import (
@@ -33,12 +32,13 @@ from dbos._conductor.conductor import ConductorWebsocket
 from dbos._debouncer import debouncer_workflow
 from dbos._serialization import DefaultSerializer, Serializer
 from dbos._sys_db import SystemDatabase, WorkflowStatus
-from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
+from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams, generate_uuid
 from dbos._workflow_commands import fork_workflow, list_queued_workflows, list_workflows
 
 from ._classproperty import classproperty
 from ._core import (
     DEBOUNCER_WORKFLOW_NAME,
+    DEFAULT_POLLING_INTERVAL,
     TEMP_SEND_WF_NAME,
     WorkflowHandleAsyncPolling,
     WorkflowHandlePolling,
@@ -112,7 +112,7 @@ from ._logger import (
     dbos_logger,
     init_logger,
 )
-from ._workflow_commands import get_workflow, list_workflow_steps
+from ._workflow_commands import get_workflow
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
 # There are cases where the parameters P and return value R should be separate
@@ -336,6 +336,8 @@ class DBOS:
         self._executor_field: Optional[ThreadPoolExecutor] = None
         self._background_threads: List[threading.Thread] = []
         self.conductor_url: Optional[str] = conductor_url
+        if config.get("conductor_url"):
+            self.conductor_url = config.get("conductor_url")
         self.conductor_key: Optional[str] = conductor_key
         if config.get("conductor_key"):
             self.conductor_key = config.get("conductor_key")
@@ -444,7 +446,7 @@ class DBOS:
             if GlobalParams.app_version == "":
                 GlobalParams.app_version = self._registry.compute_app_version()
             if self.conductor_key is not None:
-                GlobalParams.executor_id = str(uuid.uuid4())
+                GlobalParams.executor_id = generate_uuid()
             dbos_logger.info(f"Executor ID: {GlobalParams.executor_id}")
             dbos_logger.info(f"Application version: {GlobalParams.app_version}")
             self._executor_field = ThreadPoolExecutor(max_workers=sys.maxsize)
@@ -460,6 +462,7 @@ class DBOS:
                 debug_mode=debug_mode,
                 schema=schema,
                 serializer=self._serializer,
+                executor_id=GlobalParams.executor_id,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
             if self._config["database_url"]:
@@ -495,20 +498,21 @@ class DBOS:
                 except Exception as e:
                     dbos_logger.warning(f"Failed to start admin server: {e}")
 
-            dbos_logger.debug("Retrieving local pending workflows for recovery")
-            workflow_ids = self._sys_db.get_pending_workflows(
-                GlobalParams.executor_id, GlobalParams.app_version
-            )
-            if (len(workflow_ids)) > 0:
-                self.logger.info(
-                    f"Recovering {len(workflow_ids)} workflows from application version {GlobalParams.app_version}"
-                )
-            else:
-                self.logger.info(
-                    f"No workflows to recover from application version {GlobalParams.app_version}"
+            # Recover local workflows if not using a recovery service
+            if not self.conductor_key and not GlobalParams.dbos_cloud:
+                dbos_logger.debug("Retrieving local pending workflows for recovery")
+                workflow_ids = self._sys_db.get_pending_workflows(
+                    GlobalParams.executor_id, GlobalParams.app_version
                 )
-
-            self._executor.submit(startup_recovery_thread, self, workflow_ids)
+                if (len(workflow_ids)) > 0:
+                    self.logger.info(
+                        f"Recovering {len(workflow_ids)} workflows from application version {GlobalParams.app_version}"
+                    )
+                else:
+                    self.logger.info(
+                        f"No workflows to recover from application version {GlobalParams.app_version}"
+                    )
+                self._executor.submit(startup_recovery_thread, self, workflow_ids)
 
             # Listen to notifications
             dbos_logger.debug("Starting notifications listener thread")
@@ -568,8 +572,8 @@ class DBOS:
                 conductor_registration_url = (
                     f"https://console.dbos.dev/self-host?appname={app_name}"
                 )
-                print(
-                    f"To view and manage workflows, connect to DBOS Conductor at:{conductor_registration_url}"
+                dbos_logger.info(
+                    f"To view and manage workflows, connect to DBOS Conductor at: {conductor_registration_url}"
                 )
 
             # Flush handlers and add OTLP to all loggers if enabled
@@ -1089,7 +1093,6 @@ class DBOS:
             dbos_logger.info(f"Forking workflow: {workflow_id} from step {start_step}")
             return fork_workflow(
                 _get_dbos_instance()._sys_db,
-                _get_dbos_instance()._app_db,
                 workflow_id,
                 start_step,
                 application_version=application_version,
@@ -1266,9 +1269,7 @@ class DBOS:
     @classmethod
     def list_workflow_steps(cls, workflow_id: str) -> List[StepInfo]:
         def fn() -> List[StepInfo]:
-            return list_workflow_steps(
-                _get_dbos_instance()._sys_db, _get_dbos_instance()._app_db, workflow_id
-            )
+            return _get_dbos_instance()._sys_db.list_workflow_steps(workflow_id)
 
         return _get_dbos_instance()._sys_db.call_function_as_step(
             fn, "DBOS.listWorkflowSteps"
@@ -1325,11 +1326,10 @@ class DBOS:
             return None
 
     @classproperty
-    def span(cls) -> "Span":
+    def span(cls) -> Optional["Span"]:
         """Return the tracing `Span` associated with the current context."""
         ctx = assert_current_dbos_context()
         span = ctx.get_current_active_span()
-        assert span
         return span
 
     @classproperty
@@ -1383,7 +1383,7 @@ class DBOS:
                     )
             elif ctx.is_step():
                 _get_dbos_instance()._sys_db.write_stream_from_step(
-                    ctx.workflow_id, key, value
+                    ctx.workflow_id, ctx.function_id, key, value
                 )
             else:
                 raise DBOSException(
@@ -1550,7 +1550,9 @@ class WorkflowHandle(Generic[R], Protocol):
         """Return the applicable workflow ID."""
         ...
 
-    def get_result(self) -> R:
+    def get_result(
+        self, *, polling_interval_sec: float = DEFAULT_POLLING_INTERVAL
+    ) -> R:
         """Return the result of the workflow function invocation, waiting if necessary."""
         ...
 
@@ -1579,7 +1581,9 @@ class WorkflowHandleAsync(Generic[R], Protocol):
         """Return the applicable workflow ID."""
         ...
 
-    async def get_result(self) -> R:
+    async def get_result(
+        self, *, polling_interval_sec: float = DEFAULT_POLLING_INTERVAL
+    ) -> R:
         """Return the result of the workflow function invocation, waiting if necessary."""
         ...
 

dbos/_dbos_config.py

@@ -39,6 +39,7 @@ class DBOSConfig(TypedDict, total=False):
         enable_otlp (bool): If True, enable built-in DBOS OTLP tracing and logging.
         system_database_engine (sa.Engine): A custom system database engine. If provided, DBOS will not create an engine but use this instead.
         conductor_key (str): An API key for DBOS Conductor. Pass this in to connect your process to Conductor.
+        conductor_url (str): The websockets URL for your DBOS Conductor service. Only set if you're self-hosting Conductor.
         serializer (Serializer): A custom serializer and deserializer DBOS uses when storing program data in the system database
     """
 
@@ -60,6 +61,7 @@ class DBOSConfig(TypedDict, total=False):
     enable_otlp: Optional[bool]
     system_database_engine: Optional[sa.Engine]
     conductor_key: Optional[str]
+    conductor_url: Optional[str]
     serializer: Optional[Serializer]
 
 
@@ -264,8 +266,7 @@ def load_config(
                 data["telemetry"]["OTLPExporter"]["tracesEndpoint"]
             ]
 
-    data = cast(ConfigFile, data)
-    return data  # type: ignore
+    return cast(ConfigFile, data)
 
 
 def process_config(
@@ -407,25 +408,6 @@ def process_config(
 
     configure_db_engine_parameters(data["database"], connect_timeout=connect_timeout)
 
-    assert data["system_database_url"] is not None
-    # Pretty-print connection information, respecting log level
-    if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
-        printable_sys_db_url = make_url(data["system_database_url"]).render_as_string(
-            hide_password=True
-        )
-        print(f"DBOS system database URL: {printable_sys_db_url}")
-        if data["database_url"]:
-            printable_app_db_url = make_url(data["database_url"]).render_as_string(
-                hide_password=True
-            )
-            print(f"DBOS application database URL: {printable_app_db_url}")
-        if data["system_database_url"].startswith("sqlite"):
-            print(
-                f"Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use."
-            )
-        else:
-            print(f"Database engine parameters: {data['database']['db_engine_kwargs']}")
-
     # Return data as ConfigFile type
     return data
 

dbos/_debouncer.py

@@ -2,7 +2,6 @@ import asyncio
 import math
 import time
 import types
-import uuid
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -39,7 +38,7 @@ from dbos._error import DBOSQueueDeduplicatedError
 from dbos._queue import Queue
 from dbos._registrations import get_dbos_func_name
 from dbos._serialization import WorkflowInputs
-from dbos._utils import INTERNAL_QUEUE_NAME
+from dbos._utils import INTERNAL_QUEUE_NAME, generate_uuid
 
 if TYPE_CHECKING:
     from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
@@ -209,7 +208,7 @@ class Debouncer(Generic[P, R]):
 
             # Deterministically generate the user workflow ID and message ID
             def assign_debounce_ids() -> tuple[str, str]:
-                return str(uuid.uuid4()), ctx.assign_workflow_id()
+                return generate_uuid(), ctx.assign_workflow_id()
 
             message_id, user_workflow_id = dbos._sys_db.call_function_as_step(
                 assign_debounce_ids, "DBOS.assign_debounce_ids"
@@ -320,14 +319,14 @@ class DebouncerClient:
             "workflow_id": (
                 self.workflow_options["workflow_id"]
                 if self.workflow_options.get("workflow_id")
-                else str(uuid.uuid4())
+                else generate_uuid()
             ),
             "app_version": self.workflow_options.get("app_version"),
             "deduplication_id": self.workflow_options.get("deduplication_id"),
             "priority": self.workflow_options.get("priority"),
             "workflow_timeout_sec": self.workflow_options.get("workflow_timeout"),
         }
-        message_id = str(uuid.uuid4())
+        message_id = generate_uuid()
         while True:
             try:
                 # Attempt to enqueue a debouncer for this workflow.

dbos/_fastapi.py

@@ -1,4 +1,3 @@
-import uuid
 from typing import Any, Callable, MutableMapping, cast
 
 from fastapi import FastAPI
@@ -9,7 +8,7 @@ from starlette.types import ASGIApp, Receive, Scope, Send
 from . import DBOS
 from ._context import EnterDBOSHandler, OperationType, SetWorkflowID, TracedAttributes
 from ._error import DBOSException
-from ._utils import request_id_header
+from ._utils import generate_uuid, request_id_header
 
 
 def _get_or_generate_request_id(request: FastAPIRequest) -> str:
@@ -17,7 +16,7 @@ def _get_or_generate_request_id(request: FastAPIRequest) -> str:
     if request_id is not None:
         return request_id
     else:
-        return str(uuid.uuid4())
+        return generate_uuid()
 
 
 async def _dbos_error_handler(request: FastAPIRequest, gexc: Exception) -> JSONResponse:
@@ -88,5 +87,6 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
                 and not dbos._config["telemetry"]["disable_otlp"]
                 and hasattr(response, "status_code")
             ):
-                DBOS.span.set_attribute("responseCode", response.status_code)
+                if DBOS.span is not None:
+                    DBOS.span.set_attribute("responseCode", response.status_code)
         return response

dbos/_flask.py

@@ -1,4 +1,3 @@
-import uuid
 from typing import Any
 from urllib.parse import urlparse
 
@@ -6,7 +5,7 @@ from flask import Flask
 from werkzeug.wrappers import Request as WRequest
 
 from ._context import EnterDBOSHandler, OperationType, SetWorkflowID, TracedAttributes
-from ._utils import request_id_header
+from ._utils import generate_uuid, request_id_header
 
 
 class FlaskMiddleware:
@@ -41,7 +40,7 @@ def _get_or_generate_request_id(request: WRequest) -> str:
     if request_id is not None:
         return request_id
     else:
-        return str(uuid.uuid4())
+        return generate_uuid()
 
 
 def setup_flask_middleware(app: Flask) -> None:

dbos/_logger.py

@@ -71,6 +71,7 @@ def config_logger(config: "ConfigFile") -> None:
     if not disable_otlp:
 
         from opentelemetry._logs import get_logger_provider, set_logger_provider
+        from opentelemetry._logs._internal import ProxyLoggerProvider
         from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
         from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
         from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
@@ -79,8 +80,9 @@ def config_logger(config: "ConfigFile") -> None:
 
         # Only set up OTLP provider and exporter if endpoints are provided
         log_provider = get_logger_provider()
-        if otlp_logs_endpoints is not None:
-            if not isinstance(log_provider, LoggerProvider):
+        if otlp_logs_endpoints is not None and len(otlp_logs_endpoints) > 0:
+            if isinstance(log_provider, ProxyLoggerProvider):
+                # Set a real LoggerProvider if it was previously a ProxyLoggerProvider
                 log_provider = LoggerProvider(
                     Resource.create(
                         attributes={
@@ -91,7 +93,7 @@ def config_logger(config: "ConfigFile") -> None:
                 set_logger_provider(log_provider)
 
             for e in otlp_logs_endpoints:
-                log_provider.add_log_record_processor(
+                log_provider.add_log_record_processor(  # type: ignore
                     BatchLogRecordProcessor(
                         OTLPLogExporter(endpoint=e),
                         export_timeout_millis=5000,
@@ -100,10 +102,15 @@ def config_logger(config: "ConfigFile") -> None:
 
         # Even if no endpoints are provided, we still need a LoggerProvider to create the LoggingHandler
         global _otlp_handler
-        _otlp_handler = LoggingHandler(logger_provider=log_provider)
-
-        # Direct DBOS logs to OTLP
-        dbos_logger.addHandler(_otlp_handler)
+        if _otlp_handler is None:
+            if isinstance(log_provider, ProxyLoggerProvider):
+                dbos_logger.warning(
+                    "OTLP is enabled but logger provider not set, skipping log exporter setup."
+                )
+            else:
+                _otlp_handler = LoggingHandler(logger_provider=log_provider)
+                # Direct DBOS logs to OTLP
+                dbos_logger.addHandler(_otlp_handler)
 
     # Attach DBOS-specific attributes to all log entries.
     global _dbos_log_transformer

dbos/_migration.py

@@ -228,6 +228,21 @@ ALTER TABLE \"{schema}\".operation_outputs ADD COLUMN started_at_epoch_ms BIGINT
 """
 
 
+def get_dbos_migration_six(schema: str) -> str:
+    return f"""
+CREATE TABLE \"{schema}\".workflow_events_history (
+    workflow_uuid TEXT NOT NULL,
+    function_id INTEGER NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    PRIMARY KEY (workflow_uuid, function_id, key),
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+ALTER TABLE \"{schema}\".streams ADD COLUMN function_id INTEGER NOT NULL DEFAULT 0;
+"""
+
+
 def get_dbos_migrations(schema: str) -> list[str]:
     return [
         get_dbos_migration_one(schema),
@@ -235,6 +250,7 @@ def get_dbos_migrations(schema: str) -> list[str]:
         get_dbos_migration_three(schema),
         get_dbos_migration_four(schema),
         get_dbos_migration_five(schema),
+        get_dbos_migration_six(schema),
     ]
 
 
@@ -343,6 +359,19 @@ ALTER TABLE operation_outputs ADD COLUMN started_at_epoch_ms BIGINT;
 ALTER TABLE operation_outputs ADD COLUMN completed_at_epoch_ms BIGINT;
 """
 
+sqlite_migration_six = """
+CREATE TABLE workflow_events_history (
+    workflow_uuid TEXT NOT NULL,
+    function_id INTEGER NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    PRIMARY KEY (workflow_uuid, function_id, key),
+    FOREIGN KEY (workflow_uuid) REFERENCES workflow_status(workflow_uuid)
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+ALTER TABLE streams ADD COLUMN function_id INTEGER NOT NULL DEFAULT 0;
+"""
+
 
 sqlite_migrations = [
     sqlite_migration_one,
@@ -350,4 +379,5 @@ sqlite_migrations = [
     sqlite_migration_three,
     sqlite_migration_four,
     sqlite_migration_five,
+    sqlite_migration_six,
 ]