Support reading configurations from files

internal-api/build.gradle

@@ -221,6 +221,8 @@ dependencies {
   // it contains annotations that are also present in the instrumented application classes
   api "com.datadoghq:dd-javac-plugin-client:0.2.2"
 
+  implementation 'org.yaml:snakeyaml:2.0'
+
   testImplementation project(":utils:test-utils")
   testImplementation("org.assertj:assertj-core:3.20.2")
   testImplementation libs.bundles.junit5

internal-api/src/main/java/datadog/trace/api/ConfigOrigin.java

@@ -7,6 +7,10 @@ public enum ConfigOrigin {
   REMOTE("remote_config"),
   /** configurations that are set through JVM properties */
   JVM_PROP("jvm_prop"),
+  /** configuration read in the stable config file, managed by users */
+  USER_STABLE_CONFIG("user_stable_config"),
+  /** configuration read in the stable config file, managed by fleet */
+  MANAGED_STABLE_CONFIG("managed_stable_config"),
   /** set when the user has not set any configuration for the key (defaults to a value) */
   DEFAULT("default");
 

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

@@ -0,0 +1,94 @@
+package datadog.trace.bootstrap.config.provider;
+
+import static datadog.trace.util.Strings.propertyNameToEnvironmentVariableName;
+
+import datadog.trace.api.ConfigOrigin;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+public final class StableConfigSource extends ConfigProvider.Source {
+  static final String USER_STABLE_CONFIG_PATH = "/etc/datadog-agent/application_monitoring.yaml";
+  static final String MANAGED_STABLE_CONFIG_PATH =
+      "/etc/datadog-agent/managed/datadog-apm-libraries/stable/application_monitoring.yaml ";
+  private static final Logger log = LoggerFactory.getLogger(StableConfigSource.class);
+
+  final ConfigOrigin fileOrigin;
+  HashMap<String, Object> configuration;
+
+  StableConfigSource(String file, ConfigOrigin origin) {
+    this.fileOrigin = origin;
+    try {
+      configuration = parseStableConfig(file);
+    } catch (Exception e) {
+      configuration = new HashMap<>();
+    }
+  }
+
+  private static HashMap<String, Object> parseStableConfig(String filePath) throws IOException {
+    HashMap<String, Object> config = new HashMap<>();
+
+    // Check if the file exists
+    File file = new File(filePath);
+    if (!file.exists()) {
+      log.error("Stable configuration file does not exist at the specified path: {}", filePath);
+      return config; // Exit early or take other action as necessary
+    }
+
+    Yaml yaml = new Yaml(new SafeConstructor(new LoaderOptions()));
+    InputStream input = Files.newInputStream(new File(filePath).toPath());
+    HashMap<String, Object> data = yaml.load(input);
+
+    Object apmConfig = data.get("apm_configuration_default");
+    if (apmConfig instanceof HashMap<?, ?>) {
+      HashMap<?, ?> tempConfig = (HashMap<?, ?>) apmConfig;
+      for (Map.Entry<?, ?> entry : tempConfig.entrySet()) {
+        if (entry.getKey() instanceof String && entry.getValue() != null) {
+          String key = String.valueOf(entry.getKey());
+          Object value = entry.getValue();
+          config.put(key, value);
+        } else {
+          log.debug("Configuration {} in unexpected format", entry.getKey());
+        }
+      }
+    } else {
+      // do something
+      log.debug("File {} in unexpected format", filePath);
+    }
+    return config;
+  };
+
+  public String get(String key) {
+    return (String) configuration.get(propertyNameToEnvironmentVariableName(key));
+  }
+
+  public Set<String> getKeys() {
+    return this.configuration.keySet();
+  }
+
+  public ConfigOrigin origin() {
+    return fileOrigin;
+  }
+
+  private static class StableConfig {
+    private String config_id;
+    private HashMap<String, Object> apm_configuration_default;
+
+    private void setApmConfigurationDefault(HashMap<String, Object> m) {
+      apm_configuration_default = m;
+    }
+
+    private void setConfigId(String i) {
+      config_id = i;
+    }
+  }
+}

internal-api/src/test/groovy/datadog/trace/bootstrap/config/provider/StableConfigSourceTest.groovy

@@ -0,0 +1,68 @@
+package datadog.trace.bootstrap.config.provider
+
+import datadog.trace.api.ConfigOrigin
+import datadog.trace.test.util.DDSpecification
+import org.yaml.snakeyaml.DumperOptions
+import org.yaml.snakeyaml.Yaml
+
+class StableConfigSourceTest extends DDSpecification {
+
+  def "test file doesn't exist"() {
+    setup:
+    StableConfigSource config = new StableConfigSource(StableConfigSource.USER_STABLE_CONFIG_PATH, ConfigOrigin.USER_STABLE_CONFIG)
+
+    expect:
+    config.getKeys().size() == 0
+    // How to check that the "file does not exist" error was logged?
+  }
+
+  def "test valid file"() {
+    // test empty file
+    when:
+    def path = StableConfigSource.USER_STABLE_CONFIG_PATH
+    try {
+      File file = new File(path)
+      file.createNewFile()
+    } catch (IOException e) {
+      // fail fast?
+      System.out.println("Error creating file")
+      e.printStackTrace()
+    }
+    StableConfigSource config = new StableConfigSource(path, ConfigOrigin.USER_STABLE_CONFIG)
+
+    then:
+    config.getKeys().size() == 0
+
+    // test populated file
+    //    when:
+    //    def key1 = "dd_first_key"
+    //    def val1 = "dd_first_val"
+    //    def key2 = "dd_second_key"
+    //    def val2 = "dd_second_val"
+    //    // Create the map that will be used to populate the config file
+    //    Map<String, Object> data = new HashMap<>();
+    //    data.put("apm_configuration_default", new HashMap<String, Object>() {{
+    //      put(key1, val1);
+    //      put(key2, val2);
+    //    }})
+    //
+    //    DumperOptions options = new DumperOptions();
+    //    options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+    //
+    //    // Prepare to write the data map to the file in yaml format
+    //    Yaml yaml = new Yaml(options);
+    //
+    //    try (FileWriter writer = new FileWriter(path)) {
+    //      yaml.dump(data, writer);
+    //    } catch (IOException e) {
+    //      System.err.println("Error writing to file: " + e.getMessage());
+    //      // fail fast?
+    //    }
+    //
+    //    then:
+    //    StableConfigSource config2 = new StableConfigSource(StableConfigSource.USER_STABLE_CONFIG_PATH, ConfigOrigin.USER_STABLE_CONFIG);
+    //    config2.getKeys().size() == 2
+    //    config2.get(key1) == val1
+    //    config2.get(key2) == val2
+  }
+}