no api changes

2025-07-18 09:03:14 +02:00 · 2025-07-18 09:03:14 +02:00 · 9b84e85f2d
parent 4091afa0eb
commit 9b84e85f2d
16 changed files with 291 additions and 233 deletions
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/ExtendedOpenTelemetrySdk.java
+++ b/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/ExtendedOpenTelemetrySdk.java
@ -7,11 +7,14 @@ package io.opentelemetry.sdk.extension.incubator;

 import io.opentelemetry.api.incubator.ExtendedOpenTelemetry;
 import io.opentelemetry.api.incubator.config.ConfigProvider;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.logs.SdkLoggerProvider;
 import io.opentelemetry.sdk.metrics.SdkMeterProvider;
 import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import javax.annotation.Nullable;
 import java.io.Closeable;
+import java.lang.reflect.Field;

 /** A new interface for creating OpenTelemetrySdk that supports getting {@link ConfigProvider}. */
 public interface ExtendedOpenTelemetrySdk extends ExtendedOpenTelemetry, Closeable {
@ -27,4 +30,16 @@ public interface ExtendedOpenTelemetrySdk extends ExtendedOpenTelemetry, Closeab
  static ExtendedOpenTelemetrySdkBuilder builder() {
    return new ExtendedOpenTelemetrySdkBuilder();
  }
+
+  @Nullable default ExtendedOpenTelemetrySdk fromOpenTelemetrySdk(OpenTelemetrySdk openTelemetry) {
+    try {
+      Class<?> sdk = Class.forName("io.opentelemetry.sdk.OpenTelemetrySdk");
+      Field extendedOpenTelemetrySdk = sdk.getDeclaredField("extendedOpenTelemetrySdk");
+      extendedOpenTelemetrySdk.setAccessible(true);
+      return (ExtendedOpenTelemetrySdk) extendedOpenTelemetrySdk.get(openTelemetry);
+    } catch (ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) {
+      throw new IllegalStateException(
+          "Cannot create ExtendedOpenTelemetrySdk from OpenTelemetrySdk", e);
+    }
+  }
 }
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/ExtendedOpenTelemetrySdkBuilder.java
+++ b/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/ExtendedOpenTelemetrySdkBuilder.java
@ -10,22 +10,32 @@ import io.opentelemetry.api.incubator.config.ConfigProvider;
 import io.opentelemetry.context.propagation.ContextPropagators;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
 import io.opentelemetry.sdk.OpenTelemetrySdkBuilder;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.SdkConfigProvider;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.OpenTelemetryConfigurationModel;
 import io.opentelemetry.sdk.logs.SdkLoggerProvider;
 import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
 import io.opentelemetry.sdk.metrics.SdkMeterProvider;
 import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
 import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
+import java.io.Closeable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Objects;
 import java.util.function.Consumer;

-/** A new interface for creating OpenTelemetrySdk that supports {@link ConfigProvider}. */
+/** An builder for creating an {@link ExtendedOpenTelemetrySdk} instance. */
 public final class ExtendedOpenTelemetrySdkBuilder {
  private final SdkTracerProviderBuilder tracerProviderBuilder = SdkTracerProvider.builder();
  private final SdkMeterProviderBuilder meterProviderBuilder = SdkMeterProvider.builder();
  private final SdkLoggerProviderBuilder loggerProviderBuilder = SdkLoggerProvider.builder();
  private ContextPropagators propagators = ContextPropagators.noop();
-  private ConfigProvider configProvider = ConfigProvider.noop();
+  private ConfigProvider configProvider =
+      SdkConfigProvider.create(new OpenTelemetryConfigurationModel());
+  private Consumer<Closeable> closeableConsumer =
+      closeable -> {
+        // Default no-op closeable consumer
+      };

  /** Sets the {@link ContextPropagators} to use. */
  public ExtendedOpenTelemetrySdkBuilder setPropagators(ContextPropagators propagators) {
@ -39,6 +49,11 @@ public final class ExtendedOpenTelemetrySdkBuilder {
    return this;
  }

+  public ExtendedOpenTelemetrySdkBuilder setCloseableConsumer(Consumer<Closeable> configurator) {
+    this.closeableConsumer = Objects.requireNonNull(configurator, "configurator must not be null");
+    return this;
+  }
+
  /**
   * Applies a consumer callback to configure the TracerProvider being built for this OpenTelemetry.
   *
@ -84,12 +99,35 @@ public final class ExtendedOpenTelemetrySdkBuilder {
   *
   * @see GlobalOpenTelemetry
   */
-  public ExtendedOpenTelemetrySdk build() {
+  public OpenTelemetrySdk build() {
    SdkTracerProvider tracerProvider = tracerProviderBuilder.build();
    SdkMeterProvider meterProvider = meterProviderBuilder.build();
    SdkLoggerProvider loggerProvider = loggerProviderBuilder.build();
-    return new ObfuscatedExtendedOpenTelemetrySdk(
-        configProvider, tracerProvider, meterProvider, loggerProvider, propagators);
+    closeableConsumer.accept(tracerProvider);
+    closeableConsumer.accept(meterProvider);
+    closeableConsumer.accept(loggerProvider);
+    ExtendedOpenTelemetrySdk extendedOpenTelemetrySdk =
+        new ObfuscatedExtendedOpenTelemetrySdk(
+            configProvider, tracerProvider, meterProvider, loggerProvider, propagators);
+    closeableConsumer.accept(extendedOpenTelemetrySdk);
+
+    OpenTelemetrySdkBuilder builder =
+        OpenTelemetrySdk.builder()
+            .setTracerProvider(tracerProvider)
+            .setMeterProvider(meterProvider)
+            .setLoggerProvider(loggerProvider)
+            .setPropagators(propagators);
+
+    try {
+      Method setExtendedOpenTelemetrySdk =
+          builder.getClass().getDeclaredMethod("setExtendedOpenTelemetrySdk", Object.class);
+      setExtendedOpenTelemetrySdk.setAccessible(true);
+      setExtendedOpenTelemetrySdk.invoke(builder, extendedOpenTelemetrySdk);
+    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+      throw new IllegalStateException("unable to set extended OpenTelemetry SDK", e);
+    }
+
+    return builder.build();
  }

  /**
@ -102,8 +140,8 @@ public final class ExtendedOpenTelemetrySdkBuilder {
   *
   * @see GlobalOpenTelemetry
   */
-  public ExtendedOpenTelemetrySdk buildAndRegisterGlobal() {
-    ExtendedOpenTelemetrySdk sdk = build();
+  public OpenTelemetrySdk buildAndRegisterGlobal() {
+    OpenTelemetrySdk sdk = build();
    GlobalOpenTelemetry.set(sdk);
    return sdk;
  }
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/ObfuscatedExtendedOpenTelemetrySdk.java
+++ b/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/ObfuscatedExtendedOpenTelemetrySdk.java
@ -26,7 +26,7 @@ import java.util.logging.Logger;
 import javax.annotation.concurrent.ThreadSafe;

 /** The SDK implementation of {@link ExtendedOpenTelemetrySdk}. */
-final class ObfuscatedExtendedOpenTelemetrySdk implements ExtendedOpenTelemetrySdk {
+public final class ObfuscatedExtendedOpenTelemetrySdk implements ExtendedOpenTelemetrySdk {

  private static final Logger LOGGER =
      Logger.getLogger(ObfuscatedExtendedOpenTelemetrySdk.class.getName());
@ -37,7 +37,7 @@ final class ObfuscatedExtendedOpenTelemetrySdk implements ExtendedOpenTelemetryS
  private final ConfigProvider configProvider;
  private final ContextPropagators propagators;

-  ObfuscatedExtendedOpenTelemetrySdk(
+  public ObfuscatedExtendedOpenTelemetrySdk(
      ConfigProvider configProvider,
      SdkTracerProvider tracerProvider,
      SdkMeterProvider meterProvider,
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/DeclarativeConfigContext.java
+++ b/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/DeclarativeConfigContext.java
@ -7,6 +7,7 @@ package io.opentelemetry.sdk.extension.incubator.fileconfig;

 import io.opentelemetry.api.incubator.config.DeclarativeConfigException;
 import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
+import io.opentelemetry.common.ComponentLoader;
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
 import io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider;
 import java.io.Closeable;
@ -39,6 +40,9 @@ class DeclarativeConfigContext {
    return Collections.unmodifiableList(closeables);
  }

+  ComponentLoader getComponentLoader() {
+    return spiHelper.getComponentLoader();
+  }
  /**
   * Find a registered {@link ComponentProvider} with {@link ComponentProvider#getType()} matching
   * {@code type}, {@link ComponentProvider#getName()} matching {@code name}, and call {@link
--- 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,14 +15,12 @@ import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.Logger
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
 import io.opentelemetry.sdk.logs.LogLimits;
-import io.opentelemetry.sdk.logs.SdkLoggerProvider;
 import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
 import io.opentelemetry.sdk.logs.internal.LoggerConfig;
 import io.opentelemetry.sdk.logs.internal.SdkLoggerProviderUtil;
 import java.util.List;

-final class LoggerProviderFactory
-    implements Factory<LoggerProviderAndAttributeLimits, SdkLoggerProviderBuilder> {
+final class LoggerProviderFactory {

  private static final LoggerProviderFactory INSTANCE = new LoggerProviderFactory();

@ -32,14 +30,13 @@ final class LoggerProviderFactory
    return INSTANCE;
  }

-  @Override
-  public SdkLoggerProviderBuilder create(
+  public void configure(
+      SdkLoggerProviderBuilder builder,
      LoggerProviderAndAttributeLimits model, DeclarativeConfigContext context) {
-    SdkLoggerProviderBuilder builder = SdkLoggerProvider.builder();

    LoggerProviderModel loggerProviderModel = model.getLoggerProvider();
    if (loggerProviderModel == null) {
-      return builder;
+      return;
    }

    LogLimits logLimits =
@ -85,7 +82,6 @@ final class LoggerProviderFactory
      SdkLoggerProviderUtil.setLoggerConfigurator(builder, configuratorBuilder.build());
    }

-    return builder;
  }

  private static class LoggerConfigFactory
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/MeterProviderFactory.java
+++ b/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/MeterProviderFactory.java
@ -17,14 +17,13 @@ import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.ViewSe
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.ViewStreamModel;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
-import io.opentelemetry.sdk.metrics.SdkMeterProvider;
 import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
 import io.opentelemetry.sdk.metrics.export.CardinalityLimitSelector;
 import io.opentelemetry.sdk.metrics.internal.MeterConfig;
 import io.opentelemetry.sdk.metrics.internal.SdkMeterProviderUtil;
 import java.util.List;

-final class MeterProviderFactory implements Factory<MeterProviderModel, SdkMeterProviderBuilder> {
+final class MeterProviderFactory {

  private static final MeterProviderFactory INSTANCE = new MeterProviderFactory();

@ -34,10 +33,8 @@ final class MeterProviderFactory implements Factory<MeterProviderModel, SdkMeter
    return INSTANCE;
  }

-  @Override
-  public SdkMeterProviderBuilder create(
-      MeterProviderModel model, DeclarativeConfigContext context) {
-    SdkMeterProviderBuilder builder = SdkMeterProvider.builder();
+  public void configure(
+      SdkMeterProviderBuilder builder, MeterProviderModel model, DeclarativeConfigContext context) {

    List<MetricReaderModel> readerModels = model.getReaders();
    if (readerModels != null) {
@ -95,7 +92,6 @@ final class MeterProviderFactory implements Factory<MeterProviderModel, SdkMeter
      SdkMeterProviderUtil.setMeterConfigurator(builder, configuratorBuilder.build());
    }

-    return builder;
  }

  private static class MeterConfigFactory
--- 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
@ -7,8 +7,11 @@ package io.opentelemetry.sdk.extension.incubator.fileconfig;

 import io.opentelemetry.api.incubator.config.DeclarativeConfigException;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
-import io.opentelemetry.sdk.OpenTelemetrySdkBuilder;
+import io.opentelemetry.sdk.extension.incubator.ExtendedOpenTelemetrySdkBuilder;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.LoggerProviderModel;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.MeterProviderModel;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.OpenTelemetryConfigurationModel;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.TracerProviderModel;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.Objects;
 import java.util.regex.Pattern;
@ -30,7 +33,7 @@ final class OpenTelemetryConfigurationFactory
  @Override
  public OpenTelemetrySdk create(
      OpenTelemetryConfigurationModel model, DeclarativeConfigContext context) {
-    OpenTelemetrySdkBuilder builder = OpenTelemetrySdk.builder();
+    ExtendedOpenTelemetrySdkBuilder builder = new ExtendedOpenTelemetrySdkBuilder();
    String fileFormat = model.getFileFormat();
    if (fileFormat == null || !SUPPORTED_FILE_FORMATS.matcher(fileFormat).matches()) {
      throw new DeclarativeConfigException(
@ -40,52 +43,56 @@ final class OpenTelemetryConfigurationFactory
    // behavior for experimental properties.

    if (Objects.equals(true, model.getDisabled())) {
-      return builder.build();
+      return OpenTelemetrySdk.builder().build();
    }

+    builder.setCloseableConsumer(context::addCloseable);
+    builder.setConfigProvider(SdkConfigProvider.create(model, context.getComponentLoader()));
    if (model.getPropagator() != null) {
      builder.setPropagators(
          PropagatorFactory.getInstance().create(model.getPropagator(), context));
    }

-    Resource resource = Resource.getDefault();
+    Resource resource;
    if (model.getResource() != null) {
      resource = ResourceFactory.getInstance().create(model.getResource(), context);
+    } else {
+      resource = Resource.getDefault();
    }

-    if (model.getLoggerProvider() != null) {
-      builder.setLoggerProvider(
-          context.addCloseable(
+    LoggerProviderModel loggerProvider = model.getLoggerProvider();
+    if (loggerProvider != null) {
+      builder.withLoggerProvider(
+          sdkLoggerProviderBuilder ->
              LoggerProviderFactory.getInstance()
-                  .create(
+                  .configure(
+                      sdkLoggerProviderBuilder.setResource(resource),
                      LoggerProviderAndAttributeLimits.create(
-                          model.getAttributeLimits(), model.getLoggerProvider()),
-                      context)
-                  .setResource(resource)
-                  .build()));
+                          model.getAttributeLimits(), loggerProvider),
+                      context));
    }

-    if (model.getTracerProvider() != null) {
-      builder.setTracerProvider(
-          context.addCloseable(
+    TracerProviderModel tracerProvider = model.getTracerProvider();
+    if (tracerProvider != null) {
+      builder.withTracerProvider(
+          sdkTracerProviderBuilder ->
              TracerProviderFactory.getInstance()
-                  .create(
+                  .configure(
+                      sdkTracerProviderBuilder.setResource(resource),
                      TracerProviderAndAttributeLimits.create(
-                          model.getAttributeLimits(), model.getTracerProvider()),
-                      context)
-                  .setResource(resource)
-                  .build()));
+                          model.getAttributeLimits(), tracerProvider),
+                      context));
    }

-    if (model.getMeterProvider() != null) {
-      builder.setMeterProvider(
-          context.addCloseable(
+    MeterProviderModel meterProvider = model.getMeterProvider();
+    if (meterProvider != null) {
+      builder.withMeterProvider(
+          sdkMeterProviderBuilder ->
              MeterProviderFactory.getInstance()
-                  .create(model.getMeterProvider(), context)
-                  .setResource(resource)
-                  .build()));
+                  .configure(
+                      sdkMeterProviderBuilder.setResource(resource), meterProvider, context));
    }

-    return context.addCloseable(builder.build());
+    return builder.build();
  }
 }
--- a/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SdkConfigProvider.java
+++ b/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/SdkConfigProvider.java
@ -50,4 +50,9 @@ public final class SdkConfigProvider implements ConfigProvider {
  public DeclarativeConfigProperties getInstrumentationConfig() {
    return instrumentationConfig;
  }
+
+  @Override
+  public String toString() {
+    return "SdkConfigProvider{" + "instrumentationConfig=" + instrumentationConfig + '}';
+  }
 }
--- 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
@ -14,7 +14,6 @@ import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.SpanPr
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.TracerProviderModel;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
-import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
 import io.opentelemetry.sdk.trace.SpanLimits;
 import io.opentelemetry.sdk.trace.internal.SdkTracerProviderUtil;
@ -22,8 +21,7 @@ import io.opentelemetry.sdk.trace.internal.TracerConfig;
 import io.opentelemetry.sdk.trace.samplers.Sampler;
 import java.util.List;

-final class TracerProviderFactory
-    implements Factory<TracerProviderAndAttributeLimits, SdkTracerProviderBuilder> {
+final class TracerProviderFactory {

  private static final TracerProviderFactory INSTANCE = new TracerProviderFactory();

@ -33,13 +31,13 @@ final class TracerProviderFactory
    return INSTANCE;
  }

-  @Override
-  public SdkTracerProviderBuilder create(
-      TracerProviderAndAttributeLimits model, DeclarativeConfigContext context) {
-    SdkTracerProviderBuilder builder = SdkTracerProvider.builder();
+  public void configure(
+      SdkTracerProviderBuilder builder,
+      TracerProviderAndAttributeLimits model,
+      DeclarativeConfigContext context) {
    TracerProviderModel tracerProviderModel = model.getTracerProvider();
    if (tracerProviderModel == null) {
-      return builder;
+      return;
    }

    SpanLimits spanLimits =
@ -90,8 +88,6 @@ final class TracerProviderFactory
      }
      SdkTracerProviderUtil.setTracerConfigurator(builder, configuratorBuilder.build());
    }
-
-    return builder;
  }

  private static class TracerConfigFactory
--- 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
@ -25,6 +25,7 @@ import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
 import io.opentelemetry.sdk.logs.LogLimits;
 import io.opentelemetry.sdk.logs.SdkLoggerProvider;
+import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
 import io.opentelemetry.sdk.logs.internal.LoggerConfig;
 import java.io.Closeable;
 import java.util.ArrayList;
@ -50,11 +51,13 @@ class LoggerProviderFactoryTest {
    List<Closeable> closeables = new ArrayList<>();
    cleanup.addCloseable(expectedProvider);

-    SdkLoggerProvider provider = LoggerProviderFactory.getInstance().create(model, context).build();
+    SdkLoggerProviderBuilder builder = SdkLoggerProvider.builder();
+    LoggerProviderFactory.getInstance().configure(builder, model, context);
+    SdkLoggerProvider provider = builder.build();
    cleanup.addCloseable(provider);
    cleanup.addCloseables(closeables);

-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+    assertThat(provider).hasToString(expectedProvider.toString());
  }

  private static Stream<Arguments> createArguments() {
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/MeterProviderFactoryTest.java
+++ b/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/MeterProviderFactoryTest.java
@ -26,6 +26,7 @@ import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
 import io.opentelemetry.sdk.metrics.InstrumentSelector;
 import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
 import io.opentelemetry.sdk.metrics.View;
 import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
 import io.opentelemetry.sdk.metrics.internal.MeterConfig;
@ -53,11 +54,13 @@ class MeterProviderFactoryTest {
    List<Closeable> closeables = new ArrayList<>();
    cleanup.addCloseable(expectedProvider);

-    SdkMeterProvider provider = MeterProviderFactory.getInstance().create(model, context).build();
+    SdkMeterProviderBuilder builder = SdkMeterProvider.builder();
+    MeterProviderFactory.getInstance().configure(builder, model, context);
+    SdkMeterProvider provider = builder.build();
    cleanup.addCloseable(provider);
    cleanup.addCloseables(closeables);

-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+    assertThat(provider).hasToString(expectedProvider.toString());
  }

  private static Stream<Arguments> createArguments() {
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/OpenTelemetryConfigurationFactoryTest.java
+++ b/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/OpenTelemetryConfigurationFactoryTest.java
@ -24,6 +24,8 @@ import io.opentelemetry.extension.trace.propagation.OtTracePropagator;
 import io.opentelemetry.internal.testing.CleanupExtension;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
 import io.opentelemetry.sdk.autoconfigure.internal.SpiHelper;
+import io.opentelemetry.sdk.extension.incubator.ExtendedOpenTelemetrySdk;
+import io.opentelemetry.sdk.extension.incubator.ExtendedOpenTelemetrySdkBuilder;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AlwaysOnSamplerModel;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.AttributeNameValueModel;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.BatchLogRecordProcessorModel;
@ -53,11 +55,8 @@ import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.ViewMo
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.ViewSelectorModel;
 import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.ViewStreamModel;
 import io.opentelemetry.sdk.logs.LogLimits;
-import io.opentelemetry.sdk.logs.SdkLoggerProvider;
 import io.opentelemetry.sdk.metrics.InstrumentSelector;
-import io.opentelemetry.sdk.metrics.SdkMeterProvider;
 import io.opentelemetry.sdk.metrics.View;
-import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.SpanLimits;
 import java.io.Closeable;
 import java.util.ArrayList;
@ -118,25 +117,29 @@ class OpenTelemetryConfigurationFactoryTest {
  @Test
  void create_Defaults() {
    List<Closeable> closeables = new ArrayList<>();
-    OpenTelemetrySdk expectedSdk = OpenTelemetrySdk.builder().build();
+    OpenTelemetryConfigurationModel model =
+        new OpenTelemetryConfigurationModel().withFileFormat("1.0-rc.1");
+    OpenTelemetrySdk expectedSdk =
+        new ExtendedOpenTelemetrySdkBuilder()
+            .setConfigProvider(SdkConfigProvider.create(model))
+            .build();
    cleanup.addCloseable(expectedSdk);

-    OpenTelemetrySdk sdk =
-        OpenTelemetryConfigurationFactory.getInstance()
-            .create(new OpenTelemetryConfigurationModel().withFileFormat("1.0-rc.1"), context);
+    ExtendedOpenTelemetrySdk sdk =
+        OpenTelemetryConfigurationFactory.getInstance().create(model, context);
    cleanup.addCloseable(sdk);
    cleanup.addCloseables(closeables);

-    assertThat(sdk.toString()).isEqualTo(expectedSdk.toString());
+    assertThat(sdk).hasToString(expectedSdk.toString());
  }

  @Test
  void create_Disabled() {
    List<Closeable> closeables = new ArrayList<>();
-    OpenTelemetrySdk expectedSdk = OpenTelemetrySdk.builder().build();
+    ExtendedOpenTelemetrySdk expectedSdk = new ExtendedOpenTelemetrySdkBuilder().build();
    cleanup.addCloseable(expectedSdk);

-    OpenTelemetrySdk sdk =
+    ExtendedOpenTelemetrySdk sdk =
        OpenTelemetryConfigurationFactory.getInstance()
            .create(
                new OpenTelemetryConfigurationModel()
@ -158,7 +161,7 @@ class OpenTelemetryConfigurationFactoryTest {
    cleanup.addCloseable(sdk);
    cleanup.addCloseables(closeables);

-    assertThat(sdk.toString()).isEqualTo(expectedSdk.toString());
+    assertThat(sdk).hasToString(expectedSdk.toString());
  }

  @Test
@ -173,8 +176,87 @@ class OpenTelemetryConfigurationFactoryTest {
            .put("shape", "square")
            .put("order", "second")
            .build();
-    OpenTelemetrySdk expectedSdk =
-        OpenTelemetrySdk.builder()
+
+    OpenTelemetryConfigurationModel model =
+        new OpenTelemetryConfigurationModel()
+            .withFileFormat("1.0-rc.1")
+            .withPropagator(
+                new PropagatorModel()
+                    .withCompositeList("tracecontext,baggage,ottrace,b3multi,b3,jaeger"))
+            .withResource(
+                new ResourceModel()
+                    .withDetectionDevelopment(
+                        new ExperimentalResourceDetectionModel()
+                            .withDetectors(
+                                Arrays.asList(
+                                    new ExperimentalResourceDetectorModel()
+                                        .withAdditionalProperty("order_first", null),
+                                    new ExperimentalResourceDetectorModel()
+                                        .withAdditionalProperty("order_second", null),
+                                    new ExperimentalResourceDetectorModel()
+                                        .withAdditionalProperty("shape_color", null))))
+                    .withAttributes(
+                        Arrays.asList(
+                            new AttributeNameValueModel()
+                                .withName("service.name")
+                                .withValue("my-service"),
+                            new AttributeNameValueModel().withName("key").withValue("val"))))
+            .withLoggerProvider(
+                new LoggerProviderModel()
+                    .withLimits(
+                        new LogRecordLimitsModel()
+                            .withAttributeValueLengthLimit(1)
+                            .withAttributeCountLimit(2))
+                    .withProcessors(
+                        Collections.singletonList(
+                            new LogRecordProcessorModel()
+                                .withBatch(
+                                    new BatchLogRecordProcessorModel()
+                                        .withExporter(
+                                            new LogRecordExporterModel()
+                                                .withOtlpHttp(new OtlpHttpExporterModel()))))))
+            .withTracerProvider(
+                new TracerProviderModel()
+                    .withLimits(
+                        new SpanLimitsModel()
+                            .withAttributeCountLimit(1)
+                            .withAttributeValueLengthLimit(2)
+                            .withEventCountLimit(3)
+                            .withLinkCountLimit(4)
+                            .withEventAttributeCountLimit(5)
+                            .withLinkAttributeCountLimit(6))
+                    .withSampler(new SamplerModel().withAlwaysOn(new AlwaysOnSamplerModel()))
+                    .withProcessors(
+                        Collections.singletonList(
+                            new SpanProcessorModel()
+                                .withBatch(
+                                    new BatchSpanProcessorModel()
+                                        .withExporter(
+                                            new SpanExporterModel()
+                                                .withOtlpHttp(new OtlpHttpExporterModel()))))))
+            .withMeterProvider(
+                new MeterProviderModel()
+                    .withReaders(
+                        Collections.singletonList(
+                            new MetricReaderModel()
+                                .withPeriodic(
+                                    new PeriodicMetricReaderModel()
+                                        .withExporter(
+                                            new PushMetricExporterModel()
+                                                .withOtlpHttp(new OtlpHttpMetricExporterModel())))))
+                    .withViews(
+                        Collections.singletonList(
+                            new ViewModel()
+                                .withSelector(
+                                    new ViewSelectorModel().withInstrumentName("instrument-name"))
+                                .withStream(
+                                    new ViewStreamModel()
+                                        .withName("stream-name")
+                                        .withAttributeKeys(null)))));
+
+    ExtendedOpenTelemetrySdk expectedSdk =
+        new ExtendedOpenTelemetrySdkBuilder()
+            .setConfigProvider(SdkConfigProvider.create(model))
            .setPropagators(
                ContextPropagators.create(
                    TextMapPropagator.composite(
@ -184,141 +266,57 @@ class OpenTelemetryConfigurationFactoryTest {
                        B3Propagator.injectingMultiHeaders(),
                        B3Propagator.injectingSingleHeader(),
                        JaegerPropagator.getInstance())))
-            .setLoggerProvider(
-                SdkLoggerProvider.builder()
-                    .setResource(expectedResource)
-                    .setLogLimits(
-                        () ->
-                            LogLimits.builder()
-                                .setMaxAttributeValueLength(1)
-                                .setMaxNumberOfAttributes(2)
+            .withLoggerProvider(
+                sdkLoggerProviderBuilder ->
+                    sdkLoggerProviderBuilder
+                        .setResource(expectedResource)
+                        .setLogLimits(
+                            () ->
+                                LogLimits.builder()
+                                    .setMaxAttributeValueLength(1)
+                                    .setMaxNumberOfAttributes(2)
+                                    .build())
+                        .addLogRecordProcessor(
+                            io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor.builder(
+                                    OtlpHttpLogRecordExporter.getDefault())
+                                .build()))
+            .withTracerProvider(
+                sdkTracerProviderBuilder ->
+                    sdkTracerProviderBuilder
+                        .setResource(expectedResource)
+                        .setSpanLimits(
+                            SpanLimits.builder()
+                                .setMaxNumberOfAttributes(1)
+                                .setMaxAttributeValueLength(2)
+                                .setMaxNumberOfEvents(3)
+                                .setMaxNumberOfLinks(4)
+                                .setMaxNumberOfAttributesPerEvent(5)
+                                .setMaxNumberOfAttributesPerLink(6)
                                .build())
-                    .addLogRecordProcessor(
-                        io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor.builder(
-                                OtlpHttpLogRecordExporter.getDefault())
-                            .build())
-                    .build())
-            .setTracerProvider(
-                SdkTracerProvider.builder()
-                    .setResource(expectedResource)
-                    .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(
-                                OtlpHttpSpanExporter.getDefault())
-                            .build())
-                    .build())
-            .setMeterProvider(
-                SdkMeterProvider.builder()
-                    .setResource(expectedResource)
-                    .registerMetricReader(
-                        io.opentelemetry.sdk.metrics.export.PeriodicMetricReader.builder(
-                                OtlpHttpMetricExporter.getDefault())
-                            .build())
-                    .registerView(
-                        InstrumentSelector.builder().setName("instrument-name").build(),
-                        View.builder().setName("stream-name").build())
-                    .build())
+                        .setSampler(alwaysOn())
+                        .addSpanProcessor(
+                            io.opentelemetry.sdk.trace.export.BatchSpanProcessor.builder(
+                                    OtlpHttpSpanExporter.getDefault())
+                                .build()))
+            .withMeterProvider(
+                sdkMeterProviderBuilder ->
+                    sdkMeterProviderBuilder
+                        .setResource(expectedResource)
+                        .registerMetricReader(
+                            io.opentelemetry.sdk.metrics.export.PeriodicMetricReader.builder(
+                                    OtlpHttpMetricExporter.getDefault())
+                                .build())
+                        .registerView(
+                            InstrumentSelector.builder().setName("instrument-name").build(),
+                            View.builder().setName("stream-name").build()))
            .build();
    cleanup.addCloseable(expectedSdk);

-    OpenTelemetrySdk sdk =
-        OpenTelemetryConfigurationFactory.getInstance()
-            .create(
-                new OpenTelemetryConfigurationModel()
-                    .withFileFormat("1.0-rc.1")
-                    .withPropagator(
-                        new PropagatorModel()
-                            .withCompositeList("tracecontext,baggage,ottrace,b3multi,b3,jaeger"))
-                    .withResource(
-                        new ResourceModel()
-                            .withDetectionDevelopment(
-                                new ExperimentalResourceDetectionModel()
-                                    .withDetectors(
-                                        Arrays.asList(
-                                            new ExperimentalResourceDetectorModel()
-                                                .withAdditionalProperty("order_first", null),
-                                            new ExperimentalResourceDetectorModel()
-                                                .withAdditionalProperty("order_second", null),
-                                            new ExperimentalResourceDetectorModel()
-                                                .withAdditionalProperty("shape_color", null))))
-                            .withAttributes(
-                                Arrays.asList(
-                                    new AttributeNameValueModel()
-                                        .withName("service.name")
-                                        .withValue("my-service"),
-                                    new AttributeNameValueModel()
-                                        .withName("key")
-                                        .withValue("val"))))
-                    .withLoggerProvider(
-                        new LoggerProviderModel()
-                            .withLimits(
-                                new LogRecordLimitsModel()
-                                    .withAttributeValueLengthLimit(1)
-                                    .withAttributeCountLimit(2))
-                            .withProcessors(
-                                Collections.singletonList(
-                                    new LogRecordProcessorModel()
-                                        .withBatch(
-                                            new BatchLogRecordProcessorModel()
-                                                .withExporter(
-                                                    new LogRecordExporterModel()
-                                                        .withOtlpHttp(
-                                                            new OtlpHttpExporterModel()))))))
-                    .withTracerProvider(
-                        new TracerProviderModel()
-                            .withLimits(
-                                new SpanLimitsModel()
-                                    .withAttributeCountLimit(1)
-                                    .withAttributeValueLengthLimit(2)
-                                    .withEventCountLimit(3)
-                                    .withLinkCountLimit(4)
-                                    .withEventAttributeCountLimit(5)
-                                    .withLinkAttributeCountLimit(6))
-                            .withSampler(
-                                new SamplerModel().withAlwaysOn(new AlwaysOnSamplerModel()))
-                            .withProcessors(
-                                Collections.singletonList(
-                                    new SpanProcessorModel()
-                                        .withBatch(
-                                            new BatchSpanProcessorModel()
-                                                .withExporter(
-                                                    new SpanExporterModel()
-                                                        .withOtlpHttp(
-                                                            new OtlpHttpExporterModel()))))))
-                    .withMeterProvider(
-                        new MeterProviderModel()
-                            .withReaders(
-                                Collections.singletonList(
-                                    new MetricReaderModel()
-                                        .withPeriodic(
-                                            new PeriodicMetricReaderModel()
-                                                .withExporter(
-                                                    new PushMetricExporterModel()
-                                                        .withOtlpHttp(
-                                                            new OtlpHttpMetricExporterModel())))))
-                            .withViews(
-                                Collections.singletonList(
-                                    new ViewModel()
-                                        .withSelector(
-                                            new ViewSelectorModel()
-                                                .withInstrumentName("instrument-name"))
-                                        .withStream(
-                                            new ViewStreamModel()
-                                                .withName("stream-name")
-                                                .withAttributeKeys(null))))),
-                context);
+    ExtendedOpenTelemetrySdk sdk =
+        OpenTelemetryConfigurationFactory.getInstance().create(model, context);
    cleanup.addCloseable(sdk);
    cleanup.addCloseables(closeables);

-    assertThat(sdk.toString()).isEqualTo(expectedSdk.toString());
+    assertThat(sdk).hasToString(expectedSdk.toString());
  }
 }
--- 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
@ -54,11 +54,13 @@ class TracerProviderFactoryTest {
    List<Closeable> closeables = new ArrayList<>();
    cleanup.addCloseable(expectedProvider);

-    SdkTracerProvider provider = TracerProviderFactory.getInstance().create(model, context).build();
+    SdkTracerProviderBuilder builder = SdkTracerProvider.builder();
+    TracerProviderFactory.getInstance().configure(builder, model, context);
+    SdkTracerProvider provider = builder.build();
    cleanup.addCloseable(provider);
    cleanup.addCloseables(closeables);

-    assertThat(provider.toString()).isEqualTo(expectedProvider.toString());
+    assertThat(provider).hasToString(expectedProvider.toString());
  }

  private static Stream<Arguments> createArguments() {
--- a/sdk/all/src/main/java/io/opentelemetry/sdk/IncubatingUtil.java
+++ b/sdk/all/src/main/java/io/opentelemetry/sdk/IncubatingUtil.java
@ -1,22 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.sdk;
-
-import javax.annotation.Nullable;
-
-/**
- * Utilities for interacting with {@code io.opentelemetry:opentelemetry-api-incubator}, which is not
- * guaranteed to be present on the classpath. For all methods, callers MUST first separately
- * reflectively confirm that the incubator is available on the classpath.
- */
-final class IncubatingUtil {
-  private IncubatingUtil() {}
-
-  @Nullable
-  static OpenTelemetrySdk createExtendedOpenTelemetrySdk() {
-    return null;
-  }
-}
--- a/sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdk.java
+++ b/sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdk.java
@ -24,6 +24,7 @@ import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.Logger;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;

 /** The SDK implementation of {@link OpenTelemetry}. */
@ -37,16 +38,19 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
  private final ObfuscatedMeterProvider meterProvider;
  private final ObfuscatedLoggerProvider loggerProvider;
  private final ContextPropagators propagators;
+  @Nullable private final Object extendedOpenTelemetrySdk;

  OpenTelemetrySdk(
      SdkTracerProvider tracerProvider,
      SdkMeterProvider meterProvider,
      SdkLoggerProvider loggerProvider,
-      ContextPropagators propagators) {
+      ContextPropagators propagators,
+      @Nullable Object extendedOpenTelemetrySdk) {
    this.tracerProvider = new ObfuscatedTracerProvider(tracerProvider);
    this.meterProvider = new ObfuscatedMeterProvider(meterProvider);
    this.loggerProvider = new ObfuscatedLoggerProvider(loggerProvider);
    this.propagators = propagators;
+    this.extendedOpenTelemetrySdk = extendedOpenTelemetrySdk;
  }

  /**
@ -130,6 +134,8 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
        + loggerProvider.unobfuscate()
        + ", propagators="
        + propagators
+        + ", extendedOpenTelemetrySdk="
+        + extendedOpenTelemetrySdk
        + "}";
  }

--- a/sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdkBuilder.java
+++ b/sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdkBuilder.java
@ -21,6 +21,7 @@ public final class OpenTelemetrySdkBuilder {
  @Nullable private SdkTracerProvider tracerProvider;
  @Nullable private SdkMeterProvider meterProvider;
  @Nullable private SdkLoggerProvider loggerProvider;
+  @Nullable private Object extendedOpenTelemetrySdk;

  /**
   * Package protected to disallow direct initialization.
@ -70,6 +71,16 @@ public final class OpenTelemetrySdkBuilder {
    return this;
  }

+  /**
+   * Sets the ExtendedOpenTelemetrySdk to use. This can be used to configure extended
+   * OpenTelemetry settings.
+   */
+  OpenTelemetrySdkBuilder setExtendedOpenTelemetrySdk(
+      @Nullable Object extendedOpenTelemetrySdk) {
+    this.extendedOpenTelemetrySdk = extendedOpenTelemetrySdk;
+    return this;
+  }
+
  /**
   * Returns a new {@link OpenTelemetrySdk} built with the configuration of this {@link
   * OpenTelemetrySdkBuilder} and registers it as the global {@link
@ -111,6 +122,6 @@ public final class OpenTelemetrySdkBuilder {
      loggerProvider = SdkLoggerProvider.builder().build();
    }

-    return new OpenTelemetrySdk(tracerProvider, meterProvider, loggerProvider, propagators);
+    return new OpenTelemetrySdk(tracerProvider, meterProvider, loggerProvider, propagators, extendedOpenTelemetrySdk);
  }
 }