Spring starter declarative config (#14062)

Co-authored-by: otelbot <[email protected]>
Co-authored-by: Jay DeLuca <[email protected]>

Author: 3 people

docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt

@@ -1,2 +1,5 @@
 Comparing source compatibility of opentelemetry-spring-boot-autoconfigure-2.22.0-SNAPSHOT.jar against opentelemetry-spring-boot-autoconfigure-2.21.0.jar
-No changes.
+===  UNCHANGED CLASS: PUBLIC io.opentelemetry.instrumentation.spring.autoconfigure.OpenTelemetryAutoConfiguration  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+	---  REMOVED ANNOTATION: org.springframework.boot.context.properties.EnableConfigurationProperties
+		---  REMOVED ELEMENT: value=io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.OtlpExporterProperties,io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.OtelResourceProperties,io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.OtelSpringProperties (-)

instrumentation/spring/spring-boot-autoconfigure/build.gradle.kts

@@ -65,7 +65,9 @@ dependencies {
   library("org.springframework.boot:spring-boot-starter-data-jdbc:$springBootVersion")
 
   implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+  implementation("io.opentelemetry:opentelemetry-sdk-extension-incubator")
   implementation(project(":sdk-autoconfigure-support"))
+  implementation(project(":declarative-config-bridge"))
   compileOnly("io.opentelemetry:opentelemetry-extension-trace-propagators")
   compileOnly("io.opentelemetry.contrib:opentelemetry-aws-xray-propagator")
   compileOnly("io.opentelemetry:opentelemetry-exporter-logging")
@@ -80,6 +82,7 @@ dependencies {
   testLibrary("org.springframework.boot:spring-boot-starter-test:$springBootVersion") {
     exclude("org.junit.vintage", "junit-vintage-engine")
   }
+
   testImplementation("javax.servlet:javax.servlet-api:3.1.0")
   testImplementation("jakarta.servlet:jakarta.servlet-api:5.0.0")
   testRuntimeOnly("com.h2database:h2:1.4.197")
@@ -171,6 +174,17 @@ testing {
         }
       }
     }
+
+    val testDeclarativeConfig by registering(JvmTestSuite::class) {
+      dependencies {
+        implementation(project())
+        implementation("io.opentelemetry:opentelemetry-sdk")
+        implementation("org.springframework.boot:spring-boot-starter-test:$springBootVersion") {
+          exclude("org.junit.vintage", "junit-vintage-engine")
+        }
+        implementation("org.springframework.boot:spring-boot-starter-web:$springBootVersion")
+      }
+    }
   }
 }
 

instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/EmbeddedConfigFile.java

@@ -0,0 +1,152 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure;
+
+import com.fasterxml.jackson.annotation.JsonSetter;
+import com.fasterxml.jackson.annotation.Nulls;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.OpenTelemetryConfigurationModel;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.EnumerablePropertySource;
+import org.springframework.core.env.MutablePropertySources;
+import org.springframework.core.env.PropertySource;
+
+class EmbeddedConfigFile {
+
+  private static final Pattern ARRAY_PATTERN = Pattern.compile("(.+)\\[(\\d+)]$");
+
+  // the entire configuration is copied from
+  // https://github.com/open-telemetry/opentelemetry-java/blob/main/sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/DeclarativeConfiguration.java#L66-L79
+  // which is not public
+  private static final ObjectMapper MAPPER;
+
+  static {
+    MAPPER =
+        new ObjectMapper()
+            // Create empty object instances for keys which are present but have null values
+            .setDefaultSetterInfo(JsonSetter.Value.forValueNulls(Nulls.AS_EMPTY));
+    // Boxed primitives which are present but have null values should be set to null, rather than
+    // empty instances
+    MAPPER.configOverride(String.class).setSetterInfo(JsonSetter.Value.forValueNulls(Nulls.SET));
+    MAPPER.configOverride(Integer.class).setSetterInfo(JsonSetter.Value.forValueNulls(Nulls.SET));
+    MAPPER.configOverride(Double.class).setSetterInfo(JsonSetter.Value.forValueNulls(Nulls.SET));
+    MAPPER.configOverride(Boolean.class).setSetterInfo(JsonSetter.Value.forValueNulls(Nulls.SET));
+  }
+
+  private EmbeddedConfigFile() {}
+
+  static OpenTelemetryConfigurationModel extractModel(ConfigurableEnvironment environment) {
+    Map<String, String> props = extractSpringProperties(environment);
+    return convertToOpenTelemetryConfigurationModel(props);
+  }
+
+  private static Map<String, String> extractSpringProperties(ConfigurableEnvironment environment) {
+    MutablePropertySources propertySources = environment.getPropertySources();
+
+    Map<String, String> props = new HashMap<>();
+    for (PropertySource<?> propertySource : propertySources) {
+      if (propertySource instanceof EnumerablePropertySource<?>) {
+        for (String propertyName :
+            ((EnumerablePropertySource<?>) propertySource).getPropertyNames()) {
+          if (propertyName.startsWith("otel.")) {
+            String property = environment.getProperty(propertyName);
+            if (Objects.equals(property, "")) {
+              property = null; // spring returns empty string for yaml null
+            }
+            props.put(propertyName.substring("otel.".length()), property);
+          }
+        }
+      }
+    }
+
+    if (props.isEmpty()) {
+      throw new IllegalStateException(
+          "No properties found with prefix 'otel.' - this should not happen, because we checked "
+              + "'environment.getProperty(\"otel.file_format\", String.class) != null' earlier");
+    }
+    return props;
+  }
+
+  static OpenTelemetryConfigurationModel convertToOpenTelemetryConfigurationModel(
+      Map<String, String> flatProps) {
+    Map<String, Object> nested = convertFlatPropsToNested(flatProps);
+
+    return getObjectMapper().convertValue(nested, OpenTelemetryConfigurationModel.class);
+  }
+
+  static ObjectMapper getObjectMapper() {
+    return MAPPER;
+  }
+
+  /**
+   * Convert flat property map to nested structure. e.g. "otel.instrumentation.java.list[0]" = "one"
+   * and "otel.instrumentation.java.list[1]" = "two" becomes: {otel: {instrumentation: {java: {list:
+   * ["one", "two"]}}}}
+   */
+  @SuppressWarnings("unchecked")
+  static Map<String, Object> convertFlatPropsToNested(Map<String, String> flatProps) {
+    Map<String, Object> result = new HashMap<>();
+
+    for (Map.Entry<String, String> entry : flatProps.entrySet()) {
+      String key = entry.getKey();
+      String value = entry.getValue();
+
+      // Split the key by dots
+      String[] parts = key.split("\\.");
+      Map<String, Object> current = result;
+
+      for (int i = 0; i < parts.length; i++) {
+        String part = parts[i];
+        boolean isLast = (i == parts.length - 1);
+
+        // Check if this part contains an array index like "list[0]"
+        Matcher matcher = ARRAY_PATTERN.matcher(part);
+        if (matcher.matches()) {
+          String arrayName = matcher.group(1);
+          int index = Integer.parseInt(matcher.group(2));
+
+          ArrayList<Object> list =
+              (ArrayList<Object>) current.computeIfAbsent(arrayName, k -> new ArrayList<>());
+
+          // Ensure the list is large enough
+          list.ensureCapacity(index + 1);
+          while (list.size() <= index) {
+            list.add(null);
+          }
+
+          if (isLast) {
+            list.set(index, value);
+          } else {
+            // Need to create a nested map at this index
+            current = (Map<String, Object>) list.get(index);
+            if (current == null) {
+              current = new HashMap<>();
+              list.set(index, current);
+            }
+          }
+        } else {
+          // Regular property (not an array)
+          if (isLast) {
+            current.put(part, value);
+          } else {
+            // Need to create a nested map
+            if (!current.containsKey(part)) {
+              current.put(part, new HashMap<String, Object>());
+            }
+            current = (Map<String, Object>) current.get(part);
+          }
+        }
+      }
+    }
+    return result;
+  }
+}