Support reading configurations from files

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

@@ -33,6 +33,7 @@
 import datadog.trace.api.profiling.ProfilingEnablement;
 import datadog.trace.api.scopemanager.ScopeListener;
 import datadog.trace.bootstrap.benchmark.StaticEventLogger;
+import datadog.trace.bootstrap.config.provider.StableConfigSource;
 import datadog.trace.bootstrap.instrumentation.api.AgentTracer;
 import datadog.trace.bootstrap.instrumentation.api.AgentTracer.TracerAPI;
 import datadog.trace.bootstrap.instrumentation.api.ProfilingContextIntegration;
@@ -1214,9 +1215,15 @@ private static boolean isFeatureEnabled(AgentFeature feature) {
     // must be kept in sync with logic from Config!
     final String featureEnabledSysprop = feature.getSystemProp();
     String featureEnabled = System.getProperty(featureEnabledSysprop);
+    if (featureEnabled == null) {
+      featureEnabled = getStableConfig(StableConfigSource.MANAGED, featureEnabledSysprop);
+    }
     if (featureEnabled == null) {
       featureEnabled = ddGetEnv(featureEnabledSysprop);
     }
+    if (featureEnabled == null) {
+      featureEnabled = getStableConfig(StableConfigSource.USER, featureEnabledSysprop);
+    }
 
     if (feature.isEnabledByDefault()) {
       // true unless it's explicitly set to "false"
@@ -1353,6 +1360,11 @@ private static String ddGetProperty(final String sysProp) {
     return value;
   }
 
+  /** Looks for sysProp in the Stable Configuration input */
+  private static String getStableConfig(StableConfigSource source, final String sysProp) {
+    return source.get(sysProp);
+  }
+
   /** Looks for the "DD_" environment variable equivalent of the given "dd." system property. */
   private static String ddGetEnv(final String sysProp) {
     return System.getenv(toEnvVar(sysProp));

dd-java-agent/instrumentation/graal/native-image/src/main/java/datadog/trace/instrumentation/graal/nativeimage/NativeImageGeneratorRunnerInstrumentation.java

@@ -78,6 +78,7 @@ public static void onEnter(@Advice.Argument(value = 0, readOnly = false) String[
               + "datadog.trace.api.env.CapturedEnvironment:build_time,"
               + "datadog.trace.api.ConfigCollector:rerun,"
               + "datadog.trace.api.ConfigDefaults:build_time,"
+              + "datadog.trace.api.ConfigOrigin:build_time,"
               + "datadog.trace.api.ConfigSetting:build_time,"
               + "datadog.trace.api.EventTracker:build_time,"
               + "datadog.trace.api.InstrumenterConfig:build_time,"
@@ -106,6 +107,8 @@ public static void onEnter(@Advice.Argument(value = 0, readOnly = false) String[
               + "datadog.trace.bootstrap.config.provider.EnvironmentConfigSource:build_time,"
               + "datadog.trace.bootstrap.config.provider.OtelEnvironmentConfigSource:build_time,"
               + "datadog.trace.bootstrap.config.provider.SystemPropertiesConfigSource:build_time,"
+              + "datadog.trace.bootstrap.config.provider.StableConfigSource:build_time,"
+              + "datadog.trace.bootstrap.config.provider.StableConfigSource$StableConfig:build_time,"
               + "datadog.trace.bootstrap.Agent:build_time,"
               + "datadog.trace.bootstrap.BootstrapProxy:build_time,"
               + "datadog.trace.bootstrap.CallDepthThreadLocalMap:build_time,"

internal-api/build.gradle

@@ -235,6 +235,7 @@ dependencies {
   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/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/ConfigProvider.java

@@ -356,15 +356,19 @@ public static ConfigProvider createDefault() {
     if (configProperties.isEmpty()) {
       return new ConfigProvider(
           new SystemPropertiesConfigSource(),
+          StableConfigSource.MANAGED,
           new EnvironmentConfigSource(),
           new OtelEnvironmentConfigSource(),
+          StableConfigSource.USER,
           new CapturedEnvironmentConfigSource());
     } else {
       return new ConfigProvider(
           new SystemPropertiesConfigSource(),
+          StableConfigSource.MANAGED,
           new EnvironmentConfigSource(),
           new PropertiesConfigSource(configProperties, true),
           new OtelEnvironmentConfigSource(configProperties),
+          StableConfigSource.USER,
           new CapturedEnvironmentConfigSource());
     }
   }
@@ -378,16 +382,20 @@ public static ConfigProvider withoutCollector() {
       return new ConfigProvider(
           false,
           new SystemPropertiesConfigSource(),
+          StableConfigSource.MANAGED,
           new EnvironmentConfigSource(),
           new OtelEnvironmentConfigSource(),
+          StableConfigSource.USER,
           new CapturedEnvironmentConfigSource());
     } else {
       return new ConfigProvider(
           false,
           new SystemPropertiesConfigSource(),
+          StableConfigSource.MANAGED,
           new EnvironmentConfigSource(),
           new PropertiesConfigSource(configProperties, true),
           new OtelEnvironmentConfigSource(configProperties),
+          StableConfigSource.USER,
           new CapturedEnvironmentConfigSource());
     }
   }
@@ -403,17 +411,21 @@ public static ConfigProvider withPropertiesOverride(Properties properties) {
     if (configProperties.isEmpty()) {
       return new ConfigProvider(
           new SystemPropertiesConfigSource(),
+          StableConfigSource.MANAGED,
           new EnvironmentConfigSource(),
           providedConfigSource,
           new OtelEnvironmentConfigSource(),
+          StableConfigSource.USER,
           new CapturedEnvironmentConfigSource());
     } else {
       return new ConfigProvider(
           providedConfigSource,
           new SystemPropertiesConfigSource(),
+          StableConfigSource.MANAGED,
           new EnvironmentConfigSource(),
           new PropertiesConfigSource(configProperties, true),
           new OtelEnvironmentConfigSource(configProperties),
+          StableConfigSource.USER,
           new CapturedEnvironmentConfigSource());
     }
   }

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

@@ -0,0 +1,77 @@
+package datadog.trace.bootstrap.config.provider;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+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]*)$");;
+
+  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;
+    }
+    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);
+    }
+  }
+
+  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);
+    }
+    return value;
+  }
+}

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

@@ -0,0 +1,84 @@
+package datadog.trace.bootstrap.config.provider;
+
+import static datadog.trace.util.Strings.propertyNameToEnvironmentVariableName;
+
+import datadog.trace.api.ConfigOrigin;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class StableConfigSource extends ConfigProvider.Source {
+  private static final Logger log = LoggerFactory.getLogger(StableConfigSource.class);
+
+  public static final String USER_STABLE_CONFIG_PATH =
+      "/etc/datadog-agent/application_monitoring.yaml";
+  public static final String MANAGED_STABLE_CONFIG_PATH =
+      "/etc/datadog-agent/managed/datadog-agent/stable/application_monitoring.yaml";
+  public static final StableConfigSource USER =
+      new StableConfigSource(USER_STABLE_CONFIG_PATH, ConfigOrigin.USER_STABLE_CONFIG);
+  public static final StableConfigSource MANAGED =
+      new StableConfigSource(
+          StableConfigSource.MANAGED_STABLE_CONFIG_PATH, ConfigOrigin.MANAGED_STABLE_CONFIG);
+
+  private final ConfigOrigin fileOrigin;
+
+  private final StableConfig config;
+
+  StableConfigSource(String file, ConfigOrigin origin) {
+    this.fileOrigin = origin;
+    StableConfig cfg;
+    try {
+      cfg = StableConfigParser.parse(file);
+    } catch (Throwable e) {
+      log.debug("Stable configuration file not readable at specified path: {}", file);
+      cfg = StableConfig.EMPTY;
+    }
+    this.config = cfg;
+  }
+
+  @Override
+  public String get(String key) {
+    if (this.config == StableConfig.EMPTY) {
+      return null;
+    }
+    return this.config.get(propertyNameToEnvironmentVariableName(key));
+  }
+
+  @Override
+  public ConfigOrigin origin() {
+    return fileOrigin;
+  }
+
+  public Set<String> getKeys() {
+    return this.config.getKeys();
+  }
+
+  public String getConfigId() {
+    return this.config.getConfigId();
+  }
+
+  public static class StableConfig {
+    public static final StableConfig EMPTY = new StableConfig(null, Collections.emptyMap());
+    private final Map<String, String> apmConfiguration;
+    private final String configId;
+
+    StableConfig(String configId, Map<String, String> configMap) {
+      this.configId = configId;
+      this.apmConfiguration = configMap;
+    }
+
+    public String get(String key) {
+      return this.apmConfiguration.get(key);
+    }
+
+    public Set<String> getKeys() {
+      return this.apmConfiguration.keySet();
+    }
+
+    public String getConfigId() {
+      return this.configId;
+    }
+  }
+}