inferred spans

Author: zeitlinger

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

@@ -56,11 +56,13 @@ public static ConfigProperties resolveInstrumentationConfig(
   public static ConfigProperties resolveInstrumentationConfig(
       @Nullable DeclarativeConfigProperties instrumentationConfig,
       Map<String, String> translationMap) {
-    if (instrumentationConfig == null) {
-      instrumentationConfig = DeclarativeConfigProperties.empty();
-    }
+    return DeclarativeConfigPropertiesBridge.fromInstrumentationConfig(
+        instrumentationConfig, translationMap);
+  }
 
-    return new DeclarativeConfigPropertiesBridge(instrumentationConfig, translationMap);
+  public static ConfigProperties resolveConfig(
+      @Nullable DeclarativeConfigProperties config, Map<String, String> translationMap) {
+    return DeclarativeConfigPropertiesBridge.create(config, translationMap);
   }
 
   public static String propertyYamlPath(String propertyName) {

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

@@ -50,13 +50,27 @@ final class DeclarativeConfigPropertiesBridge implements ConfigProperties {
 
   private static final String OTEL_INSTRUMENTATION_PREFIX = "otel.instrumentation.";
 
-  // The node at .instrumentation.java
-  private final DeclarativeConfigProperties instrumentationJavaNode;
+  @Nullable private final DeclarativeConfigProperties baseNode;
   private final Map<String, String> translationMap;
 
-  DeclarativeConfigPropertiesBridge(
-      DeclarativeConfigProperties instrumentationNode, Map<String, String> translationMap) {
-    instrumentationJavaNode = instrumentationNode.getStructured("java", empty());
+  static DeclarativeConfigPropertiesBridge fromInstrumentationConfig(
+      @Nullable DeclarativeConfigProperties instrumentationConfig,
+      Map<String, String> translationMap) {
+    if (instrumentationConfig == null) {
+      instrumentationConfig = DeclarativeConfigProperties.empty();
+    }
+    return new DeclarativeConfigPropertiesBridge(
+        instrumentationConfig.getStructured("java", empty()), translationMap);
+  }
+
+  static DeclarativeConfigPropertiesBridge create(
+      @Nullable DeclarativeConfigProperties node, Map<String, String> translationMap) {
+    return new DeclarativeConfigPropertiesBridge(node, translationMap);
+  }
+
+  private DeclarativeConfigPropertiesBridge(
+      @Nullable DeclarativeConfigProperties baseNode, Map<String, String> translationMap) {
+    this.baseNode = baseNode;
     this.translationMap = translationMap;
   }
 
@@ -133,7 +147,7 @@ public Map<String, String> getMap(String propertyName) {
   @Nullable
   private <T> T getPropertyValue(
       String property, BiFunction<DeclarativeConfigProperties, String, T> extractor) {
-    if (instrumentationJavaNode == null) {
+    if (baseNode == null) {
       return null;
     }
 
@@ -143,7 +157,7 @@ private <T> T getPropertyValue(
     }
 
     // Extract the value by walking to the N-1 entry
-    DeclarativeConfigProperties target = instrumentationJavaNode;
+    DeclarativeConfigProperties target = baseNode;
     if (segments.length > 1) {
       for (int i = 0; i < segments.length - 1; i++) {
         target = target.getStructured(segments[i], empty());

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

@@ -65,7 +65,7 @@ void setup() {
             .withAdditionalProperty("instrumentation/development", new InstrumentationModel());
     SdkConfigProvider emptyConfigProvider = SdkConfigProvider.create(emptyModel);
     emptyBridge =
-        new DeclarativeConfigPropertiesBridge(
+        DeclarativeConfigPropertiesBridge.fromInstrumentationConfig(
             Objects.requireNonNull(emptyConfigProvider.getInstrumentationConfig()),
             Collections.emptyMap());
   }
@@ -75,7 +75,7 @@ private static DeclarativeConfigPropertiesBridge createBridge(
     OpenTelemetryConfigurationModel model =
         DeclarativeConfiguration.parse(
             new ByteArrayInputStream(YAML.getBytes(StandardCharsets.UTF_8)));
-    return new DeclarativeConfigPropertiesBridge(
+    return DeclarativeConfigPropertiesBridge.fromInstrumentationConfig(
         Objects.requireNonNull(SdkConfigProvider.create(model).getInstrumentationConfig()),
         translationMap);
   }

inferred-spans/src/main/java/io/opentelemetry/contrib/inferredspans/InferredSpansAutoConfig.java

@@ -11,8 +11,10 @@
 import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer;
 import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider;
 import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+import io.opentelemetry.sdk.trace.SpanProcessor;
 import java.time.Duration;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
@@ -44,17 +46,20 @@ public class InferredSpansAutoConfig implements AutoConfigurationCustomizerProvi
   public void customize(AutoConfigurationCustomizer config) {
     config.addTracerProviderCustomizer(
         (providerBuilder, properties) -> {
-          if (isEnabled(properties)) {
-            providerBuilder.addSpanProcessor(create(properties));
-          } else {
-            log.finest(
-                "Not enabling inferred spans processor because " + ENABLED_OPTION + " is not set");
-          }
+          providerBuilder.addSpanProcessor(create(properties, /* enableByDefault= */ false));
           return providerBuilder;
         });
   }
 
-  static InferredSpansProcessor create(ConfigProperties properties) {
+  static SpanProcessor create(ConfigProperties properties, boolean enableByDefault) {
+    if (!properties.getBoolean(ENABLED_OPTION, enableByDefault)) {
+      log.finest(
+          "Not creating inferred spans processor because "
+              + ENABLED_OPTION
+              + " is not set to true");
+      return SpanProcessor.composite(Collections.emptyList());
+    }
+
     InferredSpansProcessorBuilder builder = InferredSpansProcessor.builder();
 
     PropertiesApplier applier = new PropertiesApplier(properties);
@@ -76,12 +81,7 @@ static InferredSpansProcessor create(ConfigProperties properties) {
       builder.parentOverrideHandler(constructParentOverrideHandler(parentOverrideHandlerName));
     }
 
-    InferredSpansProcessor spanProcessor = builder.build();
-    return spanProcessor;
-  }
-
-  static boolean isEnabled(ConfigProperties properties) {
-    return properties.getBoolean(ENABLED_OPTION, false);
+    return builder.build();
   }
 
   @SuppressWarnings("unchecked")

inferred-spans/src/main/java/io/opentelemetry/contrib/inferredspans/InferredSpansComponentProvider.java

@@ -10,10 +10,12 @@
 import io.opentelemetry.contrib.sdk.autoconfigure.ConfigPropertiesUtil;
 import io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider;
 import io.opentelemetry.sdk.trace.SpanProcessor;
+import java.util.Collections;
 
 @SuppressWarnings("rawtypes")
 @AutoService(ComponentProvider.class)
 public class InferredSpansComponentProvider implements ComponentProvider<SpanProcessor> {
+
   @Override
   public String getName() {
     return "inferred_spans";
@@ -22,8 +24,9 @@ public String getName() {
   @Override
   public SpanProcessor create(DeclarativeConfigProperties config) {
     return InferredSpansAutoConfig.create(
-        ConfigPropertiesUtil.resolveInstrumentationConfig(
-            config, InferredSpansCustomizerProvider.TRANSLATION_MAP));
+        ConfigPropertiesUtil.resolveConfig(
+            config, Collections.singletonMap("otel.inferred.spans.", "")),
+        /* enableByDefault= */ true);
   }
 
   @Override

inferred-spans/src/test/java/io/opentelemetry/contrib/inferredspans/InferredSpansCustomizerProviderTest.java

@@ -5,37 +5,40 @@
 
 package io.opentelemetry.contrib.inferredspans;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import io.opentelemetry.sdk.extension.incubator.fileconfig.DeclarativeConfiguration;
-import io.opentelemetry.sdk.extension.incubator.fileconfig.internal.model.OpenTelemetryConfigurationModel;
+import org.junit.jupiter.api.Test;
+
 import java.io.ByteArrayInputStream;
 import java.nio.charset.StandardCharsets;
-import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 class InferredSpansCustomizerProviderTest {
 
+  private static final String FQDN =
+      "spanProcessor=io.opentelemetry.contrib.inferredspans.InferredSpansProcessor";
+
+  @Test
+  void enabled() {
+    assertThat(create("")).contains(FQDN);
+  }
+
   @Test
-  void declarativeConfig() {
+  void disabled() {
+    assertThat(create("enabled: false")).doesNotContain(FQDN);
+  }
+
+  private static String create(String enabled) {
     String yaml =
         "file_format: 0.4\n"
             + "tracer_provider:\n"
-            + "instrumentation/development:\n"
-            + "  java:\n"
-            + "    inferred_spans:\n"
-            + "      enabled: true\n";
-
-    OpenTelemetryConfigurationModel model =
-        DeclarativeConfiguration.parse(
-            new ByteArrayInputStream(yaml.getBytes(StandardCharsets.UTF_8)));
-
-    new InferredSpansCustomizerProvider()
-        .customize(
-            c -> {
-              OpenTelemetryConfigurationModel configurationModel = c.apply(model);
-              assertThat(configurationModel.toString())
-                  .matches(
-                      ".*SpanProcessorModel@.{8}\\[batch=<null>,simple=<null>,additionalProperties=\\{inferred_spans=null}.*");
-            });
+            + "  processors:\n"
+            + "    - inferred_spans:\n"
+            + "        "
+            + enabled
+            + "\n";
+    return DeclarativeConfiguration.parseAndCreate(
+            new ByteArrayInputStream(yaml.getBytes(StandardCharsets.UTF_8)))
+        .toString();
   }
 }