Address PR comments.

Author: herin049

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

@@ -42,7 +42,7 @@
     LoggingHandler,
     LogRecordProcessor,
 )
-from opentelemetry.sdk._logs._internal import LoggerConfiguratorT
+from opentelemetry.sdk._logs._internal import _LoggerConfiguratorT
 from opentelemetry.sdk._logs.export import (
     BatchLogRecordProcessor,
     LogRecordExporter,
@@ -312,10 +312,10 @@ def _init_logging(
     log_record_processors: Sequence[LogRecordProcessor] | None = None,
     export_log_record_processor: _ConfigurationExporterLogRecordProcessorT
     | None = None,
-    logger_configurator: LoggerConfiguratorT | None = None,
+    logger_configurator: _LoggerConfiguratorT | None = None,
 ):
     provider = LoggerProvider(
-        resource=resource, logger_configurator=logger_configurator
+        resource=resource, _logger_configurator=logger_configurator
     )
     set_logger_provider(provider)
 
@@ -389,7 +389,7 @@ def overwritten_config_fn(*args, **kwargs):
 
 def _import_logger_configurator(
     logger_configurator_name: str | None,
-) -> LoggerConfiguratorT | None:
+) -> _LoggerConfiguratorT | None:
     if not logger_configurator_name:
         return None
 
@@ -571,7 +571,7 @@ def _initialize_components(
     | None = None,
     tracer_configurator: _TracerConfiguratorT | None = None,
     meter_configurator: _MeterConfiguratorT | None = None,
-    logger_configurator: LoggerConfiguratorT | None = None,
+    logger_configurator: _LoggerConfiguratorT | None = None,
 ):
     # pylint: disable=too-many-locals
     if trace_exporter_names is None:

opentelemetry-sdk/src/opentelemetry/sdk/_logs/_internal/__init__.py

@@ -22,7 +22,6 @@
 import threading
 import traceback
 import warnings
-from _weakrefset import WeakSet
 from dataclasses import dataclass, field
 from os import environ
 from threading import Lock
@@ -36,6 +35,7 @@
     cast,
     overload,
 )
+from weakref import WeakSet
 
 from typing_extensions import deprecated
 
@@ -652,12 +652,12 @@ def flush(self) -> None:
 
 
 @dataclass
-class LoggerConfig:
+class _LoggerConfig:
     is_enabled: bool = True
 
     @classmethod
-    def default(cls) -> LoggerConfig:
-        return LoggerConfig()
+    def default(cls) -> _LoggerConfig:
+        return _LoggerConfig()
 
 
 class Logger(APILogger):
@@ -671,7 +671,7 @@ def __init__(
         instrumentation_scope: InstrumentationScope,
         *,
         logger_metrics: LoggerMetrics,
-        logger_config: LoggerConfig,
+        _logger_config: _LoggerConfig,
     ):
         super().__init__(
             instrumentation_scope.name,
@@ -683,12 +683,12 @@ def __init__(
         self._multi_log_record_processor = multi_log_record_processor
         self._instrumentation_scope = instrumentation_scope
         self._logger_metrics = logger_metrics
-        self._logger_config = logger_config
+        self._logger_config = _logger_config
 
     def _is_enabled(self) -> bool:
         return self._logger_config.is_enabled
 
-    def set_logger_config(self, logger_config: LoggerConfig) -> None:
+    def _set_logger_config(self, logger_config: _LoggerConfig) -> None:
         self._logger_config = logger_config
 
     @property
@@ -752,20 +752,20 @@ def emit(
         self._multi_log_record_processor.on_emit(writable_record)
 
 
-LoggerConfiguratorT = Callable[[InstrumentationScope], LoggerConfig]
-RuleBasedLoggerConfigurator = RuleBasedConfigurator[LoggerConfig]
+_LoggerConfiguratorT = Callable[[InstrumentationScope], _LoggerConfig]
+_RuleBasedLoggerConfigurator = RuleBasedConfigurator[_LoggerConfig]
 
 
 def _default_logger_configurator(
     _logger_scope: InstrumentationScope,
-) -> LoggerConfig:
-    return LoggerConfig.default()
+) -> _LoggerConfig:
+    return _LoggerConfig.default()
 
 
 def _disable_logger_configurator(
     _logger_scope: InstrumentationScope,
-) -> LoggerConfig:
-    return LoggerConfig(is_enabled=False)
+) -> _LoggerConfig:
+    return _LoggerConfig(is_enabled=False)
 
 
 class LoggerProvider(APILoggerProvider):
@@ -778,7 +778,7 @@ def __init__(
         | None = None,
         *,
         meter_provider: MeterProvider | None = None,
-        logger_configurator: LoggerConfiguratorT | None = None,
+        _logger_configurator: _LoggerConfiguratorT | None = None,
     ):
         if resource is None:
             self._resource = Resource.create({})
@@ -793,7 +793,7 @@ def __init__(
         disabled = environ.get(OTEL_SDK_DISABLED, "")
         self._disabled = disabled.lower().strip() == "true"
         self._logger_configurator = (
-            logger_configurator or _default_logger_configurator
+            _logger_configurator or _default_logger_configurator
         )
         self._at_exit_handler = None
         if shutdown_on_exit:
@@ -821,7 +821,7 @@ def _get_logger_no_cache(
             self._multi_log_record_processor,
             scope,
             logger_metrics=self._logger_metrics,
-            logger_config=self._apply_logger_configurator(scope),
+            _logger_config=self._apply_logger_configurator(scope),
         )
 
     def _get_logger_cached(
@@ -876,8 +876,8 @@ def add_log_record_processor(
             log_record_processor
         )
 
-    def set_logger_configurator(
-        self, *, logger_configurator: LoggerConfiguratorT
+    def _set_logger_configurator(
+        self, *, logger_configurator: _LoggerConfiguratorT
     ):
         """Set a new LoggerConfigurator for this LoggerProvider.
 
@@ -888,15 +888,16 @@ def set_logger_configurator(
         self._logger_configurator = logger_configurator
         with self._active_loggers_lock:
             for logger in self._active_loggers:
-                logger.set_logger_config(
+                # pylint: disable-next=protected-access
+                logger._set_logger_config(
                     self._apply_logger_configurator(
                         logger.instrumentation_scope
                     )
                 )
 
     def _apply_logger_configurator(
         self, instrumentation_scope: InstrumentationScope
-    ) -> LoggerConfig:
+    ) -> _LoggerConfig:
         try:
             return self._logger_configurator(instrumentation_scope)
         # pylint: disable-next=broad-exception-caught
@@ -905,7 +906,7 @@ def _apply_logger_configurator(
                 "logger configurator failed for scope '%s', using default config",
                 instrumentation_scope.name,
             )
-            return LoggerConfig.default()
+            return _LoggerConfig.default()
 
     def shutdown(self) -> None:
         """Shuts down the log processors."""

opentelemetry-sdk/tests/logs/test_logs.py

@@ -26,12 +26,12 @@
     ReadableLogRecord,
 )
 from opentelemetry.sdk._logs._internal import (
-    LoggerConfig,
     LoggerMetrics,
     NoOpLogger,
-    RuleBasedLoggerConfigurator,
     SynchronousMultiLogRecordProcessor,
     _disable_logger_configurator,
+    _LoggerConfig,
+    _RuleBasedLoggerConfigurator,
 )
 from opentelemetry.sdk.environment_variables import OTEL_SDK_DISABLED
 from opentelemetry.sdk.resources import Resource
@@ -112,18 +112,18 @@ def test_default_logger_configurator(self):
 
     def test_logger_provider_with_disabled_configurator(self):
         provider = LoggerProvider(
-            logger_configurator=_disable_logger_configurator
+            _logger_configurator=_disable_logger_configurator
         )
         logger = provider.get_logger("test")
         self.assertFalse(logger._is_enabled())
 
     def test_logger_provider_with_custom_configurator(self):
         def configurator(scope):
             if scope.name == "disabled_logger":
-                return LoggerConfig(is_enabled=False)
-            return LoggerConfig.default()
+                return _LoggerConfig(is_enabled=False)
+            return _LoggerConfig.default()
 
-        provider = LoggerProvider(logger_configurator=configurator)
+        provider = LoggerProvider(_logger_configurator=configurator)
         enabled = provider.get_logger("enabled_logger")
         disabled = provider.get_logger("disabled_logger")
         self.assertTrue(enabled._is_enabled())
@@ -134,14 +134,14 @@ def test_set_logger_configurator_updates_existing_loggers(self):
         logger = provider.get_logger("test")
         self.assertTrue(logger._is_enabled())
 
-        provider.set_logger_configurator(
+        provider._set_logger_configurator(
             logger_configurator=_disable_logger_configurator
         )
         self.assertFalse(logger._is_enabled())
 
     def test_set_logger_configurator_affects_new_loggers(self):
         provider = LoggerProvider()
-        provider.set_logger_configurator(
+        provider._set_logger_configurator(
             logger_configurator=_disable_logger_configurator
         )
         logger = provider.get_logger("new_logger")
@@ -150,7 +150,7 @@ def test_set_logger_configurator_affects_new_loggers(self):
     # pylint: disable-next=no-self-use
     def test_disabled_logger_skips_emit(self):
         provider = LoggerProvider(
-            logger_configurator=_disable_logger_configurator
+            _logger_configurator=_disable_logger_configurator
         )
         logger = provider.get_logger("test")
         processor_mock = Mock()
@@ -165,15 +165,15 @@ def test_rule_based_logger_configurator(self):
         rules = [
             (
                 _scope_name_matches_glob(glob_pattern="module_name"),
-                LoggerConfig(is_enabled=True),
+                _LoggerConfig(is_enabled=True),
             ),
             (
                 _scope_name_matches_glob(glob_pattern="other_module_name"),
-                LoggerConfig(is_enabled=False),
+                _LoggerConfig(is_enabled=False),
             ),
         ]
-        configurator = RuleBasedLoggerConfigurator(
-            rules=rules, default_config=LoggerConfig(is_enabled=True)
+        configurator = _RuleBasedLoggerConfigurator(
+            rules=rules, default_config=_LoggerConfig(is_enabled=True)
         )
 
         provider = LoggerProvider()
@@ -185,7 +185,7 @@ def test_rule_based_logger_configurator(self):
         self.assertTrue(logger._is_enabled())
         self.assertTrue(other_logger._is_enabled())
 
-        provider.set_logger_configurator(logger_configurator=configurator)
+        provider._set_logger_configurator(logger_configurator=configurator)
 
         self.assertTrue(logger._is_enabled())
         self.assertFalse(other_logger._is_enabled())
@@ -196,11 +196,11 @@ def test_rule_based_logger_configurator_default_when_rules_dont_match(
         rules = [
             (
                 _scope_name_matches_glob(glob_pattern="module_name"),
-                LoggerConfig(is_enabled=False),
+                _LoggerConfig(is_enabled=False),
             ),
         ]
-        configurator = RuleBasedLoggerConfigurator(
-            rules=rules, default_config=LoggerConfig(is_enabled=True)
+        configurator = _RuleBasedLoggerConfigurator(
+            rules=rules, default_config=_LoggerConfig(is_enabled=True)
         )
 
         provider = LoggerProvider()
@@ -212,15 +212,15 @@ def test_rule_based_logger_configurator_default_when_rules_dont_match(
         self.assertTrue(logger._is_enabled())
         self.assertTrue(other_logger._is_enabled())
 
-        provider.set_logger_configurator(logger_configurator=configurator)
+        provider._set_logger_configurator(logger_configurator=configurator)
 
         self.assertFalse(logger._is_enabled())
         self.assertTrue(other_logger._is_enabled())
 
     def test_rule_based_configurator_first_match_wins(self):
-        disabled_config = LoggerConfig(is_enabled=False)
-        enabled_config = LoggerConfig(is_enabled=True)
-        configurator = RuleBasedLoggerConfigurator(
+        disabled_config = _LoggerConfig(is_enabled=False)
+        enabled_config = _LoggerConfig(is_enabled=True)
+        configurator = _RuleBasedLoggerConfigurator(
             rules=[
                 (lambda s: s.name == "foo", disabled_config),
                 (lambda s: s.name == "foo", enabled_config),
@@ -287,7 +287,7 @@ def _get_logger():
                 {"an": "attribute"},
             ),
             logger_metrics=LoggerMetrics(NoOpMeterProvider()),
-            logger_config=LoggerConfig.default(),
+            _logger_config=_LoggerConfig.default(),
         )
         return logger, log_record_processor_mock
 

opentelemetry-sdk/tests/test_configurator.py

@@ -53,7 +53,7 @@
     _OTelSDKConfigurator,
 )
 from opentelemetry.sdk._logs import LoggingHandler, LogRecordProcessor
-from opentelemetry.sdk._logs._internal import RuleBasedLoggerConfigurator
+from opentelemetry.sdk._logs._internal import _RuleBasedLoggerConfigurator
 from opentelemetry.sdk._logs._internal.export import LogRecordExporter
 from opentelemetry.sdk._logs.export import (
     ConsoleLogRecordExporter,
@@ -119,10 +119,10 @@ def add_span_processor(self, processor):
 
 
 class DummyLoggerProvider:
-    def __init__(self, resource=None, *, logger_configurator=None):
+    def __init__(self, resource=None, *, _logger_configurator=None):
         self.resource = resource
         self.processors = []
-        self._logger_configurator = logger_configurator
+        self._logger_configurator = _logger_configurator
 
     def add_log_record_processor(self, processor):
         self.processors.append(processor)
@@ -1184,7 +1184,7 @@ def test_logging_init_custom_logger_configurator_with_env(
         self, mock_entry_points
     ):
         def custom_logger_configurator(logger_scope):
-            return mock.Mock(spec=RuleBasedLoggerConfigurator)(logger_scope)
+            return mock.Mock(spec=_RuleBasedLoggerConfigurator)(logger_scope)
 
         mock_entry_points.configure_mock(
             return_value=[