dbos 2.2.0__py3-none-any.whl → 2.4.0a5__py3-none-any.whl

dbos/_sys_db.py

@@ -106,7 +106,7 @@ class WorkflowStatus:
     updated_at: Optional[int]
     # If this workflow was enqueued, on which queue
     queue_name: Optional[str]
-    # The executor to most recently executed this workflow
+    # The executor to most recently execute this workflow
     executor_id: Optional[str]
     # The application version on which this workflow was started
     app_version: Optional[str]
@@ -114,6 +114,14 @@ class WorkflowStatus:
     workflow_timeout_ms: Optional[int]
     # The deadline of a workflow, computed by adding its timeout to its start time.
     workflow_deadline_epoch_ms: Optional[int]
+    # Unique ID for deduplication on a queue
+    deduplication_id: Optional[str]
+    # Priority of the workflow on the queue, starting from 1 ~ 2,147,483,647. Default 0 (highest priority).
+    priority: Optional[int]
+    # If this workflow is enqueued on a partitioned queue, its partition key
+    queue_partition_key: Optional[str]
+    # If this workflow was forked from another, that workflow's ID.
+    forked_from: Optional[str]
 
     # INTERNAL FIELDS
 
@@ -141,19 +149,13 @@ class WorkflowStatusInternal(TypedDict):
     app_version: Optional[str]
     app_id: Optional[str]
     recovery_attempts: Optional[int]
-    # The start-to-close timeout of the workflow in ms
     workflow_timeout_ms: Optional[int]
-    # The deadline of a workflow, computed by adding its timeout to its start time.
-    # Deadlines propagate to children. When the deadline is reached, the workflow is cancelled.
     workflow_deadline_epoch_ms: Optional[int]
-    # Unique ID for deduplication on a queue
     deduplication_id: Optional[str]
-    # Priority of the workflow on the queue, starting from 1 ~ 2,147,483,647. Default 0 (highest priority).
     priority: int
-    # Serialized workflow inputs
     inputs: str
-    # If this workflow is enqueued on a partitioned queue, its partition key
     queue_partition_key: Optional[str]
+    forked_from: Optional[str]
 
 
 class EnqueueOptionsInternal(TypedDict):
@@ -178,6 +180,7 @@ class OperationResultInternal(TypedDict):
     function_name: str
     output: Optional[str]  # JSON (jsonpickle)
     error: Optional[str]  # JSON (jsonpickle)
+    started_at_epoch_ms: int
 
 
 class GetEventWorkflowContext(TypedDict):
@@ -194,42 +197,34 @@ class GetWorkflowsInput:
     """
 
     def __init__(self) -> None:
-        self.workflow_ids: Optional[List[str]] = (
-            None  # Search only in these workflow IDs
-        )
-        self.name: Optional[str] = None  # The name of the workflow function
-        self.authenticated_user: Optional[str] = None  # The user who ran the workflow.
-        self.start_time: Optional[str] = None  # Timestamp in ISO 8601 format
-        self.end_time: Optional[str] = None  # Timestamp in ISO 8601 format
-        self.status: Optional[List[str]] = (
-            None  # Get workflows with one of these statuses
-        )
-        self.application_version: Optional[str] = (
-            None  # The application version that ran this workflow. = None
-        )
-        self.limit: Optional[int] = (
-            None  # Return up to this many workflows IDs. IDs are ordered by workflow creation time.
-        )
-        self.offset: Optional[int] = (
-            None  # Offset into the matching records for pagination
-        )
-        self.sort_desc: bool = (
-            False  # If true, sort by created_at in DESC order. Default false (in ASC order).
-        )
-        self.workflow_id_prefix: Optional[str] = (
-            None  # If set, search for workflow IDs starting with this string
-        )
-
-
-class GetQueuedWorkflowsInput(TypedDict):
-    queue_name: Optional[str]  # Get workflows belonging to this queue
-    status: Optional[list[str]]  # Get workflows with one of these statuses
-    start_time: Optional[str]  # Timestamp in ISO 8601 format
-    end_time: Optional[str]  # Timestamp in ISO 8601 format
-    limit: Optional[int]  # Return up to this many workflows IDs.
-    offset: Optional[int]  # Offset into the matching records for pagination
-    name: Optional[str]  # The name of the workflow function
-    sort_desc: Optional[bool]  # Sort by created_at in DESC or ASC order
+        # Search only in these workflow IDs
+        self.workflow_ids: Optional[List[str]] = None
+        # The name of the workflow function
+        self.name: Optional[str] = None
+        # The user who ran the workflow.
+        self.authenticated_user: Optional[str] = None
+        # Timestamp in ISO 8601 format
+        self.start_time: Optional[str] = None
+        # Timestamp in ISO 8601 format
+        self.end_time: Optional[str] = None
+        # Get workflows with one of these statuses
+        self.status: Optional[List[str]] = None
+        # The application version that ran this workflow.
+        self.application_version: Optional[str] = None
+        # Get workflows forked from this workflow ID.
+        self.forked_from: Optional[str] = None
+        # Return up to this many workflows IDs. IDs are ordered by workflow creation time.
+        self.limit: Optional[int] = None
+        # Offset into the matching records for pagination
+        self.offset: Optional[int] = None
+        # If true, sort by created_at in DESC order. Default false (in ASC order).
+        self.sort_desc: bool = False
+        # Search only for workflow IDs starting with this string
+        self.workflow_id_prefix: Optional[str] = None
+        # Search only for workflows enqueued on this queue
+        self.queue_name: Optional[str] = None
+        # Search only currently enqueued workflows
+        self.queues_only: bool = False
 
 
 class GetPendingWorkflowsOutput:
@@ -249,6 +244,10 @@ class StepInfo(TypedDict):
     error: Optional[Exception]
     # If the step starts or retrieves the result of a workflow, its ID
     child_workflow_id: Optional[str]
+    # The Unix epoch timestamp at which this step started
+    started_at_epoch_ms: Optional[int]
+    # The Unix epoch timestamp at which this step completed
+    completed_at_epoch_ms: Optional[int]
 
 
 _dbos_null_topic = "__null__topic__"
@@ -352,6 +351,7 @@ class SystemDatabase(ABC):
         engine: Optional[sa.Engine],
         schema: Optional[str],
         serializer: Serializer,
+        executor_id: Optional[str],
         debug_mode: bool = False,
     ) -> "SystemDatabase":
         """Factory method to create the appropriate SystemDatabase implementation based on URL."""
@@ -364,6 +364,7 @@ class SystemDatabase(ABC):
                 engine=engine,
                 schema=schema,
                 serializer=serializer,
+                executor_id=executor_id,
                 debug_mode=debug_mode,
             )
         else:
@@ -375,6 +376,7 @@ class SystemDatabase(ABC):
                 engine=engine,
                 schema=schema,
                 serializer=serializer,
+                executor_id=executor_id,
                 debug_mode=debug_mode,
             )
 
@@ -386,6 +388,7 @@ class SystemDatabase(ABC):
         engine: Optional[sa.Engine],
         schema: Optional[str],
         serializer: Serializer,
+        executor_id: Optional[str],
         debug_mode: bool = False,
     ):
         import sqlalchemy.dialects.postgresql as pg
@@ -411,6 +414,8 @@ class SystemDatabase(ABC):
 
         self.notifications_map = ThreadSafeConditionDict()
         self.workflow_events_map = ThreadSafeConditionDict()
+        self.executor_id = executor_id
+
         self._listener_thread_lock = threading.Lock()
 
         # Now we can run background processes
@@ -706,6 +711,7 @@ class SystemDatabase(ABC):
                     assumed_role=status["assumed_role"],
                     queue_name=INTERNAL_QUEUE_NAME,
                     inputs=status["inputs"],
+                    forked_from=original_workflow_id,
                 )
             )
 
@@ -767,6 +773,7 @@ class SystemDatabase(ABC):
                     SystemSchema.workflow_status.c.priority,
                     SystemSchema.workflow_status.c.inputs,
                     SystemSchema.workflow_status.c.queue_partition_key,
+                    SystemSchema.workflow_status.c.forked_from,
                 ).where(SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid)
             ).fetchone()
             if row is None:
@@ -795,6 +802,7 @@ class SystemDatabase(ABC):
                 "priority": row[17],
                 "inputs": row[18],
                 "queue_partition_key": row[19],
+                "forked_from": row[20],
             }
             return status
 
@@ -881,6 +889,10 @@ class SystemDatabase(ABC):
             SystemSchema.workflow_status.c.application_id,
             SystemSchema.workflow_status.c.workflow_deadline_epoch_ms,
             SystemSchema.workflow_status.c.workflow_timeout_ms,
+            SystemSchema.workflow_status.c.deduplication_id,
+            SystemSchema.workflow_status.c.priority,
+            SystemSchema.workflow_status.c.queue_partition_key,
+            SystemSchema.workflow_status.c.forked_from,
         ]
         if load_input:
             load_columns.append(SystemSchema.workflow_status.c.inputs)
@@ -888,7 +900,15 @@ class SystemDatabase(ABC):
             load_columns.append(SystemSchema.workflow_status.c.output)
             load_columns.append(SystemSchema.workflow_status.c.error)
 
-        query = sa.select(*load_columns)
+        if input.queues_only:
+            query = sa.select(*load_columns).where(
+                sa.and_(
+                    SystemSchema.workflow_status.c.queue_name.isnot(None),
+                    SystemSchema.workflow_status.c.status.in_(["ENQUEUED", "PENDING"]),
+                )
+            )
+        else:
+            query = sa.select(*load_columns)
         if input.sort_desc:
             query = query.order_by(SystemSchema.workflow_status.c.created_at.desc())
         else:
@@ -917,6 +937,10 @@ class SystemDatabase(ABC):
                 SystemSchema.workflow_status.c.application_version
                 == input.application_version
             )
+        if input.forked_from:
+            query = query.where(
+                SystemSchema.workflow_status.c.forked_from == input.forked_from
+            )
         if input.workflow_ids:
             query = query.where(
                 SystemSchema.workflow_status.c.workflow_uuid.in_(input.workflow_ids)
@@ -927,6 +951,10 @@ class SystemDatabase(ABC):
                     input.workflow_id_prefix
                 )
             )
+        if input.queue_name:
+            query = query.where(
+                SystemSchema.workflow_status.c.queue_name == input.queue_name
+            )
         if input.limit:
             query = query.limit(input.limit)
         if input.offset:
@@ -936,6 +964,7 @@ class SystemDatabase(ABC):
             rows = c.execute(query).fetchall()
 
         infos: List[WorkflowStatus] = []
+        workflow_ids: List[str] = []
         for row in rows:
             info = WorkflowStatus()
             info.workflow_id = row[0]
@@ -957,10 +986,14 @@ class SystemDatabase(ABC):
             info.app_id = row[14]
             info.workflow_deadline_epoch_ms = row[15]
             info.workflow_timeout_ms = row[16]
-
-            raw_input = row[17] if load_input else None
-            raw_output = row[18] if load_output else None
-            raw_error = row[19] if load_output else None
+            info.deduplication_id = row[17]
+            info.priority = row[18]
+            info.queue_partition_key = row[19]
+            info.forked_from = row[20]
+
+            raw_input = row[21] if load_input else None
+            raw_output = row[22] if load_output else None
+            raw_error = row[23] if load_output else None
             inputs, output, exception = safe_deserialize(
                 self.serializer,
                 info.workflow_id,
@@ -972,122 +1005,10 @@ class SystemDatabase(ABC):
             info.output = output
             info.error = exception
 
+            workflow_ids.append(info.workflow_id)
             infos.append(info)
         return infos
 
-    def get_queued_workflows(
-        self,
-        input: GetQueuedWorkflowsInput,
-        *,
-        load_input: bool = True,
-    ) -> List[WorkflowStatus]:
-        """
-        Retrieve a list of queued workflows result and inputs based on the input criteria. The result is a list of external-facing workflow status objects.
-        """
-        load_columns = [
-            SystemSchema.workflow_status.c.workflow_uuid,
-            SystemSchema.workflow_status.c.status,
-            SystemSchema.workflow_status.c.name,
-            SystemSchema.workflow_status.c.recovery_attempts,
-            SystemSchema.workflow_status.c.config_name,
-            SystemSchema.workflow_status.c.class_name,
-            SystemSchema.workflow_status.c.authenticated_user,
-            SystemSchema.workflow_status.c.authenticated_roles,
-            SystemSchema.workflow_status.c.assumed_role,
-            SystemSchema.workflow_status.c.queue_name,
-            SystemSchema.workflow_status.c.executor_id,
-            SystemSchema.workflow_status.c.created_at,
-            SystemSchema.workflow_status.c.updated_at,
-            SystemSchema.workflow_status.c.application_version,
-            SystemSchema.workflow_status.c.application_id,
-            SystemSchema.workflow_status.c.workflow_deadline_epoch_ms,
-            SystemSchema.workflow_status.c.workflow_timeout_ms,
-        ]
-        if load_input:
-            load_columns.append(SystemSchema.workflow_status.c.inputs)
-
-        query = sa.select(*load_columns).where(
-            sa.and_(
-                SystemSchema.workflow_status.c.queue_name.isnot(None),
-                SystemSchema.workflow_status.c.status.in_(["ENQUEUED", "PENDING"]),
-            )
-        )
-        if input["sort_desc"]:
-            query = query.order_by(SystemSchema.workflow_status.c.created_at.desc())
-        else:
-            query = query.order_by(SystemSchema.workflow_status.c.created_at.asc())
-
-        if input.get("name"):
-            query = query.where(SystemSchema.workflow_status.c.name == input["name"])
-
-        if input.get("queue_name"):
-            query = query.where(
-                SystemSchema.workflow_status.c.queue_name == input["queue_name"]
-            )
-
-        status = input.get("status", None)
-        if status:
-            query = query.where(SystemSchema.workflow_status.c.status.in_(status))
-        if "start_time" in input and input["start_time"] is not None:
-            query = query.where(
-                SystemSchema.workflow_status.c.created_at
-                >= datetime.datetime.fromisoformat(input["start_time"]).timestamp()
-                * 1000
-            )
-        if "end_time" in input and input["end_time"] is not None:
-            query = query.where(
-                SystemSchema.workflow_status.c.created_at
-                <= datetime.datetime.fromisoformat(input["end_time"]).timestamp() * 1000
-            )
-        if input.get("limit"):
-            query = query.limit(input["limit"])
-        if input.get("offset"):
-            query = query.offset(input["offset"])
-
-        with self.engine.begin() as c:
-            rows = c.execute(query).fetchall()
-
-        infos: List[WorkflowStatus] = []
-        for row in rows:
-            info = WorkflowStatus()
-            info.workflow_id = row[0]
-            info.status = row[1]
-            info.name = row[2]
-            info.recovery_attempts = row[3]
-            info.config_name = row[4]
-            info.class_name = row[5]
-            info.authenticated_user = row[6]
-            info.authenticated_roles = (
-                json.loads(row[7]) if row[7] is not None else None
-            )
-            info.assumed_role = row[8]
-            info.queue_name = row[9]
-            info.executor_id = row[10]
-            info.created_at = row[11]
-            info.updated_at = row[12]
-            info.app_version = row[13]
-            info.app_id = row[14]
-            info.workflow_deadline_epoch_ms = row[15]
-            info.workflow_timeout_ms = row[16]
-
-            raw_input = row[17] if load_input else None
-
-            # Error and Output are not loaded because they should always be None for queued workflows.
-            inputs, output, exception = safe_deserialize(
-                self.serializer,
-                info.workflow_id,
-                serialized_input=raw_input,
-                serialized_output=None,
-                serialized_exception=None,
-            )
-            info.input = inputs
-            info.output = output
-            info.error = exception
-
-            infos.append(info)
-
-        return infos
-
     def get_pending_workflows(
         self, executor_id: str, app_version: str
     ) -> list[GetPendingWorkflowsOutput]:
@@ -1121,6 +1042,8 @@ class SystemDatabase(ABC):
                     SystemSchema.operation_outputs.c.output,
                     SystemSchema.operation_outputs.c.error,
                     SystemSchema.operation_outputs.c.child_workflow_id,
+                    SystemSchema.operation_outputs.c.started_at_epoch_ms,
+                    SystemSchema.operation_outputs.c.completed_at_epoch_ms,
                 ).where(SystemSchema.operation_outputs.c.workflow_uuid == workflow_id)
             ).fetchall()
             steps = []
@@ -1138,6 +1061,8 @@ class SystemDatabase(ABC):
                     output=output,
                     error=exception,
                     child_workflow_id=row[4],
+                    started_at_epoch_ms=row[5],
+                    completed_at_epoch_ms=row[6],
                 )
                 steps.append(step)
             return steps
@@ -1150,10 +1075,33 @@ class SystemDatabase(ABC):
         error = result["error"]
         output = result["output"]
         assert error is None or output is None, "Only one of error or output can be set"
+        wf_executor_id_row = conn.execute(
+            sa.select(
+                SystemSchema.workflow_status.c.executor_id,
+            ).where(
+                SystemSchema.workflow_status.c.workflow_uuid == result["workflow_uuid"]
+            )
+        ).fetchone()
+        assert wf_executor_id_row is not None
+        wf_executor_id = wf_executor_id_row[0]
+        if self.executor_id is not None and wf_executor_id != self.executor_id:
+            dbos_logger.debug(
+                f'Resetting executor_id from {wf_executor_id} to {self.executor_id} for workflow {result["workflow_uuid"]}'
+            )
+            conn.execute(
+                sa.update(SystemSchema.workflow_status)
+                .values(executor_id=self.executor_id)
+                .where(
+                    SystemSchema.workflow_status.c.workflow_uuid
+                    == result["workflow_uuid"]
+                )
+            )
         sql = sa.insert(SystemSchema.operation_outputs).values(
             workflow_uuid=result["workflow_uuid"],
             function_id=result["function_id"],
             function_name=result["function_name"],
+            started_at_epoch_ms=result["started_at_epoch_ms"],
+            completed_at_epoch_ms=int(time.time() * 1000),
             output=output,
             error=error,
         )
@@ -1340,6 +1288,7 @@ class SystemDatabase(ABC):
         topic: Optional[str] = None,
     ) -> None:
         function_name = "DBOS.send"
+        start_time = int(time.time() * 1000)
         topic = topic if topic is not None else _dbos_null_topic
         with self.engine.begin() as c:
             recorded_output = self._check_operation_execution_txn(
@@ -1376,6 +1325,7 @@ class SystemDatabase(ABC):
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
                 "function_name": function_name,
+                "started_at_epoch_ms": start_time,
                 "output": None,
                 "error": None,
             }
@@ -1391,6 +1341,7 @@ class SystemDatabase(ABC):
         timeout_seconds: float = 60,
     ) -> Any:
         function_name = "DBOS.recv"
+        start_time = int(time.time() * 1000)
         topic = topic if topic is not None else _dbos_null_topic
 
         # First, check for previous executions.
@@ -1475,6 +1426,7 @@ class SystemDatabase(ABC):
                     "workflow_uuid": workflow_uuid,
                     "function_id": function_id,
                     "function_name": function_name,
+                    "started_at_epoch_ms": start_time,
                     "output": self.serializer.serialize(
                         message
                     ),  # None will be serialized to 'null'
@@ -1510,6 +1462,7 @@ class SystemDatabase(ABC):
         skip_sleep: bool = False,
     ) -> float:
         function_name = "DBOS.sleep"
+        start_time = int(time.time() * 1000)
         recorded_output = self.check_operation_execution(
             workflow_uuid, function_id, function_name
         )
@@ -1530,6 +1483,7 @@ class SystemDatabase(ABC):
                         "workflow_uuid": workflow_uuid,
                         "function_id": function_id,
                         "function_name": function_name,
+                        "started_at_epoch_ms": start_time,
                         "output": self.serializer.serialize(end_time),
                         "error": None,
                     }
@@ -1550,6 +1504,7 @@ class SystemDatabase(ABC):
         message: Any,
     ) -> None:
         function_name = "DBOS.setEvent"
+        start_time = int(time.time() * 1000)
         with self.engine.begin() as c:
             recorded_output = self._check_operation_execution_txn(
                 workflow_uuid, function_id, function_name, conn=c
@@ -1579,6 +1534,7 @@ class SystemDatabase(ABC):
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
                 "function_name": function_name,
+                "started_at_epoch_ms": start_time,
                 "output": None,
                 "error": None,
             }
@@ -1639,6 +1595,7 @@ class SystemDatabase(ABC):
         caller_ctx: Optional[GetEventWorkflowContext] = None,
     ) -> Any:
         function_name = "DBOS.getEvent"
+        start_time = int(time.time() * 1000)
         get_sql = sa.select(
             SystemSchema.workflow_events.c.value,
         ).where(
@@ -1713,6 +1670,7 @@ class SystemDatabase(ABC):
                     "workflow_uuid": caller_ctx["workflow_uuid"],
                     "function_id": caller_ctx["function_id"],
                     "function_name": function_name,
+                    "started_at_epoch_ms": start_time,
                     "output": self.serializer.serialize(
                         value
                     ),  # None will be serialized to 'null'
@@ -1951,6 +1909,7 @@ class SystemDatabase(ABC):
 
     def call_function_as_step(self, fn: Callable[[], T], function_name: str) -> T:
         ctx = get_local_dbos_context()
+        start_time = int(time.time() * 1000)
         if ctx and ctx.is_transaction():
             raise Exception(f"Invalid call to `{function_name}` inside a transaction")
         if ctx and ctx.is_workflow():
@@ -1978,6 +1937,7 @@ class SystemDatabase(ABC):
                     "workflow_uuid": ctx.workflow_id,
                     "function_id": ctx.function_id,
                     "function_name": function_name,
+                    "started_at_epoch_ms": start_time,
                     "output": self.serializer.serialize(result),
                     "error": None,
                 }
@@ -2056,6 +2016,7 @@ class SystemDatabase(ABC):
             if value == _dbos_stream_closed_sentinel
             else "DBOS.writeStream"
         )
+        start_time = int(time.time() * 1000)
 
         with self.engine.begin() as c:
 
@@ -2102,6 +2063,7 @@ class SystemDatabase(ABC):
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
                 "function_name": function_name,
+                "started_at_epoch_ms": start_time,
                 "output": None,
                 "error": None,
             }

dbos/_sys_db_postgres.py

@@ -41,7 +41,7 @@ class PostgresSystemDatabase(SystemDatabase):
                     parameters={"db_name": sysdb_name},
                 ).scalar():
                     dbos_logger.info(f"Creating system database {sysdb_name}")
-                    conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
+                    conn.execute(sa.text(f'CREATE DATABASE "{sysdb_name}"'))
             engine.dispose()
         else:
             # If we were provided an engine, validate it can connect

dbos/_tracer.py

@@ -25,6 +25,10 @@ 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
+        otlp_traces_endpoints = (
+            config.get("telemetry", {}).get("OTLPExporter", {}).get("tracesEndpoint")  # type: ignore
+        )
+
         if not self.disable_otlp:
             from opentelemetry import trace
             from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
@@ -38,25 +42,26 @@ class DBOSTracer:
             )
             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)
-                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)
+            tracer_provider = trace.get_tracer_provider()
+
+            # Only set up OTLP provider and exporter if endpoints are provided
+            if otlp_traces_endpoints is not None:
+                if not isinstance(tracer_provider, TracerProvider):
+                    resource = Resource(
+                        attributes={
+                            SERVICE_NAME: config["name"],
+                        }
+                    )
+
+                    tracer_provider = TracerProvider(resource=resource)
+                    if os.environ.get("DBOS__CONSOLE_TRACES", None) is not None:
+                        processor = BatchSpanProcessor(ConsoleSpanExporter())
+                        tracer_provider.add_span_processor(processor)
+                    trace.set_tracer_provider(tracer_provider)
+
+                for e in otlp_traces_endpoints:
+                    processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=e))
+                    tracer_provider.add_span_processor(processor)
 
     def set_provider(self, provider: "Optional[TracerProvider]") -> None:
         self.provider = provider