General attribute limits configuration factory (#5779)

2023-08-30 14:31:05 -05:00 · 2023-08-30 14:31:05 -05:00 · da7927883c
parent 68d7ab5763
commit da7927883c
13 changed files with 357 additions and 209 deletions
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogLimitsFactory.java
+++ b/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();
  }
 }
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogRecordLimitsAndAttributeLimits.java
+++ b/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();
+}
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LoggerProviderAndAttributeLimits.java
+++ b/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();
+}
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LoggerProviderFactory.java
+++ b/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 ->
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/OpenTelemetryConfigurationFactory.java
+++ b/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());
  }
 }
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SpanLimitsAndAttributeLimits.java
+++ b/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();
+}
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SpanLimitsFactory.java
+++ b/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());
-    }
-    if (model.getEventCountLimit() != null) {
-      builder.setMaxNumberOfEvents(model.getEventCountLimit());
-    }
-    if (model.getLinkCountLimit() != null) {
-      builder.setMaxNumberOfLinks(model.getLinkCountLimit());
-    }
-    if (model.getEventAttributeCountLimit() != null) {
-      builder.setMaxNumberOfAttributesPerEvent(model.getEventAttributeCountLimit());
-    }
-    if (model.getLinkAttributeCountLimit() != null) {
-      builder.setMaxNumberOfAttributesPerLink(model.getLinkAttributeCountLimit());
+
+    SpanLimits spanLimitsModel = model.getSpanLimits();
+    if (spanLimitsModel != null) {
+      if (spanLimitsModel.getAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributes(spanLimitsModel.getAttributeCountLimit());
+      }
+      if (spanLimitsModel.getAttributeValueLengthLimit() != null) {
+        builder.setMaxAttributeValueLength(spanLimitsModel.getAttributeValueLengthLimit());
+      }
+      if (spanLimitsModel.getEventCountLimit() != null) {
+        builder.setMaxNumberOfEvents(spanLimitsModel.getEventCountLimit());
+      }
+      if (spanLimitsModel.getLinkCountLimit() != null) {
+        builder.setMaxNumberOfLinks(spanLimitsModel.getLinkCountLimit());
+      }
+      if (spanLimitsModel.getEventAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributesPerEvent(spanLimitsModel.getEventAttributeCountLimit());
+      }
+      if (spanLimitsModel.getLinkAttributeCountLimit() != null) {
+        builder.setMaxNumberOfAttributesPerLink(spanLimitsModel.getLinkAttributeCountLimit());
+      }
    }

    return builder.build();
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/TracerProviderAndAttributeLimits.java
+++ b/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();
+}
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/TracerProviderFactory.java
+++ b/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 ->
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogLimitsFactoryTest.java
+++ b/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
-  void create_Null() {
+  @ParameterizedTest
+  @MethodSource("createArguments")
+  void create(LogRecordLimitsAndAttributeLimits model, LogLimits expectedLogLimits) {
    assertThat(
            LogLimitsFactory.getInstance()
-                .create(null, mock(SpiHelper.class), Collections.emptyList()))
-        .isEqualTo(LogLimits.getDefault());
+                .create(model, mock(SpiHelper.class), Collections.emptyList()))
+        .isEqualTo(expectedLogLimits);
  }

-  @Test
-  void create_Defaults() {
-    assertThat(
-            LogLimitsFactory.getInstance()
-                .create(new LogRecordLimits(), mock(SpiHelper.class), Collections.emptyList()))
-        .isEqualTo(LogLimits.getDefault());
-  }
-
-  @Test
-  void create() {
-    assertThat(
-            LogLimitsFactory.getInstance()
-                .create(
-                    new LogRecordLimits()
-                        .withAttributeCountLimit(1)
-                        .withAttributeValueLengthLimit(2),
-                    mock(SpiHelper.class),
-                    Collections.emptyList()))
-        .isEqualTo(
-            LogLimits.builder().setMaxNumberOfAttributes(1).setMaxAttributeValueLength(2).build());
+  private static Stream<Arguments> createArguments() {
+    return Stream.of(
+        Arguments.of(null, LogLimits.builder().build()),
+        Arguments.of(
+            LogRecordLimitsAndAttributeLimits.create(null, null), LogLimits.builder().build()),
+        Arguments.of(
+            LogRecordLimitsAndAttributeLimits.create(new AttributeLimits(), new LogRecordLimits()),
+            LogLimits.builder().build()),
+        Arguments.of(
+            LogRecordLimitsAndAttributeLimits.create(
+                new AttributeLimits().withAttributeValueLengthLimit(1).withAttributeCountLimit(2),
+                new LogRecordLimits()),
+            LogLimits.builder().setMaxAttributeValueLength(1).setMaxNumberOfAttributes(2).build()),
+        Arguments.of(
+            LogRecordLimitsAndAttributeLimits.create(
+                new AttributeLimits().withAttributeValueLengthLimit(1).withAttributeCountLimit(2),
+                new LogRecordLimits().withAttributeValueLengthLimit(3).withAttributeCountLimit(4)),
+            LogLimits.builder().setMaxAttributeValueLength(3).setMaxNumberOfAttributes(4).build()));
  }
 }
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LoggerProviderFactoryTest.java
+++ b/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
-  void create_Null() {
+  @ParameterizedTest
+  @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
-  void create_Defaults() {
-    List<Closeable> closeables = new ArrayList<>();
-    SdkLoggerProvider expectedProvider = SdkLoggerProvider.builder().build();
-    cleanup.addCloseable(expectedProvider);
-
-    SdkLoggerProvider provider =
-        LoggerProviderFactory.getInstance()
-            .create(new LoggerProvider(), spiHelper, closeables)
-            .build();
-    cleanup.addCloseable(provider);
-    cleanup.addCloseables(closeables);
-
-    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(
+  private static Stream<Arguments> createArguments() {
+    return Stream.of(
+        Arguments.of(null, SdkLoggerProvider.builder().build()),
+        Arguments.of(
+            LoggerProviderAndAttributeLimits.create(null, null),
+            SdkLoggerProvider.builder().build()),
+        Arguments.of(
+            LoggerProviderAndAttributeLimits.create(new AttributeLimits(), new LoggerProvider()),
+            SdkLoggerProvider.builder().build()),
+        Arguments.of(
+            LoggerProviderAndAttributeLimits.create(
+                new AttributeLimits(),
                new LoggerProvider()
                    .withLimits(
                        new LogRecordLimits()
@ -94,13 +73,18 @@ class LoggerProviderFactoryTest {
                                .withBatch(
                                    new BatchLogRecordProcessor()
                                        .withExporter(
-                                            new LogRecordExporter().withOtlp(new Otlp()))))),
-                spiHelper,
-                closeables)
-            .build();
-    cleanup.addCloseable(provider);
-    cleanup.addCloseables(closeables);
-
-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+                                            new LogRecordExporter().withOtlp(new Otlp())))))),
+            SdkLoggerProvider.builder()
+                .setLogLimits(
+                    () ->
+                        LogLimits.builder()
+                            .setMaxNumberOfAttributes(1)
+                            .setMaxAttributeValueLength(2)
+                            .build())
+                .addLogRecordProcessor(
+                    io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor.builder(
+                            OtlpGrpcLogRecordExporter.getDefault())
+                        .build())
+                .build()));
  }
 }
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SpanLimitsFactoryTest.java
+++ b/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
-  void create_Null() {
+  @ParameterizedTest
+  @MethodSource("createArguments")
+  void create(
+      SpanLimitsAndAttributeLimits model,
+      io.opentelemetry.sdk.trace.SpanLimits expectedSpanLimits) {
    assertThat(
            SpanLimitsFactory.getInstance()
-                .create(null, mock(SpiHelper.class), Collections.emptyList()))
-        .isEqualTo(io.opentelemetry.sdk.trace.SpanLimits.getDefault());
+                .create(model, mock(SpiHelper.class), Collections.emptyList()))
+        .isEqualTo(expectedSpanLimits);
  }

-  @Test
-  void create_Defaults() {
-    assertThat(
-            SpanLimitsFactory.getInstance()
-                .create(new SpanLimits(), mock(SpiHelper.class), Collections.emptyList()))
-        .isEqualTo(io.opentelemetry.sdk.trace.SpanLimits.getDefault());
-  }
-
-  @Test
-  void create() {
-    assertThat(
-            SpanLimitsFactory.getInstance()
-                .create(
-                    new SpanLimits()
-                        .withAttributeCountLimit(1)
-                        .withAttributeValueLengthLimit(2)
-                        .withEventCountLimit(3)
-                        .withLinkCountLimit(4)
-                        .withEventAttributeCountLimit(5)
-                        .withLinkAttributeCountLimit(6),
-                    mock(SpiHelper.class),
-                    Collections.emptyList()))
-        .isEqualTo(
+  private static Stream<Arguments> createArguments() {
+    return Stream.of(
+        Arguments.of(null, io.opentelemetry.sdk.trace.SpanLimits.getDefault()),
+        Arguments.of(
+            SpanLimitsAndAttributeLimits.create(null, null),
+            io.opentelemetry.sdk.trace.SpanLimits.getDefault()),
+        Arguments.of(
+            SpanLimitsAndAttributeLimits.create(new AttributeLimits(), new SpanLimits()),
+            io.opentelemetry.sdk.trace.SpanLimits.getDefault()),
+        Arguments.of(
+            SpanLimitsAndAttributeLimits.create(
+                new AttributeLimits().withAttributeCountLimit(1).withAttributeValueLengthLimit(2),
+                new SpanLimits()),
            io.opentelemetry.sdk.trace.SpanLimits.builder()
                .setMaxNumberOfAttributes(1)
                .setMaxAttributeValueLength(2)
-                .setMaxNumberOfEvents(3)
-                .setMaxNumberOfLinks(4)
-                .setMaxNumberOfAttributesPerEvent(5)
-                .setMaxNumberOfAttributesPerLink(6)
-                .build());
+                .build()),
+        Arguments.of(
+            SpanLimitsAndAttributeLimits.create(
+                new AttributeLimits().withAttributeCountLimit(1).withAttributeValueLengthLimit(2),
+                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()));
  }
 }
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/TracerProviderFactoryTest.java
+++ b/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
-  void create_Null() {
+  @ParameterizedTest
+  @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
-  void create_Defaults() {
-    List<Closeable> closeables = new ArrayList<>();
-    SdkTracerProvider expectedProvider = SdkTracerProvider.builder().build();
-    cleanup.addCloseable(expectedProvider);
-
-    SdkTracerProvider provider =
-        TracerProviderFactory.getInstance()
-            .create(new TracerProvider(), spiHelper, closeables)
-            .build();
-    cleanup.addCloseable(provider);
-    cleanup.addCloseables(closeables);
-
-    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(
+  private static Stream<Arguments> createArguments() {
+    return Stream.of(
+        Arguments.of(null, SdkTracerProvider.builder().build()),
+        Arguments.of(
+            TracerProviderAndAttributeLimits.create(null, null),
+            SdkTracerProvider.builder().build()),
+        Arguments.of(
+            TracerProviderAndAttributeLimits.create(new AttributeLimits(), new TracerProvider()),
+            SdkTracerProvider.builder().build()),
+        Arguments.of(
+            TracerProviderAndAttributeLimits.create(
+                new AttributeLimits(),
                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()))))),
-                spiHelper,
-                closeables)
-            .build();
-    cleanup.addCloseable(provider);
-    cleanup.addCloseables(closeables);
-
-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+                                        .withExporter(new SpanExporter().withOtlp(new Otlp())))))),
+            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()));
  }
 }