Fix filter labels

Author: rads-1996

CHANGELOG.md

@@ -27,7 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#4737](https://github.com/open-telemetry/opentelemetry-python/pull/4737))
 - logs: add warnings for classes that would be deprecated and renamed in 1.39.0
   ([#4771](https://github.com/open-telemetry/opentelemetry-python/pull/4771))
-- Add `minimum_severity` and `trace_based` logger parameters to filter logs
+- Add `minimum_severity level` and `trace_based sampling` logger parameters to filter logs
   ([#4765](https://github.com/open-telemetry/opentelemetry-python/pull/4765))
 
 ## Version 1.37.0/0.58b0 (2025-09-11)

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

@@ -106,33 +106,33 @@ class LoggerConfig:
     def __init__(
         self,
         disabled: bool = False,
-        minimum_severity: SeverityNumber = SeverityNumber.UNSPECIFIED,
-        trace_based: bool = False,
+        minimum_severity_level: SeverityNumber = SeverityNumber.UNSPECIFIED,
+        trace_based_sampling: bool = False,
     ):
         """Initialize LoggerConfig with specified parameters.
 
         Args:
             disabled: A boolean indication of whether the logger is enabled.
                 If not explicitly set, defaults to False (i.e. Loggers are enabled by default).
                 If True, the logger behaves equivalently to a No-op Logger.
-            minimum_severity: A SeverityNumber indicating the minimum severity level
+            minimum_severity_level: A SeverityNumber indicating the minimum severity level
                 for log records to be processed. If not explicitly set, defaults to UNSPECIFIED (0).
                 If a log record's SeverityNumber is specified and is less than the configured
-                minimum_severity, the log record is dropped by the Logger.
-            trace_based: A boolean indication of whether the logger should only
+                minimum_severity_level, the log record is dropped by the Logger.
+            trace_based_sampling: A boolean indication of whether the logger should only
                 process log records associated with sampled traces. If not explicitly set,
                 defaults to False. If True, log records associated with unsampled traces
                 are dropped by the Logger.
         """
         self.disabled = disabled
-        self.minimum_severity = minimum_severity
-        self.trace_based = trace_based
+        self.minimum_severity_level = minimum_severity_level
+        self.trace_based_sampling = trace_based_sampling
 
     def __repr__(self):
         return (
             f"LoggerConfig(disabled={self.disabled}, "
-            f"minimum_severity={self.minimum_severity}, "
-            f"trace_based={self.trace_based})"
+            f"minimum_severity_level={self.minimum_severity_level}, "
+            f"trace_based_sampling={self.trace_based_sampling})"
         )
 
 
@@ -768,7 +768,7 @@ def __init__(
         instrumentation_scope: InstrumentationScope,
         config: LoggerConfig | None = None,
         min_severity_level: SeverityNumber = SeverityNumber.UNSPECIFIED,
-        trace_based: bool = False,
+        trace_based_sampling: bool = False,
     ):
         if config is not None:
             self._config = config
@@ -785,7 +785,7 @@ def __init__(
         self._multi_log_record_processor = multi_log_record_processor
         self._instrumentation_scope = instrumentation_scope
         self._min_severity_level = min_severity_level
-        self._trace_based = trace_based
+        self._trace_based_sampling = trace_based_sampling
 
     @property
     def resource(self):
@@ -869,11 +869,11 @@ def emit(
         if self._config.disabled:
             return
 
-        if is_less_than_min_severity(record, self._config.minimum_severity):
+        if is_less_than_min_severity(record, self._config.minimum_severity_level):
             return
 
         if should_drop_logs_for_unsampled_traces(
-            record, self._config.trace_based
+            record, self._config.trace_based_sampling
         ):
             return
 
@@ -891,7 +891,7 @@ def __init__(
         | ConcurrentMultiLogRecordProcessor
         | None = None,
         min_severity_level: SeverityNumber = SeverityNumber.UNSPECIFIED,
-        trace_based: bool = False,
+        trace_based_sampling: bool = False,
         logger_configurator: LoggerConfigurator | None = None,
     ):
         if resource is None:
@@ -909,7 +909,7 @@ def __init__(
         self._logger_cache = {}
         self._logger_cache_lock = Lock()
         self._min_severity_level = min_severity_level
-        self._trace_based = trace_based
+        self._trace_based_sampling = trace_based_sampling
 
         if logger_configurator is not None:
             self._logger_configurator = logger_configurator
@@ -920,8 +920,8 @@ def default_configurator(
             ) -> LoggerConfig:
                 return LoggerConfig(
                     disabled=self._disabled,
-                    minimum_severity=self._min_severity_level,
-                    trace_based=self._trace_based,
+                    minimum_severity_level=self._min_severity_level,
+                    trace_based_sampling=self._trace_based_sampling,
                 )
 
             self._logger_configurator = default_configurator
@@ -947,8 +947,8 @@ def _get_logger_no_cache(
         if config is None:
             config = LoggerConfig(
                 disabled=self._disabled,
-                minimum_severity=self._min_severity_level,
-                trace_based=self._trace_based,
+                minimum_severity_level=self._min_severity_level,
+                trace_based_sampling=self._trace_based_sampling,
             )
         return Logger(
             self._resource,
@@ -1013,8 +1013,8 @@ def set_logger_configurator(
                 if new_config is None:
                     new_config = LoggerConfig(
                         disabled=self._disabled,
-                        minimum_severity=self._min_severity_level,
-                        trace_based=self._trace_based,
+                        minimum_severity_level=self._min_severity_level,
+                        trace_based_sampling=self._trace_based_sampling,
                     )
                 logger.update_config(new_config)
 
@@ -1124,24 +1124,24 @@ def is_less_than_min_severity(
 
 
 def should_drop_logs_for_unsampled_traces(
-    record: LogRecord, trace_based_flag: bool
+    record: LogRecord, trace_based_sampling_flag: bool
 ) -> bool:
     """Determines whether the logger should drop log records associated with unsampled traces.
 
-    If `trace_based` is `true`, log records associated with unsampled traces are dropped by the `Logger`.
+    If `trace_based_sampling` is `true`, log records associated with unsampled traces are dropped by the `Logger`.
     A log record is considered associated with an unsampled trace if it has a valid `SpanId` and its
     `TraceFlags` indicate that the trace is unsampled. A log record that isn't associated with a trace
     context is not affected by this parameter and therefore bypasses trace-based filtering.
 
     Args:
         record: The log record to be processed.
-        trace_based_flag: A boolean flag indicating whether trace-based filtering is enabled. If not explicitly set,
-        the `trace_based` parameter is set to `false`
+        trace_based_sampling_flag: A boolean flag indicating whether trace-based filtering is enabled. If not explicitly set,
+        the `trace_based_sampling` parameter is set to `false`
 
     Returns:
         True if the log record should be dropped due to being associated with an unsampled trace.
     """
-    if trace_based_flag:
+    if trace_based_sampling_flag:
         if record.context is not None:
             span = get_current_span(record.context)
             span_context = span.get_span_context()

opentelemetry-sdk/tests/logs/test_logs.py

@@ -86,7 +86,7 @@ def test_get_logger_with_sdk_disabled(self):
     @patch.object(Resource, "create")
     def test_logger_provider_init(self, resource_patch):
         logger_provider = LoggerProvider(
-            min_severity_level=SeverityNumber.DEBUG4, trace_based=True
+            min_severity_level=SeverityNumber.DEBUG4, trace_based_sampling=True
         )
         resource_patch.assert_called_once()
         self.assertIsNotNone(logger_provider._resource)
@@ -99,7 +99,7 @@ def test_logger_provider_init(self, resource_patch):
         self.assertEqual(
             logger_provider._min_severity_level, SeverityNumber.DEBUG4
         )
-        self.assertTrue(logger_provider._trace_based)
+        self.assertTrue(logger_provider._trace_based_sampling)
         self.assertIsNotNone(logger_provider._at_exit_handler)
 
 
@@ -183,7 +183,7 @@ def test_can_emit_with_keywords_arguments(self):
 
     def test_emit_logrecord_with_min_severity_filtering(self):
         """Test that logs below minimum severity are filtered out"""
-        config = LoggerConfig(minimum_severity=SeverityNumber.DEBUG4)
+        config = LoggerConfig(minimum_severity_level=SeverityNumber.DEBUG4)
         logger, log_record_processor_mock = self._get_logger(config)
 
         log_record_info = LogRecord(
@@ -226,9 +226,9 @@ def test_emit_logrecord_with_min_severity_unspecified(self):
         logger.emit(log_record)
         log_record_processor_mock.on_emit.assert_called_once()
 
-    def test_emit_logrecord_with_trace_based_filtering(self):
+    def test_emit_logrecord_with_trace_based_sampling_filtering(self):
         """Test that logs are filtered based on trace sampling state"""
-        config = LoggerConfig(trace_based=True)
+        config = LoggerConfig(trace_based_sampling=True)
         logger, log_record_processor_mock = self._get_logger(config)
 
         mock_span_context = Mock()
@@ -294,7 +294,7 @@ def test_emit_logrecord_trace_filtering_disabled(self):
 
     def test_emit_logrecord_trace_filtering_edge_cases(self):
         """Test edge cases for trace-based filtering"""
-        config = LoggerConfig(trace_based=True)
+        config = LoggerConfig(trace_based_sampling=True)
         logger, log_record_processor_mock = self._get_logger(config)
 
         mock_span_context = Mock()
@@ -345,10 +345,10 @@ def test_emit_logrecord_trace_filtering_edge_cases(self):
             logger.emit(log_record)
             log_record_processor_mock.on_emit.assert_not_called()
 
-    def test_emit_both_min_severity_and_trace_based_filtering(self):
+    def test_emit_both_min_severity_and_trace_based_sampling_filtering(self):
         """Test that both min severity and trace-based filtering work together"""
         config = LoggerConfig(
-            minimum_severity=SeverityNumber.WARN, trace_based=True
+            minimum_severity_level=SeverityNumber.WARN, trace_based_sampling=True
         )
         logger, log_record_processor_mock = self._get_logger(config)
 
@@ -408,24 +408,24 @@ def test_logger_config_property(self):
         """Test that logger config property works correctly"""
         config = LoggerConfig(
             disabled=True,
-            minimum_severity=SeverityNumber.WARN,
-            trace_based=True,
+            minimum_severity_level=SeverityNumber.WARN,
+            trace_based_sampling=True,
         )
         logger, _ = self._get_logger(config)
 
         self.assertEqual(logger.config.disabled, True)
-        self.assertEqual(logger.config.minimum_severity, SeverityNumber.WARN)
-        self.assertEqual(logger.config.trace_based, True)
+        self.assertEqual(logger.config.minimum_severity_level, SeverityNumber.WARN)
+        self.assertEqual(logger.config.trace_based_sampling, True)
 
     def test_logger_configurator_behavior(self):
         """Test LoggerConfigurator functionality including custom configurators and dynamic updates"""
 
         logger_configs = {
             "test.database": LoggerConfig(
-                minimum_severity=SeverityNumber.ERROR
+                minimum_severity_level=SeverityNumber.ERROR
             ),
             "test.auth": LoggerConfig(disabled=True),
-            "test.performance": LoggerConfig(trace_based=True),
+            "test.performance": LoggerConfig(trace_based_sampling=True),
         }
 
         configurator = create_logger_configurator_by_name(logger_configs)
@@ -434,59 +434,59 @@ def test_logger_configurator_behavior(self):
 
         db_logger = provider.get_logger("test.database")
         self.assertEqual(
-            db_logger.config.minimum_severity, SeverityNumber.ERROR
+            db_logger.config.minimum_severity_level, SeverityNumber.ERROR
         )
         self.assertFalse(db_logger.config.disabled)
-        self.assertFalse(db_logger.config.trace_based)
+        self.assertFalse(db_logger.config.trace_based_sampling)
 
         auth_logger = provider.get_logger("test.auth")
         self.assertTrue(auth_logger.config.disabled)
 
         perf_logger = provider.get_logger("test.performance")
-        self.assertTrue(perf_logger.config.trace_based)
+        self.assertTrue(perf_logger.config.trace_based_sampling)
 
         other_logger = provider.get_logger("test.other")
         self.assertEqual(
-            other_logger.config.minimum_severity, SeverityNumber.UNSPECIFIED
+            other_logger.config.minimum_severity_level, SeverityNumber.UNSPECIFIED
         )
         self.assertFalse(other_logger.config.disabled)
-        self.assertFalse(other_logger.config.trace_based)
+        self.assertFalse(other_logger.config.trace_based_sampling)
 
     def test_logger_configurator_pattern_matching(self):
         """Test LoggerConfigurator with pattern matching"""
         patterns = [
             (
                 "test.database.*",
-                LoggerConfig(minimum_severity=SeverityNumber.ERROR),
+                LoggerConfig(minimum_severity_level=SeverityNumber.ERROR),
             ),
             ("test.*.debug", LoggerConfig(disabled=True)),
-            ("test.*", LoggerConfig(trace_based=True)),
-            ("*", LoggerConfig(minimum_severity=SeverityNumber.WARN)),
+            ("test.*", LoggerConfig(trace_based_sampling=True)),
+            ("*", LoggerConfig(minimum_severity_level=SeverityNumber.WARN)),
         ]
 
         configurator = create_logger_configurator_with_pattern(patterns)
         provider = LoggerProvider(logger_configurator=configurator)
 
         db_logger = provider.get_logger("test.database.connection")
         self.assertEqual(
-            db_logger.config.minimum_severity, SeverityNumber.ERROR
+            db_logger.config.minimum_severity_level, SeverityNumber.ERROR
         )
 
         debug_logger = provider.get_logger("test.module.debug")
         self.assertTrue(debug_logger.config.disabled)
 
         general_logger = provider.get_logger("test.module")
-        self.assertTrue(general_logger.config.trace_based)
+        self.assertTrue(general_logger.config.trace_based_sampling)
 
         other_logger = provider.get_logger("other.module")
         self.assertEqual(
-            other_logger.config.minimum_severity, SeverityNumber.WARN
+            other_logger.config.minimum_severity_level, SeverityNumber.WARN
         )
 
     def test_logger_configurator_dynamic_updates(self):
         """Test that LoggerConfigurator updates apply to existing loggers"""
         initial_configs = {
-            "test.module": LoggerConfig(minimum_severity=SeverityNumber.INFO)
+            "test.module": LoggerConfig(minimum_severity_level=SeverityNumber.INFO)
         }
 
         initial_configurator = create_logger_configurator_by_name(
@@ -496,12 +496,12 @@ def test_logger_configurator_dynamic_updates(self):
         provider = LoggerProvider(logger_configurator=initial_configurator)
 
         logger = provider.get_logger("test.module")
-        self.assertEqual(logger.config.minimum_severity, SeverityNumber.INFO)
+        self.assertEqual(logger.config.minimum_severity_level, SeverityNumber.INFO)
         self.assertFalse(logger.config.disabled)
 
         updated_configs = {
             "test.module": LoggerConfig(
-                minimum_severity=SeverityNumber.ERROR, disabled=True
+                minimum_severity_level=SeverityNumber.ERROR, disabled=True
             )
         }
         updated_configurator = create_logger_configurator_by_name(
@@ -510,12 +510,12 @@ def test_logger_configurator_dynamic_updates(self):
 
         provider.set_logger_configurator(updated_configurator)
 
-        self.assertEqual(logger.config.minimum_severity, SeverityNumber.ERROR)
+        self.assertEqual(logger.config.minimum_severity_level, SeverityNumber.ERROR)
         self.assertTrue(logger.config.disabled)
 
         new_logger = provider.get_logger("test.module")
         self.assertEqual(
-            new_logger.config.minimum_severity, SeverityNumber.ERROR
+            new_logger.config.minimum_severity_level, SeverityNumber.ERROR
         )
         self.assertTrue(new_logger.config.disabled)
 
@@ -528,23 +528,23 @@ def none_configurator(scope):
         provider = LoggerProvider(
             logger_configurator=none_configurator,
             min_severity_level=SeverityNumber.WARN,
-            trace_based=True,
+            trace_based_sampling=True,
         )
 
         logger = provider.get_logger("test.module")
 
-        self.assertEqual(logger.config.minimum_severity, SeverityNumber.WARN)
-        self.assertTrue(logger.config.trace_based)
+        self.assertEqual(logger.config.minimum_severity_level, SeverityNumber.WARN)
+        self.assertTrue(logger.config.trace_based_sampling)
         self.assertFalse(logger.config.disabled)
 
     @staticmethod
     def _selective_configurator(scope):
         if scope.name == "disabled.logger":
             return LoggerConfig(disabled=True)
         if scope.name == "error.logger":
-            return LoggerConfig(minimum_severity=SeverityNumber.ERROR)
+            return LoggerConfig(minimum_severity_level=SeverityNumber.ERROR)
         if scope.name == "trace.logger":
-            return LoggerConfig(trace_based=True)
+            return LoggerConfig(trace_based_sampling=True)
         return LoggerConfig()
 
     def test_logger_configurator_with_filtering(self):