clean up ConfigPropertiesUtil

instrumentation-api/build.gradle.kts

@@ -22,6 +22,7 @@ dependencies {
   testImplementation("io.opentelemetry.javaagent:opentelemetry-testing-common")
   testImplementation("io.opentelemetry:opentelemetry-sdk-testing")
   testImplementation("io.opentelemetry:opentelemetry-exporter-common")
+  testImplementation("io.opentelemetry:opentelemetry-sdk-extension-incubator")
   testImplementation("org.junit-pioneer:junit-pioneer")
 
   jmhImplementation(project(":instrumentation-api-incubator"))

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/InstrumenterBuilder.java

@@ -49,11 +49,6 @@ public final class InstrumenterBuilder<REQUEST, RESPONSE> {
 
   private static final Logger logger = Logger.getLogger(InstrumenterBuilder.class.getName());
 
-  private static final SpanSuppressionStrategy spanSuppressionStrategy =
-      SpanSuppressionStrategy.fromConfig(
-          ConfigPropertiesUtil.getString(
-              "otel.instrumentation.experimental.span-suppression-strategy"));
-
   final OpenTelemetry openTelemetry;
   final String instrumentationName;
   SpanNameExtractor<? super REQUEST> spanNameExtractor;
@@ -373,8 +368,17 @@ private String getSchemaUrl() {
   }
 
   SpanSuppressor buildSpanSuppressor() {
+    // otel.instrumentation.experimental.* doesn't fit the usual pattern of configuration properties
+    // for instrumentations, so we need to handle both declarative and non-declarative configs here
+    String value =
+        ConfigPropertiesUtil.isDeclarativeConfig(openTelemetry)
+            ? ConfigPropertiesUtil.getString(
+                    openTelemetry, "common", "experimental", "span_suppression_strategy")
+                .orElse(null)
+            : ConfigPropertiesUtil.getString(
+                "otel.instrumentation.experimental.span-suppression-strategy");
     return new SpanSuppressors.ByContextKey(
-        spanSuppressionStrategy.create(getSpanKeysFromAttributesExtractors()));
+        SpanSuppressionStrategy.fromConfig(value).create(getSpanKeysFromAttributesExtractors()));
   }
 
   private Set<SpanKey> getSpanKeysFromAttributesExtractors() {

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/ConfigPropertiesUtil.java

@@ -5,9 +5,17 @@
 
 package io.opentelemetry.instrumentation.api.internal;
 
+import static io.opentelemetry.api.incubator.config.DeclarativeConfigProperties.empty;
+import static java.util.Collections.emptyList;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.incubator.ExtendedOpenTelemetry;
+import io.opentelemetry.api.incubator.config.ConfigProvider;
+import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 
@@ -17,43 +25,111 @@
  */
 public final class ConfigPropertiesUtil {
 
-  public static boolean getBoolean(String propertyName, boolean defaultValue) {
-    String strValue = getString(propertyName);
-    return strValue == null ? defaultValue : Boolean.parseBoolean(strValue);
+  private static final boolean supportsDeclarativeConfig = supportsDeclarativeConfig();
+
+  private static boolean supportsDeclarativeConfig() {
+    try {
+      Class.forName("io.opentelemetry.api.incubator.ExtendedOpenTelemetry");
+      return true;
+    } catch (ClassNotFoundException e) {
+      // The incubator module is not available.
+      // This only happens in OpenTelemetry API instrumentation tests, where an older version of
+      // OpenTelemetry API is used that does not have ExtendedOpenTelemetry.
+      // Having the incubator module without ExtendedOpenTelemetry class should still return false
+      // for those tests to avoid a ClassNotFoundException.
+      return false;
+    }
   }
 
-  public static int getInt(String propertyName, int defaultValue) {
-    String strValue = getString(propertyName);
-    if (strValue == null) {
-      return defaultValue;
+  /**
+   * Returns the boolean value of the given property name from system properties and environment
+   * variables.
+   *
+   * <p>It's recommended to use {@link #getBoolean(OpenTelemetry, String...)} instead to support
+   * Declarative Config.
+   */
+  public static Optional<Boolean> getBoolean(String propertyName) {
+    Optional<String> string = getString(propertyName);
+    // lambdas must not be used here in early initialization phase on early JDK8 versions
+    if (string.isPresent()) {
+      return Optional.of(Boolean.parseBoolean(string.get()));
     }
-    try {
-      return Integer.parseInt(strValue);
-    } catch (NumberFormatException ignored) {
-      return defaultValue;
+    return Optional.empty();
+  }
+
+  /**
+   * Returns the boolean value of the given property name from Declarative Config if available,
+   * otherwise falls back to system properties and environment variables.
+   */
+  public static Optional<Boolean> getBoolean(OpenTelemetry openTelemetry, String... propertyName) {
+    DeclarativeConfigProperties node = getDeclarativeConfigNode(openTelemetry, propertyName);
+    if (node != null) {
+      return Optional.ofNullable(node.getBoolean(leaf(propertyName)));
     }
+    return getBoolean(toSystemProperty(propertyName));
   }
 
-  @Nullable
-  public static String getString(String propertyName) {
+  /**
+   * Returns the int value of the given property name from system properties and environment
+   * variables.
+   */
+  public static Optional<Integer> getInt(String propertyName) {
+    Optional<String> string = getString(propertyName);
+    // lambdas must not be used here in early initialization phase on early JDK8 versions
+    if (string.isPresent()) {
+      try {
+        return Optional.of(Integer.parseInt(string.get()));
+      } catch (NumberFormatException ignored) {
+        // ignored
+      }
+    }
+    return Optional.empty();
+  }
+
+  /**
+   * Returns the string value of the given property name from system properties and environment
+   * variables.
+   *
+   * <p>It's recommended to use {@link #getString(OpenTelemetry, String...)} instead to support
+   * Declarative Config.
+   */
+  public static Optional<String> getString(String propertyName) {
     String value = System.getProperty(propertyName);
     if (value != null) {
-      return value;
+      return Optional.of(value);
     }
-    return System.getenv(toEnvVarName(propertyName));
+    return Optional.ofNullable(System.getenv(toEnvVarName(propertyName)));
   }
 
-  public static String getString(String propertyName, String defaultValue) {
-    String strValue = getString(propertyName);
-    return strValue == null ? defaultValue : strValue;
+  /**
+   * Returns the string value of the given property name from Declarative Config if available,
+   * otherwise falls back to system properties and environment variables.
+   */
+  public static Optional<String> getString(OpenTelemetry openTelemetry, String... propertyName) {
+    DeclarativeConfigProperties node = getDeclarativeConfigNode(openTelemetry, propertyName);
+    if (node != null) {
+      return Optional.ofNullable(node.getString(leaf(propertyName)));
+    }
+    return getString(toSystemProperty(propertyName));
   }
 
-  public static List<String> getList(String propertyName, List<String> defaultValue) {
-    String value = getString(propertyName);
-    if (value == null) {
-      return defaultValue;
+  /**
+   * Returns the list of strings value of the given property name from Declarative Config if
+   * available, otherwise falls back to system properties and environment variables.
+   */
+  public static List<String> getList(OpenTelemetry openTelemetry, String... propertyName) {
+    DeclarativeConfigProperties node = getDeclarativeConfigNode(openTelemetry, propertyName);
+    if (node != null) {
+      return node.getScalarList(leaf(propertyName), String.class, emptyList());
     }
-    return filterBlanksAndNulls(value.split(","));
+    return getString(toSystemProperty(propertyName))
+        .map(value -> filterBlanksAndNulls(value.split(",")))
+        .orElse(emptyList());
+  }
+
+  /** Returns true if the given OpenTelemetry instance supports Declarative Config. */
+  public static boolean isDeclarativeConfig(OpenTelemetry openTelemetry) {
+    return supportsDeclarativeConfig && openTelemetry instanceof ExtendedOpenTelemetry;
   }
 
   private static List<String> filterBlanksAndNulls(String[] values) {
@@ -67,5 +143,33 @@ private static String toEnvVarName(String propertyName) {
     return propertyName.toUpperCase(Locale.ROOT).replace('-', '_').replace('.', '_');
   }
 
+  private static String leaf(String[] propertyName) {
+    return propertyName[propertyName.length - 1];
+  }
+
+  @Nullable
+  private static DeclarativeConfigProperties getDeclarativeConfigNode(
+      OpenTelemetry openTelemetry, String... propertyName) {
+    if (isDeclarativeConfig(openTelemetry)) {
+      ExtendedOpenTelemetry extendedOpenTelemetry = (ExtendedOpenTelemetry) openTelemetry;
+      ConfigProvider configProvider = extendedOpenTelemetry.getConfigProvider();
+      DeclarativeConfigProperties instrumentationConfig = configProvider.getInstrumentationConfig();
+      if (instrumentationConfig == null) {
+        return empty();
+      }
+      DeclarativeConfigProperties node = instrumentationConfig.getStructured("java", empty());
+      // last part is the leaf property
+      for (int i = 0; i < propertyName.length - 1; i++) {
+        node = node.getStructured(propertyName[i], empty());
+      }
+      return node;
+    }
+    return null;
+  }
+
+  public static String toSystemProperty(String[] propertyName) {
+    return "otel.instrumentation." + String.join(".", propertyName).replace('_', '-');
+  }
+
   private ConfigPropertiesUtil() {}
 }

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/ContextPropagationDebug.java

@@ -32,13 +32,16 @@ public final class ContextPropagationDebug {
   private static final boolean FAIL_ON_CONTEXT_LEAK;
 
   static {
-    boolean agentDebugEnabled = ConfigPropertiesUtil.getBoolean("otel.javaagent.debug", false);
+    boolean agentDebugEnabled =
+        ConfigPropertiesUtil.getBoolean("otel.javaagent.debug").orElse(false);
 
     THREAD_PROPAGATION_DEBUGGER =
         ConfigPropertiesUtil.getBoolean(
-            "otel.javaagent.experimental.thread-propagation-debugger.enabled", agentDebugEnabled);
+                "otel.javaagent.experimental.thread-propagation-debugger.enabled")
+            .orElse(agentDebugEnabled);
     FAIL_ON_CONTEXT_LEAK =
-        ConfigPropertiesUtil.getBoolean("otel.javaagent.testing.fail-on-context-leak", false);
+        ConfigPropertiesUtil.getBoolean("otel.javaagent.testing.fail-on-context-leak")
+            .orElse(false);
   }
 
   // context to which debug locations were added

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/SemconvStability.java

@@ -31,7 +31,7 @@ public final class SemconvStability {
     boolean oldCode = true;
     boolean stableCode = false;
 
-    String value = ConfigPropertiesUtil.getString("otel.semconv-stability.opt-in");
+    String value = ConfigPropertiesUtil.getString("otel.semconv-stability.opt-in").orElse(null);
     if (value != null) {
       Set<String> values = new HashSet<>(asList(value.split(",")));
 

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/SupportabilityMetrics.java

@@ -30,7 +30,7 @@ public final class SupportabilityMetrics {
 
   private static final SupportabilityMetrics INSTANCE =
       new SupportabilityMetrics(
-              ConfigPropertiesUtil.getBoolean("otel.javaagent.debug", false), logger::fine)
+              ConfigPropertiesUtil.getBoolean("otel.javaagent.debug").orElse(false), logger::fine)
           .start();
 
   public static SupportabilityMetrics instance() {