General attribute limits configuration factory (#5779)

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogLimitsFactory.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.sdk.extension.incubator.fileconfig;
 
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LogRecordLimits;
 import io.opentelemetry.sdk.logs.LogLimits;
 import io.opentelemetry.sdk.logs.LogLimitsBuilder;
@@ -13,7 +14,7 @@ import java.io.Closeable;
 import java.util.List;
 import javax.annotation.Nullable;
 
-final class LogLimitsFactory implements Factory<LogRecordLimits, LogLimits> {
+final class LogLimitsFactory implements Factory<LogRecordLimitsAndAttributeLimits, LogLimits> {
 
   private static final LogLimitsFactory INSTANCE = new LogLimitsFactory();
 
@@ -25,18 +26,34 @@ final class LogLimitsFactory implements Factory<LogRecordLimits, LogLimits> {
 
   @Override
   public LogLimits create(
-      @Nullable LogRecordLimits model, SpiHelper spiHelper, List<Closeable> closeables) {
+      @Nullable LogRecordLimitsAndAttributeLimits model,
+      SpiHelper spiHelper,
+      List<Closeable> closeables) {
     if (model == null) {
       return LogLimits.getDefault();
     }
-
     LogLimitsBuilder builder = LogLimits.builder();
-    if (model.getAttributeCountLimit() != null) {
+
-      builder.setMaxNumberOfAttributes(model.getAttributeCountLimit());
+    AttributeLimits attributeLimitsModel = model.getAttributeLimits();
+    if (attributeLimitsModel != null) {
+      if (attributeLimitsModel.getAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributes(attributeLimitsModel.getAttributeCountLimit());
+      }
+      if (attributeLimitsModel.getAttributeValueLengthLimit() != null) {
+        builder.setMaxAttributeValueLength(attributeLimitsModel.getAttributeValueLengthLimit());
+      }
     }
-    if (model.getAttributeValueLengthLimit() != null) {
+
-      builder.setMaxAttributeValueLength(model.getAttributeValueLengthLimit());
+    LogRecordLimits logRecordLimitsModel = model.getLogRecordLimits();
+    if (logRecordLimitsModel != null) {
+      if (logRecordLimitsModel.getAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributes(logRecordLimitsModel.getAttributeCountLimit());
+      }
+      if (logRecordLimitsModel.getAttributeValueLengthLimit() != null) {
+        builder.setMaxAttributeValueLength(logRecordLimitsModel.getAttributeValueLengthLimit());
+      }
     }
+
     return builder.build();
   }
 }

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogRecordLimitsAndAttributeLimits.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.extension.incubator.fileconfig;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LogRecordLimits;
+import javax.annotation.Nullable;
+
+@AutoValue
+abstract class LogRecordLimitsAndAttributeLimits {
+
+  static LogRecordLimitsAndAttributeLimits create(
+      @Nullable AttributeLimits attributeLimits, @Nullable LogRecordLimits spanLimits) {
+    return new AutoValue_LogRecordLimitsAndAttributeLimits(attributeLimits, spanLimits);
+  }
+
+  @Nullable
+  abstract AttributeLimits getAttributeLimits();
+
+  @Nullable
+  abstract LogRecordLimits getLogRecordLimits();
+}

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LoggerProviderAndAttributeLimits.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.extension.incubator.fileconfig;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LoggerProvider;
+import javax.annotation.Nullable;
+
+@AutoValue
+abstract class LoggerProviderAndAttributeLimits {
+
+  static LoggerProviderAndAttributeLimits create(
+      @Nullable AttributeLimits attributeLimits, @Nullable LoggerProvider loggerProvider) {
+    return new AutoValue_LoggerProviderAndAttributeLimits(attributeLimits, loggerProvider);
+  }
+
+  @Nullable
+  abstract AttributeLimits getAttributeLimits();
+
+  @Nullable
+  abstract LoggerProvider getLoggerProvider();
+}

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LoggerProviderFactory.java

@@ -15,7 +15,8 @@ import java.io.Closeable;
 import java.util.List;
 import javax.annotation.Nullable;
 
-final class LoggerProviderFactory implements Factory<LoggerProvider, SdkLoggerProviderBuilder> {
+final class LoggerProviderFactory
+    implements Factory<LoggerProviderAndAttributeLimits, SdkLoggerProviderBuilder> {
 
   private static final LoggerProviderFactory INSTANCE = new LoggerProviderFactory();
 
@@ -27,18 +28,28 @@ final class LoggerProviderFactory implements Factory<LoggerProvider, SdkLoggerPr
 
   @Override
   public SdkLoggerProviderBuilder create(
-      @Nullable LoggerProvider model, SpiHelper spiHelper, List<Closeable> closeables) {
+      @Nullable LoggerProviderAndAttributeLimits model,
+      SpiHelper spiHelper,
+      List<Closeable> closeables) {
+    SdkLoggerProviderBuilder builder = SdkLoggerProvider.builder();
     if (model == null) {
-      return SdkLoggerProvider.builder();
+      return builder;
+    }
+    LoggerProvider loggerProviderModel = model.getLoggerProvider();
+    if (loggerProviderModel == null) {
+      return builder;
     }
 
-    SdkLoggerProviderBuilder builder = SdkLoggerProvider.builder();
-
     LogLimits logLimits =
-        LogLimitsFactory.getInstance().create(model.getLimits(), spiHelper, closeables);
+        LogLimitsFactory.getInstance()
+            .create(
+                LogRecordLimitsAndAttributeLimits.create(
+                    model.getAttributeLimits(), loggerProviderModel.getLimits()),
+                spiHelper,
+                closeables);
     builder.setLogLimits(() -> logLimits);
 
-    List<LogRecordProcessor> processors = model.getProcessors();
+    List<LogRecordProcessor> processors = loggerProviderModel.getProcessors();
     if (processors != null) {
       processors.forEach(
           processor ->

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/OpenTelemetryConfigurationFactory.java

@@ -31,16 +31,15 @@ final class OpenTelemetryConfigurationFactory
   @Override
   public OpenTelemetrySdk create(
       @Nullable OpenTelemetryConfiguration model, SpiHelper spiHelper, List<Closeable> closeables) {
+    OpenTelemetrySdkBuilder builder = OpenTelemetrySdk.builder();
     if (model == null) {
-      return FileConfigUtil.addAndReturn(closeables, OpenTelemetrySdk.builder().build());
+      return FileConfigUtil.addAndReturn(closeables, builder.build());
     }
 
     if (!"0.1".equals(model.getFileFormat())) {
       throw new ConfigurationException("Unsupported file format. Supported formats include: 0.1");
     }
 
-    OpenTelemetrySdkBuilder builder = OpenTelemetrySdk.builder();
-
     if (Objects.equals(Boolean.TRUE, model.getDisabled())) {
       return builder.build();
     }
@@ -56,7 +55,11 @@ final class OpenTelemetryConfigurationFactory
           FileConfigUtil.addAndReturn(
               closeables,
               LoggerProviderFactory.getInstance()
-                  .create(model.getLoggerProvider(), spiHelper, closeables)
+                  .create(
+                      LoggerProviderAndAttributeLimits.create(
+                          model.getAttributeLimits(), model.getLoggerProvider()),
+                      spiHelper,
+                      closeables)
                   .setResource(resource)
                   .build()));
     }
@@ -66,7 +69,11 @@ final class OpenTelemetryConfigurationFactory
           FileConfigUtil.addAndReturn(
               closeables,
               TracerProviderFactory.getInstance()
-                  .create(model.getTracerProvider(), spiHelper, closeables)
+                  .create(
+                      TracerProviderAndAttributeLimits.create(
+                          model.getAttributeLimits(), model.getTracerProvider()),
+                      spiHelper,
+                      closeables)
                   .setResource(resource)
                   .build()));
     }
@@ -81,8 +88,6 @@ final class OpenTelemetryConfigurationFactory
                   .build()));
     }
 
-    // TODO(jack-berg): add support for general attribute limits
-
     return FileConfigUtil.addAndReturn(closeables, builder.build());
   }
 }

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SpanLimitsAndAttributeLimits.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.extension.incubator.fileconfig;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.SpanLimits;
+import javax.annotation.Nullable;
+
+@AutoValue
+abstract class SpanLimitsAndAttributeLimits {
+
+  static SpanLimitsAndAttributeLimits create(
+      @Nullable AttributeLimits attributeLimits, @Nullable SpanLimits spanLimits) {
+    return new AutoValue_SpanLimitsAndAttributeLimits(attributeLimits, spanLimits);
+  }
+
+  @Nullable
+  abstract AttributeLimits getAttributeLimits();
+
+  @Nullable
+  abstract SpanLimits getSpanLimits();
+}

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SpanLimitsFactory.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.sdk.extension.incubator.fileconfig;
 
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.SpanLimits;
 import io.opentelemetry.sdk.trace.SpanLimitsBuilder;
 import java.io.Closeable;
@@ -13,7 +14,7 @@ import java.util.List;
 import javax.annotation.Nullable;
 
 final class SpanLimitsFactory
-    implements Factory<SpanLimits, io.opentelemetry.sdk.trace.SpanLimits> {
+    implements Factory<SpanLimitsAndAttributeLimits, io.opentelemetry.sdk.trace.SpanLimits> {
 
   private static final SpanLimitsFactory INSTANCE = new SpanLimitsFactory();
 
@@ -25,29 +26,45 @@ final class SpanLimitsFactory
 
   @Override
   public io.opentelemetry.sdk.trace.SpanLimits create(
-      @Nullable SpanLimits model, SpiHelper spiHelper, List<Closeable> closeables) {
+      @Nullable SpanLimitsAndAttributeLimits model,
+      SpiHelper spiHelper,
+      List<Closeable> closeables) {
     if (model == null) {
       return io.opentelemetry.sdk.trace.SpanLimits.getDefault();
     }
 
     SpanLimitsBuilder builder = io.opentelemetry.sdk.trace.SpanLimits.builder();
-    if (model.getAttributeCountLimit() != null) {
+
-      builder.setMaxNumberOfAttributes(model.getAttributeCountLimit());
+    AttributeLimits attributeLimitsModel = model.getAttributeLimits();
+    if (attributeLimitsModel != null) {
+      if (attributeLimitsModel.getAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributes(attributeLimitsModel.getAttributeCountLimit());
+      }
+      if (attributeLimitsModel.getAttributeValueLengthLimit() != null) {
+        builder.setMaxAttributeValueLength(attributeLimitsModel.getAttributeValueLengthLimit());
+      }
     }
-    if (model.getAttributeValueLengthLimit() != null) {
+
-      builder.setMaxAttributeValueLength(model.getAttributeValueLengthLimit());
+    SpanLimits spanLimitsModel = model.getSpanLimits();
-    }
+    if (spanLimitsModel != null) {
-    if (model.getEventCountLimit() != null) {
+      if (spanLimitsModel.getAttributeCountLimit() != null) {
-      builder.setMaxNumberOfEvents(model.getEventCountLimit());
+        builder.setMaxNumberOfAttributes(spanLimitsModel.getAttributeCountLimit());
-    }
+      }
-    if (model.getLinkCountLimit() != null) {
+      if (spanLimitsModel.getAttributeValueLengthLimit() != null) {
-      builder.setMaxNumberOfLinks(model.getLinkCountLimit());
+        builder.setMaxAttributeValueLength(spanLimitsModel.getAttributeValueLengthLimit());
-    }
+      }
-    if (model.getEventAttributeCountLimit() != null) {
+      if (spanLimitsModel.getEventCountLimit() != null) {
-      builder.setMaxNumberOfAttributesPerEvent(model.getEventAttributeCountLimit());
+        builder.setMaxNumberOfEvents(spanLimitsModel.getEventCountLimit());
-    }
+      }
-    if (model.getLinkAttributeCountLimit() != null) {
+      if (spanLimitsModel.getLinkCountLimit() != null) {
-      builder.setMaxNumberOfAttributesPerLink(model.getLinkAttributeCountLimit());
+        builder.setMaxNumberOfLinks(spanLimitsModel.getLinkCountLimit());
+      }
+      if (spanLimitsModel.getEventAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributesPerEvent(spanLimitsModel.getEventAttributeCountLimit());
+      }
+      if (spanLimitsModel.getLinkAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributesPerLink(spanLimitsModel.getLinkAttributeCountLimit());
+      }
     }
 
     return builder.build();

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/TracerProviderAndAttributeLimits.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.extension.incubator.fileconfig;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.TracerProvider;
+import javax.annotation.Nullable;
+
+@AutoValue
+abstract class TracerProviderAndAttributeLimits {
+
+  static TracerProviderAndAttributeLimits create(
+      @Nullable AttributeLimits attributeLimits, @Nullable TracerProvider tracerProvider) {
+    return new AutoValue_TracerProviderAndAttributeLimits(attributeLimits, tracerProvider);
+  }
+
+  @Nullable
+  abstract AttributeLimits getAttributeLimits();
+
+  @Nullable
+  abstract TracerProvider getTracerProvider();
+}

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/TracerProviderFactory.java

@@ -16,7 +16,8 @@ import java.io.Closeable;
 import java.util.List;
 import javax.annotation.Nullable;
 
-final class TracerProviderFactory implements Factory<TracerProvider, SdkTracerProviderBuilder> {
+final class TracerProviderFactory
+    implements Factory<TracerProviderAndAttributeLimits, SdkTracerProviderBuilder> {
 
   private static final TracerProviderFactory INSTANCE = new TracerProviderFactory();
 
@@ -28,22 +29,33 @@ final class TracerProviderFactory implements Factory<TracerProvider, SdkTracerPr
 
   @Override
   public SdkTracerProviderBuilder create(
-      @Nullable TracerProvider model, SpiHelper spiHelper, List<Closeable> closeables) {
+      @Nullable TracerProviderAndAttributeLimits model,
+      SpiHelper spiHelper,
+      List<Closeable> closeables) {
+    SdkTracerProviderBuilder builder = SdkTracerProvider.builder();
     if (model == null) {
-      return SdkTracerProvider.builder();
+      return builder;
+    }
+    TracerProvider tracerProviderModel = model.getTracerProvider();
+    if (tracerProviderModel == null) {
+      return builder;
     }
 
-    SdkTracerProviderBuilder builder = SdkTracerProvider.builder();
-
     SpanLimits spanLimits =
-        SpanLimitsFactory.getInstance().create(model.getLimits(), spiHelper, closeables);
+        SpanLimitsFactory.getInstance()
+            .create(
+                SpanLimitsAndAttributeLimits.create(
+                    model.getAttributeLimits(), tracerProviderModel.getLimits()),
+                spiHelper,
+                closeables);
     builder.setSpanLimits(spanLimits);
 
     Sampler sampler =
-        SamplerFactory.getInstance().create(model.getSampler(), spiHelper, closeables);
+        SamplerFactory.getInstance()
+            .create(tracerProviderModel.getSampler(), spiHelper, closeables);
     builder.setSampler(sampler);
 
-    List<SpanProcessor> processors = model.getProcessors();
+    List<SpanProcessor> processors = tracerProviderModel.getProcessors();
     if (processors != null) {
       processors.forEach(
           processor ->

sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogLimitsFactoryTest.java

@@ -9,40 +9,43 @@ import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.asser
 import static org.mockito.Mockito.mock;
 
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LogRecordLimits;
 import io.opentelemetry.sdk.logs.LogLimits;
 import java.util.Collections;
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class LogLimitsFactoryTest {
 
-  @Test
+  @ParameterizedTest
-  void create_Null() {
+  @MethodSource("createArguments")
+  void create(LogRecordLimitsAndAttributeLimits model, LogLimits expectedLogLimits) {
     assertThat(
             LogLimitsFactory.getInstance()
-                .create(null, mock(SpiHelper.class), Collections.emptyList()))
+                .create(model, mock(SpiHelper.class), Collections.emptyList()))
-        .isEqualTo(LogLimits.getDefault());
+        .isEqualTo(expectedLogLimits);
   }
 
-  @Test
+  private static Stream<Arguments> createArguments() {
-  void create_Defaults() {
+    return Stream.of(
-    assertThat(
+        Arguments.of(null, LogLimits.builder().build()),
-            LogLimitsFactory.getInstance()
+        Arguments.of(
-                .create(new LogRecordLimits(), mock(SpiHelper.class), Collections.emptyList()))
+            LogRecordLimitsAndAttributeLimits.create(null, null), LogLimits.builder().build()),
-        .isEqualTo(LogLimits.getDefault());
+        Arguments.of(
-  }
+            LogRecordLimitsAndAttributeLimits.create(new AttributeLimits(), new LogRecordLimits()),
-
+            LogLimits.builder().build()),
-  @Test
+        Arguments.of(
-  void create() {
+            LogRecordLimitsAndAttributeLimits.create(
-    assertThat(
+                new AttributeLimits().withAttributeValueLengthLimit(1).withAttributeCountLimit(2),
-            LogLimitsFactory.getInstance()
+                new LogRecordLimits()),
-                .create(
+            LogLimits.builder().setMaxAttributeValueLength(1).setMaxNumberOfAttributes(2).build()),
-                    new LogRecordLimits()
+        Arguments.of(
-                        .withAttributeCountLimit(1)
+            LogRecordLimitsAndAttributeLimits.create(
-                        .withAttributeValueLengthLimit(2),
+                new AttributeLimits().withAttributeValueLengthLimit(1).withAttributeCountLimit(2),
-                    mock(SpiHelper.class),
+                new LogRecordLimits().withAttributeValueLengthLimit(3).withAttributeCountLimit(4)),
-                    Collections.emptyList()))
+            LogLimits.builder().setMaxAttributeValueLength(3).setMaxNumberOfAttributes(4).build()));
-        .isEqualTo(
-            LogLimits.builder().setMaxNumberOfAttributes(1).setMaxAttributeValueLength(2).build());
   }
 }

sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LoggerProviderFactoryTest.java

@@ -10,6 +10,7 @@ import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.asser
 import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter;
 import io.opentelemetry.internal.testing.CleanupExtension;
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.BatchLogRecordProcessor;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LogRecordExporter;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LogRecordLimits;
@@ -22,8 +23,11 @@ import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class LoggerProviderFactoryTest {
 
@@ -32,57 +36,32 @@ class LoggerProviderFactoryTest {
   private final SpiHelper spiHelper =
       SpiHelper.create(LoggerProviderFactoryTest.class.getClassLoader());
 
-  @Test
+  @ParameterizedTest
-  void create_Null() {
+  @MethodSource("createArguments")
+  void create(LoggerProviderAndAttributeLimits model, SdkLoggerProvider expectedProvider) {
     List<Closeable> closeables = new ArrayList<>();
-    SdkLoggerProvider expectedProvider = SdkLoggerProvider.builder().build();
     cleanup.addCloseable(expectedProvider);
 
     SdkLoggerProvider provider =
-        LoggerProviderFactory.getInstance().create(null, spiHelper, closeables).build();
+        LoggerProviderFactory.getInstance().create(model, spiHelper, closeables).build();
     cleanup.addCloseable(provider);
     cleanup.addCloseables(closeables);
 
     assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
   }
 
-  @Test
+  private static Stream<Arguments> createArguments() {
-  void create_Defaults() {
+    return Stream.of(
-    List<Closeable> closeables = new ArrayList<>();
+        Arguments.of(null, SdkLoggerProvider.builder().build()),
-    SdkLoggerProvider expectedProvider = SdkLoggerProvider.builder().build();
+        Arguments.of(
-    cleanup.addCloseable(expectedProvider);
+            LoggerProviderAndAttributeLimits.create(null, null),
-
+            SdkLoggerProvider.builder().build()),
-    SdkLoggerProvider provider =
+        Arguments.of(
-        LoggerProviderFactory.getInstance()
+            LoggerProviderAndAttributeLimits.create(new AttributeLimits(), new LoggerProvider()),
-            .create(new LoggerProvider(), spiHelper, closeables)
+            SdkLoggerProvider.builder().build()),
-            .build();
+        Arguments.of(
-    cleanup.addCloseable(provider);
+            LoggerProviderAndAttributeLimits.create(
-    cleanup.addCloseables(closeables);
+                new AttributeLimits(),
-
-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
-  }
-
-  @Test
-  void create_Configured() {
-    List<Closeable> closeables = new ArrayList<>();
-    SdkLoggerProvider expectedProvider =
-        SdkLoggerProvider.builder()
-            .setLogLimits(
-                () ->
-                    LogLimits.builder()
-                        .setMaxNumberOfAttributes(1)
-                        .setMaxAttributeValueLength(2)
-                        .build())
-            .addLogRecordProcessor(
-                io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor.builder(
-                        OtlpGrpcLogRecordExporter.getDefault())
-                    .build())
-            .build();
-    cleanup.addCloseable(expectedProvider);
-
-    SdkLoggerProvider provider =
-        LoggerProviderFactory.getInstance()
-            .create(
                 new LoggerProvider()
                     .withLimits(
                         new LogRecordLimits()
@@ -94,13 +73,18 @@ class LoggerProviderFactoryTest {
                                 .withBatch(
                                     new BatchLogRecordProcessor()
                                         .withExporter(
-                                            new LogRecordExporter().withOtlp(new Otlp()))))),
+                                            new LogRecordExporter().withOtlp(new Otlp())))))),
-                spiHelper,
+            SdkLoggerProvider.builder()
-                closeables)
+                .setLogLimits(
-            .build();
+                    () ->
-    cleanup.addCloseable(provider);
+                        LogLimits.builder()
-    cleanup.addCloseables(closeables);
+                            .setMaxNumberOfAttributes(1)
-
+                            .setMaxAttributeValueLength(2)
-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+                            .build())
+                .addLogRecordProcessor(
+                    io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor.builder(
+                            OtlpGrpcLogRecordExporter.getDefault())
+                        .build())
+                .build()));
   }
 }

sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SpanLimitsFactoryTest.java

@@ -9,50 +9,61 @@ import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.asser
 import static org.mockito.Mockito.mock;
 
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.SpanLimits;
 import java.util.Collections;
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class SpanLimitsFactoryTest {
 
-  @Test
+  @ParameterizedTest
-  void create_Null() {
+  @MethodSource("createArguments")
+  void create(
+      SpanLimitsAndAttributeLimits model,
+      io.opentelemetry.sdk.trace.SpanLimits expectedSpanLimits) {
     assertThat(
             SpanLimitsFactory.getInstance()
-                .create(null, mock(SpiHelper.class), Collections.emptyList()))
+                .create(model, mock(SpiHelper.class), Collections.emptyList()))
-        .isEqualTo(io.opentelemetry.sdk.trace.SpanLimits.getDefault());
+        .isEqualTo(expectedSpanLimits);
   }
 
-  @Test
+  private static Stream<Arguments> createArguments() {
-  void create_Defaults() {
+    return Stream.of(
-    assertThat(
+        Arguments.of(null, io.opentelemetry.sdk.trace.SpanLimits.getDefault()),
-            SpanLimitsFactory.getInstance()
+        Arguments.of(
-                .create(new SpanLimits(), mock(SpiHelper.class), Collections.emptyList()))
+            SpanLimitsAndAttributeLimits.create(null, null),
-        .isEqualTo(io.opentelemetry.sdk.trace.SpanLimits.getDefault());
+            io.opentelemetry.sdk.trace.SpanLimits.getDefault()),
-  }
+        Arguments.of(
-
+            SpanLimitsAndAttributeLimits.create(new AttributeLimits(), new SpanLimits()),
-  @Test
+            io.opentelemetry.sdk.trace.SpanLimits.getDefault()),
-  void create() {
+        Arguments.of(
-    assertThat(
+            SpanLimitsAndAttributeLimits.create(
-            SpanLimitsFactory.getInstance()
+                new AttributeLimits().withAttributeCountLimit(1).withAttributeValueLengthLimit(2),
-                .create(
+                new SpanLimits()),
-                    new SpanLimits()
-                        .withAttributeCountLimit(1)
-                        .withAttributeValueLengthLimit(2)
-                        .withEventCountLimit(3)
-                        .withLinkCountLimit(4)
-                        .withEventAttributeCountLimit(5)
-                        .withLinkAttributeCountLimit(6),
-                    mock(SpiHelper.class),
-                    Collections.emptyList()))
-        .isEqualTo(
             io.opentelemetry.sdk.trace.SpanLimits.builder()
                 .setMaxNumberOfAttributes(1)
                 .setMaxAttributeValueLength(2)
-                .setMaxNumberOfEvents(3)
+                .build()),
-                .setMaxNumberOfLinks(4)
+        Arguments.of(
-                .setMaxNumberOfAttributesPerEvent(5)
+            SpanLimitsAndAttributeLimits.create(
-                .setMaxNumberOfAttributesPerLink(6)
+                new AttributeLimits().withAttributeCountLimit(1).withAttributeValueLengthLimit(2),
-                .build());
+                new SpanLimits()
+                    .withAttributeCountLimit(3)
+                    .withAttributeValueLengthLimit(4)
+                    .withEventCountLimit(5)
+                    .withLinkCountLimit(6)
+                    .withEventAttributeCountLimit(7)
+                    .withLinkAttributeCountLimit(8)),
+            io.opentelemetry.sdk.trace.SpanLimits.builder()
+                .setMaxNumberOfAttributes(3)
+                .setMaxAttributeValueLength(4)
+                .setMaxNumberOfEvents(5)
+                .setMaxNumberOfLinks(6)
+                .setMaxNumberOfAttributesPerEvent(7)
+                .setMaxNumberOfAttributesPerLink(8)
+                .build()));
   }
 }

sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/TracerProviderFactoryTest.java

@@ -12,6 +12,7 @@ import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
 import io.opentelemetry.internal.testing.CleanupExtension;
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AlwaysOn;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeLimits;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.BatchSpanProcessor;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.Otlp;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.Sampler;
@@ -24,8 +25,11 @@ import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class TracerProviderFactoryTest {
 
@@ -34,61 +38,32 @@ class TracerProviderFactoryTest {
   private final SpiHelper spiHelper =
       SpiHelper.create(TracerProviderFactoryTest.class.getClassLoader());
 
-  @Test
+  @ParameterizedTest
-  void create_Null() {
+  @MethodSource("createArguments")
+  void create(TracerProviderAndAttributeLimits model, SdkTracerProvider expectedProvider) {
     List<Closeable> closeables = new ArrayList<>();
-    SdkTracerProvider expectedProvider = SdkTracerProvider.builder().build();
     cleanup.addCloseable(expectedProvider);
 
     SdkTracerProvider provider =
-        TracerProviderFactory.getInstance().create(null, spiHelper, closeables).build();
+        TracerProviderFactory.getInstance().create(model, spiHelper, closeables).build();
     cleanup.addCloseable(provider);
     cleanup.addCloseables(closeables);
 
     assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
   }
 
-  @Test
+  private static Stream<Arguments> createArguments() {
-  void create_Defaults() {
+    return Stream.of(
-    List<Closeable> closeables = new ArrayList<>();
+        Arguments.of(null, SdkTracerProvider.builder().build()),
-    SdkTracerProvider expectedProvider = SdkTracerProvider.builder().build();
+        Arguments.of(
-    cleanup.addCloseable(expectedProvider);
+            TracerProviderAndAttributeLimits.create(null, null),
-
+            SdkTracerProvider.builder().build()),
-    SdkTracerProvider provider =
+        Arguments.of(
-        TracerProviderFactory.getInstance()
+            TracerProviderAndAttributeLimits.create(new AttributeLimits(), new TracerProvider()),
-            .create(new TracerProvider(), spiHelper, closeables)
+            SdkTracerProvider.builder().build()),
-            .build();
+        Arguments.of(
-    cleanup.addCloseable(provider);
+            TracerProviderAndAttributeLimits.create(
-    cleanup.addCloseables(closeables);
+                new AttributeLimits(),
-
-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
-  }
-
-  @Test
-  void create_Configured() {
-    List<Closeable> closeables = new ArrayList<>();
-    SdkTracerProvider expectedProvider =
-        SdkTracerProvider.builder()
-            .setSpanLimits(
-                SpanLimits.builder()
-                    .setMaxNumberOfAttributes(1)
-                    .setMaxAttributeValueLength(2)
-                    .setMaxNumberOfEvents(3)
-                    .setMaxNumberOfLinks(4)
-                    .setMaxNumberOfAttributesPerEvent(5)
-                    .setMaxNumberOfAttributesPerLink(6)
-                    .build())
-            .setSampler(alwaysOn())
-            .addSpanProcessor(
-                io.opentelemetry.sdk.trace.export.BatchSpanProcessor.builder(
-                        OtlpGrpcSpanExporter.getDefault())
-                    .build())
-            .build();
-    cleanup.addCloseable(expectedProvider);
-
-    SdkTracerProvider provider =
-        TracerProviderFactory.getInstance()
-            .create(
                 new TracerProvider()
                     .withLimits(
                         new io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model
@@ -105,13 +80,22 @@ class TracerProviderFactoryTest {
                             new SpanProcessor()
                                 .withBatch(
                                     new BatchSpanProcessor()
-                                        .withExporter(new SpanExporter().withOtlp(new Otlp()))))),
+                                        .withExporter(new SpanExporter().withOtlp(new Otlp())))))),
-                spiHelper,
+            SdkTracerProvider.builder()
-                closeables)
+                .setSpanLimits(
-            .build();
+                    SpanLimits.builder()
-    cleanup.addCloseable(provider);
+                        .setMaxNumberOfAttributes(1)
-    cleanup.addCloseables(closeables);
+                        .setMaxAttributeValueLength(2)
-
+                        .setMaxNumberOfEvents(3)
-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+                        .setMaxNumberOfLinks(4)
+                        .setMaxNumberOfAttributesPerEvent(5)
+                        .setMaxNumberOfAttributesPerLink(6)
+                        .build())
+                .setSampler(alwaysOn())
+                .addSpanProcessor(
+                    io.opentelemetry.sdk.trace.export.BatchSpanProcessor.builder(
+                            OtlpGrpcSpanExporter.getDefault())
+                        .build())
+                .build()));
   }
 }