Add experimental SdkResourceProvider implementation

all/src/test/java/io/opentelemetry/all/NoSharedInternalCodeTest.java

@@ -39,6 +39,7 @@ class NoSharedInternalCodeTest {
           "opentelemetry-exporter-prometheus",
           "opentelemetry-extension-trace-propagators",
           "opentelemetry-opencensus-shim",
+          "opentelemetry-sdk",
           "opentelemetry-sdk-logs",
           "opentelemetry-sdk-metrics",
           "opentelemetry-sdk-profiles",

sdk/all/build.gradle.kts

@@ -30,3 +30,20 @@ dependencies {
   jmh(project(":sdk:testing"))
   jmh(project(":api:incubator"))
 }
+
+testing {
+  suites {
+    register<JvmTestSuite>("testIncubating") {
+      dependencies {
+        implementation(project(":api:incubator"))
+        implementation(project(":sdk:testing"))
+      }
+    }
+  }
+}
+
+tasks {
+  check {
+    dependsOn(testing.suites)
+  }
+}

sdk/all/src/main/java/io/opentelemetry/sdk/internal/ExtendedOpenTelemetrySdk.java

@@ -9,6 +9,15 @@
 import io.opentelemetry.api.incubator.config.ConfigProvider;
 import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.logs.SdkLoggerProvider;
+import io.opentelemetry.sdk.logs.internal.SdkLoggerProviderUtil;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.metrics.internal.SdkMeterProviderUtil;
+import io.opentelemetry.sdk.resources.Resource;
+import io.opentelemetry.sdk.resources.internal.SdkResourceProvider;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.internal.SdkTracerProviderUtil;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -23,6 +32,7 @@ public final class ExtendedOpenTelemetrySdk extends OpenTelemetrySdk
 
   private final OpenTelemetrySdk openTelemetrySdk;
   private final ObfuscatedConfigProvider configProvider;
+  @Nullable private final SdkResourceProvider resourceProvider;
 
   private ExtendedOpenTelemetrySdk(
       OpenTelemetrySdk openTelemetrySdk, SdkConfigProvider configProvider) {
@@ -33,6 +43,7 @@ private ExtendedOpenTelemetrySdk(
         openTelemetrySdk.getPropagators());
     this.openTelemetrySdk = openTelemetrySdk;
     this.configProvider = new ObfuscatedConfigProvider(configProvider);
+    this.resourceProvider = resolveSdkResourceProvider(openTelemetrySdk);
   }
 
   public static ExtendedOpenTelemetrySdk create(
@@ -50,13 +61,48 @@ public SdkConfigProvider getSdkConfigProvider() {
     return configProvider.unobfuscate();
   }
 
+  /**
+   * Returns the {@link SdkResourceProvider} shared by the SDK's tracer, meter, and logger
+   * providers.
+   *
+   * @throws IllegalStateException if the three signal providers were not configured with equivalent
+   *     resources.
+   */
+  public SdkResourceProvider getSdkResourceProvider() {
+    if (resourceProvider == null) {
+      throw new IllegalStateException(
+          "SdkTracerProvider, SdkMeterProvider, and SdkLoggerProvider are configured with"
+              + " different resources. Configure all three signal providers with the same"
+              + " SdkResourceProvider (or the same Resource) to resolve this.");
+    }
+    return resourceProvider;
+  }
+
+  @Nullable
+  private static SdkResourceProvider resolveSdkResourceProvider(OpenTelemetrySdk sdk) {
+    SdkTracerProvider tracerProvider = sdk.getSdkTracerProvider();
+    SdkMeterProvider meterProvider = sdk.getSdkMeterProvider();
+    SdkLoggerProvider loggerProvider = sdk.getSdkLoggerProvider();
+    SdkResourceProvider tracerRp = SdkTracerProviderUtil.getSdkResourceProvider(tracerProvider);
+    SdkResourceProvider meterRp = SdkMeterProviderUtil.getSdkResourceProvider(meterProvider);
+    SdkResourceProvider loggerRp = SdkLoggerProviderUtil.getSdkResourceProvider(loggerProvider);
+    Resource tracerResource = tracerRp.getResource();
+    if (tracerResource.equals(meterRp.getResource())
+        && tracerResource.equals(loggerRp.getResource())) {
+      return tracerRp;
+    }
+    return null;
+  }
+
   @Override
   public String toString() {
     return "ExtendedOpenTelemetrySdk{"
         + "openTelemetrySdk="
         + openTelemetrySdk
         + ", configProvider="
         + configProvider.unobfuscate()
+        + ", resourceProvider="
+        + resourceProvider
         + "}";
   }
 

sdk/all/src/testIncubating/java/io/opentelemetry/sdk/internal/ExtendedOpenTelemetrySdkTest.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.logs.SdkLoggerProvider;
+import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
+import io.opentelemetry.sdk.logs.internal.SdkLoggerProviderUtil;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
+import io.opentelemetry.sdk.metrics.internal.SdkMeterProviderUtil;
+import io.opentelemetry.sdk.resources.Resource;
+import io.opentelemetry.sdk.resources.internal.SdkResourceProvider;
+import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
+import io.opentelemetry.sdk.trace.internal.SdkTracerProviderUtil;
+import javax.annotation.Nullable;
+import org.junit.jupiter.api.Test;
+
+class ExtendedOpenTelemetrySdkTest {
+
+  private static final Resource RESOURCE_A =
+      Resource.create(Attributes.of(AttributeKey.stringKey("a"), "1"));
+  private static final Resource RESOURCE_B =
+      Resource.create(Attributes.of(AttributeKey.stringKey("b"), "2"));
+
+  @Test
+  void getSdkResourceProvider_defaultResources_returnsAutoWrapped() {
+    ExtendedOpenTelemetrySdk sdk = buildExtended(null, null, null, null, null, null);
+
+    assertThat(sdk.getSdkResourceProvider().getResource()).isEqualTo(Resource.getDefault());
+  }
+
+  @Test
+  void getSdkResourceProvider_sameSdkResourceProviderOnAll_returnsIt() {
+    SdkResourceProvider resourceProvider = SdkResourceProvider.create(RESOURCE_A);
+    ExtendedOpenTelemetrySdk sdk =
+        buildExtended(null, resourceProvider, null, resourceProvider, null, resourceProvider);
+
+    assertThat(sdk.getSdkResourceProvider()).isSameAs(resourceProvider);
+  }
+
+  @Test
+  void getSdkResourceProvider_equivalentAutoWrappedResources_returnsFirst() {
+    // Distinct RP instances resolving to the same Resource: composite check is equal-by-Resource
+    // so this must succeed.
+    ExtendedOpenTelemetrySdk sdk =
+        buildExtended(RESOURCE_A, null, RESOURCE_A, null, RESOURCE_A, null);
+
+    assertThat(sdk.getSdkResourceProvider().getResource()).isEqualTo(RESOURCE_A);
+  }
+
+  @Test
+  void getSdkResourceProvider_mismatchedResources_throws() {
+    ExtendedOpenTelemetrySdk sdk =
+        buildExtended(RESOURCE_A, null, RESOURCE_B, null, RESOURCE_A, null);
+
+    assertThatThrownBy(sdk::getSdkResourceProvider)
+        .isInstanceOf(IllegalStateException.class)
+        .hasMessageContaining("configured with different");
+  }
+
+  private static ExtendedOpenTelemetrySdk buildExtended(
+      @Nullable Resource tracerResource,
+      @Nullable SdkResourceProvider tracerRp,
+      @Nullable Resource meterResource,
+      @Nullable SdkResourceProvider meterRp,
+      @Nullable Resource loggerResource,
+      @Nullable SdkResourceProvider loggerRp) {
+    SdkTracerProviderBuilder tracerBuilder = SdkTracerProvider.builder();
+    if (tracerResource != null) {
+      tracerBuilder.setResource(tracerResource);
+    }
+    if (tracerRp != null) {
+      SdkTracerProviderUtil.setSdkResourceProvider(tracerBuilder, tracerRp);
+    }
+    SdkMeterProviderBuilder meterBuilder =
+        SdkMeterProvider.builder().registerMetricReader(InMemoryMetricReader.create());
+    if (meterResource != null) {
+      meterBuilder.setResource(meterResource);
+    }
+    if (meterRp != null) {
+      SdkMeterProviderUtil.setSdkResourceProvider(meterBuilder, meterRp);
+    }
+    SdkLoggerProviderBuilder loggerBuilder = SdkLoggerProvider.builder();
+    if (loggerResource != null) {
+      loggerBuilder.setResource(loggerResource);
+    }
+    if (loggerRp != null) {
+      SdkLoggerProviderUtil.setSdkResourceProvider(loggerBuilder, loggerRp);
+    }
+    return (ExtendedOpenTelemetrySdk)
+        OpenTelemetrySdk.builder()
+            .setTracerProvider(tracerBuilder.build())
+            .setMeterProvider(meterBuilder.build())
+            .setLoggerProvider(loggerBuilder.build())
+            .build();
+  }
+}

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/ConstantResourceDetector.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.resources.internal;
+
+import io.opentelemetry.sdk.resources.Resource;
+import javax.annotation.Nullable;
+
+final class ConstantResourceDetector implements ResourceDetector {
+
+  @Nullable private final String name;
+  private final Resource resource;
+
+  ConstantResourceDetector(@Nullable String name, Resource resource) {
+    this.name = name;
+    this.resource = resource;
+  }
+
+  @Nullable
+  @Override
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public Resource getResource() {
+    return resource;
+  }
+
+  @Override
+  public boolean shouldReinvoke() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return "ConstantResourceDetector{name=" + name + ", resource=" + resource + "}";
+  }
+}

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/ResourceDetector.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.resources.internal;
+
+import io.opentelemetry.sdk.resources.Resource;
+import javax.annotation.Nullable;
+
+/** A source of a {@link Resource} to be merged by an {@link SdkResourceProvider}. */
+interface ResourceDetector {
+
+  /**
+   * Returns the name of this detector, or {@code null} if unnamed. Names are informational (e.g.
+   * for logging / debugging) and are not required to be unique.
+   */
+  @Nullable
+  String getName();
+
+  /** Returns the {@link Resource} detected by this detector. */
+  Resource getResource();
+
+  /**
+   * Returns whether the enclosing {@link SdkResourceProvider} must re-invoke this detector on every
+   * call to {@link SdkResourceProvider#getResource()}.
+   *
+   * <p>When {@code true}, {@link #getResource()} may be called on every {@link
+   * SdkResourceProvider#getResource()}. When {@code false}, this detector's result may be resolved
+   * once at {@link SdkResourceProvider} construction and cached.
+   *
+   * <p>This flag is part of the target API but has no effect on runtime behavior in the current
+   * iteration - all detectors are cached at construction. TTL-based cache invalidation using this
+   * flag is planned for a future iteration.
+   */
+  boolean shouldReinvoke();
+}

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/SdkResourceProvider.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.resources.internal;
+
+import static java.util.Objects.requireNonNull;
+
+import io.opentelemetry.sdk.resources.Resource;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Provides the {@link Resource} used by the SDK by merging the results of a configured, ordered
+ * list of {@link ResourceDetector}s.
+ *
+ * <p>All detectors are invoked once at construction and the merged {@link Resource} is cached for
+ * the lifetime of this provider. {@link ResourceDetector#shouldReinvoke()} is part of the target
+ * API shape but has no effect on runtime behavior in this iteration. A future iteration will add
+ * TTL-based cache invalidation that re-invokes only {@code shouldReinvoke=true} detectors when the
+ * cache expires. Until then, {@code getResource()} is a single field read on the hot path.
+ *
+ * <p>This class is internal and experimental. Its APIs are unstable and can change at any time. Its
+ * APIs (or a version of them) may be promoted to the public stable API in the future, but no
+ * guarantees are made.
+ */
+public final class SdkResourceProvider {
+
+  private final List<ResourceDetector> detectors;
+  private final Resource cachedResource;
+
+  SdkResourceProvider(List<ResourceDetector> detectors) {
+    this.detectors = Collections.unmodifiableList(new ArrayList<>(detectors));
+    this.cachedResource = merge(this.detectors);
+  }
+
+  /** Returns a new {@link SdkResourceProviderBuilder}. */
+  public static SdkResourceProviderBuilder builder() {
+    return new SdkResourceProviderBuilder();
+  }
+
+  /** Returns an {@link SdkResourceProvider} backed by a single constant {@link Resource}. */
+  public static SdkResourceProvider create(Resource resource) {
+    requireNonNull(resource, "resource");
+    return builder().addConstantResource(resource).build();
+  }
+
+  /** Returns the merged {@link Resource}. */
+  public Resource getResource() {
+    return cachedResource;
+  }
+
+  private static Resource merge(List<ResourceDetector> detectors) {
+    Resource resource = Resource.empty();
+    for (ResourceDetector detector : detectors) {
+      resource = resource.merge(detector.getResource());
+    }
+    return resource;
+  }
+
+  @Override
+  public String toString() {
+    return "SdkResourceProvider{detectors=" + detectors + "}";
+  }
+}