Do not use lru_cache on method

Author: sfc-gh-jopel

opentelemetry-sdk/benchmarks/logs/test_benchmark_logs.py renamed to opentelemetry-sdk/benchmarks/logs/test_benchmark_logging_handler.py

@@ -20,8 +20,8 @@
 import threading
 import traceback
 import warnings
-from functools import lru_cache
 from os import environ
+from threading import Lock
 from time import time_ns
 from typing import Any, Callable, Optional, Tuple, Union  # noqa
 
@@ -644,6 +644,8 @@ def __init__(
         self._at_exit_handler = None
         if shutdown_on_exit:
             self._at_exit_handler = atexit.register(self.shutdown)
+        self._logger_cache = {}
+        self._logger_cache_lock = Lock()
 
     @property
     def resource(self):
@@ -667,23 +669,31 @@ def _get_logger_no_cache(
             ),
         )
 
-    @lru_cache(maxsize=None)
     def _get_logger_cached(
         self,
         name: str,
         version: Optional[str] = None,
         schema_url: Optional[str] = None,
     ) -> Logger:
-        return Logger(
-            self._resource,
-            self._multi_log_record_processor,
-            InstrumentationScope(
-                name,
-                version,
-                schema_url,
-                None,
-            ),
-        )
+        key = (name, version, schema_url)
+        if key in self._logger_cache:
+            return self._logger_cache[key]
+
+        with self._logger_cache_lock:
+            if key in self._logger_cache:
+                return self._logger_cache[key]
+
+            self._logger_cache[key] = Logger(
+                self._resource,
+                self._multi_log_record_processor,
+                InstrumentationScope(
+                    name,
+                    version,
+                    schema_url,
+                    None,
+                ),
+            )
+            return self._logger_cache[key]
 
     def get_logger(
         self,
@@ -702,10 +712,7 @@ def get_logger(
             )
         if attributes is None:
             return self._get_logger_cached(name, version, schema_url)
-        else:
-            return self._get_logger_no_cache(
-                name, version, schema_url, attributes
-            )
+        return self._get_logger_no_cache(name, version, schema_url, attributes)
 
     def add_log_record_processor(
         self, log_record_processor: LogRecordProcessor

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

@@ -23,58 +23,44 @@ def create_logger(handler, name):
     return logger
 
 
-class TestLogProviderCache(unittest.TestCase):
+class TestLoggerProviderCache(unittest.TestCase):
 
     def test_get_logger_single_handler(self):
         handler, logger_provider = set_up_logging_handler(level=logging.DEBUG)
 
-        cache_info = logger_provider._get_logger_cached.cache_clear()
-
         logger = create_logger(handler, "test_logger")
 
         # Ensure logger is lazily cached
-        cache_info = logger_provider._get_logger_cached.cache_info()
-        self.assertEqual(0, cache_info.currsize)
+        self.assertEqual(0, len(logger_provider._logger_cache))
 
         logger.warning("test message")
 
-        cache_info = logger_provider._get_logger_cached.cache_info()
-        self.assertEqual(1, cache_info.currsize)
-        self.assertEqual(1, cache_info.misses)
+        self.assertEqual(1, len(logger_provider._logger_cache))
 
         # Ensure only one logger is cached
         rounds = 100
         for _ in range(rounds):
             logger.warning("test message")
 
-        cache_info = logger_provider._get_logger_cached.cache_info()
-        self.assertEqual(1, cache_info.currsize)
-        self.assertEqual(1, cache_info.misses)
+        self.assertEqual(1, len(logger_provider._logger_cache))
 
     def test_get_logger_multiple_loggers(self):
         handler, logger_provider = set_up_logging_handler(level=logging.DEBUG)
 
-        cache_info = logger_provider._get_logger_cached.cache_clear()
-
         num_loggers = 10
         loggers = [create_logger(handler, str(i)) for i in range(num_loggers)]
 
         # Ensure loggers are lazily cached
-        cache_info = logger_provider._get_logger_cached.cache_info()
-        self.assertEqual(0, cache_info.currsize)
+        self.assertEqual(0, len(logger_provider._logger_cache))
 
         for logger in loggers:
             logger.warning("test message")
 
-        cache_info = logger_provider._get_logger_cached.cache_info()
-        self.assertEqual(num_loggers, cache_info.currsize)
-        self.assertEqual(num_loggers, cache_info.misses)
+        self.assertEqual(num_loggers, len(logger_provider._logger_cache))
 
         rounds = 100
         for _ in range(rounds):
             for logger in loggers:
                 logger.warning("test message")
 
-        cache_info = logger_provider._get_logger_cached.cache_info()
-        self.assertEqual(num_loggers, cache_info.currsize)
-        self.assertEqual(num_loggers, cache_info.misses)
+        self.assertEqual(num_loggers, len(logger_provider._logger_cache))