dbos 0.5.0a5__tar.gz → 0.5.0a11__tar.gz

{dbos-0.5.0a5 → dbos-0.5.0a11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.5.0a5
+Version: 0.5.0a11
 Summary: A Python framework for backends that scale
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-0.5.0a5 → dbos-0.5.0a11}/dbos/context.py

@@ -8,13 +8,10 @@ from types import TracebackType
 from typing import TYPE_CHECKING, List, Literal, Optional, Type, TypedDict
 
 from opentelemetry.trace import Span, Status, StatusCode
-
-if TYPE_CHECKING:
-    from .fastapi import Request
-
 from sqlalchemy.orm import Session
 
 from .logger import dbos_logger
+from .request import Request
 from .tracer import dbos_tracer
 
 

{dbos-0.5.0a5 → dbos-0.5.0a11}/dbos/dbos.py

@@ -52,7 +52,7 @@ from .tracer import dbos_tracer
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
-    from .fastapi import Request
+    from .request import Request
 
 from sqlalchemy.orm import Session
 
@@ -72,7 +72,7 @@ from dbos.error import DBOSException, DBOSNonExistentWorkflowError
 
 from .application_database import ApplicationDatabase
 from .dbos_config import ConfigFile, load_config, set_env_vars
-from .logger import config_logger, dbos_logger, init_logger
+from .logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from .system_database import SystemDatabase
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
@@ -202,9 +202,9 @@ class DBOS:
 
     def __new__(
         cls: Type[DBOS],
-        fastapi: Optional["FastAPI"] = None,
+        *,
         config: Optional[ConfigFile] = None,
-        launch: bool = True,
+        fastapi: Optional["FastAPI"] = None,
     ) -> DBOS:
         global _dbos_global_instance
         global _dbos_global_registry
@@ -219,7 +219,7 @@ class DBOS:
                     )
                 config = _dbos_global_registry.config
             _dbos_global_instance = super().__new__(cls)
-            _dbos_global_instance.__init__(fastapi=fastapi, config=config, launch=launch)  # type: ignore
+            _dbos_global_instance.__init__(fastapi=fastapi, config=config)  # type: ignore
         else:
             if (config is not None and _dbos_global_instance.config is not config) or (
                 _dbos_global_instance.fastapi is not fastapi
@@ -240,9 +240,9 @@ class DBOS:
 
     def __init__(
         self,
-        fastapi: Optional["FastAPI"] = None,
+        *,
         config: Optional[ConfigFile] = None,
-        launch: bool = True,
+        fastapi: Optional["FastAPI"] = None,
     ) -> None:
         if hasattr(self, "_initialized") and self._initialized:
             return
@@ -269,8 +269,8 @@ class DBOS:
             from dbos.fastapi import setup_fastapi_middleware
 
             setup_fastapi_middleware(self.fastapi)
-            self.fastapi.on_event("startup")(self.launch)
-            launch = False
+            self.fastapi.on_event("startup")(self._launch)
+            self.fastapi.on_event("shutdown")(self._destroy)
 
         # Register send_stub as a workflow
         def send_temp_workflow(
@@ -283,8 +283,8 @@ class DBOS:
         set_temp_workflow_type(send_temp_workflow, "send")
         self._registry.register_wf_function(TEMP_SEND_WF_NAME, temp_send_wf)
 
-        if launch:
-            self.launch()
+        for handler in dbos_logger.handlers:
+            handler.flush()
 
     @property
     def executor(self) -> ThreadPoolExecutor:
@@ -316,7 +316,12 @@ class DBOS:
         rv: AdminServer = self._admin_server
         return rv
 
-    def launch(self) -> None:
+    @classmethod
+    def launch(cls) -> None:
+        if _dbos_global_instance is not None:
+            _dbos_global_instance._launch()
+
+    def _launch(self) -> None:
         if self._launched:
             dbos_logger.warning(f"DBOS was already launched")
             return
@@ -342,9 +347,13 @@ class DBOS:
             self.executor.submit(func, *args, **kwargs)
         self._registry.pollers = []
 
-        dbos_logger.info("DBOS initialized")
+        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()
 
     def _destroy(self) -> None:
         self._initialized = False
@@ -650,7 +659,7 @@ class DBOS:
 
     @classproperty
     def request(cls) -> Optional["Request"]:
-        """Return the FastAPI `Request`, if any, associated with the current context."""
+        """Return the HTTP `Request`, if any, associated with the current context."""
         ctx = assert_current_dbos_context()
         return ctx.request
 

{dbos-0.5.0a5 → dbos-0.5.0a11}/dbos/fastapi.py

@@ -11,6 +11,7 @@ from .context import (
     TracedAttributes,
     assert_current_dbos_context,
 )
+from .request import Address, Request
 
 request_id_header = "x-request-id"
 
@@ -23,31 +24,17 @@ def get_or_generate_request_id(request: FastAPIRequest) -> str:
         return str(uuid.uuid4())
 
 
-class Request:
-    """
-    Serializable subset of the FastAPI Request object.
-
-    Attributes:
-        base_url(URL): Base of URL requested, as in application code
-        client(Address): HTTP Client
-        cookies(Dict[str, str]): HTTP Cookies
-        headers(Headers): HTTP headers
-        method(str): HTTP verb
-        path_params(Dict[str,Any]): Parameters extracted from URL path sections
-        query_params(QueryParams): URL query string parameters
-        url(URL): Full URL accessed
-
-    """
-
-    def __init__(self, req: FastAPIRequest):
-        self.headers = req.headers
-        self.path_params = req.path_params
-        self.query_params = req.query_params
-        self.url = req.url
-        self.base_url = req.base_url
-        self.client = req.client
-        self.cookies = req.cookies
-        self.method = req.method
+def make_request(request: FastAPIRequest) -> Request:
+    return Request(
+        headers=request.headers,
+        path_params=request.path_params,
+        query_params=request.query_params,
+        url=str(request.url),
+        base_url=str(request.base_url),
+        client=Address(*request.client) if request.client is not None else None,
+        cookies=request.cookies,
+        method=request.method,
+    )
 
 
 def setup_fastapi_middleware(app: FastAPI) -> None:
@@ -65,7 +52,7 @@ def setup_fastapi_middleware(app: FastAPI) -> None:
         }
         with EnterDBOSHandler(attributes):
             ctx = assert_current_dbos_context()
-            ctx.request = Request(request)
+            ctx.request = make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key", "")
             with SetWorkflowID(workflow_id):
                 response = await call_next(request)

{dbos-0.5.0a5 → dbos-0.5.0a11}/dbos/logger.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from dbos.dbos_config import ConfigFile
 
 dbos_logger = logging.getLogger("dbos")
+otlp_handler, otlp_transformer = None, None
 
 
 class DBOSLogTransformer(logging.Filter):
@@ -73,25 +74,28 @@ def config_logger(config: "ConfigFile") -> None:
                 export_timeout_millis=5000,
             )
         )
+        global otlp_handler
         otlp_handler = LoggingHandler(logger_provider=log_provider)
 
         # Attach DBOS-specific attributes to all log entries.
+        global otlp_transformer
         otlp_transformer = DBOSLogTransformer()
 
-        # Direct all logs to OTLP
-        add_otlp_to_all_loggers(otlp_handler, otlp_transformer)
+        # Direct DBOS logs to OTLP
+        dbos_logger.addHandler(otlp_handler)
+        dbos_logger.addFilter(otlp_transformer)
 
 
-def add_otlp_to_all_loggers(
-    otlp_handler: LoggingHandler, otlp_transformer: DBOSLogTransformer
-) -> None:
-    root = logging.root
+def add_otlp_to_all_loggers() -> None:
+    if otlp_handler is not None and otlp_transformer is not None:
+        root = logging.root
 
-    root.addHandler(otlp_handler)
-    root.addFilter(otlp_transformer)
+        root.addHandler(otlp_handler)
+        root.addFilter(otlp_transformer)
 
-    for logger_name in root.manager.loggerDict:
-        logger = logging.getLogger(logger_name)
-        if not logger.propagate:
-            logger.addHandler(otlp_handler)
-        logger.addFilter(otlp_transformer)
+        for logger_name in root.manager.loggerDict:
+            if logger_name != dbos_logger.name:
+                logger = logging.getLogger(logger_name)
+                if not logger.propagate:
+                    logger.addHandler(otlp_handler)
+                logger.addFilter(otlp_transformer)

dbos-0.5.0a11/dbos/request.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Any, Mapping, NamedTuple, Optional
+
+
+class Address(NamedTuple):
+    hostname: str
+    port: int
+
+
+@dataclass
+class Request:
+    """
+    Serializable HTTP Request object.
+    Attributes:
+        base_url(str): Base of URL requested, as in application code
+        client(Optional[Address]): HTTP Client
+        cookies(Mapping[str, str]): HTTP Cookies
+        headers(Mapping[str, str]): HTTP headers
+        method(str): HTTP verb
+        path_params(Mapping[str, Any]): Parameters extracted from URL path sections
+        query_params(Mapping[str, str]): URL query string parameters
+        url(str): Full URL accessed
+    """
+
+    headers: Mapping[str, str]
+    path_params: Mapping[str, Any]
+    query_params: Mapping[str, str]
+    url: str
+    base_url: str
+    client: Optional[Address]
+    cookies: Mapping[str, str]
+    method: str

{dbos-0.5.0a5 → dbos-0.5.0a11}/dbos/system_database.py

@@ -734,7 +734,6 @@ class SystemDatabase:
                 )
                 notification_cursor = self.notification_conn.cursor()
 
-                dbos_logger.info("Listening to notifications")
                 notification_cursor.execute("LISTEN dbos_notifications_channel")
                 notification_cursor.execute("LISTEN dbos_workflow_events_channel")
                 while self._run_background_processes:

{dbos-0.5.0a5 → dbos-0.5.0a11}/dbos/templates/hello/__package/main.py

@@ -15,7 +15,7 @@ from dbos import DBOS
 from .schema import dbos_hello
 
 app = FastAPI()
-DBOS(app)
+DBOS(fastapi=app)
 
 # Next, let's write a function that greets visitors.
 # To make it more interesting, we'll keep track of how

{dbos-0.5.0a5 → dbos-0.5.0a11}/pyproject.toml

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

{dbos-0.5.0a5 → dbos-0.5.0a11}/tests/atexit_no_launch.py

@@ -26,4 +26,4 @@ def default_config() -> ConfigFile:
     }
 
 
-DBOS(config=default_config(), launch=False)
+DBOS(config=default_config())

{dbos-0.5.0a5 → dbos-0.5.0a11}/tests/conftest.py

@@ -1,6 +1,7 @@
 import glob
 import os
 import subprocess
+import warnings
 from typing import Any, Generator, Tuple
 
 import pytest
@@ -103,7 +104,8 @@ def dbos(
     #     launch themselves.
     # If your test is tricky and has a problem with this, use a different
     #   fixture that does not launch.
-    dbos = DBOS(config=config, launch=True)
+    dbos = DBOS(config=config)
+    DBOS.launch()
 
     yield dbos
     DBOS.destroy()
@@ -115,11 +117,19 @@ def dbos_fastapi(
 ) -> Generator[Tuple[DBOS, FastAPI], Any, None]:
     DBOS.destroy()
     app = FastAPI()
-    dbos = DBOS(fastapi=app, config=config)
+
+    # ignore the on_event deprecation warnings
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message="\s*on_event is deprecated, use lifespan event handlers instead\.",
+        )
+        dbos = DBOS(fastapi=app, config=config)
 
     # This is for test convenience.
     #    Usually fastapi itself does launch, but we are not completing the fastapi lifecycle
-    dbos.launch()
+    DBOS.launch()
 
     yield dbos, app
     DBOS.destroy()

{dbos-0.5.0a5 → dbos-0.5.0a11}/tests/test_concurrency.py

@@ -34,24 +34,20 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     condition = threading.Condition()
     step_count = 0
     txn_count = 0
-    notified = False
 
     @DBOS.step()
     def test_step() -> str:
-        nonlocal step_count, notified
+        nonlocal step_count
+        condition.acquire()
         step_count += 1
-        if step_count == 1:
+        if step_count % 2 == 1:
             # Wait for the other one to notify
-            condition.acquire()
             condition.wait()
-            notified = True
-            condition.release()
         else:
-            while not notified:
-                condition.acquire()
-                condition.notify()
-                condition.release()
-                time.sleep(0.1)
+            # Notify the other one
+            condition.notify()
+        condition.release()
+
         return DBOS.workflow_id
 
     @DBOS.workflow()
@@ -67,20 +63,17 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     @DBOS.transaction(isolation_level="REPEATABLE READ")
     def test_transaction() -> str:
         DBOS.sql_session.execute(text("SELECT 1")).fetchall()
-        nonlocal txn_count, notified
+        nonlocal txn_count
+        condition.acquire()
         txn_count += 1
-        if txn_count == 1:
+        if txn_count % 2 == 1:
             # Wait for the other one to notify
-            condition.acquire()
             condition.wait()
-            notified = True
-            condition.release()
         else:
-            while not notified:
-                condition.acquire()
-                condition.notify()
-                condition.release()
-                time.sleep(0.1)
+            # Notify the other one
+            condition.notify()
+        condition.release()
+
         return DBOS.workflow_id
 
     def test_txn_thread(id: str) -> str:
@@ -99,8 +92,6 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     assert wf_handle2.get_result() == wfuuid
 
     # Make sure temp workflows can handle conflicts as well.
-    step_count = 0
-    notified = False
     wfuuid = str(uuid.uuid4())
     with ThreadPoolExecutor(max_workers=2) as executor:
         future1 = executor.submit(test_comm_thread, wfuuid)
@@ -111,7 +102,6 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
 
     # Make sure temp transactions can handle conflicts as well.
     wfuuid = str(uuid.uuid4())
-    notified = False
     with ThreadPoolExecutor(max_workers=2) as executor:
         future1 = executor.submit(test_txn_thread, wfuuid)
         future2 = executor.submit(test_txn_thread, wfuuid)

{dbos-0.5.0a5 → dbos-0.5.0a11}/tests/test_dbos.py

@@ -472,7 +472,7 @@ def test_recovery_thread(config: ConfigFile, dbos: DBOS) -> None:
     )
 
     dbos._destroy()  # Unusual pattern - reusing the memory
-    dbos.__init__(config=config, launch=False)  # type: ignore
+    dbos.__init__(config=config)  # type: ignore
 
     @DBOS.workflow()  # type: ignore
     def test_workflow(var: str) -> str:
@@ -481,7 +481,7 @@ def test_recovery_thread(config: ConfigFile, dbos: DBOS) -> None:
             wf_counter += 1
         return var
 
-    dbos.launch()  # Usually the framework does this but we destroyed it above
+    DBOS.launch()  # Usually the framework does this but we destroyed it above
 
     # Upon re-initialization, the background thread should recover the workflow safely.
     max_retries = 10
@@ -685,6 +685,7 @@ def test_without_fastapi() -> None:
         sys.meta_path.remove(blocker)
 
     dbos = DBOS(config=config)
+    DBOS.launch()
 
     try:
 

{dbos-0.5.0a5 → dbos-0.5.0a11}/tests/test_schema_migration.py

@@ -65,6 +65,7 @@ def test_custom_sysdb_name_migration(
     # Test migrating up
     DBOS.destroy()  # In case of other tests leaving it
     dbos = DBOS(config=config)
+    DBOS.launch()
 
     # Make sure all tables exist
     with dbos.sys_db.engine.connect() as connection:

{dbos-0.5.0a5 → dbos-0.5.0a11}/tests/test_singleton.py

@@ -22,11 +22,11 @@ def test_dbos_singleton(cleanup_test_databases: None) -> None:
     #    then imports more
     from tests.classdefs import DBOSSendRecv, DBOSTestClass, DBOSTestRoles
 
-    dbos: DBOS = DBOS(None, default_config(), launch=False)
+    dbos: DBOS = DBOS(config=default_config())
 
     from tests.more_classdefs import DBOSWFEvents, wfFunc
 
-    dbos.launch()  # Usually framework (fastapi) does this via lifecycle event
+    DBOS.launch()  # Usually framework (fastapi) does this via lifecycle event
 
     # Basics
     with SetWorkflowID("wfid"):
@@ -120,11 +120,11 @@ def test_dbos_singleton_negative(cleanup_test_databases: None) -> None:
     #    then imports more
     from tests.classdefs import DBOSTestClass
 
-    dbos: DBOS = DBOS(None, default_config())
+    dbos: DBOS = DBOS(config=default_config())
 
     # Don't initialize DBOS twice
     with pytest.raises(Exception) as exc_info:
-        DBOS(None, default_config())
+        DBOS(config=default_config())
     assert "conflicting configuration" in str(exc_info.value)
 
     # Something should have launched
@@ -188,7 +188,7 @@ def test_config_before_singleton_negative(cleanup_test_databases: None) -> None:
 
         # Not OK, config already loaded in the default way
         with pytest.raises(Exception) as exc_info:
-            DBOS(None, config=default_config())
+            DBOS(config=default_config())
         assert "configured multiple" in str(exc_info.value)
     finally:
         DBOS.destroy()