Only set up logger and tracer if the lists are not none (#510)

It fixed a minor bug.

Author: qianl15

dbos/_dbos_config.py

@@ -264,8 +264,7 @@ def load_config(
                 data["telemetry"]["OTLPExporter"]["tracesEndpoint"]
             ]
 
-    data = cast(ConfigFile, data)
-    return data
+    return cast(ConfigFile, data)
 
 
 def process_config(

dbos/_logger.py

@@ -79,7 +79,7 @@ def config_logger(config: "ConfigFile") -> None:
 
         # Only set up OTLP provider and exporter if endpoints are provided
         log_provider = get_logger_provider()
-        if otlp_logs_endpoints is not None:
+        if otlp_logs_endpoints is not None and len(otlp_logs_endpoints) > 0:
             if not isinstance(log_provider, LoggerProvider):
                 log_provider = LoggerProvider(
                     Resource.create(
@@ -100,10 +100,11 @@ def config_logger(config: "ConfigFile") -> None:
 
         # Even if no endpoints are provided, we still need a LoggerProvider to create the LoggingHandler
         global _otlp_handler
-        _otlp_handler = LoggingHandler(logger_provider=log_provider)
+        if _otlp_handler is None:
+            _otlp_handler = LoggingHandler(logger_provider=log_provider)
 
-        # Direct DBOS logs to OTLP
-        dbos_logger.addHandler(_otlp_handler)
+            # Direct DBOS logs to OTLP
+            dbos_logger.addHandler(_otlp_handler)
 
     # Attach DBOS-specific attributes to all log entries.
     global _dbos_log_transformer

dbos/_tracer.py

@@ -45,7 +45,7 @@ def config(self, config: ConfigFile) -> None:
             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 otlp_traces_endpoints is not None and len(otlp_traces_endpoints) > 0:
                 if not isinstance(tracer_provider, TracerProvider):
                     resource = Resource(
                         attributes={

tests/conftest.py

@@ -10,6 +10,13 @@
 import sqlalchemy as sa
 from fastapi import FastAPI
 from flask import Flask
+from opentelemetry import trace
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.sdk import trace as tracesdk
+from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, InMemoryLogExporter
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
 
 from dbos import DBOS, DBOSClient, DBOSConfig
 from dbos._schemas.system_database import SystemSchema
@@ -54,7 +61,7 @@ def default_config() -> DBOSConfig:
             if using_sqlite()
             else f"postgresql+psycopg://postgres:{quote(os.environ.get('PGPASSWORD', 'dbos'), safe='')}@localhost:5432/dbostestpy_dbos_sys"
         ),
-        "enable_otlp": True,
+        "enable_otlp": False,
     }
 
 
@@ -150,9 +157,11 @@ def client(config: DBOSConfig, dbos: DBOS) -> Generator[DBOSClient, Any, None]:
 
 
 @pytest.fixture()
-def dbos_fastapi(
-    config: DBOSConfig, cleanup_test_databases: None
+def dbos_fastapi(  # type: ignore
+    config: DBOSConfig, cleanup_test_databases: None, setup_in_memory_otlp_collector
 ) -> Generator[Tuple[DBOS, FastAPI], Any, None]:
+    exporter, log_processor, log_exporter = setup_in_memory_otlp_collector
+    config["enable_otlp"] = True
     DBOS.destroy(destroy_registry=True)
     app = FastAPI()
     dbos = DBOS(fastapi=app, config=config)
@@ -182,6 +191,37 @@ def dbos_flask(
     DBOS.destroy(destroy_registry=True)
 
 
+# Type for mypy
+# define type
+TestOtelType = Tuple[
+    InMemorySpanExporter,
+    BatchLogRecordProcessor,
+    InMemoryLogExporter,
+]
+
+
+@pytest.fixture(scope="session")
+def setup_in_memory_otlp_collector() -> Generator[
+    TestOtelType,
+    Any,
+    None,
+]:
+    exporter = InMemorySpanExporter()
+    span_processor = SimpleSpanProcessor(exporter)
+    provider = tracesdk.TracerProvider()
+    provider.add_span_processor(span_processor)
+    trace.set_tracer_provider(provider)
+
+    # Set up in-memory log exporter
+    log_exporter = InMemoryLogExporter()  # type: ignore
+    log_processor = BatchLogRecordProcessor(log_exporter)
+    log_provider = LoggerProvider()
+    log_provider.add_log_record_processor(log_processor)
+    set_logger_provider(log_provider)
+
+    yield exporter, log_processor, log_exporter
+
+
 # Pretty-print test names
 def pytest_collection_modifyitems(session: Any, config: Any, items: Any) -> None:
     for item in items:

tests/test_fastapi_roles.py

@@ -18,18 +18,15 @@
 from dbos._context import assert_current_dbos_context
 from dbos._error import DBOSInitializationError, DBOSNotAuthorizedError
 from dbos._sys_db import GetWorkflowsInput
-from dbos._tracer import dbos_tracer
+from tests.conftest import TestOtelType
 
 
 @pytest.mark.order(1)
-def test_simple_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
-    # Set up a simple in-memory span exporter for testing
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
+def test_simple_endpoint(
+    dbos_fastapi: Tuple[DBOS, FastAPI], setup_in_memory_otlp_collector: TestOtelType
+) -> None:
 
+    exporter, log_processor, log_exporter = setup_in_memory_otlp_collector
     dbos, app = dbos_fastapi
 
     @app.middleware("http")
@@ -100,6 +97,7 @@ def test_error() -> None:
         raise HTTPException(status_code=401)
 
     client = TestClient(app)
+    exporter.clear()
 
     response = client.get("/user/b")
     assert response.status_code == 200

tests/test_spans.py

@@ -1,22 +1,16 @@
 from dataclasses import dataclass, field
-from typing import Optional, Tuple
+from typing import Optional
 
 import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 from inline_snapshot import snapshot
-from opentelemetry.sdk import trace as tracesdk
-from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
-from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, InMemoryLogExporter
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from opentelemetry import trace
 from opentelemetry.trace.span import format_trace_id
 
 from dbos import DBOS, DBOSConfig
-from dbos._logger import dbos_logger
-from dbos._tracer import dbos_tracer
 from dbos._utils import GlobalParams
-from tests.conftest import default_config
+from tests.conftest import TestOtelType
 
 
 @dataclass
@@ -26,18 +20,18 @@ class BasicSpan:
     parent_id: Optional[int] = field(repr=False, compare=False, default=None)
 
 
-def test_spans(config: DBOSConfig) -> None:
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
+def test_spans(
+    config: DBOSConfig, setup_in_memory_otlp_collector: TestOtelType
+) -> None:
+    exporter, log_processor, log_exporter = setup_in_memory_otlp_collector
 
     DBOS.destroy(destroy_registry=True)
     config["otlp_attributes"] = {"foo": "bar"}
+    config["enable_otlp"] = True
     DBOS(config=config)
     DBOS.launch()
 
+    provider = trace.get_tracer_provider()
     my_tracer = provider.get_tracer("dbos")
 
     @DBOS.workflow()
@@ -60,12 +54,9 @@ def test_step() -> None:
         DBOS.logger.info("This is a test_step")
         return
 
-    # Set up in-memory log exporter
-    log_exporter = InMemoryLogExporter()  # type: ignore
-    log_processor = BatchLogRecordProcessor(log_exporter)
-    log_provider = LoggerProvider()
-    log_provider.add_log_record_processor(log_processor)
-    dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
+    log_processor.force_flush(timeout_millis=5000)
+    log_exporter.clear()  # Clear any logs generated during setup
+    exporter.clear()
 
     test_workflow()
 
@@ -157,13 +148,18 @@ def test_step() -> None:
 
 
 @pytest.mark.asyncio
-async def test_spans_async(dbos: DBOS) -> None:
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
+async def test_spans_async(
+    config: DBOSConfig, setup_in_memory_otlp_collector: TestOtelType
+) -> None:
+    exporter, log_processor, log_exporter = setup_in_memory_otlp_collector
+
+    DBOS.destroy(destroy_registry=True)
+    config["otlp_attributes"] = {"foo": "bar"}
+    config["enable_otlp"] = True
+    DBOS(config=config)
+    DBOS.launch()
 
+    provider = trace.get_tracer_provider()
     my_tracer = provider.get_tracer("dbos")
 
     @DBOS.workflow()
@@ -186,12 +182,9 @@ async def test_step() -> None:
         DBOS.logger.info("This is a test_step")
         return
 
-    # Set up in-memory log exporter
-    log_exporter = InMemoryLogExporter()  # type: ignore
-    log_processor = BatchLogRecordProcessor(log_exporter)
-    log_provider = LoggerProvider()
-    log_provider.add_log_record_processor(log_processor)
-    dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
+    log_processor.force_flush(timeout_millis=5000)
+    log_exporter.clear()  # Clear any logs generated during setup
+    exporter.clear()
 
     await test_workflow()
 
@@ -281,27 +274,26 @@ async def test_step() -> None:
     )
 
 
-def test_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
-    dbos, app = dbos_fastapi
+def test_wf_fastapi(
+    config: DBOSConfig, setup_in_memory_otlp_collector: TestOtelType
+) -> None:
+    exporter, log_processor, log_exporter = setup_in_memory_otlp_collector
+
+    DBOS.destroy(destroy_registry=True)
+    config["enable_otlp"] = True
+    app = FastAPI()
+    dbos = DBOS(fastapi=app, config=config)
+    DBOS.launch()
 
     @app.get("/wf")
     @DBOS.workflow()
     def test_workflow_endpoint() -> str:
         dbos.logger.info("This is a test_workflow_endpoint")
         return "test"
 
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
-
-    # Set up in-memory log exporter
-    log_exporter = InMemoryLogExporter()  # type: ignore
-    log_processor = BatchLogRecordProcessor(log_exporter)
-    log_provider = LoggerProvider()
-    log_provider.add_log_record_processor(log_processor)
-    dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
+    log_processor.force_flush(timeout_millis=5000)
+    log_exporter.clear()  # Clear any logs generated during setup
+    exporter.clear()
 
     client = TestClient(app)
     response = client.get("/wf")
@@ -310,7 +302,8 @@ def test_workflow_endpoint() -> str:
 
     log_processor.force_flush(timeout_millis=5000)
     logs = log_exporter.get_finished_logs()
-    assert len(logs) == 1
+
+    assert len(logs) == 2
     assert logs[0].log_record.attributes is not None
     assert (
         logs[0].log_record.attributes["applicationVersion"] == DBOS.application_version
@@ -347,7 +340,11 @@ def test_workflow_endpoint() -> str:
     assert logs[0].log_record.trace_id == spans[0].context.trace_id
 
 
-def test_disable_otlp_no_spans(config: DBOSConfig) -> None:
+def test_disable_otlp_no_spans(
+    config: DBOSConfig, setup_in_memory_otlp_collector: TestOtelType
+) -> None:
+    exporter, log_processor, log_exporter = setup_in_memory_otlp_collector
+
     DBOS.destroy(destroy_registry=True)
     config["otlp_attributes"] = {"foo": "bar"}
     config["enable_otlp"] = False
@@ -364,18 +361,9 @@ def test_step() -> None:
         DBOS.logger.info("This is a test_step")
         return
 
-    exporter = InMemorySpanExporter()
-    span_processor = SimpleSpanProcessor(exporter)
-    provider = tracesdk.TracerProvider()
-    provider.add_span_processor(span_processor)
-    dbos_tracer.set_provider(provider)
-
-    # Set up in-memory log exporter
-    log_exporter = InMemoryLogExporter()  # type: ignore
-    log_processor = BatchLogRecordProcessor(log_exporter)
-    log_provider = LoggerProvider()
-    log_provider.add_log_record_processor(log_processor)
-    dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
+    log_processor.force_flush(timeout_millis=5000)
+    log_exporter.clear()  # Clear any logs generated during setup
+    exporter.clear()
 
     test_workflow()