Allow Passing Limit

Author: giongto35

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

@@ -556,6 +556,7 @@ def __init__(
     ) -> None:
         super().__init__(level=level)
         self._logger_provider = logger_provider or get_logger_provider()
+        self._log_limits = LogLimits()
 
     @staticmethod
     def _get_attributes(record: logging.LogRecord) -> _ExtendedAttributes:
@@ -629,6 +630,7 @@ def _translate(self, record: logging.LogRecord) -> LogRecord:
             body=body,
             resource=logger.resource,
             attributes=attributes,
+            limits=self._log_limits,
         )
 
     def emit(self, record: logging.LogRecord) -> None:

opentelemetry-sdk/tests/logs/test_handler.py

@@ -27,6 +27,7 @@
     LoggingHandler,
     LogRecordProcessor,
 )
+from opentelemetry.sdk.environment_variables import OTEL_ATTRIBUTE_COUNT_LIMIT
 from opentelemetry.semconv._incubating.attributes import code_attributes
 from opentelemetry.semconv.attributes import exception_attributes
 from opentelemetry.trace import (
@@ -367,6 +368,152 @@ def test_handler_root_logger_with_disabled_sdk_does_not_go_into_recursion_error(
 
         self.assertEqual(processor.emit_count(), 0)
 
+    @patch.dict(os.environ, {OTEL_ATTRIBUTE_COUNT_LIMIT: "3"})
+    def test_otel_attribute_count_limit_respected_in_logging_handler(self):
+        """Test that OTEL_ATTRIBUTE_COUNT_LIMIT is properly respected by LoggingHandler."""
+        processor, logger = set_up_test_logging(logging.WARNING)
+
+        # Create a log record with many extra attributes
+        extra_attrs = {f"custom_attr_{i}": f"value_{i}" for i in range(10)}
+
+        with self.assertLogs(level=logging.WARNING):
+            logger.warning(
+                "Test message with many attributes", extra=extra_attrs
+            )
+
+        log_record = processor.get_log_record(0)
+
+        # With OTEL_ATTRIBUTE_COUNT_LIMIT=3, should have exactly 3 attributes
+        total_attrs = len(log_record.attributes)
+        self.assertEqual(
+            total_attrs,
+            3,
+            f"Should have exactly 3 attributes due to limit, got {total_attrs}",
+        )
+
+        # Should have 10 dropped attributes (10 custom + 3 code - 3 kept = 10 dropped)
+        self.assertEqual(
+            log_record.dropped_attributes,
+            10,
+            f"Should have 10 dropped attributes, got {log_record.dropped_attributes}",
+        )
+
+    @patch.dict(os.environ, {OTEL_ATTRIBUTE_COUNT_LIMIT: "5"})
+    def test_otel_attribute_count_limit_includes_code_attributes(self):
+        """Test that OTEL_ATTRIBUTE_COUNT_LIMIT applies to all attributes including code attributes."""
+        processor, logger = set_up_test_logging(logging.WARNING)
+
+        # Create a log record with some extra attributes
+        extra_attrs = {f"user_attr_{i}": f"value_{i}" for i in range(8)}
+
+        with self.assertLogs(level=logging.WARNING):
+            logger.warning("Test message", extra=extra_attrs)
+
+        log_record = processor.get_log_record(0)
+
+        # With OTEL_ATTRIBUTE_COUNT_LIMIT=5, should have exactly 5 attributes
+        total_attrs = len(log_record.attributes)
+        self.assertEqual(
+            total_attrs,
+            5,
+            f"Should have exactly 5 attributes due to limit, got {total_attrs}",
+        )
+
+        # Should have 6 dropped attributes (8 user + 3 code - 5 kept = 6 dropped)
+        self.assertEqual(
+            log_record.dropped_attributes,
+            6,
+            f"Should have 6 dropped attributes, got {log_record.dropped_attributes}",
+        )
+
+    @patch.dict(os.environ, {OTEL_ATTRIBUTE_COUNT_LIMIT: "0"})
+    def test_otel_attribute_count_limit_zero_prevents_all_attributes(self):
+        """Test that OTEL_ATTRIBUTE_COUNT_LIMIT=0 prevents all attributes."""
+        processor, logger = set_up_test_logging(logging.WARNING)
+
+        # Create a log record with extra attributes
+        extra_attrs = {"user_attr": "value", "another_attr": "another_value"}
+
+        with self.assertLogs(level=logging.WARNING):
+            logger.warning("Test message", extra=extra_attrs)
+
+        log_record = processor.get_log_record(0)
+
+        # With OTEL_ATTRIBUTE_COUNT_LIMIT=0, should have 0 attributes
+        self.assertEqual(
+            len(log_record.attributes),
+            0,
+            "With OTEL_ATTRIBUTE_COUNT_LIMIT=0, should have no attributes",
+        )
+
+        # Should have 5 dropped attributes (2 user + 3 code = 5 dropped)
+        self.assertEqual(
+            log_record.dropped_attributes,
+            5,
+            f"Should have 5 dropped attributes, got {log_record.dropped_attributes}",
+        )
+
+    def test_logging_handler_without_env_var_uses_default_limit(self):
+        """Test that without OTEL_ATTRIBUTE_COUNT_LIMIT, default limit (128) should apply."""
+        processor, logger = set_up_test_logging(logging.WARNING)
+
+        # Create a log record with many attributes (more than default limit of 128)
+        extra_attrs = {f"attr_{i}": f"value_{i}" for i in range(150)}
+
+        with self.assertLogs(level=logging.WARNING):
+            logger.warning(
+                "Test message with many attributes", extra=extra_attrs
+            )
+
+        log_record = processor.get_log_record(0)
+
+        # Should be limited to default limit (128) total attributes
+        total_attrs = len(log_record.attributes)
+        self.assertEqual(
+            total_attrs,
+            128,
+            f"Should have exactly 128 attributes (default limit), got {total_attrs}",
+        )
+
+        # Should have 25 dropped attributes (150 user + 3 code - 128 kept = 25 dropped)
+        self.assertEqual(
+            log_record.dropped_attributes,
+            25,
+            f"Should have 25 dropped attributes, got {log_record.dropped_attributes}",
+        )
+
+    @patch.dict(os.environ, {OTEL_ATTRIBUTE_COUNT_LIMIT: "2"})
+    def test_otel_attribute_count_limit_with_exception_attributes(self):
+        """Test that OTEL_ATTRIBUTE_COUNT_LIMIT applies even with exception attributes."""
+        processor, logger = set_up_test_logging(logging.ERROR)
+
+        try:
+            raise ValueError("test exception")
+        except ValueError:
+            with self.assertLogs(level=logging.ERROR):
+                logger.exception(
+                    "Exception occurred", extra={"custom_attr": "value"}
+                )
+
+        log_record = processor.get_log_record(0)
+
+        # With OTEL_ATTRIBUTE_COUNT_LIMIT=2, should have exactly 2 attributes
+        # Total available: 3 code + 3 exception + 1 custom = 7 attributes
+        # But limited to 2, so 5 should be dropped
+        total_attrs = len(log_record.attributes)
+        self.assertEqual(
+            total_attrs,
+            2,
+            f"Should have exactly 2 attributes due to limit, got {total_attrs}",
+        )
+
+        # Should have 5 dropped attributes (7 total - 2 kept = 5 dropped)
+        self.assertEqual(
+            log_record.dropped_attributes,
+            5,
+            f"Should have 5 dropped attributes, got {log_record.dropped_attributes}",
+        )
+
 
 def set_up_test_logging(level, formatter=None, root_logger=False):
     logger_provider = LoggerProvider()