dbos 1.14.0a9__py3-none-any.whl → 1.15.0a2__py3-none-any.whl

dbos/_docker_pg_helper.py

@@ -1,11 +1,10 @@
+import json
 import logging
 import os
 import subprocess
 import time
 
-import docker
 import psycopg
-from docker.errors import APIError, NotFound
 
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 from typing import Any, Dict, Optional, Tuple
@@ -86,48 +85,71 @@ def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
     image_name = "pgvector/pgvector:pg16"
 
     try:
-        client = docker.from_env()
-
         # Check if the container already exists
         try:
-            container = client.containers.get(container_name)
-            if container.status == "running":
-                logging.info(f"Container '{container_name}' is already running.")
-                return True
-            elif container.status == "exited":
-                container.start()
-                logging.info(
-                    f"Container '{container_name}' was stopped and has been restarted."
-                )
-                return True
-        except NotFound:
-            # Container doesn't exist, proceed with creation
+            result = subprocess.run(
+                f"docker inspect {container_name}",
+                shell=True,
+                text=True,
+                capture_output=True,
+            )
+
+            if result.returncode == 0:
+                # Container exists, check its status
+                container_info = json.loads(result.stdout)
+                status = container_info[0]["State"]["Status"]
+
+                if status == "running":
+                    logging.info(f"Container '{container_name}' is already running.")
+                    return True
+                elif status == "exited":
+                    subprocess.run(
+                        f"docker start {container_name}", shell=True, check=True
+                    )
+                    logging.info(
+                        f"Container '{container_name}' was stopped and has been restarted."
+                    )
+                    return True
+        except (
+            subprocess.CalledProcessError,
+            json.JSONDecodeError,
+            KeyError,
+            IndexError,
+        ):
+            # Container doesn't exist or error parsing, proceed with creation
             pass
 
-        # Pull the image if it doesn't exist
-        imgs = client.images.list(name=image_name)
-        if len(imgs) == 0:
+        # Check if the image exists locally
+        result = subprocess.run(
+            f"docker images -q {image_name}", shell=True, text=True, capture_output=True
+        )
+
+        if not result.stdout.strip():
             logging.info(f"Pulling Docker image {image_name}...")
-            client.images.pull(image_name)
+            subprocess.run(f"docker pull {image_name}", shell=True, check=True)
 
         # Create and start the container
-        container = client.containers.run(
-            image=image_name,
-            name=container_name,
-            detach=True,
-            environment={
-                "POSTGRES_PASSWORD": pool_config["password"],
-                "PGDATA": pg_data,
-            },
-            ports={"5432/tcp": pool_config["port"]},
-            volumes={pg_data: {"bind": pg_data, "mode": "rw"}},
-            remove=True,  # Equivalent to --rm
+        cmd = [
+            "docker run",
+            "-d",
+            f"--name {container_name}",
+            f"-e POSTGRES_PASSWORD={pool_config['password']}",
+            f"-e PGDATA={pg_data}",
+            f"-p {pool_config['port']}:5432",
+            f"-v {pg_data}:{pg_data}",
+            "--rm",
+            image_name,
+        ]
+
+        result = subprocess.run(
+            " ".join(cmd), shell=True, text=True, capture_output=True, check=True
         )
 
-        logging.info(f"Created container: {container.id}")
+        container_id = result.stdout.strip()
+        logging.info(f"Created container: {container_id}")
 
-    except APIError as e:
-        raise Exception(f"Docker API error: {str(e)}")
+    except subprocess.CalledProcessError as e:
+        raise Exception(f"Docker command error: {e.stderr if e.stderr else str(e)}")
 
     # Wait for PostgreSQL to be ready
     attempts = 30
@@ -148,15 +170,16 @@ def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
 
 def check_docker_installed() -> bool:
     """
-    Check if Docker is installed and running using the docker library.
+    Check if Docker is installed and running using the Docker CLI.
 
     Returns:
         bool: True if Docker is installed and running, False otherwise.
     """
     try:
-        client = docker.from_env()
-        client.ping()  # type: ignore
-        return True
+        result = subprocess.run(
+            "docker version --format json", shell=True, capture_output=True, text=True
+        )
+        return result.returncode == 0
     except Exception:
         return False
 
@@ -176,22 +199,41 @@ def stop_docker_pg() -> None:
     try:
         logger.info(f"Stopping Docker Postgres container {container_name}...")
 
-        client = docker.from_env()
-
-        try:
-            container = client.containers.get(container_name)
-
-            if container.status == "running":
-                container.stop()
-                logger.info(
-                    f"Successfully stopped Docker Postgres container {container_name}."
-                )
-            else:
-                logger.info(f"Container {container_name} exists but is not running.")
+        # Check if container exists
+        result = subprocess.run(
+            f"docker inspect {container_name}",
+            shell=True,
+            text=True,
+            capture_output=True,
+        )
 
-        except docker.errors.NotFound:
+        if result.returncode == 0:
+            # Container exists, check its status
+            try:
+                container_info = json.loads(result.stdout)
+                status = container_info[0]["State"]["Status"]
+
+                if status == "running":
+                    subprocess.run(
+                        f"docker stop {container_name}", shell=True, check=True
+                    )
+                    logger.info(
+                        f"Successfully stopped Docker Postgres container {container_name}."
+                    )
+                else:
+                    logger.info(
+                        f"Container {container_name} exists but is not running."
+                    )
+            except (json.JSONDecodeError, KeyError, IndexError) as e:
+                logger.error(f"Error parsing container info: {e}")
+                raise
+        else:
             logger.info(f"Container {container_name} does not exist.")
 
+    except subprocess.CalledProcessError as error:
+        error_message = error.stderr if error.stderr else str(error)
+        logger.error(f"Failed to stop Docker Postgres container: {error_message}")
+        raise
     except Exception as error:
         error_message = str(error)
         logger.error(f"Failed to stop Docker Postgres container: {error_message}")

dbos/_fastapi.py

@@ -83,6 +83,10 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
                     response = await call_next(request)
             else:
                 response = await call_next(request)
-            if hasattr(response, "status_code"):
+            if (
+                dbos._config["telemetry"]
+                and not dbos._config["telemetry"]["disable_otlp"]
+                and hasattr(response, "status_code")
+            ):
                 DBOS.span.set_attribute("responseCode", response.status_code)
         return response

dbos/_logger.py

@@ -2,14 +2,6 @@ import logging
 import os
 from typing import TYPE_CHECKING, Any
 
-from opentelemetry._logs import set_logger_provider
-from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
-from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
-from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.semconv.resource import ResourceAttributes
-from opentelemetry.trace.span import format_trace_id
-
 from dbos._utils import GlobalParams
 
 if TYPE_CHECKING:
@@ -24,6 +16,7 @@ class DBOSLogTransformer(logging.Filter):
         super().__init__()
         self.app_id = os.environ.get("DBOS__APPID", "")
         self.otlp_attributes: dict[str, str] = config.get("telemetry", {}).get("otlp_attributes", {})  # type: ignore
+        self.disable_otlp = config.get("telemetry", {}).get("disable_otlp", True)  # type: ignore
 
     def filter(self, record: Any) -> bool:
         record.applicationID = self.app_id
@@ -39,19 +32,15 @@ class DBOSLogTransformer(logging.Filter):
         if ctx:
             if ctx.is_within_workflow():
                 record.operationUUID = ctx.workflow_id
-            span = ctx.get_current_active_span()
-            if span:
-                trace_id = format_trace_id(span.get_span_context().trace_id)
-                record.traceId = trace_id
-
-        return True
+            if not self.disable_otlp:
+                from opentelemetry.trace.span import format_trace_id
 
+                span = ctx.get_current_active_span()
+                if span:
+                    trace_id = format_trace_id(span.get_span_context().trace_id)
+                    record.traceId = trace_id
 
-# Mitigation for https://github.com/open-telemetry/opentelemetry-python/issues/3193
-# Reduce the force flush timeout
-class PatchedOTLPLoggerProvider(LoggerProvider):
-    def force_flush(self, timeout_millis: int = 5000) -> bool:
-        return super().force_flush(timeout_millis)
+        return True
 
 
 def init_logger() -> None:
@@ -80,10 +69,18 @@ def config_logger(config: "ConfigFile") -> None:
     disable_otlp = config.get("telemetry", {}).get("disable_otlp", False)  # type: ignore
 
     if not disable_otlp and otlp_logs_endpoints:
-        log_provider = PatchedOTLPLoggerProvider(
+
+        from opentelemetry._logs import set_logger_provider
+        from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+        from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+        from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+        from opentelemetry.sdk.resources import Resource
+        from opentelemetry.semconv.attributes.service_attributes import SERVICE_NAME
+
+        log_provider = LoggerProvider(
             Resource.create(
                 attributes={
-                    ResourceAttributes.SERVICE_NAME: config["name"],
+                    SERVICE_NAME: config["name"],
                 }
             )
         )

dbos/_migration.py

@@ -1,16 +1,11 @@
-import logging
-import os
-import re
 import sys
 
 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:
+def ensure_dbos_schema(engine: sa.Engine) -> None:
     """
     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)
@@ -22,10 +17,10 @@ def ensure_dbos_schema(engine: sa.Engine) -> bool:
                 "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'dbos'"
             )
         )
-        schema_existed = schema_result.fetchone() is not None
+        schema_exists = schema_result.fetchone() is not None
 
         # Create schema if it doesn't exist
-        if not schema_existed:
+        if not schema_exists:
             conn.execute(sa.text("CREATE SCHEMA dbos"))
 
         # Check if dbos_migrations table exists
@@ -36,44 +31,12 @@ def ensure_dbos_schema(engine: sa.Engine) -> bool:
         )
         table_exists = table_result.fetchone() is not None
 
-        if table_exists:
-            return True
-        elif schema_existed:
-            return False
-        else:
+        if not table_exists:
             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:

dbos/_serialization.py

@@ -1,8 +1,8 @@
+import base64
+import pickle
 import types
 from typing import Any, Dict, Optional, Tuple, TypedDict
 
-import jsonpickle  # type: ignore
-
 from ._logger import dbos_logger
 
 
@@ -11,54 +11,43 @@ class WorkflowInputs(TypedDict):
     kwargs: Dict[str, Any]
 
 
-def _validate_item(data: Any) -> None:
-    if isinstance(data, (types.MethodType)):
-        raise TypeError("Serialized data item should not be a class method")
-    if isinstance(data, (types.FunctionType)):
-        if jsonpickle.decode(jsonpickle.encode(data, unpicklable=True)) is None:
-            raise TypeError(
-                "Serialized function should be defined at the top level of a module"
-            )
-
-
 def serialize(data: Any) -> str:
-    """Serialize an object to a JSON string using jsonpickle."""
-    _validate_item(data)
-    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
+    pickled_data: bytes = pickle.dumps(data)
+    encoded_data: str = base64.b64encode(pickled_data).decode("utf-8")
     return encoded_data
 
 
 def serialize_args(data: WorkflowInputs) -> str:
-    """Serialize args to a JSON string using jsonpickle."""
-    arg: Any
-    for arg in data["args"]:
-        _validate_item(arg)
-    for arg in data["kwargs"].values():
-        _validate_item(arg)
-    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
+    """Serialize args to a base64-encoded string using pickle."""
+    pickled_data: bytes = pickle.dumps(data)
+    encoded_data: str = base64.b64encode(pickled_data).decode("utf-8")
     return encoded_data
 
 
 def serialize_exception(data: Exception) -> str:
-    """Serialize an Exception object to a JSON string using jsonpickle."""
-    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
+    """Serialize an Exception object to a base64-encoded string using pickle."""
+    pickled_data: bytes = pickle.dumps(data)
+    encoded_data: str = base64.b64encode(pickled_data).decode("utf-8")
     return encoded_data
 
 
 def deserialize(serialized_data: str) -> Any:
-    """Deserialize a JSON string back to a Python object using jsonpickle."""
-    return jsonpickle.decode(serialized_data)
+    """Deserialize a base64-encoded string back to a Python object using pickle."""
+    pickled_data: bytes = base64.b64decode(serialized_data)
+    return pickle.loads(pickled_data)
 
 
 def deserialize_args(serialized_data: str) -> WorkflowInputs:
-    """Deserialize a JSON string back to a Python object list using jsonpickle."""
-    args: WorkflowInputs = jsonpickle.decode(serialized_data)
+    """Deserialize a base64-encoded string back to a Python object list using pickle."""
+    pickled_data: bytes = base64.b64decode(serialized_data)
+    args: WorkflowInputs = pickle.loads(pickled_data)
     return args
 
 
 def deserialize_exception(serialized_data: str) -> Exception:
-    """Deserialize JSON string back to a Python Exception using jsonpickle."""
-    exc: Exception = jsonpickle.decode(serialized_data)
+    """Deserialize a base64-encoded string back to a Python Exception using pickle."""
+    pickled_data: bytes = base64.b64decode(serialized_data)
+    exc: Exception = pickle.loads(pickled_data)
     return exc
 
 

dbos/_sys_db_postgres.py

@@ -5,11 +5,7 @@ import psycopg
 import sqlalchemy as sa
 from sqlalchemy.exc import DBAPIError
 
-from dbos._migration import (
-    ensure_dbos_schema,
-    run_alembic_migrations,
-    run_dbos_migrations,
-)
+from dbos._migration import ensure_dbos_schema, run_dbos_migrations
 from dbos._schemas.system_database import SystemSchema
 
 from ._logger import dbos_logger
@@ -66,10 +62,7 @@ class PostgresSystemDatabase(SystemDatabase):
                 conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
         engine.dispose()
 
-        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)
+        ensure_dbos_schema(self.engine)
         run_dbos_migrations(self.engine)
 
     def _cleanup_connections(self) -> None:

dbos/_templates/dbos-db-starter/migrations/create_table.py.dbos

@@ -0,0 +1,34 @@
+"""
+Create the dbos_hello table using SQLAlchemy.
+"""
+
+import os
+from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String
+
+
+def create_dbos_hello_table() -> None:
+    """
+    Create the dbos_hello table in the database.
+    
+    Args:
+        database_url: Database connection string. If not provided,
+                     uses DATABASE_URL environment variable.
+    """
+    database_url = os.environ.get("DBOS_DATABASE_URL", "postgresql+psycopg://postgres:dbos@localhost:5432/${default_db_name}?connect_timeout=5")
+    
+    engine = create_engine(database_url)
+    metadata = MetaData()
+    
+    dbos_hello = Table(
+        'dbos_hello',
+        metadata,
+        Column('greet_count', Integer, primary_key=True, autoincrement=True, nullable=False),
+        Column('name', String, nullable=False)
+    )
+    
+    metadata.create_all(engine)
+    engine.dispose()
+
+
+if __name__ == "__main__":
+    create_dbos_hello_table()

dbos/_tracer.py

@@ -1,13 +1,9 @@
 import os
 from typing import TYPE_CHECKING, Optional
 
-from opentelemetry import trace
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
-from opentelemetry.semconv.resource import ResourceAttributes
-from opentelemetry.trace import Span
+if TYPE_CHECKING:
+    from opentelemetry.trace import Span
+    from opentelemetry.sdk.trace import TracerProvider
 
 from dbos._utils import GlobalParams
 
@@ -29,34 +25,47 @@ class DBOSTracer:
     def config(self, config: ConfigFile) -> None:
         self.otlp_attributes = config.get("telemetry", {}).get("otlp_attributes", {})  # type: ignore
         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"],
-                }
+        if not self.disable_otlp:
+            from opentelemetry import trace
+            from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+                OTLPSpanExporter,
             )
-
-            provider = TracerProvider(resource=resource)
-            if os.environ.get("DBOS__CONSOLE_TRACES", None) is not None:
-                processor = BatchSpanProcessor(ConsoleSpanExporter())
-                provider.add_span_processor(processor)
-            otlp_traces_endpoints = (
-                config.get("telemetry", {}).get("OTLPExporter", {}).get("tracesEndpoint")  # type: ignore
+            from opentelemetry.sdk.resources import Resource
+            from opentelemetry.sdk.trace import TracerProvider
+            from opentelemetry.sdk.trace.export import (
+                BatchSpanProcessor,
+                ConsoleSpanExporter,
             )
-            if otlp_traces_endpoints:
-                for e in otlp_traces_endpoints:
-                    processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=e))
+            from opentelemetry.semconv.attributes.service_attributes import SERVICE_NAME
+
+            if not isinstance(trace.get_tracer_provider(), TracerProvider):
+                resource = Resource(
+                    attributes={
+                        SERVICE_NAME: config["name"],
+                    }
+                )
+
+                provider = TracerProvider(resource=resource)
+                if os.environ.get("DBOS__CONSOLE_TRACES", None) is not None:
+                    processor = BatchSpanProcessor(ConsoleSpanExporter())
                     provider.add_span_processor(processor)
-            trace.set_tracer_provider(provider)
-
-    def set_provider(self, provider: Optional[TracerProvider]) -> None:
+                otlp_traces_endpoints = (
+                    config.get("telemetry", {}).get("OTLPExporter", {}).get("tracesEndpoint")  # type: ignore
+                )
+                if otlp_traces_endpoints:
+                    for e in otlp_traces_endpoints:
+                        processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=e))
+                        provider.add_span_processor(processor)
+                trace.set_tracer_provider(provider)
+
+    def set_provider(self, provider: "Optional[TracerProvider]") -> None:
         self.provider = provider
 
     def start_span(
-        self, attributes: "TracedAttributes", parent: Optional[Span] = None
-    ) -> Span:
+        self, attributes: "TracedAttributes", parent: "Optional[Span]" = None
+    ) -> "Span":
+        from opentelemetry import trace
+
         tracer = (
             self.provider.get_tracer("dbos-tracer")
             if self.provider is not None
@@ -74,11 +83,13 @@ class DBOSTracer:
             span.set_attribute(k, v)
         return span
 
-    def end_span(self, span: Span) -> None:
+    def end_span(self, span: "Span") -> None:
         span.end()
 
-    def get_current_span(self) -> Optional[Span]:
+    def get_current_span(self) -> "Optional[Span]":
         # Return the current active span if any. It might not be a DBOS span.
+        from opentelemetry import trace
+
         span = trace.get_current_span()
         if span.get_span_context().is_valid:
             return span

dbos/_workflow_commands.py

@@ -98,10 +98,10 @@ def get_workflow(sys_db: SystemDatabase, workflow_id: str) -> Optional[WorkflowS
 
 
 def list_workflow_steps(
-    sys_db: SystemDatabase, app_db: ApplicationDatabase, workflow_id: str
+    sys_db: SystemDatabase, app_db: Optional[ApplicationDatabase], workflow_id: str
 ) -> List[StepInfo]:
     steps = sys_db.get_workflow_steps(workflow_id)
-    transactions = app_db.get_transactions(workflow_id)
+    transactions = app_db.get_transactions(workflow_id) if app_db else []
     merged_steps = steps + transactions
     merged_steps.sort(key=lambda step: step["function_id"])
     return merged_steps
@@ -109,7 +109,7 @@ def list_workflow_steps(
 
 def fork_workflow(
     sys_db: SystemDatabase,
-    app_db: ApplicationDatabase,
+    app_db: Optional[ApplicationDatabase],
     workflow_id: str,
     start_step: int,
     *,
@@ -122,7 +122,8 @@ def fork_workflow(
         ctx.id_assigned_for_next_workflow = ""
     else:
         forked_workflow_id = str(uuid.uuid4())
-    app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
+    if app_db:
+        app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
     sys_db.fork_workflow(
         workflow_id,
         forked_workflow_id,
@@ -145,7 +146,10 @@ def garbage_collect(
     )
     if result is not None:
         cutoff_epoch_timestamp_ms, pending_workflow_ids = result
-        dbos._app_db.garbage_collect(cutoff_epoch_timestamp_ms, pending_workflow_ids)
+        if dbos._app_db:
+            dbos._app_db.garbage_collect(
+                cutoff_epoch_timestamp_ms, pending_workflow_ids
+            )
 
 
 def global_timeout(dbos: "DBOS", cutoff_epoch_timestamp_ms: int) -> None: