Support targeting services with configurations in stable configuration file

components/yaml/build.gradle.kts

@@ -0,0 +1,14 @@
+plugins {
+  id("me.champeau.jmh")
+}
+
+apply(from = "$rootDir/gradle/java.gradle")
+
+jmh {
+  version = "1.28"
+}
+
+// https://repo1.maven.org/maven2/org/yaml/snakeyaml/2.4/snakeyaml-2.4.pom
+dependencies {
+  implementation("org.yaml", "snakeyaml", "2.4")
+}

components/yaml/src/main/java/datadog/yaml/YamlParser.java

@@ -0,0 +1,19 @@
+package datadog.yaml;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import org.yaml.snakeyaml.Yaml;
+
+public class YamlParser {
+  // Supports clazz == null for default yaml parsing
+  public static <T> T parse(String filePath, Class<T> clazz) throws IOException {
+    Yaml yaml = new Yaml();
+    try (FileInputStream fis = new FileInputStream(filePath)) {
+      if (clazz == null) {
+        return yaml.load(fis);
+      } else {
+        return yaml.loadAs(fis, clazz);
+      }
+    }
+  }
+}

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/Constants.java

@@ -16,6 +16,7 @@ public final class Constants {
   public static final String[] BOOTSTRAP_PACKAGE_PREFIXES = {
     "datadog.slf4j",
     "datadog.json",
+    "datadog.yaml",
     "datadog.context",
     "datadog.cli",
     "datadog.appsec.api",

dd-java-agent/build.gradle

@@ -59,8 +59,9 @@ ext.generalShadowJarConfig = {
 
   final String projectName = "${project.name}"
 
-  // Prevents conflict with other OkHttp instances, but don't relocate instrumentation
+  // Prevents conflict with other instances, but doesn't relocate instrumentation
   if (!projectName.equals('instrumentation')) {
+    relocate 'org.yaml.snakeyaml', 'datadog.snakeyaml'
     relocate 'okhttp3', 'datadog.okhttp3'
     relocate 'okio',  'datadog.okio'
   }

dd-java-agent/instrumentation/build.gradle

@@ -59,6 +59,9 @@ subprojects { Project subProj ->
       def name = "java$version.majorVersion"
       jdkCompile = "main_${name}Implementation"
     }
+    configurations.muzzleBootstrap {
+      exclude group: 'org.yaml', module : 'snakeyaml' // we vendor this in the agent jar
+    }
     dependencies {
       // Apply common dependencies for instrumentation.
       implementation project(':dd-trace-api')

dd-java-agent/instrumentation/snakeyaml/build.gradle

@@ -18,7 +18,13 @@ addTestSuiteForDir('latestDepTest', 'test')
 
 dependencies {
   compileOnly group: 'org.yaml', name: 'snakeyaml', version: '1.33'
-  testImplementation group: 'org.yaml', name: 'snakeyaml', version: '1.33'
+
+  testImplementation('org.yaml:snakeyaml') {
+    version {
+      strictly "[1.4, 2.0)"
+      prefer '1.33'
+    }
+  }
 
   latestDepTestImplementation group: 'org.yaml', name: 'snakeyaml', version: '1.+'
 }

dd-java-agent/testing/build.gradle

@@ -38,6 +38,10 @@ excludedClassesCoverage += [
   'datadog.trace.agent.test.TestProfilingContextIntegration.TestQueueTiming'
 ]
 
+configurations.api {
+  exclude group: 'org.yaml', module: 'snakeyaml' // we vendor this in the agent jar
+}
+
 dependencies {
   api libs.bytebuddy
   api libs.bytebuddyagent

dd-java-agent/testing/src/main/groovy/datadog/trace/agent/test/SpockRunner.java

@@ -39,6 +39,7 @@ public class SpockRunner extends JUnitPlatform {
   public static final String[] BOOTSTRAP_PACKAGE_PREFIXES_COPY = {
     "datadog.slf4j",
     "datadog.json",
+    "datadog.yaml",
     "datadog.context",
     "datadog.cli",
     "datadog.appsec.api",

gradle/dependencies.gradle

@@ -18,6 +18,7 @@ final class CachedData {
       exclude(project(':communication'))
       exclude(project(':components:context'))
       exclude(project(':components:json'))
+      exclude(project(':components:yaml'))
       exclude(project(':components:cli'))
       exclude(project(':remote-config:remote-config-api'))
       exclude(project(':remote-config:remote-config-core'))
@@ -49,6 +50,9 @@ final class CachedData {
 
       // cafe_crypto and its transitives
       exclude(dependency('cafe.cryptography::'))
+
+      // snakeyaml and its transitives
+      exclude(dependency('org.yaml:snakeyaml'))
     }
   ]
 }

internal-api/build.gradle

@@ -239,21 +239,22 @@ dependencies {
   api project(':dd-trace-api')
   api libs.slf4j
   api project(':components:context')
+  api project(':components:yaml')
   api project(':components:cli')
   api project(":utils:time-utils")
 
   // has to be loaded by system classloader:
   // it contains annotations that are also present in the instrumented application classes
   api "com.datadoghq:dd-javac-plugin-client:0.2.2"
 
+  testImplementation("org.yaml:snakeyaml:2.4")
   testImplementation project(":utils:test-utils")
   testImplementation("org.assertj:assertj-core:3.20.2")
   testImplementation libs.bundles.junit5
   testImplementation group: 'org.junit.vintage', name: 'junit-vintage-engine', version: libs.versions.junit5.get()
   testImplementation libs.commons.math
   testImplementation libs.bundles.mockito
   testImplementation libs.truth
-  testImplementation 'org.yaml:snakeyaml:2.0'
 }
 
 jmh {

internal-api/src/main/java/datadog/trace/bootstrap/config/provider/StableConfigParser.java

@@ -1,77 +1,179 @@
 package datadog.trace.bootstrap.config.provider;
 
-import java.io.File;
+import datadog.cli.CLIHelper;
+import datadog.trace.bootstrap.config.provider.stableconfigyaml.ConfigurationMap;
+import datadog.trace.bootstrap.config.provider.stableconfigyaml.Rule;
+import datadog.trace.bootstrap.config.provider.stableconfigyaml.Selector;
+import datadog.trace.bootstrap.config.provider.stableconfigyaml.StableConfigYaml;
+import datadog.yaml.YamlParser;
 import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
+import java.util.Collections;
 import java.util.HashMap;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Stream;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.BiPredicate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class StableConfigParser {
   private static final Logger log = LoggerFactory.getLogger(StableConfigParser.class);
-  // Match config_id:<value>
-  private static final Pattern idPattern = Pattern.compile("^config_id\\s*:(.*)$");
-  // Match 'apm_configuration_default:'
-  private static final Pattern apmConfigPattern = Pattern.compile("^apm_configuration_default:$");
-  // Match indented (2 spaces) key-value pairs, either with double quotes or without
-  private static final Pattern keyValPattern =
-      Pattern.compile("^\\s{2}([^:]+):\\s*(\"[^\"]*\"|[^\"\\n]*)$");;
 
+  private static final Set<String> VM_ARGS = new HashSet<>(CLIHelper.getVmArgs());
+
+  /**
+   * Parses a configuration file and returns a stable configuration object.
+   *
+   * <p>This method reads a configuration file from the given file path, parses the YAML content,
+   * and identifies configurations for the process using a combination of apm_configuration_default
+   * and apm_configuration_rules. If a matching rule is found in apm_configuration_rules, it returns
+   * a {@link StableConfigSource.StableConfig} object with the merged configuration. If no matching
+   * rule is found, it returns the default configuration. If neither a matching rule nor a default
+   * configuration is found, an empty configuration is returned.
+   *
+   * @param filePath The path to the YAML configuration file to be parsed.
+   * @return A {@link StableConfigSource.StableConfig} object containing the stable configuration.
+   * @throws IOException If there is an error reading the file or parsing the YAML content.
+   */
   public static StableConfigSource.StableConfig parse(String filePath) throws IOException {
-    File file = new File(filePath);
-    if (!file.exists()) {
-      log.debug("Stable configuration file not available at specified path: {}", file);
-      return StableConfigSource.StableConfig.EMPTY;
+    try {
+      StableConfigYaml data = YamlParser.parse(filePath, StableConfigYaml.class);
+
+      String configId = data.getConfig_id();
+      ConfigurationMap configMap = data.getApm_configuration_default();
+      List<Rule> rules = data.getApm_configuration_rules();
+
+      if (!rules.isEmpty()) {
+        for (Rule rule : rules) {
+          // Use the first matching rule
+          if (doesRuleMatch(rule)) {
+            // Merge configs found in apm_configuration_rules with those found in
+            // apm_configuration_default
+            configMap.putAll(rule.getConfiguration());
+            return createStableConfig(configId, configMap);
+          }
+        }
+      }
+      // If configs were found in apm_configuration_default, use them
+      if (!configMap.isEmpty()) {
+        return createStableConfig(configId, configMap);
+      }
+
+      // If there's a configId but no configMap, use configId but return an empty map
+      if (configId != null) {
+        return new StableConfigSource.StableConfig(configId, Collections.emptyMap());
+      }
+
+    } catch (IOException e) {
+      log.debug(
+          "Stable configuration file either not found or not readable at filepath {}", filePath);
+    }
+    return StableConfigSource.StableConfig.EMPTY;
+  }
+
+  /**
+   * Checks if the rule's selectors match the current process. All must match for a "true" return
+   * value.
+   */
+  private static boolean doesRuleMatch(Rule rule) {
+    for (Selector selector : rule.getSelectors()) {
+      if (!selectorMatch(
+          selector.getOrigin(), selector.getMatches(), selector.getOperator(), selector.getKey())) {
+        return false; // Return false immediately if any selector doesn't match
+      }
+    }
+    return true; // Return true if all selectors match
+  }
+
+  /** Creates a StableConfig object from the provided configId and configMap. */
+  private static StableConfigSource.StableConfig createStableConfig(
+      String configId, ConfigurationMap configMap) {
+    return new StableConfigSource.StableConfig(configId, new HashMap<>(configMap));
+  }
+
+  private static boolean validOperatorForLanguageOrigin(String operator) {
+    operator = operator.toLowerCase();
+    // "exists" is not valid
+    switch (operator) {
+      case "equals":
+      case "starts_with":
+      case "ends_with":
+      case "contains":
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  private static boolean checkEnvMatches(
+      List<String> values, List<String> matches, BiPredicate<String, String> compareFunc) {
+    // envValue shouldn't be null, but doing an extra check to avoid NullPointerException on
+    // compareFunc.test
+    if (values == null) {
+      return false;
     }
-    Map<String, String> configMap = new HashMap<>();
-    String[] configId = new String[1];
-    try (Stream<String> lines = Files.lines(Paths.get(filePath))) {
-      int apmConfigNotFound = -1, apmConfigStarted = 0, apmConfigComplete = 1;
-      int[] apmConfigFound = {apmConfigNotFound};
-      lines.forEach(
-          line -> {
-            Matcher matcher = idPattern.matcher(line);
-            if (matcher.find()) {
-              // Do not allow duplicate config_id keys
-              if (configId[0] != null) {
-                throw new RuntimeException("Duplicate config_id keys found; file may be malformed");
-              }
-              configId[0] = trimQuotes(matcher.group(1).trim());
-              return; // go to next line
-            }
-            // TODO: Do not allow duplicate apm_configuration_default keys; and/or return early once
-            // apmConfigFound[0] == apmConfigComplete
-            if (apmConfigFound[0] == apmConfigNotFound
-                && apmConfigPattern.matcher(line).matches()) {
-              apmConfigFound[0] = apmConfigStarted;
-              return; // go to next line
-            }
-            if (apmConfigFound[0] == apmConfigStarted) {
-              Matcher keyValueMatcher = keyValPattern.matcher(line);
-              if (keyValueMatcher.matches()) {
-                configMap.put(
-                    keyValueMatcher.group(1).trim(),
-                    trimQuotes(keyValueMatcher.group(2).trim())); // Store key-value pair in map
-              } else {
-                // If we encounter a non-indented or non-key-value line, stop processing
-                apmConfigFound[0] = apmConfigComplete;
-              }
-            }
-          });
-      return new StableConfigSource.StableConfig(configId[0], configMap);
+    for (String match : matches) {
+      if (match == null) {
+        continue;
+      }
+      for (String value : values) {
+        if (compareFunc.test(value, match.toLowerCase())) {
+          return true;
+        }
+      }
     }
+    return false;
   }
 
-  private static String trimQuotes(String value) {
-    if (value.length() > 1 && (value.startsWith("'") && value.endsWith("'"))
-        || (value.startsWith("\"") && value.endsWith("\""))) {
-      return value.substring(1, value.length() - 1);
+  // We do all of the case insensitivity modifications in this function, because each selector will
+  // be viewed just once
+  static boolean selectorMatch(String origin, List<String> matches, String operator, String key) {
+    switch (origin.toLowerCase()) {
+      case "language":
+        if (!validOperatorForLanguageOrigin(operator)) {
+          return false;
+        }
+        for (String entry : matches) {
+          // loose match on any reference to "*java*"
+          if (entry.toLowerCase().contains("java")) {
+            return true;
+          }
+        }
+      case "environment_variables":
+        if (key == null) {
+          return false;
+        }
+        String envValue = System.getenv(key.toUpperCase());
+        if (envValue == null) {
+          return false;
+        }
+        envValue = envValue.toLowerCase();
+        switch (operator.toLowerCase()) {
+          case "exists":
+            // We don't care about the value
+            return true;
+          case "equals":
+            return checkEnvMatches(
+                Collections.singletonList(envValue), matches, String::equalsIgnoreCase);
+          case "starts_with":
+            return checkEnvMatches(
+                Collections.singletonList(envValue), matches, String::startsWith);
+          case "ends_with":
+            return checkEnvMatches(Collections.singletonList(envValue), matches, String::endsWith);
+          case "contains":
+            return checkEnvMatches(Collections.singletonList(envValue), matches, String::contains);
+          default:
+            return false;
+        }
+      case "process_arguments":
+        // For now, always return true if `key` exists in the JVM Args
+        // TODO: flesh out the meaning of each operator for process_arguments
+        return VM_ARGS.contains(key);
+      case "tags":
+        // TODO: Support this down the line (Must define the source of "tags" first)
+        return false;
+      default:
+        return false;
     }
-    return value;
   }
 }