Add unit test

Author: pmcollins

opentelemetry-sdk/src/opentelemetry/sdk/_configuration/__init__.py

@@ -266,29 +266,18 @@ def _patch_basic_config():
     original_basic_config = logging.basicConfig
 
     def patched_basic_config(*args, **kwargs):
-        # Get the root logger
         root = logging.getLogger()
-
-        # Check if the only handler is our OTel handler
         has_only_otel = len(root.handlers) == 1 and isinstance(
             root.handlers[0], LoggingHandler
         )
-
         if has_only_otel:
-            # Temporarily remove OTel handler
             otel_handler = root.handlers[0]
             root.handlers = []
-
-            # Call original basicConfig
             original_basic_config(*args, **kwargs)
-
-            # Add OTel handler back
             root.addHandler(otel_handler)
         else:
-            # Normal behavior
             original_basic_config(*args, **kwargs)
 
-    # Apply the monkey patch
     logging.basicConfig = patched_basic_config
 
 

opentelemetry-sdk/tests/test_configurator.py

@@ -845,30 +845,58 @@ def test_initialize_components_kwargs(
 
     def test_basicConfig_works_with_otel_handler(self):
         with ClearLoggingHandlers():
-            # Initialize auto-instrumentation with logging enabled
             _init_logging(
                 {"otlp": DummyOTLPLogExporter},
                 Resource.create({}),
                 setup_logging_handler=True,
             )
 
-            # Call basicConfig - this should work despite OTel handler being present
             logging.basicConfig(level=logging.INFO)
 
-            # Verify a StreamHandler was added
             root_logger = logging.getLogger()
             stream_handlers = [
                 h
                 for h in root_logger.handlers
                 if isinstance(h, logging.StreamHandler)
-                and not isinstance(h, LoggingHandler)
             ]
             self.assertEqual(
                 len(stream_handlers),
                 1,
                 "basicConfig should add a StreamHandler even when OTel handler exists",
             )
 
+    def test_basicConfig_preserves_otel_handler(self):
+        with ClearLoggingHandlers():
+            _init_logging(
+                {"otlp": DummyOTLPLogExporter},
+                Resource.create({}),
+                setup_logging_handler=True,
+            )
+
+            root_logger = logging.getLogger()
+            self.assertEqual(
+                len(root_logger.handlers),
+                1,
+                "Should be exactly one OpenTelemetry LoggingHandler",
+            )
+            handler = root_logger.handlers[0]
+            self.assertIsInstance(handler, LoggingHandler)
+
+            logging.basicConfig()
+
+            self.assertGreater(len(root_logger.handlers), 1)
+
+            logging_handlers = [
+                h
+                for h in root_logger.handlers
+                if isinstance(h, LoggingHandler)
+            ]
+            self.assertEqual(
+                len(logging_handlers),
+                1,
+                "Should still have exactly one OpenTelemetry LoggingHandler",
+            )
+
 
 class TestMetricsInit(TestCase):
     def setUp(self):
@@ -1112,43 +1140,32 @@ def __init__(self):
         self.original_handlers = None
 
     def __enter__(self):
-        # Save original state
         self.original_handlers = self.root_logger.handlers[:]
-        # Remove all handlers
         self.root_logger.handlers = []
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        # Restore original state
         self.root_logger.handlers = []
         for handler in self.original_handlers:
             self.root_logger.addHandler(handler)
 
 
 class TestClearLoggingHandlers(TestCase):
     def test_preserves_handlers(self):
-        root_logger = getLogger()  # Get the root logger
-        initial_handlers = root_logger.handlers[
-            :
-        ]  # Save initial test environment handlers
+        root_logger = getLogger()
+        initial_handlers = root_logger.handlers[:]
 
-        # Add our test handler
         test_handler = logging.StreamHandler()
         root_logger.addHandler(test_handler)
         expected_handlers = initial_handlers + [test_handler]
 
         with ClearLoggingHandlers():
-            # Should have no handlers during the test
             self.assertEqual(len(root_logger.handlers), 0)
-
-            # Add a temporary handler that should get cleaned up
             temp_handler = logging.StreamHandler()
             root_logger.addHandler(temp_handler)
 
-        # After the test, should be back to initial handlers plus our test handler
         self.assertEqual(len(root_logger.handlers), len(expected_handlers))
         for h1, h2 in zip(root_logger.handlers, expected_handlers):
             self.assertIs(h1, h2)
 
-        # Cleanup our test handler
         root_logger.removeHandler(test_handler)