Fix ruff

Author: rads-1996

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

@@ -17,12 +17,12 @@
 import atexit
 import base64
 import concurrent.futures
+import fnmatch
 import json
 import logging
 import threading
 import traceback
 import warnings
-import fnmatch
 from os import environ
 from threading import Lock
 from time import time_ns
@@ -107,18 +107,18 @@ def __init__(
         trace_based: 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
                 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 
+                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 
-                process log records associated with sampled traces. If not explicitly set, 
-                defaults to False. If True, log records associated with unsampled traces 
+            trace_based: 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
@@ -134,39 +134,43 @@ def __repr__(self):
 
 
 def create_logger_configurator_by_name(
-    logger_configs: dict[str, LoggerConfig]
+    logger_configs: dict[str, LoggerConfig],
 ) -> LoggerConfigurator:
     """Create a LoggerConfigurator that selects configuration based on logger name.
 
     Args:
         logger_configs: A dictionary mapping logger names to LoggerConfig instances.
                        Loggers not found in this mapping will use the default config.
-    
+
     Returns:
         A LoggerConfigurator function that can be used with LoggerProvider.
     """
+
     def configurator(scope: InstrumentationScope) -> LoggerConfig | None:
         return logger_configs.get(scope.name)
+
     return configurator
 
 
 def create_logger_configurator_with_pattern(
-    patterns: list[tuple[str, LoggerConfig]]
+    patterns: list[tuple[str, LoggerConfig]],
 ) -> LoggerConfigurator:
     """Create a LoggerConfigurator that matches logger names using patterns.
-    
+
     Args:
         patterns: A list of (pattern, config) tuples. Patterns are matched in order,
                  and the first match is used. Use '*' as a wildcard.
-    
+
     Returns:
         A LoggerConfigurator function that can be used with LoggerProvider.
     """
+
     def configurator(scope: InstrumentationScope) -> LoggerConfig | None:
         for pattern, config in patterns:
             if fnmatch.fnmatch(scope.name, pattern):
                 return config
         return None
+
     return configurator
 
 
@@ -795,7 +799,7 @@ def instrumentation_scope(self):
 
     def update_config(self, config: LoggerConfig) -> None:
         """Update the logger's configuration.
-        
+
         Args:
             config: The new LoggerConfig to use.
         """
@@ -865,7 +869,9 @@ def emit(
         if is_less_than_min_severity(record, self._config.minimum_severity):
             return
 
-        if should_drop_logs_for_unsampled_traces(record, self._config.trace_based):
+        if should_drop_logs_for_unsampled_traces(
+            record, self._config.trace_based
+        ):
             return
 
         log_data = LogData(record, self._instrumentation_scope)
@@ -905,12 +911,16 @@ def __init__(
         if logger_configurator is not None:
             self._logger_configurator = logger_configurator
         else:
-            def default_configurator(scope: InstrumentationScope) -> LoggerConfig:
+
+            def default_configurator(
+                scope: InstrumentationScope,
+            ) -> LoggerConfig:
                 return LoggerConfig(
                     disabled=self._disabled,
                     minimum_severity=self._min_severity_level,
                     trace_based=self._trace_based,
                 )
+
             self._logger_configurator = default_configurator
 
     @property
@@ -989,9 +999,10 @@ def add_log_record_processor(
             log_record_processor
         )
 
-    def set_logger_configurator(self, configurator: LoggerConfigurator) -> None:
-        """Update the logger configurator and apply the new configuration to all existing loggers.
-        """
+    def set_logger_configurator(
+        self, configurator: LoggerConfigurator
+    ) -> None:
+        """Update the logger configurator and apply the new configuration to all existing loggers."""
         with self._logger_cache_lock:
             self._logger_configurator = configurator
             for logger in self._logger_cache.values():

opentelemetry-sdk/tests/logs/test_logs.py

@@ -18,8 +18,7 @@
 from unittest.mock import Mock, patch
 
 from opentelemetry._logs import LogRecord as APILogRecord
-from opentelemetry._logs import SeverityNumber
-from opentelemetry._logs import NoOpLogger
+from opentelemetry._logs import NoOpLogger, SeverityNumber
 from opentelemetry.context import get_current
 from opentelemetry.sdk._logs import (
     Logger,
@@ -347,8 +346,7 @@ def test_emit_logrecord_trace_filtering_edge_cases(self):
     def test_emit_both_min_severity_and_trace_based_filtering(self):
         """Test that both min severity and trace-based filtering work together"""
         config = LoggerConfig(
-            minimum_severity=SeverityNumber.WARN,
-            trace_based=True
+            minimum_severity=SeverityNumber.WARN, trace_based=True
         )
         logger, log_record_processor_mock = self._get_logger(config)
 
@@ -409,7 +407,7 @@ def test_logger_config_property(self):
         config = LoggerConfig(
             disabled=True,
             minimum_severity=SeverityNumber.WARN,
-            trace_based=True
+            trace_based=True,
         )
         logger, _ = self._get_logger(config)
 
@@ -421,19 +419,25 @@ def test_logger_configurator_behavior(self):
         """Test LoggerConfigurator functionality including custom configurators and dynamic updates"""
 
         logger_configs = {
-            "test.database": LoggerConfig(minimum_severity=SeverityNumber.ERROR),
+            "test.database": LoggerConfig(
+                minimum_severity=SeverityNumber.ERROR
+            ),
             "test.auth": LoggerConfig(disabled=True),
-            "test.performance": LoggerConfig(trace_based=True)
+            "test.performance": LoggerConfig(trace_based=True),
         }
 
-        from opentelemetry.sdk._logs._internal import create_logger_configurator_by_name # pylint:disable=import-outside-toplevel
+        from opentelemetry.sdk._logs._internal import (
+            create_logger_configurator_by_name,  # pylint:disable=import-outside-toplevel
+        )
+
         configurator = create_logger_configurator_by_name(logger_configs)
 
         provider = LoggerProvider(logger_configurator=configurator)
 
-
         db_logger = provider.get_logger("test.database")
-        self.assertEqual(db_logger.config.minimum_severity, SeverityNumber.ERROR)
+        self.assertEqual(
+            db_logger.config.minimum_severity, SeverityNumber.ERROR
+        )
         self.assertFalse(db_logger.config.disabled)
         self.assertFalse(db_logger.config.trace_based)
 
@@ -444,26 +448,35 @@ def test_logger_configurator_behavior(self):
         self.assertTrue(perf_logger.config.trace_based)
 
         other_logger = provider.get_logger("test.other")
-        self.assertEqual(other_logger.config.minimum_severity, SeverityNumber.UNSPECIFIED)
+        self.assertEqual(
+            other_logger.config.minimum_severity, SeverityNumber.UNSPECIFIED
+        )
         self.assertFalse(other_logger.config.disabled)
         self.assertFalse(other_logger.config.trace_based)
 
     def test_logger_configurator_pattern_matching(self):
         """Test LoggerConfigurator with pattern matching"""
-        from opentelemetry.sdk._logs._internal import create_logger_configurator_with_pattern
+        from opentelemetry.sdk._logs._internal import (
+            create_logger_configurator_with_pattern,
+        )
 
         patterns = [
-            ("test.database.*", LoggerConfig(minimum_severity=SeverityNumber.ERROR)),
+            (
+                "test.database.*",
+                LoggerConfig(minimum_severity=SeverityNumber.ERROR),
+            ),
             ("test.*.debug", LoggerConfig(disabled=True)),
             ("test.*", LoggerConfig(trace_based=True)),
-            ("*", LoggerConfig(minimum_severity=SeverityNumber.WARN))
+            ("*", LoggerConfig(minimum_severity=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)
+        self.assertEqual(
+            db_logger.config.minimum_severity, SeverityNumber.ERROR
+        )
 
         debug_logger = provider.get_logger("test.module.debug")
         self.assertTrue(debug_logger.config.disabled)
@@ -472,16 +485,23 @@ def test_logger_configurator_pattern_matching(self):
         self.assertTrue(general_logger.config.trace_based)
 
         other_logger = provider.get_logger("other.module")
-        self.assertEqual(other_logger.config.minimum_severity, SeverityNumber.WARN)
+        self.assertEqual(
+            other_logger.config.minimum_severity, 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)
         }
 
-        from opentelemetry.sdk._logs._internal import create_logger_configurator_by_name # pylint:disable=import-outside-toplevel
-        initial_configurator = create_logger_configurator_by_name(initial_configs)
+        from opentelemetry.sdk._logs._internal import (
+            create_logger_configurator_by_name,  # pylint:disable=import-outside-toplevel
+        )
+
+        initial_configurator = create_logger_configurator_by_name(
+            initial_configs
+        )
 
         provider = LoggerProvider(logger_configurator=initial_configurator)
 
@@ -490,28 +510,35 @@ def test_logger_configurator_dynamic_updates(self):
         self.assertFalse(logger.config.disabled)
 
         updated_configs = {
-            "test.module": LoggerConfig(minimum_severity=SeverityNumber.ERROR, disabled=True)
+            "test.module": LoggerConfig(
+                minimum_severity=SeverityNumber.ERROR, disabled=True
+            )
         }
-        updated_configurator = create_logger_configurator_by_name(updated_configs)
+        updated_configurator = create_logger_configurator_by_name(
+            updated_configs
+        )
 
         provider.set_logger_configurator(updated_configurator)
 
         self.assertEqual(logger.config.minimum_severity, SeverityNumber.ERROR)
         self.assertTrue(logger.config.disabled)
 
         new_logger = provider.get_logger("test.module")
-        self.assertEqual(new_logger.config.minimum_severity, SeverityNumber.ERROR)
+        self.assertEqual(
+            new_logger.config.minimum_severity, SeverityNumber.ERROR
+        )
         self.assertTrue(new_logger.config.disabled)
 
     def test_logger_configurator_returns_none(self):
         """Test LoggerConfigurator that returns None falls back to default"""
+
         def none_configurator(scope):
             return None
 
         provider = LoggerProvider(
             logger_configurator=none_configurator,
             min_severity_level=SeverityNumber.WARN,
-            trace_based=True
+            trace_based=True,
         )
 
         logger = provider.get_logger("test.module")
@@ -522,6 +549,7 @@ def none_configurator(scope):
 
     def test_logger_configurator_with_filtering(self):
         """Test that LoggerConfigurator configs are properly applied during filtering"""
+
         def selective_configurator(scope):
             if scope.name == "disabled.logger":
                 return LoggerConfig(disabled=True)