dbos 1.15.0a9__py3-none-any.whl → 2.4.0a5__py3-none-any.whl

dbos/_core.py

@@ -23,7 +23,6 @@ from typing import (
 from dbos._outcome import Immediate, NoResult, Outcome, Pending
 from dbos._utils import GlobalParams, retriable_postgres_exception
 
-from . import _serialization
 from ._app_db import ApplicationDatabase, TransactionResultInternal
 from ._context import (
     DBOSAssumeRole,
@@ -94,14 +93,6 @@ TEMP_SEND_WF_NAME = "<temp>.temp_send_workflow"
 DEBOUNCER_WORKFLOW_NAME = "_dbos_debouncer_workflow"
 
 
-def check_is_in_coroutine() -> bool:
-    try:
-        asyncio.get_running_loop()
-        return True
-    except RuntimeError:
-        return False
-
-
 class WorkflowHandleFuture(Generic[R]):
 
     def __init__(self, workflow_id: str, future: Future[R], dbos: "DBOS"):
@@ -116,10 +107,10 @@ class WorkflowHandleFuture(Generic[R]):
         try:
             r = self.future.result()
         except Exception as e:
-            serialized_e = _serialization.serialize_exception(e)
+            serialized_e = self.dbos._serializer.serialize(e)
             self.dbos._sys_db.record_get_result(self.workflow_id, None, serialized_e)
             raise
-        serialized_r = _serialization.serialize(r)
+        serialized_r = self.dbos._serializer.serialize(r)
         self.dbos._sys_db.record_get_result(self.workflow_id, serialized_r, None)
         return r
 
@@ -143,10 +134,10 @@ class WorkflowHandlePolling(Generic[R]):
         try:
             r: R = self.dbos._sys_db.await_workflow_result(self.workflow_id)
         except Exception as e:
-            serialized_e = _serialization.serialize_exception(e)
+            serialized_e = self.dbos._serializer.serialize(e)
             self.dbos._sys_db.record_get_result(self.workflow_id, None, serialized_e)
             raise
-        serialized_r = _serialization.serialize(r)
+        serialized_r = self.dbos._serializer.serialize(r)
         self.dbos._sys_db.record_get_result(self.workflow_id, serialized_r, None)
         return r
 
@@ -171,7 +162,7 @@ class WorkflowHandleAsyncTask(Generic[R]):
         try:
             r = await self.task
         except Exception as e:
-            serialized_e = _serialization.serialize_exception(e)
+            serialized_e = self.dbos._serializer.serialize(e)
             await asyncio.to_thread(
                 self.dbos._sys_db.record_get_result,
                 self.workflow_id,
@@ -179,7 +170,7 @@ class WorkflowHandleAsyncTask(Generic[R]):
                 serialized_e,
             )
             raise
-        serialized_r = _serialization.serialize(r)
+        serialized_r = self.dbos._serializer.serialize(r)
         await asyncio.to_thread(
             self.dbos._sys_db.record_get_result, self.workflow_id, serialized_r, None
         )
@@ -207,7 +198,7 @@ class WorkflowHandleAsyncPolling(Generic[R]):
                 self.dbos._sys_db.await_workflow_result, self.workflow_id
             )
         except Exception as e:
-            serialized_e = _serialization.serialize_exception(e)
+            serialized_e = self.dbos._serializer.serialize(e)
             await asyncio.to_thread(
                 self.dbos._sys_db.record_get_result,
                 self.workflow_id,
@@ -215,7 +206,7 @@ class WorkflowHandleAsyncPolling(Generic[R]):
                 serialized_e,
             )
             raise
-        serialized_r = _serialization.serialize(r)
+        serialized_r = self.dbos._serializer.serialize(r)
         await asyncio.to_thread(
             self.dbos._sys_db.record_get_result, self.workflow_id, serialized_r, None
         )
@@ -303,7 +294,13 @@ def _init_workflow(
             if enqueue_options is not None
             else 0
         ),
-        "inputs": _serialization.serialize_args(inputs),
+        "inputs": dbos._serializer.serialize(inputs),
+        "queue_partition_key": (
+            enqueue_options["queue_partition_key"]
+            if enqueue_options is not None
+            else None
+        ),
+        "forked_from": None,
     }
 
     # Synchronously record the status and inputs for workflows
@@ -319,7 +316,8 @@ def _init_workflow(
                 "function_id": ctx.parent_workflow_fid,
                 "function_name": wf_name,
                 "output": None,
-                "error": _serialization.serialize_exception(e),
+                "error": dbos._serializer.serialize(e),
+                "started_at_epoch_ms": int(time.time() * 1000),
             }
             dbos._sys_db.record_operation_result(result)
         raise
@@ -378,7 +376,7 @@ def _get_wf_invoke_func(
                 dbos._sys_db.update_workflow_outcome(
                     status["workflow_uuid"],
                     "SUCCESS",
-                    output=_serialization.serialize(output),
+                    output=dbos._serializer.serialize(output),
                 )
             return output
         except DBOSWorkflowConflictIDError:
@@ -392,7 +390,7 @@ def _get_wf_invoke_func(
                 dbos._sys_db.update_workflow_outcome(
                     status["workflow_uuid"],
                     "ERROR",
-                    error=_serialization.serialize_exception(error),
+                    error=dbos._serializer.serialize(error),
                 )
             raise
         finally:
@@ -464,7 +462,7 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
     status = dbos._sys_db.get_workflow_status(workflow_id)
     if not status:
         raise DBOSRecoveryError(workflow_id, "Workflow status not found")
-    inputs = _serialization.deserialize_args(status["inputs"])
+    inputs: WorkflowInputs = dbos._serializer.deserialize(status["inputs"])
     wf_func = dbos._registry.workflow_info_map.get(status["name"], None)
     if not wf_func:
         raise DBOSWorkflowFunctionNotFoundError(
@@ -572,6 +570,9 @@ def start_workflow(
         deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
         priority=local_ctx.priority if local_ctx is not None else None,
         app_version=local_ctx.app_version if local_ctx is not None else None,
+        queue_partition_key=(
+            local_ctx.queue_partition_key if local_ctx is not None else None
+        ),
     )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
@@ -665,6 +666,9 @@ async def start_workflow_async(
         deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
         priority=local_ctx.priority if local_ctx is not None else None,
         app_version=local_ctx.app_version if local_ctx is not None else None,
+        queue_partition_key=(
+            local_ctx.queue_partition_key if local_ctx is not None else None
+        ),
     )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
@@ -837,20 +841,15 @@ def workflow_wrapper(
             try:
                 r = func()
             except Exception as e:
-                serialized_e = _serialization.serialize_exception(e)
+                serialized_e = dbos._serializer.serialize(e)
                 assert workflow_id is not None
                 dbos._sys_db.record_get_result(workflow_id, None, serialized_e)
                 raise
-            serialized_r = _serialization.serialize(r)
+            serialized_r = dbos._serializer.serialize(r)
             assert workflow_id is not None
             dbos._sys_db.record_get_result(workflow_id, serialized_r, None)
             return r
 
-        if check_is_in_coroutine() and not inspect.iscoroutinefunction(func):
-            dbos_logger.warning(
-                f"Sync workflow ({get_dbos_func_name(func)}) shouldn't be invoked from within another async function. Define it as async or use asyncio.to_thread instead."
-            )
-
         outcome = (
             wfOutcome.wrap(init_wf, dbos=dbos)
             .also(DBOSAssumeRole(rr))
@@ -948,15 +947,15 @@ def decorate_transaction(
                                         f"Replaying transaction, id: {ctx.function_id}, name: {attributes['name']}"
                                     )
                                     if recorded_output["error"]:
-                                        deserialized_error = (
-                                            _serialization.deserialize_exception(
+                                        deserialized_error: Exception = (
+                                            dbos._serializer.deserialize(
                                                 recorded_output["error"]
                                             )
                                         )
                                         has_recorded_error = True
                                         raise deserialized_error
                                     elif recorded_output["output"]:
-                                        return _serialization.deserialize(
+                                        return dbos._serializer.deserialize(
                                             recorded_output["output"]
                                         )
                                     else:
@@ -969,7 +968,9 @@ def decorate_transaction(
                                     )
 
                                 output = func(*args, **kwargs)
-                                txn_output["output"] = _serialization.serialize(output)
+                                txn_output["output"] = dbos._serializer.serialize(
+                                    output
+                                )
                                 assert (
                                     ctx.sql_session is not None
                                 ), "Cannot find a database connection"
@@ -1010,8 +1011,8 @@ 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"] = (
-                                    _serialization.serialize_exception(txn_error)
+                                txn_output["error"] = dbos._serializer.serialize(
+                                    txn_error
                                 )
                                 dbos._app_db.record_transaction_error(txn_output)
             return output
@@ -1034,10 +1035,6 @@ def decorate_transaction(
                 assert (
                     ctx.is_workflow()
                 ), "Transactions must be called from within workflows"
-                if check_is_in_coroutine():
-                    dbos_logger.warning(
-                        f"Transaction function ({get_dbos_func_name(func)}) shouldn't be invoked from within another async function. Use asyncio.to_thread instead."
-                    )
                 with DBOSAssumeRole(rr):
                     return invoke_tx(*args, **kwargs)
             else:
@@ -1123,15 +1120,16 @@ def decorate_step(
                     "function_name": step_name,
                     "output": None,
                     "error": None,
+                    "started_at_epoch_ms": int(time.time() * 1000),
                 }
 
                 try:
                     output = func()
                 except Exception as error:
-                    step_output["error"] = _serialization.serialize_exception(error)
+                    step_output["error"] = dbos._serializer.serialize(error)
                     dbos._sys_db.record_operation_result(step_output)
                     raise
-                step_output["output"] = _serialization.serialize(output)
+                step_output["output"] = dbos._serializer.serialize(output)
                 dbos._sys_db.record_operation_result(step_output)
                 return output
 
@@ -1147,13 +1145,13 @@ def decorate_step(
                         f"Replaying step, id: {ctx.function_id}, name: {attributes['name']}"
                     )
                     if recorded_output["error"] is not None:
-                        deserialized_error = _serialization.deserialize_exception(
+                        deserialized_error: Exception = dbos._serializer.deserialize(
                             recorded_output["error"]
                         )
                         raise deserialized_error
                     elif recorded_output["output"] is not None:
                         return cast(
-                            R, _serialization.deserialize(recorded_output["output"])
+                            R, dbos._serializer.deserialize(recorded_output["output"])
                         )
                     else:
                         raise Exception("Output and error are both None")
@@ -1182,10 +1180,6 @@ def decorate_step(
 
         @wraps(func)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
-            if check_is_in_coroutine() and not inspect.iscoroutinefunction(func):
-                dbos_logger.warning(
-                    f"Sync step ({get_dbos_func_name(func)}) shouldn't be invoked from within another async function. Define it as async or use asyncio.to_thread instead."
-                )
             # If the step is called from a workflow, run it as a step.
             # Otherwise, run it as a normal function.
             ctx = get_local_dbos_context()
@@ -1278,21 +1272,24 @@ def recv(dbos: "DBOS", topic: Optional[str] = None, timeout_seconds: float = 60)
 def set_event(dbos: "DBOS", key: str, value: Any) -> None:
     cur_ctx = get_local_dbos_context()
     if cur_ctx is not None:
-        # Must call it within a workflow
-        assert (
-            cur_ctx.is_workflow()
-        ), "set_event() must be called from within a workflow"
-        attributes: TracedAttributes = {
-            "name": "set_event",
-        }
-        with EnterDBOSStep(attributes):
-            ctx = assert_current_dbos_context()
-            dbos._sys_db.set_event(
-                ctx.workflow_id, ctx.curr_step_function_id, key, value
+        if cur_ctx.is_workflow():
+            # If called from a workflow function, run as a step
+            attributes: TracedAttributes = {
+                "name": "set_event",
+            }
+            with EnterDBOSStep(attributes):
+                ctx = assert_current_dbos_context()
+                dbos._sys_db.set_event_from_workflow(
+                    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)
+        else:
+            raise DBOSException(
+                "set_event() must be called from within a workflow or step"
             )
     else:
-        # Cannot call it from outside of a workflow
-        raise DBOSException("set_event() must be called from within a workflow")
+        raise DBOSException("set_event() must be called from within a workflow or step")
 
 
 def get_event(

dbos/_dbos.py

@@ -31,6 +31,7 @@ from typing import (
 
 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._workflow_commands import fork_workflow, list_queued_workflows, list_workflows
@@ -341,6 +342,8 @@ class DBOS:
         self.conductor_websocket: Optional[ConductorWebsocket] = None
         self._background_event_loop: BackgroundEventLoop = BackgroundEventLoop()
         self._active_workflows_set: set[str] = set()
+        serializer = config.get("serializer")
+        self._serializer: Serializer = serializer if serializer else DefaultSerializer()
 
         # Globally set the application version and executor ID.
         # In DBOS Cloud, instead use the values supplied through environment variables.
@@ -449,28 +452,35 @@ class DBOS:
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
             # Get the schema configuration, use "dbos" as default
             schema = self._config.get("dbos_system_schema", "dbos")
+            dbos_logger.debug("Creating system database")
             self._sys_db_field = SystemDatabase.create(
                 system_database_url=get_system_database_url(self._config),
                 engine_kwargs=self._config["database"]["sys_db_engine_kwargs"],
                 engine=self._config["system_database_engine"],
                 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"]:
+                dbos_logger.debug("Creating application database")
                 self._app_db_field = ApplicationDatabase.create(
                     database_url=self._config["database_url"],
                     engine_kwargs=self._config["database"]["db_engine_kwargs"],
                     debug_mode=debug_mode,
                     schema=schema,
+                    serializer=self._serializer,
                 )
 
             if debug_mode:
                 return
 
             # Run migrations for the system and application databases
+            dbos_logger.debug("Running system database migrations")
             self._sys_db.run_migrations()
             if self._app_db:
+                dbos_logger.debug("Running application database migrations")
                 self._app_db.run_migrations()
 
             admin_port = self._config.get("runtimeConfig", {}).get("admin_port")
@@ -481,10 +491,12 @@ class DBOS:
             )
             if run_admin_server:
                 try:
+                    dbos_logger.debug("Starting admin server")
                     self._admin_server_field = AdminServer(dbos=self, port=admin_port)
                 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
             )
@@ -500,6 +512,7 @@ class DBOS:
             self._executor.submit(startup_recovery_thread, self, workflow_ids)
 
             # Listen to notifications
+            dbos_logger.debug("Starting notifications listener thread")
             notification_listener_thread = threading.Thread(
                 target=self._sys_db._notification_listener,
                 daemon=True,
@@ -511,6 +524,7 @@ class DBOS:
             self._registry.get_internal_queue()
 
             # Start the queue thread
+            dbos_logger.debug("Starting queue thread")
             evt = threading.Event()
             self.background_thread_stop_events.append(evt)
             bg_queue_thread = threading.Thread(
@@ -526,6 +540,7 @@ class DBOS:
                     self.conductor_url = f"wss://{dbos_domain}/conductor/v1alpha1"
                 evt = threading.Event()
                 self.background_thread_stop_events.append(evt)
+                dbos_logger.debug("Starting Conductor thread")
                 self.conductor_websocket = ConductorWebsocket(
                     self,
                     conductor_url=self.conductor_url,
@@ -536,6 +551,7 @@ class DBOS:
                 self._background_threads.append(self.conductor_websocket)
 
             # Grab any pollers that were deferred and start them
+            dbos_logger.debug("Starting event receivers")
             for evt, func, args, kwargs in self._registry.pollers:
                 self.poller_stop_events.append(evt)
                 poller_thread = threading.Thread(
@@ -1112,7 +1128,9 @@ class DBOS:
         end_time: Optional[str] = None,
         name: Optional[str] = None,
         app_version: Optional[str] = None,
+        forked_from: Optional[str] = None,
         user: Optional[str] = None,
+        queue_name: Optional[str] = None,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         sort_desc: bool = False,
@@ -1129,6 +1147,7 @@ class DBOS:
                 end_time=end_time,
                 name=name,
                 app_version=app_version,
+                forked_from=forked_from,
                 user=user,
                 limit=limit,
                 offset=offset,
@@ -1136,6 +1155,7 @@ class DBOS:
                 workflow_id_prefix=workflow_id_prefix,
                 load_input=load_input,
                 load_output=load_output,
+                queue_name=queue_name,
             )
 
         return _get_dbos_instance()._sys_db.call_function_as_step(
@@ -1152,6 +1172,7 @@ class DBOS:
         end_time: Optional[str] = None,
         name: Optional[str] = None,
         app_version: Optional[str] = None,
+        forked_from: Optional[str] = None,
         user: Optional[str] = None,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
@@ -1169,6 +1190,7 @@ class DBOS:
             end_time=end_time,
             name=name,
             app_version=app_version,
+            forked_from=forked_from,
             user=user,
             limit=limit,
             offset=offset,
@@ -1184,6 +1206,7 @@ class DBOS:
         *,
         queue_name: Optional[str] = None,
         status: Optional[Union[str, List[str]]] = None,
+        forked_from: Optional[str] = None,
         start_time: Optional[str] = None,
         end_time: Optional[str] = None,
         name: Optional[str] = None,
@@ -1197,6 +1220,7 @@ class DBOS:
                 _get_dbos_instance()._sys_db,
                 queue_name=queue_name,
                 status=status,
+                forked_from=forked_from,
                 start_time=start_time,
                 end_time=end_time,
                 name=name,
@@ -1216,6 +1240,7 @@ class DBOS:
         *,
         queue_name: Optional[str] = None,
         status: Optional[Union[str, List[str]]] = None,
+        forked_from: Optional[str] = None,
         start_time: Optional[str] = None,
         end_time: Optional[str] = None,
         name: Optional[str] = None,
@@ -1229,6 +1254,7 @@ class DBOS:
             cls.list_queued_workflows,
             queue_name=queue_name,
             status=status,
+            forked_from=forked_from,
             start_time=start_time,
             end_time=end_time,
             name=name,

dbos/_dbos_config.py

@@ -7,6 +7,8 @@ import sqlalchemy as sa
 import yaml
 from sqlalchemy import make_url
 
+from dbos._serialization import Serializer
+
 from ._error import DBOSInitializationError
 from ._logger import dbos_logger
 from ._schemas.system_database import SystemSchema
@@ -37,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.
+        serializer (Serializer): A custom serializer and deserializer DBOS uses when storing program data in the system database
     """
 
     name: str
@@ -57,6 +60,7 @@ class DBOSConfig(TypedDict, total=False):
     enable_otlp: Optional[bool]
     system_database_engine: Optional[sa.Engine]
     conductor_key: Optional[str]
+    serializer: Optional[Serializer]
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -67,16 +71,6 @@ class RuntimeConfig(TypedDict, total=False):
 
 
 class DatabaseConfig(TypedDict, total=False):
-    """
-    Internal data structure containing the DBOS database configuration.
-    Attributes:
-        sys_db_name (str): System database name
-        sys_db_pool_size (int): System database pool size
-        db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs
-        migrate (List[str]): Migration commands to run on startup
-        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
-    """
-
     sys_db_pool_size: Optional[int]
     db_engine_kwargs: Optional[Dict[str, Any]]
     sys_db_engine_kwargs: Optional[Dict[str, Any]]
@@ -450,6 +444,7 @@ def configure_db_engine_parameters(
 
     # Configure user database engine parameters
     app_engine_kwargs: dict[str, Any] = {
+        "connect_args": {"application_name": "dbos_transact"},
         "pool_timeout": 30,
         "max_overflow": 0,
         "pool_size": 20,
@@ -483,8 +478,6 @@ def is_valid_database_url(database_url: str) -> bool:
         return True
     url = make_url(database_url)
     required_fields = [
-        ("username", "Username must be specified in the connection URL"),
-        ("host", "Host must be specified in the connection URL"),
         ("database", "Database name must be specified in the connection URL"),
     ]
     for field_name, error_message in required_fields:

dbos/_debouncer.py

@@ -86,6 +86,7 @@ def debouncer_workflow(
     dbos = _get_dbos_instance()
 
     workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+
     # Every time the debounced workflow is called, a message is sent to this workflow.
     # It waits until debounce_period_sec have passed since the last message or until
     # debounce_timeout_sec has elapsed.
@@ -95,7 +96,10 @@ def debouncer_workflow(
             if options["debounce_timeout_sec"]
             else math.inf
         )
-    debounce_deadline_epoch_sec = dbos._sys_db.call_function_as_step(get_debounce_deadline_epoch_sec, "get_debounce_deadline_epoch_sec")
+
+    debounce_deadline_epoch_sec = dbos._sys_db.call_function_as_step(
+        get_debounce_deadline_epoch_sec, "get_debounce_deadline_epoch_sec"
+    )
     debounce_period_sec = initial_debounce_period_sec
     while time.time() < debounce_deadline_epoch_sec:
         time_until_deadline = max(debounce_deadline_epoch_sec - time.time(), 0)

dbos/_kafka.py

@@ -1,6 +1,6 @@
 import re
 import threading
-from typing import TYPE_CHECKING, Any, Callable, NoReturn
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, NoReturn
 
 from confluent_kafka import Consumer, KafkaError, KafkaException
 
@@ -15,7 +15,9 @@ from ._kafka_message import KafkaMessage
 from ._logger import dbos_logger
 from ._registrations import get_dbos_func_name
 
-_KafkaConsumerWorkflow = Callable[[KafkaMessage], None]
+_KafkaConsumerWorkflow = (
+    Callable[[KafkaMessage], None] | Callable[[KafkaMessage], Coroutine[Any, Any, None]]
+)
 
 _kafka_queue: Queue
 _in_order_kafka_queues: dict[str, Queue] = {}
@@ -37,8 +39,8 @@ def _kafka_consumer_loop(
     in_order: bool,
 ) -> None:
 
-    def on_error(err: KafkaError) -> NoReturn:
-        raise KafkaException(err)
+    def on_error(err: KafkaError) -> None:
+        dbos_logger.error(f"Exception in Kafka consumer: {err}")
 
     config["error_cb"] = on_error
     if "auto.offset.reset" not in config:

dbos/_logger.py

@@ -68,30 +68,37 @@ 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:
+    if not disable_otlp:
 
-        from opentelemetry._logs import set_logger_provider
+        from opentelemetry._logs import get_logger_provider, 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={
-                    SERVICE_NAME: config["name"],
-                }
-            )
-        )
-        set_logger_provider(log_provider)
-        for e in otlp_logs_endpoints:
-            log_provider.add_log_record_processor(
-                BatchLogRecordProcessor(
-                    OTLPLogExporter(endpoint=e),
-                    export_timeout_millis=5000,
+        # 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):
+                log_provider = LoggerProvider(
+                    Resource.create(
+                        attributes={
+                            SERVICE_NAME: config["name"],
+                        }
+                    )
+                )
+                set_logger_provider(log_provider)
+
+            for e in otlp_logs_endpoints:
+                log_provider.add_log_record_processor(
+                    BatchLogRecordProcessor(
+                        OTLPLogExporter(endpoint=e),
+                        export_timeout_millis=5000,
+                    )
                 )
-            )
+
+        # 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)