declarative config: add declaravite config bridge, gcp auth, span stacktrace

declarative-config-bridge/build.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+  id("otel.java-conventions")
+  id("otel.publish-conventions")
+}
+
+description = "OpenTelemetry extension that provides a bridge for declarative configuration."
+otelJava.moduleName.set("io.opentelemetry.contrib.sdk.declarative.config.bridge")
+
+dependencies {
+  // We use `compileOnly` dependency because during runtime all necessary classes are provided by
+  // javaagent itself.
+  compileOnly("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+  compileOnly("io.opentelemetry:opentelemetry-sdk-extension-incubator")
+
+  testImplementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+  testImplementation("io.opentelemetry:opentelemetry-sdk-extension-incubator")
+  testImplementation("org.mockito:mockito-inline")
+}

declarative-config-bridge/src/main/java/io/opentelemetry/contrib/sdk/autoconfigure/ConfigPropertiesUtil.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.sdk.autoconfigure;
+
+public final class ConfigPropertiesUtil {
+  private ConfigPropertiesUtil() {}
+
+  public static String propertyYamlPath(String propertyName) {
+    return yamlPath(propertyName);
+  }
+
+  static String yamlPath(String property) {
+    String[] segments = DeclarativeConfigPropertiesBridge.getSegments(property);
+    if (segments.length == 0) {
+      throw new IllegalArgumentException("Invalid property: " + property);
+    }
+
+    return "'instrumentation/development' / 'java' / '" + String.join("' / '", segments) + "'";
+  }
+}

declarative-config-bridge/src/main/java/io/opentelemetry/contrib/sdk/autoconfigure/DeclarativeConfigPropertiesBridge.java

@@ -0,0 +1,188 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.sdk.autoconfigure;
+
+import static io.opentelemetry.api.incubator.config.DeclarativeConfigProperties.empty;
+
+import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BiFunction;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ConfigProperties} which resolves properties based on {@link
+ * DeclarativeConfigProperties}.
+ *
+ * <p>Only properties starting with "otel.instrumentation." are resolved. Others return null (or
+ * default value if provided).
+ *
+ * <p>To resolve:
+ *
+ * <ul>
+ *   <li>"otel.instrumentation" refers to the ".instrumentation.java" node
+ *   <li>The portion of the property after "otel.instrumentation." is split into segments based on
+ *       ".".
+ *   <li>For each N-1 segment, we walk down the tree to find the relevant leaf {@link
+ *       DeclarativeConfigProperties}.
+ *   <li>We extract the property from the resolved {@link DeclarativeConfigProperties} using the
+ *       last segment as the property key.
+ * </ul>
+ *
+ * <p>For example, given the following YAML, asking for {@code
+ * ConfigProperties#getString("otel.instrumentation.common.string_key")} yields "value":
+ *
+ * <pre>
+ *   instrumentation:
+ *     java:
+ *       common:
+ *         string_key: value
+ * </pre>
+ */
+final class DeclarativeConfigPropertiesBridge implements ConfigProperties {
+
+  private static final String OTEL_INSTRUMENTATION_PREFIX = "otel.instrumentation.";
+
+  private final DeclarativeConfigProperties baseNode;
+
+  // lookup order matters - we choose the first match
+  private final Map<String, String> mappings;
+  private final Map<String, Object> overrideValues;
+
+  DeclarativeConfigPropertiesBridge(
+      DeclarativeConfigProperties baseNode,
+      Map<String, String> mappings,
+      Map<String, Object> overrideValues) {
+    this.baseNode = Objects.requireNonNull(baseNode);
+    this.mappings = mappings;
+    this.overrideValues = overrideValues;
+  }
+
+  @Nullable
+  @Override
+  public String getString(String propertyName) {
+    return getPropertyValue(propertyName, String.class, DeclarativeConfigProperties::getString);
+  }
+
+  @Nullable
+  @Override
+  public Boolean getBoolean(String propertyName) {
+    return getPropertyValue(propertyName, Boolean.class, DeclarativeConfigProperties::getBoolean);
+  }
+
+  @Nullable
+  @Override
+  public Integer getInt(String propertyName) {
+    return getPropertyValue(propertyName, Integer.class, DeclarativeConfigProperties::getInt);
+  }
+
+  @Nullable
+  @Override
+  public Long getLong(String propertyName) {
+    return getPropertyValue(propertyName, Long.class, DeclarativeConfigProperties::getLong);
+  }
+
+  @Nullable
+  @Override
+  public Double getDouble(String propertyName) {
+    return getPropertyValue(propertyName, Double.class, DeclarativeConfigProperties::getDouble);
+  }
+
+  @Nullable
+  @Override
+  public Duration getDuration(String propertyName) {
+    Long millis = getPropertyValue(propertyName, Long.class, DeclarativeConfigProperties::getLong);
+    if (millis == null) {
+      return null;
+    }
+    return Duration.ofMillis(millis);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public List<String> getList(String propertyName) {
+    List<String> propertyValue =
+        getPropertyValue(
+            propertyName,
+            List.class,
+            (properties, lastPart) -> properties.getScalarList(lastPart, String.class));
+    return propertyValue == null ? Collections.emptyList() : propertyValue;
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public Map<String, String> getMap(String propertyName) {
+    DeclarativeConfigProperties propertyValue =
+        getPropertyValue(
+            propertyName,
+            DeclarativeConfigProperties.class,
+            DeclarativeConfigProperties::getStructured);
+    if (propertyValue == null) {
+      return Collections.emptyMap();
+    }
+    Map<String, String> result = new HashMap<>();
+    propertyValue
+        .getPropertyKeys()
+        .forEach(
+            key -> {
+              String value = propertyValue.getString(key);
+              if (value == null) {
+                return;
+              }
+              result.put(key, value);
+            });
+    return Collections.unmodifiableMap(result);
+  }
+
+  @Nullable
+  private <T> T getPropertyValue(
+      String property,
+      Class<T> clazz,
+      BiFunction<DeclarativeConfigProperties, String, T> extractor) {
+    T override = clazz.cast(overrideValues.get(property));
+    if (override != null) {
+      return override;
+    }
+
+    String[] segments = getSegments(translateProperty(property));
+    if (segments.length == 0) {
+      return null;
+    }
+
+    // Extract the value by walking to the N-1 entry
+    DeclarativeConfigProperties target = baseNode;
+    if (segments.length > 1) {
+      for (int i = 0; i < segments.length - 1; i++) {
+        target = target.getStructured(segments[i], empty());
+      }
+    }
+    String lastPart = segments[segments.length - 1];
+
+    return extractor.apply(target, lastPart);
+  }
+
+  static String[] getSegments(String property) {
+    if (property.startsWith(OTEL_INSTRUMENTATION_PREFIX)) {
+      property = property.substring(OTEL_INSTRUMENTATION_PREFIX.length());
+    }
+    // Split the remainder of the property on "."
+    return property.replace('-', '_').split("\\.");
+  }
+
+  private String translateProperty(String property) {
+    for (Map.Entry<String, String> entry : mappings.entrySet()) {
+      if (property.startsWith(entry.getKey())) {
+        return entry.getValue() + property.substring(entry.getKey().length());
+      }
+    }
+    return property;
+  }
+}

declarative-config-bridge/src/main/java/io/opentelemetry/contrib/sdk/autoconfigure/DeclarativeConfigPropertiesBridgeBuilder.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.sdk.autoconfigure;
+
+import static io.opentelemetry.api.incubator.config.DeclarativeConfigProperties.empty;
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.opentelemetry.api.incubator.config.ConfigProvider;
+import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
+import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
+import io.opentelemetry.sdk.autoconfigure.internal.AutoConfigureUtil;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * A builder for {@link DeclarativeConfigPropertiesBridge} that allows adding translations and fixed
+ * values for properties.
+ */
+public class DeclarativeConfigPropertiesBridgeBuilder {
+  /**
+   * order is important here, so we use LinkedHashMap - see {@link #addMapping(String, String)} for
+   * more details
+   */
+  private final Map<String, String> mappings = new LinkedHashMap<>();
+
+  private final Map<String, Object> overrideValues = new HashMap<>();
+
+  public DeclarativeConfigPropertiesBridgeBuilder() {}
+
+  /**
+   * Adds a mapping from a property prefix to a YAML path.
+   *
+   * <p>For example, if the property prefix is "otel.javaagent" and the YAML path is "agent", then
+   * any property starting with "otel.javaagent." will be resolved against the "agent" node in the
+   * instrumentation/java section of the YAML configuration.
+   *
+   * @param propertyPrefix the prefix of the property to translate
+   * @param yamlPath the YAML path to resolve the property against
+   */
+  @CanIgnoreReturnValue
+  public DeclarativeConfigPropertiesBridgeBuilder addMapping(
+      String propertyPrefix, String yamlPath) {
+    mappings.put(propertyPrefix, yamlPath);
+    return this;
+  }
+
+  /**
+   * Adds a fixed override value for a property.
+   *
+   * @param propertyName the name of the property to override
+   * @param value the value to return when the property is requested
+   */
+  @CanIgnoreReturnValue
+  public DeclarativeConfigPropertiesBridgeBuilder addOverride(String propertyName, Object value) {
+    overrideValues.put(propertyName, value);
+    return this;
+  }
+
+  /** Build {@link ConfigProperties} from the {@code autoConfiguredOpenTelemetrySdk}. */
+  public ConfigProperties build(AutoConfiguredOpenTelemetrySdk autoConfiguredOpenTelemetrySdk) {
+    ConfigProperties sdkConfigProperties =
+        AutoConfigureUtil.getConfig(autoConfiguredOpenTelemetrySdk);
+    if (sdkConfigProperties != null) {
+      return sdkConfigProperties;
+    }
+    ConfigProvider configProvider =
+        AutoConfigureUtil.getConfigProvider(autoConfiguredOpenTelemetrySdk);
+    if (configProvider != null) {
+      return buildFromInstrumentationConfig(configProvider.getInstrumentationConfig());
+    }
+    // Should never happen
+    throw new IllegalStateException(
+        "AutoConfiguredOpenTelemetrySdk does not have ConfigProperties or DeclarativeConfigProperties. This is likely a programming error in opentelemetry-java");
+  }
+
+  /**
+   * Build {@link ConfigProperties} from the {@link DeclarativeConfigProperties} provided by the
+   * instrumentation configuration.
+   *
+   * <p>If the provided {@code instrumentationConfig} is null, an empty {@link
+   * DeclarativeConfigProperties} will be used.
+   *
+   * @param instrumentationConfig the instrumentation configuration to build from
+   * @return a new instance of {@link ConfigProperties}
+   */
+  public ConfigProperties buildFromInstrumentationConfig(
+      @Nullable DeclarativeConfigProperties instrumentationConfig) {
+    // leave the name "build" for a future method that builds from a DeclarativeConfigProperties
+    // instance that doesn't come from the top-level instrumentation config
+    if (instrumentationConfig == null) {
+      instrumentationConfig = DeclarativeConfigProperties.empty();
+    }
+    return new DeclarativeConfigPropertiesBridge(
+        instrumentationConfig.getStructured("java", empty()), mappings, overrideValues);
+  }
+}

declarative-config-bridge/src/test/java/io/opentelemetry/contrib/sdk/autoconfigure/ConfigPropertiesUtilTest.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.sdk.autoconfigure;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class ConfigPropertiesUtilTest {
+  @Test
+  void propertyYamlPath() {
+    assertThat(ConfigPropertiesUtil.propertyYamlPath("google.otel.auth.target.signals"))
+        .isEqualTo(
+            "'instrumentation/development' / 'java' / 'google' / 'otel' / 'auth' / 'target' / 'signals'");
+  }
+}