Config Provider Bridge

CHANGELOG.md

@@ -6,6 +6,12 @@
 
 ### ⚠️ Breaking Changes
 
+- Rename `otel.experimental.javascript-snippet` to
+  `otel.instrumentation.servlet.experimental.javascript-snippet` to follow naming conventions
+  ([#15339](https://github.com/open-telemetry/opentelemetry-java-instrumentation/pull/15339))
+
+### ⚠️ Breaking Changes
+
 - ActiveMQ Classic JMX metrics: rename attributes and metrics to align
   with semantic conventions (see PR description for specifics)
   ([#14996](https://github.com/open-telemetry/opentelemetry-java-instrumentation/pull/14996))

declarative-config-bridge/build.gradle.kts

@@ -8,6 +8,7 @@ group = "io.opentelemetry.instrumentation"
 
 dependencies {
   compileOnly("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+  implementation(project(":instrumentation-api"))
   implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi")
   implementation("io.opentelemetry:opentelemetry-api-incubator")
 

declarative-config-bridge/src/main/java/io/opentelemetry/instrumentation/config/bridge/ConfigPropertiesDeclarativeConfigProperties.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.config.bridge;
+
+import io.opentelemetry.api.incubator.config.ConfigProvider;
+import io.opentelemetry.instrumentation.api.internal.BridgedConfigProvider;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+
+public final class ConfigPropertiesDeclarativeConfigProperties {
+
+  private ConfigPropertiesDeclarativeConfigProperties() {}
+
+  public static ConfigProvider create(ConfigProperties configProperties) {
+    return new BridgedConfigProvider(configProperties::getString);
+  }
+}

declarative-config-bridge/src/test/java/io/opentelemetry/instrumentation/config/bridge/ConfigPropertiesDeclarativeConfigPropertiesTest.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.config.bridge;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.opentelemetry.api.incubator.config.ConfigProvider;
+import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+import org.junit.jupiter.api.Test;
+
+class ConfigPropertiesDeclarativeConfigPropertiesTest {
+
+  @Test
+  void shouldBridgeConfigProperties() {
+    ConfigProperties configProperties = mock(ConfigProperties.class);
+    when(configProperties.getString("otel.instrumentation.foo.bar")).thenReturn("baz");
+    when(configProperties.getString("otel.instrumentation.experimental.foo.bar")).thenReturn("qux");
+
+    ConfigProvider configProvider =
+        ConfigPropertiesDeclarativeConfigProperties.create(configProperties);
+    DeclarativeConfigProperties properties = configProvider.getInstrumentationConfig();
+
+    assertThat(properties.getStructured("java").getStructured("foo").getString("bar"))
+        .isEqualTo("baz");
+    assertThat(properties.getStructured("java").getStructured("foo/development").getString("bar"))
+        .isEqualTo("qux");
+  }
+}

docs/advanced-configuration-options.md

@@ -45,9 +45,9 @@ This feature is designed for integrating client-side monitoring.
 We plan to integrate OpenTelemetry's own client-side monitoring solution by default once it's available
 (see the [browser instrumentation proposal](https://github.com/open-telemetry/community/blob/main/projects/browser-phase-1.md)).
 
-| System property                      | Environment variable                 | Purpose                                                                                                                                                                                                                                                                                      |
-|--------------------------------------|--------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| otel.experimental.javascript-snippet | OTEL_EXPERIMENTAL_JAVASCRIPT_SNIPPET | Experimental setting to inject a JavaScript snippet into HTML responses after the opening `<head>` tag. The value should be a complete JavaScript snippet including `<script>` tags if needed, e.g. `-Dotel.experimental.javascript-snippet="<script>console.log('Hello world!');</script>"` |
+| System property                                                | Environment variable                                           | Purpose                                                                                                                                                                                                                                                                                                              |
+|----------------------------------------------------------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `otel.instrumentation.servlet.experimental.javascript-snippet` | `OTEL_INSTRUMENTATION_SERVLET_EXPERIMENTAL_JAVASCRIPT_SNIPPET` | Experimental setting to inject a JavaScript snippet into HTML responses after the opening `<head>` tag. The value should be a complete JavaScript snippet including `<script>` tags if needed, e.g. `-Dotel.instrumentation.servlet.experimental.javascript-snippet="<script>console.log('Hello world!');</script>"` |
 
 **Important notes:**
 

docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt

@@ -1,2 +1,5 @@
 Comparing source compatibility of opentelemetry-instrumentation-api-2.24.0-SNAPSHOT.jar against opentelemetry-instrumentation-api-2.23.0.jar
-No changes.
+***  MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+	GENERIC TEMPLATES: === REQUEST:java.lang.Object, === RESPONSE:java.lang.Object
+	+++  NEW METHOD: PUBLIC(+) STATIC(+) boolean isDeclarativeConfig(io.opentelemetry.api.OpenTelemetry)

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/config/internal/CommonConfig.java

@@ -175,9 +175,8 @@ private static <T> T getFromConfigProviderOrFallback(
       ValueProvider<T> getFromConfigProvider,
       T defaultValue,
       Supplier<T> fallback) {
-    ConfigProvider configProvider = config.getConfigProvider();
-    if (configProvider != null) {
-      T value = getFromConfigProvider.get(configProvider);
+    if (config.isDeclarative()) {
+      T value = getFromConfigProvider.get(config.getConfigProvider());
       return value != null ? value : defaultValue;
     }
     // fallback doesn't return null, so we can safely call it

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/config/internal/InstrumentationConfig.java

@@ -5,10 +5,13 @@
 
 package io.opentelemetry.instrumentation.api.incubator.config.internal;
 
+import static io.opentelemetry.api.incubator.config.DeclarativeConfigProperties.empty;
 import static java.util.Collections.emptyList;
 
 import io.opentelemetry.api.incubator.config.ConfigProvider;
 import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
+import io.opentelemetry.api.incubator.config.InstrumentationConfigUtil;
+import io.opentelemetry.instrumentation.api.internal.BridgedConfigProvider;
 import java.time.Duration;
 import java.util.List;
 import java.util.Map;
@@ -111,29 +114,34 @@ default List<String> getList(String name) {
   Map<String, String> getMap(String name, Map<String, String> defaultValue);
 
   /** Returns {@code true} if declarative configuration is used in this configuration. */
-  boolean isDeclarative();
+  default boolean isDeclarative() {
+    return !(getConfigProvider() instanceof BridgedConfigProvider);
+  }
 
   /**
    * Returns a {@link DeclarativeConfigProperties} for the given node name, which is usually an
-   * instrumentation name
-   *
-   * <p>Call {@link #isDeclarative()} first to check if declarative configuration is used.
+   * instrumentation name. If declarative configuration is not used, a bridge to ConfigProperties is
    *
    * <p>Declarative configuration is used to configure instrumentation properties in a declarative
    * way, such as through YAML or JSON files.
    *
    * @param node the name of the instrumentation (e.g. "log4j"), the vendor name (e.g. "google"), or
    *     "common" for common Java settings that don't apply to other languages.
    * @return the declarative configuration properties for the given node name
-   * @throws IllegalStateException if {@link #isDeclarative()} returns {@code false}
    */
-  DeclarativeConfigProperties getDeclarativeConfig(String node);
+  default DeclarativeConfigProperties getDeclarativeConfig(String node) {
+    DeclarativeConfigProperties config =
+        InstrumentationConfigUtil.javaInstrumentationConfig(getConfigProvider(), node);
+    if (config == null) {
+      // there is no declarative config for this node
+      return empty();
+    }
+    return config;
+  }
 
   /**
-   * Returns the {@link ConfigProvider} if declarative configuration is used.
-   *
-   * @return the {@link ConfigProvider} or {@code null} if no provider is available
+   * Returns the {@link ConfigProvider}, which is a bridge to ConfigProperties if declarative
+   * configuration is not used
    */
-  @Nullable
   ConfigProvider getConfigProvider();
 }

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

@@ -9,7 +9,10 @@
 import static java.util.logging.Level.WARNING;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.opentelemetry.api.GlobalOpenTelemetry;
 import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.incubator.ExtendedOpenTelemetry;
+import io.opentelemetry.api.incubator.config.InstrumentationConfigUtil;
 import io.opentelemetry.api.metrics.Meter;
 import io.opentelemetry.api.metrics.MeterBuilder;
 import io.opentelemetry.api.trace.SpanKind;
@@ -20,6 +23,7 @@
 import io.opentelemetry.context.propagation.TextMapGetter;
 import io.opentelemetry.context.propagation.TextMapSetter;
 import io.opentelemetry.instrumentation.api.internal.ConfigPropertiesUtil;
+import io.opentelemetry.instrumentation.api.internal.ConfigProviderUtil;
 import io.opentelemetry.instrumentation.api.internal.EmbeddedInstrumentationProperties;
 import io.opentelemetry.instrumentation.api.internal.Experimental;
 import io.opentelemetry.instrumentation.api.internal.InstrumenterBuilderAccess;
@@ -48,11 +52,7 @@
 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"));
+  private static final boolean supportsDeclarativeConfig = supportsDeclarativeConfig();
 
   final OpenTelemetry openTelemetry;
   final String instrumentationName;
@@ -76,6 +76,20 @@ public final class InstrumenterBuilder<REQUEST, RESPONSE> {
   boolean propagateOperationListenersToOnEnd = false;
   boolean enabled = true;
 
+  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;
+    }
+  }
+
   static {
     Experimental.internalAddOperationListenerAttributesExtractor(
         (builder, operationListenerAttributesExtractor) ->
@@ -373,8 +387,19 @@ 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 =
+        isDeclarativeConfig(openTelemetry)
+            ? InstrumentationConfigUtil.getOrNull(
+                ConfigProviderUtil.getConfigProvider(GlobalOpenTelemetry.get()),
+                config -> config.getString("span_suppression_strategy/development"),
+                "java",
+                "common")
+            : ConfigPropertiesUtil.getString(
+                "otel.instrumentation.experimental.span-suppression-strategy");
     return new SpanSuppressors.ByContextKey(
-        spanSuppressionStrategy.create(getSpanKeysFromAttributesExtractors()));
+        SpanSuppressionStrategy.fromConfig(value).create(getSpanKeysFromAttributesExtractors()));
   }
 
   private Set<SpanKey> getSpanKeysFromAttributesExtractors() {
@@ -454,6 +479,11 @@ public void setSpanStatusExtractorCustomizer(
     }
   }
 
+  /** Returns true if the given OpenTelemetry instance supports Declarative Config. */
+  public static boolean isDeclarativeConfig(OpenTelemetry openTelemetry) {
+    return supportsDeclarativeConfig && openTelemetry instanceof ExtendedOpenTelemetry;
+  }
+
   private interface InstrumenterConstructor<RQ, RS> {
     Instrumenter<RQ, RS> create(InstrumenterBuilder<RQ, RS> builder);
 

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.api.internal;
+
+import io.opentelemetry.api.incubator.config.ConfigProvider;
+import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
+import io.opentelemetry.common.ComponentLoader;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+public final class BridgedConfigProvider implements ConfigProvider {
+
+  private final Function<String, String> propertySource;
+
+  public BridgedConfigProvider(Function<String, String> propertySource) {
+    this.propertySource = propertySource;
+  }
+
+  @Nullable
+  @Override
+  public DeclarativeConfigProperties getInstrumentationConfig() {
+    return createEmptyDeclarativeConfigProperties(
+        java -> {
+          if (java.equals("java")) {
+            return createEmptyDeclarativeConfigProperties(
+                name -> new BridgedDeclarativeConfigProperties(name, null, propertySource));
+          }
+          throw new UnsupportedOperationException();
+        });
+  }
+
+  private static DeclarativeConfigProperties createEmptyDeclarativeConfigProperties(
+      Function<String, DeclarativeConfigProperties> getStructuredFunc) {
+    return EmptyDeclarativeConfigPropertiesFactory.create(getStructuredFunc);
+  }
+
+  private static final class EmptyDeclarativeConfigPropertiesFactory {
+    private EmptyDeclarativeConfigPropertiesFactory() {}
+
+    static DeclarativeConfigProperties create(
+        Function<String, DeclarativeConfigProperties> getStructuredFunc) {
+      return new InnerDeclarativeConfigProperties(getStructuredFunc);
+    }
+  }
+
+  private static final class InnerDeclarativeConfigProperties
+      implements DeclarativeConfigProperties {
+    private final Function<String, DeclarativeConfigProperties> getStructuredFunc;
+
+    InnerDeclarativeConfigProperties(
+        Function<String, DeclarativeConfigProperties> getStructuredFunc) {
+      this.getStructuredFunc = getStructuredFunc;
+    }
+
+    @Nullable
+    @Override
+    public String getString(String name) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public Boolean getBoolean(String name) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public Integer getInt(String name) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public Long getLong(String name) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public Double getDouble(String name) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public <T> List<T> getScalarList(String name, Class<T> scalarType) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public DeclarativeConfigProperties getStructured(String name) {
+      return getStructuredFunc.apply(name);
+    }
+
+    @Nullable
+    @Override
+    public List<DeclarativeConfigProperties> getStructuredList(String name) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Set<String> getPropertyKeys() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ComponentLoader getComponentLoader() {
+      throw new UnsupportedOperationException();
+    }
+  }
+}