feat(config): wire top-level attribute_limits into per-signal providers

Parses config.attribute_limits in configure_sdk() and passes it as a
global fallback to create_tracer_provider() and create_logger_provider().
Per-signal limits (tracer_provider.limits / logger_provider.limits)
always take precedence; absent fields fall back to the global value, then
to OTel spec defaults.

For logs, adds log_record_limits to the LoggerProvider constructor,
threads it through Logger, and applies it when constructing each
ReadWriteLogRecord — mirroring how SpanLimits flows through TracerProvider.

Author: ocelotl

.changelog/5365.added

@@ -0,0 +1 @@
+`opentelemetry-sdk`: wire top-level `attribute_limits` into per-signal providers via declarative config; add `log_record_limits` support to `LoggerProvider`

opentelemetry-configuration/src/opentelemetry/configuration/_logger_provider.py

@@ -16,6 +16,9 @@
     ConfigurationError,
     MissingDependencyError,
 )
+from opentelemetry.configuration.models import (
+    AttributeLimits,
+)
 from opentelemetry.configuration.models import (
     BatchLogRecordProcessor as BatchLogRecordProcessorConfig,
 )
@@ -28,6 +31,9 @@
 from opentelemetry.configuration.models import (
     LogRecordExporter as LogRecordExporterConfig,
 )
+from opentelemetry.configuration.models import (
+    LogRecordLimits as LogRecordLimitsConfig,
+)
 from opentelemetry.configuration.models import (
     LogRecordProcessor as LogRecordProcessorConfig,
 )
@@ -41,6 +47,7 @@
     SimpleLogRecordProcessor as SimpleLogRecordProcessorConfig,
 )
 from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry.sdk._logs._internal import LogRecordLimits
 from opentelemetry.sdk._logs._internal.export import (
     BatchLogRecordProcessor,
     ConsoleLogRecordExporter,
@@ -51,6 +58,8 @@
 
 _logger = logging.getLogger(__name__)
 
+_DEFAULT_OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 128
+
 # BatchLogRecordProcessor defaults per OTel spec (milliseconds).
 _DEFAULT_SCHEDULE_DELAY_MILLIS = 1000
 _DEFAULT_EXPORT_TIMEOUT_MILLIS = 30000
@@ -235,9 +244,44 @@ def _create_log_record_processor(
     )
 
 
+def _create_log_record_limits(
+    config: LogRecordLimitsConfig,
+    global_limits: AttributeLimits | None = None,
+) -> LogRecordLimits:
+    """Create LogRecordLimits from config.
+
+    Absent fields fall back to global_limits (if provided), then to OTel spec
+    defaults (128 for counts, unlimited for lengths).
+    Explicit values suppress env-var reading — matching Java SDK behavior.
+    """
+    attribute_count_limit = config.attribute_count_limit
+    if attribute_count_limit is None and global_limits is not None:
+        attribute_count_limit = global_limits.attribute_count_limit
+
+    attribute_value_length_limit = config.attribute_value_length_limit
+    if attribute_value_length_limit is None and global_limits is not None:
+        attribute_value_length_limit = (
+            global_limits.attribute_value_length_limit
+        )
+
+    return LogRecordLimits(
+        max_attributes=(
+            attribute_count_limit
+            if attribute_count_limit is not None
+            else _DEFAULT_OTEL_LOG_ATTRIBUTE_COUNT_LIMIT
+        ),
+        max_attribute_length=(
+            attribute_value_length_limit
+            if attribute_value_length_limit is not None
+            else LogRecordLimits.UNSET
+        ),
+    )
+
+
 def create_logger_provider(
     config: LoggerProviderConfig | None,
     resource: Resource | None = None,
+    global_attribute_limits: AttributeLimits | None = None,
 ) -> LoggerProvider:
     """Create an SDK LoggerProvider from declarative config.
 
@@ -247,21 +291,28 @@ def create_logger_provider(
     Args:
         config: LoggerProvider config from the parsed config file, or None.
         resource: Resource to attach to the provider.
+        global_attribute_limits: Top-level attribute_limits from the root config,
+            used as a fallback when per-signal limits are not specified.
 
     Returns:
         A configured LoggerProvider.
     """
-    provider = LoggerProvider(resource=resource)
+    if config is not None and config.limits is not None:
+        log_record_limits = _create_log_record_limits(
+            config.limits, global_attribute_limits
+        )
+    else:
+        log_record_limits = _create_log_record_limits(
+            LogRecordLimitsConfig(), global_attribute_limits
+        )
+
+    provider = LoggerProvider(
+        resource=resource, log_record_limits=log_record_limits
+    )
 
     if config is None:
         return provider
 
-    if config.limits is not None:
-        _logger.warning(
-            "log_record_limits are specified in config but are not supported "
-            "by the Python SDK LoggerProvider constructor; limits will be ignored."
-        )
-
     for processor_config in config.processors:
         provider.add_log_record_processor(
             _create_log_record_processor(processor_config)
@@ -273,6 +324,7 @@ def create_logger_provider(
 def configure_logger_provider(
     config: LoggerProviderConfig | None,
     resource: Resource | None = None,
+    global_attribute_limits: AttributeLimits | None = None,
 ) -> None:
     """Configure the global LoggerProvider from declarative config.
 
@@ -282,7 +334,11 @@ def configure_logger_provider(
     Args:
         config: LoggerProvider config from the parsed config file, or None.
         resource: Resource to attach to the provider.
+        global_attribute_limits: Top-level attribute_limits from the root config,
+            used as a fallback when per-signal limits are not specified.
     """
     if config is None:
         return
-    set_logger_provider(create_logger_provider(config, resource))
+    set_logger_provider(
+        create_logger_provider(config, resource, global_attribute_limits)
+    )

opentelemetry-configuration/src/opentelemetry/configuration/_sdk.py

@@ -26,7 +26,10 @@
 from opentelemetry.configuration.instrumentation import (
     configure_instrumentation,
 )
-from opentelemetry.configuration.models import OpenTelemetryConfiguration
+from opentelemetry.configuration.models import (
+    AttributeLimits,
+    OpenTelemetryConfiguration,
+)
 
 _logger = getLogger(__name__)
 
@@ -60,9 +63,14 @@ def configure_sdk(config: OpenTelemetryConfiguration) -> None:
         )
         return
 
+    global_attribute_limits: AttributeLimits | None = config.attribute_limits
     resource = create_resource(config.resource)
-    configure_tracer_provider(config.tracer_provider, resource)
+    configure_tracer_provider(
+        config.tracer_provider, resource, global_attribute_limits
+    )
     configure_meter_provider(config.meter_provider, resource)
-    configure_logger_provider(config.logger_provider, resource)
+    configure_logger_provider(
+        config.logger_provider, resource, global_attribute_limits
+    )
     configure_propagator(config.propagator)
     configure_instrumentation(config.instrumentation_development)

opentelemetry-configuration/src/opentelemetry/configuration/_tracer_provider.py

@@ -16,6 +16,9 @@
     ConfigurationError,
     MissingDependencyError,
 )
+from opentelemetry.configuration.models import (
+    AttributeLimits,
+)
 from opentelemetry.configuration.models import (
     ExperimentalComposableRuleBasedSampler as RuleBasedSamplerConfig,
 )
@@ -400,16 +403,30 @@ def _create_parent_based_sampler(config: ParentBasedSamplerConfig) -> Sampler:
     return ParentBased(**kwargs)
 
 
-def _create_span_limits(config: SpanLimitsConfig) -> SpanLimits:
+def _create_span_limits(
+    config: SpanLimitsConfig,
+    global_limits: AttributeLimits | None = None,
+) -> SpanLimits:
     """Create SpanLimits from config.
 
-    Absent fields use the OTel spec defaults (128 for counts, unlimited for lengths).
+    Absent fields fall back to global_limits (if provided), then to OTel spec
+    defaults (128 for counts, unlimited for lengths).
     Explicit values suppress env-var reading — matching Java SDK behavior.
     """
+    attribute_count_limit = config.attribute_count_limit
+    if attribute_count_limit is None and global_limits is not None:
+        attribute_count_limit = global_limits.attribute_count_limit
+
+    attribute_value_length_limit = config.attribute_value_length_limit
+    if attribute_value_length_limit is None and global_limits is not None:
+        attribute_value_length_limit = (
+            global_limits.attribute_value_length_limit
+        )
+
     return SpanLimits(
         max_span_attributes=(
-            config.attribute_count_limit
-            if config.attribute_count_limit is not None
+            attribute_count_limit
+            if attribute_count_limit is not None
             else _DEFAULT_OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT
         ),
         max_events=(
@@ -432,13 +449,23 @@ def _create_span_limits(config: SpanLimitsConfig) -> SpanLimits:
             if config.link_attribute_count_limit is not None
             else _DEFAULT_OTEL_LINK_ATTRIBUTE_COUNT_LIMIT
         ),
-        max_attribute_length=config.attribute_value_length_limit,
+        max_attribute_length=(
+            attribute_value_length_limit
+            if attribute_value_length_limit is not None
+            else SpanLimits.UNSET
+        ),
+        max_span_attribute_length=(
+            attribute_value_length_limit
+            if attribute_value_length_limit is not None
+            else SpanLimits.UNSET
+        ),
     )
 
 
 def create_tracer_provider(
     config: TracerProviderConfig | None,
     resource: Resource | None = None,
+    global_attribute_limits: AttributeLimits | None = None,
 ) -> TracerProvider:
     """Create an SDK TracerProvider from declarative config.
 
@@ -449,6 +476,8 @@ def create_tracer_provider(
     Args:
         config: TracerProvider config from the parsed config file, or None.
         resource: Resource to attach to the provider.
+        global_attribute_limits: Top-level attribute_limits from the root config,
+            used as a fallback when per-signal limits are not specified.
 
     Returns:
         A configured TracerProvider.
@@ -463,17 +492,14 @@ def create_tracer_provider(
         if config is not None and config.id_generator is not None
         else None
     )
-    span_limits = (
-        _create_span_limits(config.limits)
-        if config is not None and config.limits is not None
-        else SpanLimits(
-            max_span_attributes=_DEFAULT_OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
-            max_events=_DEFAULT_OTEL_SPAN_EVENT_COUNT_LIMIT,
-            max_links=_DEFAULT_OTEL_SPAN_LINK_COUNT_LIMIT,
-            max_event_attributes=_DEFAULT_OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT,
-            max_link_attributes=_DEFAULT_OTEL_LINK_ATTRIBUTE_COUNT_LIMIT,
+    if config is not None and config.limits is not None:
+        span_limits = _create_span_limits(
+            config.limits, global_attribute_limits
+        )
+    else:
+        span_limits = _create_span_limits(
+            SpanLimitsConfig(), global_attribute_limits
         )
-    )
 
     provider = TracerProvider(
         resource=resource,
@@ -492,6 +518,7 @@ def create_tracer_provider(
 def configure_tracer_provider(
     config: TracerProviderConfig | None,
     resource: Resource | None = None,
+    global_attribute_limits: AttributeLimits | None = None,
 ) -> None:
     """Configure the global TracerProvider from declarative config.
 
@@ -502,7 +529,11 @@ def configure_tracer_provider(
     Args:
         config: TracerProvider config from the parsed config file, or None.
         resource: Resource to attach to the provider.
+        global_attribute_limits: Top-level attribute_limits from the root config,
+            used as a fallback when per-signal limits are not specified.
     """
     if config is None:
         return
-    trace.set_tracer_provider(create_tracer_provider(config, resource))
+    trace.set_tracer_provider(
+        create_tracer_provider(config, resource, global_attribute_limits)
+    )