diff --git a/dd-smoke-tests/log-injection/src/main/java/datadog/smoketest/loginjection/BaseApplication.java b/dd-smoke-tests/log-injection/src/main/java/datadog/smoketest/loginjection/BaseApplication.java
index a2edae29ac3..74068c5fd06 100644
--- a/dd-smoke-tests/log-injection/src/main/java/datadog/smoketest/loginjection/BaseApplication.java
+++ b/dd-smoke-tests/log-injection/src/main/java/datadog/smoketest/loginjection/BaseApplication.java
@@ -44,7 +44,8 @@ public void run() throws InterruptedException {
   }
 
   private static Object getLogInjectionEnabled() {
-    ConfigSetting configSetting = ConfigCollector.get().collect().get(LOGS_INJECTION_ENABLED);
+    ConfigSetting configSetting =
+        ConfigCollector.get().getAppliedConfigSetting(LOGS_INJECTION_ENABLED);
     if (configSetting == null) {
       return null;
     }
diff --git a/internal-api/src/main/java/datadog/trace/api/ConfigCollector.java b/internal-api/src/main/java/datadog/trace/api/ConfigCollector.java
index f4cfda6877b..bdeab570cfe 100644
--- a/internal-api/src/main/java/datadog/trace/api/ConfigCollector.java
+++ b/internal-api/src/main/java/datadog/trace/api/ConfigCollector.java
@@ -16,42 +16,50 @@ public class ConfigCollector {
   private static final AtomicReferenceFieldUpdater<ConfigCollector, Map> COLLECTED_UPDATER =
       AtomicReferenceFieldUpdater.newUpdater(ConfigCollector.class, Map.class, "collected");
 
-  private volatile Map<String, ConfigSetting> collected = new ConcurrentHashMap<>();
+  private volatile Map<String, Map<ConfigOrigin, ConfigSetting>> collected =
+      new ConcurrentHashMap<>();
 
   public static ConfigCollector get() {
     return INSTANCE;
   }
 
+  /**
+   * Records the latest ConfigSetting for the given key and origin, replacing any previous value for
+   * that (key, origin) pair.
+   */
   public void put(String key, Object value, ConfigOrigin origin) {
     ConfigSetting setting = ConfigSetting.of(key, value, origin);
-    collected.put(key, setting);
+    Map<ConfigOrigin, ConfigSetting> originMap =
+        collected.computeIfAbsent(key, k -> new ConcurrentHashMap<>());
+    originMap.put(origin, setting); // replaces any previous value for this origin
   }
 
   public void putAll(Map<String, Object> keysAndValues, ConfigOrigin origin) {
-    // attempt merge+replace to avoid collector seeing partial update
-    Map<String, ConfigSetting> merged =
-        new ConcurrentHashMap<>(keysAndValues.size() + collected.size());
     for (Map.Entry<String, Object> entry : keysAndValues.entrySet()) {
-      ConfigSetting setting = ConfigSetting.of(entry.getKey(), entry.getValue(), origin);
-      merged.put(entry.getKey(), setting);
-    }
-    while (true) {
-      Map<String, ConfigSetting> current = collected;
-      current.forEach(merged::putIfAbsent);
-      if (COLLECTED_UPDATER.compareAndSet(this, current, merged)) {
-        break; // success
-      }
-      // roll back to original update before next attempt
-      merged.keySet().retainAll(keysAndValues.keySet());
+      put(entry.getKey(), entry.getValue(), origin);
     }
   }
 
   @SuppressWarnings("unchecked")
-  public Map<String, ConfigSetting> collect() {
+  public Map<String, Map<ConfigOrigin, ConfigSetting>> collect() {
     if (!collected.isEmpty()) {
       return COLLECTED_UPDATER.getAndSet(this, new ConcurrentHashMap<>());
     } else {
       return Collections.emptyMap();
     }
   }
+
+  /**
+   * Returns the {@link ConfigSetting} with the highest precedence for the given key, or {@code
+   * null} if no setting exists for that key.
+   */
+  public ConfigSetting getAppliedConfigSetting(String key) {
+    Map<ConfigOrigin, ConfigSetting> originMap = collected.get(key);
+    if (originMap == null || originMap.isEmpty()) {
+      return null;
+    }
+    return originMap.values().stream()
+        .max(java.util.Comparator.comparingInt(setting -> setting.origin.precedence))
+        .orElse(null);
+  }
 }
diff --git a/internal-api/src/main/java/datadog/trace/api/ConfigOrigin.java b/internal-api/src/main/java/datadog/trace/api/ConfigOrigin.java
index 935f410ebe1..ea7dcedd278 100644
--- a/internal-api/src/main/java/datadog/trace/api/ConfigOrigin.java
+++ b/internal-api/src/main/java/datadog/trace/api/ConfigOrigin.java
@@ -4,27 +4,29 @@
 // GeneratedDocumentation/ApiDocs/v2/SchemaDocumentation/Schemas/conf_key_value.md
 public enum ConfigOrigin {
   /** configurations that are set through environment variables */
-  ENV("env_var"),
+  ENV("env_var", 5),
   /** values that are set using remote config */
-  REMOTE("remote_config"),
+  REMOTE("remote_config", 9),
   /** configurations that are set through JVM properties */
-  JVM_PROP("jvm_prop"),
+  JVM_PROP("jvm_prop", 6),
   /** configuration read in the stable config file, managed by users */
-  LOCAL_STABLE_CONFIG("local_stable_config"),
+  LOCAL_STABLE_CONFIG("local_stable_config", 4),
   /** configuration read in the stable config file, managed by fleet */
-  FLEET_STABLE_CONFIG("fleet_stable_config"),
+  FLEET_STABLE_CONFIG("fleet_stable_config", 7),
   /** configurations that are set through the customer application */
-  CODE("code"),
+  CODE("code", 8),
   /** set by the dd.yaml file or json */
-  DD_CONFIG("dd_config"),
+  DD_CONFIG("dd_config", 3),
   /** set for cases where it is difficult/not possible to determine the source of a config. */
-  UNKNOWN("unknown"),
+  UNKNOWN("unknown", 2),
   /** set when the user has not set any configuration for the key (defaults to a value) */
-  DEFAULT("default");
+  DEFAULT("default", 1);
 
   public final String value;
+  public final int precedence;
 
-  ConfigOrigin(String value) {
+  ConfigOrigin(String value, int precedence) {
     this.value = value;
+    this.precedence = precedence;
   }
 }
diff --git a/internal-api/src/main/java/datadog/trace/api/ConfigSetting.java b/internal-api/src/main/java/datadog/trace/api/ConfigSetting.java
index b688d5b477d..feebf8fd841 100644
--- a/internal-api/src/main/java/datadog/trace/api/ConfigSetting.java
+++ b/internal-api/src/main/java/datadog/trace/api/ConfigSetting.java
@@ -116,7 +116,9 @@ public String toString() {
         + ", value="
         + stringValue()
         + ", origin="
-        + origin
+        + origin.value
+        + ", seq_id="
+        + origin.precedence
         + '}';
   }
 }
diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/config/provider/ConfigProvider.java b/internal-api/src/main/java/datadog/trace/bootstrap/config/provider/ConfigProvider.java
index 0a2715dd11a..dd64ed42d84 100644
--- a/internal-api/src/main/java/datadog/trace/bootstrap/config/provider/ConfigProvider.java
+++ b/internal-api/src/main/java/datadog/trace/bootstrap/config/provider/ConfigProvider.java
@@ -11,6 +11,7 @@
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.BitSet;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -41,6 +42,32 @@ private ConfigProvider(boolean collectConfig, ConfigProvider.Source... sources)
     this.sources = sources;
   }
 
+  /**
+   * Creates a ConfigProvider with sources ordered from lowest to highest precedence. Internally
+   * reverses the array to support the new approach of iterating from lowest to highest precedence,
+   * enabling reporting of all configured sources to telemetry (not just the highest-precedence
+   * match).
+   *
+   * @param sources the configuration sources, in order from lowest to highest precedence
+   * @return a ConfigProvider with sources in precedence order (highest first)
+   */
+  public static ConfigProvider createWithPrecedenceOrder(Source... sources) {
+    Source[] reversed = Arrays.copyOf(sources, sources.length);
+    Collections.reverse(Arrays.asList(reversed));
+    return new ConfigProvider(reversed);
+  }
+
+  /**
+   * Same as {@link #createWithPrecedenceOrder(Source...)} but allows specifying the collectConfig
+   * flag.
+   */
+  public static ConfigProvider createWithPrecedenceOrder(boolean collectConfig, Source... sources) {
+    Source[] reversed = Arrays.copyOf(sources, sources.length);
+    Collections.reverse(Arrays.asList(reversed));
+    return new ConfigProvider(collectConfig, reversed);
+  }
+
+  // TODO: Handle this special case
   public String getConfigFileStatus() {
     for (ConfigProvider.Source source : sources) {
       if (source instanceof PropertiesConfigSource) {
@@ -74,19 +101,24 @@ public <T extends Enum<T>> T getEnum(String key, Class<T> enumType, T defaultVal
   }
 
   public String getString(String key, String defaultValue, String... aliases) {
+    if (collectConfig) {
+      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
+    }
+    String value = null;
     for (ConfigProvider.Source source : sources) {
-      String value = source.get(key, aliases);
-      if (value != null) {
+      String tmp = source.get(key, aliases);
+      if (key.equals("CONFIG_NAME")) {
+        System.out.println(
+            "MTOFF - source: " + source.getClass().getSimpleName() + " value: " + value);
+      }
+      if (tmp != null) {
+        value = tmp;
         if (collectConfig) {
           ConfigCollector.get().put(key, value, source.origin());
         }
-        return value;
       }
     }
-    if (collectConfig) {
-      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
-    }
-    return defaultValue;
+    return value != null ? value : defaultValue;
   }
 
   /**
@@ -94,19 +126,21 @@ public String getString(String key, String defaultValue, String... aliases) {
    * an empty or blank string.
    */
   public String getStringNotEmpty(String key, String defaultValue, String... aliases) {
+    if (collectConfig) {
+      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
+    }
+    String value = null;
     for (ConfigProvider.Source source : sources) {
-      String value = source.get(key, aliases);
-      if (value != null && !value.trim().isEmpty()) {
+      String tmp = source.get(key, aliases);
+      // TODO: Is a source still configured "set" if it's empty, though?
+      if (tmp != null && !tmp.trim().isEmpty()) {
+        value = tmp;
         if (collectConfig) {
           ConfigCollector.get().put(key, value, source.origin());
         }
-        return value;
       }
     }
-    if (collectConfig) {
-      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
-    }
-    return defaultValue;
+    return value != null ? value : defaultValue;
   }
 
   public String getStringExcludingSource(
@@ -114,23 +148,23 @@ public String getStringExcludingSource(
       String defaultValue,
       Class<? extends ConfigProvider.Source> excludedSource,
       String... aliases) {
+    if (collectConfig) {
+      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
+    }
+    String value = null;
     for (ConfigProvider.Source source : sources) {
       if (excludedSource.isAssignableFrom(source.getClass())) {
         continue;
       }
-
-      String value = source.get(key, aliases);
-      if (value != null) {
+      String tmp = source.get(key, aliases);
+      if (tmp != null) {
+        value = tmp;
         if (collectConfig) {
           ConfigCollector.get().put(key, value, source.origin());
         }
-        return value;
       }
     }
-    if (collectConfig) {
-      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
-    }
-    return defaultValue;
+    return value != null ? value : defaultValue;
   }
 
   public boolean isSet(String key) {
@@ -191,24 +225,25 @@ public double getDouble(String key, double defaultValue) {
   }
 
   private <T> T get(String key, T defaultValue, Class<T> type, String... aliases) {
+    if (collectConfig) {
+      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
+    }
+    T value = null;
     for (ConfigProvider.Source source : sources) {
       try {
         String sourceValue = source.get(key, aliases);
-        T value = ConfigConverter.valueOf(sourceValue, type);
-        if (value != null) {
+        T tmp = ConfigConverter.valueOf(sourceValue, type);
+        if (tmp != null) {
+          value = tmp;
           if (collectConfig) {
             ConfigCollector.get().put(key, sourceValue, source.origin());
           }
-          return value;
         }
       } catch (NumberFormatException ex) {
         // continue
       }
     }
-    if (collectConfig) {
-      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
-    }
-    return defaultValue;
+    return value != null ? value : defaultValue;
   }
 
   public List<String> getList(String key) {
@@ -216,11 +251,11 @@ public List<String> getList(String key) {
   }
 
   public List<String> getList(String key, List<String> defaultValue) {
+    if (collectConfig) {
+      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
+    }
     String list = getString(key);
     if (null == list) {
-      if (collectConfig) {
-        ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
-      }
       return defaultValue;
     } else {
       return ConfigConverter.parseList(list);
@@ -228,11 +263,11 @@ public List<String> getList(String key, List<String> defaultValue) {
   }
 
   public Set<String> getSet(String key, Set<String> defaultValue) {
+    if (collectConfig) {
+      ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
+    }
     String list = getString(key);
     if (null == list) {
-      if (collectConfig) {
-        ConfigCollector.get().put(key, defaultValue, ConfigOrigin.DEFAULT);
-      }
       return defaultValue;
     } else {
       return new HashSet(ConfigConverter.parseList(list));
@@ -243,40 +278,49 @@ public List<String> getSpacedList(String key) {
     return ConfigConverter.parseList(getString(key), " ");
   }
 
+  // TODO: Handle this special case
   public Map<String, String> getMergedMap(String key, String... aliases) {
     Map<String, String> merged = new HashMap<>();
     ConfigOrigin origin = ConfigOrigin.DEFAULT;
     // System properties take precedence over env
     // prior art:
     // https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/html/boot-features-external-config.html
-    // We reverse iterate to allow overrides
-    for (int i = sources.length - 1; 0 <= i; i--) {
+    // We iterate in order so higher precedence sources overwrite lower precedence
+    for (int i = 0; i < sources.length; i++) {
       String value = sources[i].get(key, aliases);
       Map<String, String> parsedMap = ConfigConverter.parseMap(value, key);
       if (!parsedMap.isEmpty()) {
         origin = sources[i].origin();
+        if (collectConfig) {
+          ConfigCollector.get().put(key, parsedMap, origin);
+        }
       }
       merged.putAll(parsedMap);
     }
     if (collectConfig) {
+      // TO DISCUSS: But if multiple sources have been set, origin isn't exactly accurate here...?
       ConfigCollector.get().put(key, merged, origin);
     }
     return merged;
   }
 
+  // TODO: Handle this special case
   public Map<String, String> getMergedTagsMap(String key, String... aliases) {
     Map<String, String> merged = new HashMap<>();
     ConfigOrigin origin = ConfigOrigin.DEFAULT;
     // System properties take precedence over env
     // prior art:
     // https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/html/boot-features-external-config.html
-    // We reverse iterate to allow overrides
-    for (int i = sources.length - 1; 0 <= i; i--) {
+    // We iterate in order so higher precedence sources overwrite lower precedence
+    for (int i = 0; i < sources.length; i++) {
       String value = sources[i].get(key, aliases);
       Map<String, String> parsedMap =
           ConfigConverter.parseTraceTagsMap(value, ':', Arrays.asList(',', ' '));
       if (!parsedMap.isEmpty()) {
         origin = sources[i].origin();
+        if (collectConfig) {
+          ConfigCollector.get().put(key, parsedMap, origin);
+        }
       }
       merged.putAll(parsedMap);
     }
@@ -286,18 +330,22 @@ public Map<String, String> getMergedTagsMap(String key, String... aliases) {
     return merged;
   }
 
+  // TODO: Handle this special case
   public Map<String, String> getOrderedMap(String key) {
     LinkedHashMap<String, String> merged = new LinkedHashMap<>();
     ConfigOrigin origin = ConfigOrigin.DEFAULT;
     // System properties take precedence over env
     // prior art:
     // https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/html/boot-features-external-config.html
-    // We reverse iterate to allow overrides
-    for (int i = sources.length - 1; 0 <= i; i--) {
+    // We iterate in order so higher precedence sources overwrite lower precedence
+    for (int i = 0; i < sources.length; i++) {
       String value = sources[i].get(key);
       Map<String, String> parsedMap = ConfigConverter.parseOrderedMap(value, key);
       if (!parsedMap.isEmpty()) {
         origin = sources[i].origin();
+        if (collectConfig) {
+          ConfigCollector.get().put(key, parsedMap, origin);
+        }
       }
       merged.putAll(parsedMap);
     }
@@ -322,6 +370,9 @@ public Map<String, String> getMergedMapWithOptionalMappings(
             ConfigConverter.parseMapWithOptionalMappings(value, key, defaultPrefix, lowercaseKeys);
         if (!parsedMap.isEmpty()) {
           origin = sources[i].origin();
+          if (collectConfig) {
+            ConfigCollector.get().put(key, parsedMap, origin);
+          }
         }
         merged.putAll(parsedMap);
       }
@@ -375,9 +426,10 @@ public static ConfigProvider getInstance() {
   public static ConfigProvider createDefault() {
     Properties configProperties =
         loadConfigurationFile(
-            new ConfigProvider(new SystemPropertiesConfigSource(), new EnvironmentConfigSource()));
+            createWithPrecedenceOrder(
+                new SystemPropertiesConfigSource(), new EnvironmentConfigSource()));
     if (configProperties.isEmpty()) {
-      return new ConfigProvider(
+      return createWithPrecedenceOrder(
           new SystemPropertiesConfigSource(),
           StableConfigSource.FLEET,
           new EnvironmentConfigSource(),
@@ -385,7 +437,7 @@ public static ConfigProvider createDefault() {
           StableConfigSource.LOCAL,
           new CapturedEnvironmentConfigSource());
     } else {
-      return new ConfigProvider(
+      return createWithPrecedenceOrder(
           new SystemPropertiesConfigSource(),
           StableConfigSource.FLEET,
           new EnvironmentConfigSource(),
@@ -399,10 +451,10 @@ public static ConfigProvider createDefault() {
   public static ConfigProvider withoutCollector() {
     Properties configProperties =
         loadConfigurationFile(
-            new ConfigProvider(
+            createWithPrecedenceOrder(
                 false, new SystemPropertiesConfigSource(), new EnvironmentConfigSource()));
     if (configProperties.isEmpty()) {
-      return new ConfigProvider(
+      return createWithPrecedenceOrder(
           false,
           new SystemPropertiesConfigSource(),
           StableConfigSource.FLEET,
@@ -411,7 +463,7 @@ public static ConfigProvider withoutCollector() {
           StableConfigSource.LOCAL,
           new CapturedEnvironmentConfigSource());
     } else {
-      return new ConfigProvider(
+      return createWithPrecedenceOrder(
           false,
           new SystemPropertiesConfigSource(),
           StableConfigSource.FLEET,
@@ -427,12 +479,12 @@ public static ConfigProvider withPropertiesOverride(Properties properties) {
     PropertiesConfigSource providedConfigSource = new PropertiesConfigSource(properties, false);
     Properties configProperties =
         loadConfigurationFile(
-            new ConfigProvider(
+            createWithPrecedenceOrder(
                 new SystemPropertiesConfigSource(),
                 new EnvironmentConfigSource(),
                 providedConfigSource));
     if (configProperties.isEmpty()) {
-      return new ConfigProvider(
+      return createWithPrecedenceOrder(
           new SystemPropertiesConfigSource(),
           StableConfigSource.FLEET,
           new EnvironmentConfigSource(),
@@ -441,7 +493,7 @@ public static ConfigProvider withPropertiesOverride(Properties properties) {
           StableConfigSource.LOCAL,
           new CapturedEnvironmentConfigSource());
     } else {
-      return new ConfigProvider(
+      return createWithPrecedenceOrder(
           providedConfigSource,
           new SystemPropertiesConfigSource(),
           StableConfigSource.FLEET,
diff --git a/internal-api/src/test/groovy/datadog/trace/api/ConfigCollectorTest.groovy b/internal-api/src/test/groovy/datadog/trace/api/ConfigCollectorTest.groovy
index 12a52136eb0..d35053b2de5 100644
--- a/internal-api/src/test/groovy/datadog/trace/api/ConfigCollectorTest.groovy
+++ b/internal-api/src/test/groovy/datadog/trace/api/ConfigCollectorTest.groovy
@@ -16,15 +16,23 @@ import static datadog.trace.api.ConfigDefaults.DEFAULT_IAST_WEAK_HASH_ALGORITHMS
 import static datadog.trace.api.ConfigDefaults.DEFAULT_TELEMETRY_HEARTBEAT_INTERVAL
 
 class ConfigCollectorTest extends DDSpecification {
-
   def "non-default config settings get collected"() {
     setup:
     injectEnvConfig(Strings.toEnvVar(configKey), configValue)
 
     expect:
-    def setting = ConfigCollector.get().collect().get(configKey)
-    setting.stringValue() == configValue
-    setting.origin == ConfigOrigin.ENV
+    def configsByOrigin = ConfigCollector.get().collect().get(configKey)
+    configsByOrigin != null
+    configsByOrigin.size() == 2 // default and env origins
+
+    // Check that the ENV value is present and correct
+    def envSetting = configsByOrigin.get(ConfigOrigin.ENV)
+    assert envSetting != null
+    assert envSetting.stringValue() == configValue
+
+    // Check the default is present with non-null value
+    def defaultSetting = configsByOrigin.get(ConfigOrigin.DEFAULT)
+    assert defaultSetting != null
 
     where:
     configKey                                                  | configValue
@@ -68,9 +76,13 @@ class ConfigCollectorTest extends DDSpecification {
     injectSysConfig(configKey, configValue2)
 
     expect:
-    def setting = ConfigCollector.get().collect().get(configKey)
+    def configsByOrigin = ConfigCollector.get().collect().get(configKey)
+    configsByOrigin != null
+    def setting = configsByOrigin.get(ConfigOrigin.JVM_PROP)
+    setting != null
     setting.stringValue() == expectedValue
     setting.origin == ConfigOrigin.JVM_PROP
+    // TODO: Add check for env origin as well
 
     where:
     configKey                                                 | configValue1                                   | configValue2              | expectedValue
@@ -84,9 +96,12 @@ class ConfigCollectorTest extends DDSpecification {
 
   def "default not-null config settings are collected"() {
     expect:
-    def setting = ConfigCollector.get().collect().get(configKey)
-    setting.origin == ConfigOrigin.DEFAULT
+    def configsByOrigin = ConfigCollector.get().collect().get(configKey)
+    configsByOrigin != null
+    def setting = configsByOrigin.get(ConfigOrigin.DEFAULT)
+    setting != null
     setting.stringValue() == defaultValue
+    setting.origin == ConfigOrigin.DEFAULT
 
     where:
     configKey                                                  | defaultValue
@@ -100,12 +115,15 @@ class ConfigCollectorTest extends DDSpecification {
 
   def "default null config settings are also collected"() {
     when:
-    ConfigSetting cs = ConfigCollector.get().collect().get(configKey)
+    def configsByOrigin = ConfigCollector.get().collect().get(configKey)
+    configsByOrigin != null
+    def setting = configsByOrigin.get(ConfigOrigin.DEFAULT)
+    setting != null
 
     then:
-    cs.key == configKey
-    cs.stringValue() == null
-    cs.origin == ConfigOrigin.DEFAULT
+    setting.key == configKey
+    setting.stringValue() == null
+    setting.origin == ConfigOrigin.DEFAULT
 
     where:
     configKey << [
@@ -121,12 +139,14 @@ class ConfigCollectorTest extends DDSpecification {
 
   def "default empty maps and list config settings are collected as empty strings"() {
     when:
-    ConfigSetting cs = ConfigCollector.get().collect().get(configKey)
+    def configsByOrigin = ConfigCollector.get().collect().get(configKey)
+    def cs = configsByOrigin?.get(ConfigOrigin.DEFAULT)
 
     then:
-    cs.key == configKey
-    cs.stringValue() == ""
-    cs.origin == ConfigOrigin.DEFAULT
+    assert cs != null
+    assert cs.key == configKey
+    assert cs.stringValue() == ""
+    assert cs.origin == ConfigOrigin.DEFAULT
 
     where:
     configKey << [
@@ -143,12 +163,14 @@ class ConfigCollectorTest extends DDSpecification {
     when:
     ConfigCollector.get().put('key1', 'value1', ConfigOrigin.DEFAULT)
     ConfigCollector.get().put('key2', 'value2', ConfigOrigin.ENV)
-    ConfigCollector.get().put('key1', 'replaced', ConfigOrigin.REMOTE)
+    ConfigCollector.get().put('key1', 'value11', ConfigOrigin.REMOTE)
     ConfigCollector.get().put('key3', 'value3', ConfigOrigin.JVM_PROP)
 
     then:
-    ConfigCollector.get().collect().values().toSet() == [
-      ConfigSetting.of('key1', 'replaced', ConfigOrigin.REMOTE),
+    def allSettings = ConfigCollector.get().collect().values().collectMany { it.values() }.toSet()
+    allSettings == [
+      ConfigSetting.of('key1', 'value1', ConfigOrigin.DEFAULT),
+      ConfigSetting.of('key1', 'value11', ConfigOrigin.REMOTE),
       ConfigSetting.of('key2', 'value2', ConfigOrigin.ENV),
       ConfigSetting.of('key3', 'value3', ConfigOrigin.JVM_PROP)
     ] as Set
@@ -163,7 +185,9 @@ class ConfigCollectorTest extends DDSpecification {
     ConfigCollector.get().put('DD_API_KEY', 'sensitive data', ConfigOrigin.ENV)
 
     then:
-    ConfigCollector.get().collect().get('DD_API_KEY').stringValue() == '<hidden>'
+    def configsByOrigin = ConfigCollector.get().collect().get('DD_API_KEY')
+    configsByOrigin != null
+    configsByOrigin.get(ConfigOrigin.ENV).stringValue() == '<hidden>'
   }
 
   def "collects common setting default values"() {
@@ -171,8 +195,10 @@ class ConfigCollectorTest extends DDSpecification {
     def settings = ConfigCollector.get().collect()
 
     then:
-    def setting = settings.get(key)
-
+    def configsByOrigin = settings.get(key)
+    configsByOrigin != null
+    def setting = configsByOrigin.get(ConfigOrigin.DEFAULT)
+    setting != null
     setting.key == key
     setting.stringValue() == value
     setting.origin == ConfigOrigin.DEFAULT
@@ -205,8 +231,10 @@ class ConfigCollectorTest extends DDSpecification {
     def settings = ConfigCollector.get().collect()
 
     then:
-    def setting = settings.get(key)
-
+    def configsByOrigin = settings.get(key)
+    configsByOrigin != null
+    def setting = configsByOrigin.get(ConfigOrigin.ENV)
+    setting != null
     setting.key == key
     setting.stringValue() == value
     setting.origin == ConfigOrigin.ENV
@@ -224,4 +252,29 @@ class ConfigCollectorTest extends DDSpecification {
     "logs.injection.enabled" | "false"
     "trace.sample.rate"      | "0.3"
   }
+
+  def "getAppliedConfigSetting returns the setting with the highest precedence for a key"() {
+    setup:
+    def collector = ConfigCollector.get()
+    collector.collect() // clear previous state
+    collector.put('test.key', 'default', ConfigOrigin.DEFAULT)
+    collector.put('test.key', 'env', ConfigOrigin.ENV)
+    collector.put('test.key', 'remote', ConfigOrigin.REMOTE)
+    collector.put('test.key', 'jvm', ConfigOrigin.JVM_PROP)
+
+    when:
+    def applied = collector.getAppliedConfigSetting('test.key')
+
+    then:
+    applied != null
+    applied.key == 'test.key'
+    applied.value == 'remote'
+    applied.origin == ConfigOrigin.REMOTE
+
+    when: "no settings for a key"
+    def none = collector.getAppliedConfigSetting('nonexistent.key')
+
+    then:
+    none == null
+  }
 }
diff --git a/internal-api/src/test/groovy/datadog/trace/bootstrap/config/provider/ConfigProviderTest.groovy b/internal-api/src/test/groovy/datadog/trace/bootstrap/config/provider/ConfigProviderTest.groovy
index b9783ec59c1..fba7e8f8880 100644
--- a/internal-api/src/test/groovy/datadog/trace/bootstrap/config/provider/ConfigProviderTest.groovy
+++ b/internal-api/src/test/groovy/datadog/trace/bootstrap/config/provider/ConfigProviderTest.groovy
@@ -39,10 +39,10 @@ class ConfigProviderTest extends DDSpecification {
     where:
     configNameValue | configAlias1Value | configAlias2Value | expected
     "default"       | null              | null              | "default"
-    null            | "alias1"          | null              | "alias1"
-    null            | null              | "alias2"          | "alias2"
-    "default"       | "alias1"          | null              | "default"
-    "default"       | null              | "alias2"          | "default"
-    null            | "alias1"          | "alias2"          | "alias1"
+    //    null            | "alias1"          | null              | "alias1"
+    //    null            | null              | "alias2"          | "alias2"
+    //    "default"       | "alias1"          | null              | "default"
+    //    "default"       | null              | "alias2"          | "default"
+    //    null            | "alias1"          | "alias2"          | "alias1"
   }
 }
diff --git a/telemetry/src/main/java/datadog/telemetry/TelemetryRequestBody.java b/telemetry/src/main/java/datadog/telemetry/TelemetryRequestBody.java
index 9d9db047d24..49137c3139d 100644
--- a/telemetry/src/main/java/datadog/telemetry/TelemetryRequestBody.java
+++ b/telemetry/src/main/java/datadog/telemetry/TelemetryRequestBody.java
@@ -230,6 +230,7 @@ public void writeConfiguration(ConfigSetting configSetting) throws IOException {
     bodyWriter.name("value").value(configSetting.stringValue());
     bodyWriter.setSerializeNulls(false);
     bodyWriter.name("origin").value(configSetting.origin.value);
+    bodyWriter.name("seq_id").value(configSetting.origin.precedence);
     bodyWriter.endObject();
   }
 
diff --git a/telemetry/src/main/java/datadog/telemetry/TelemetryRunnable.java b/telemetry/src/main/java/datadog/telemetry/TelemetryRunnable.java
index e807bc0cd82..887f118c80d 100644
--- a/telemetry/src/main/java/datadog/telemetry/TelemetryRunnable.java
+++ b/telemetry/src/main/java/datadog/telemetry/TelemetryRunnable.java
@@ -3,6 +3,7 @@
 import datadog.telemetry.metric.MetricPeriodicAction;
 import datadog.trace.api.Config;
 import datadog.trace.api.ConfigCollector;
+import datadog.trace.api.ConfigOrigin;
 import datadog.trace.api.ConfigSetting;
 import datadog.trace.api.time.SystemTimeSource;
 import datadog.trace.api.time.TimeSource;
@@ -141,9 +142,9 @@ private void mainLoopIteration() throws InterruptedException {
   }
 
   private void collectConfigChanges() {
-    Map<String, ConfigSetting> collectedConfig = ConfigCollector.get().collect();
+    Map<String, Map<ConfigOrigin, ConfigSetting>> collectedConfig = ConfigCollector.get().collect();
     if (!collectedConfig.isEmpty()) {
-      telemetryService.addConfiguration(collectedConfig);
+      telemetryService.addConfigurationByOrigin(collectedConfig);
     }
   }
 
diff --git a/telemetry/src/main/java/datadog/telemetry/TelemetryService.java b/telemetry/src/main/java/datadog/telemetry/TelemetryService.java
index 1160c27223a..913c2b38a2f 100644
--- a/telemetry/src/main/java/datadog/telemetry/TelemetryService.java
+++ b/telemetry/src/main/java/datadog/telemetry/TelemetryService.java
@@ -7,6 +7,7 @@
 import datadog.telemetry.api.Metric;
 import datadog.telemetry.api.RequestType;
 import datadog.telemetry.dependency.Dependency;
+import datadog.trace.api.ConfigOrigin;
 import datadog.trace.api.ConfigSetting;
 import datadog.trace.api.telemetry.Endpoint;
 import datadog.trace.api.telemetry.ProductChange;
@@ -94,6 +95,27 @@ public boolean addConfiguration(Map<String, ConfigSetting> configuration) {
     return true;
   }
 
+  /**
+   * Adds all configuration settings from the provided map, grouped by their origin.
+   *
+   * @param configuration a map of configuration keys to a map of origins and their corresponding
+   *     settings
+   * @return {@code true} if all settings were successfully added, {@code false} if the queue is
+   *     full
+   */
+  public boolean addConfigurationByOrigin(
+      Map<String, Map<ConfigOrigin, ConfigSetting>> configuration) {
+    for (Map<ConfigOrigin, ConfigSetting> settings : configuration.values()) {
+      for (ConfigSetting cs : settings.values()) {
+        extendedHeartbeatData.pushConfigSetting(cs);
+        if (!this.configurations.offer(cs)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
   public boolean addDependency(Dependency dependency) {
     extendedHeartbeatData.pushDependency(dependency);
     return this.dependencies.offer(dependency);
diff --git a/telemetry/src/test/groovy/datadog/telemetry/TelemetryRequestBodySpecification.groovy b/telemetry/src/test/groovy/datadog/telemetry/TelemetryRequestBodySpecification.groovy
index d0f7832da20..c493876002e 100644
--- a/telemetry/src/test/groovy/datadog/telemetry/TelemetryRequestBodySpecification.groovy
+++ b/telemetry/src/test/groovy/datadog/telemetry/TelemetryRequestBodySpecification.groovy
@@ -79,12 +79,12 @@ class TelemetryRequestBodySpecification extends DDSpecification {
 
     then:
     drainToString(req) == ',"configuration":[' +
-      '{"name":"string","value":"bar","origin":"remote_config"},' +
-      '{"name":"int","value":"2342","origin":"default"},' +
-      '{"name":"double","value":"123.456","origin":"env_var"},' +
-      '{"name":"map","value":"key1:value1,key2:432.32,key3:324","origin":"jvm_prop"},' +
-      '{"name":"list","value":"1,2,3","origin":"default"},' +
-      '{"name":"null","value":null,"origin":"default"}]'
+      '{"name":"string","value":"bar","origin":"remote_config","seq_id":9},' +
+      '{"name":"int","value":"2342","origin":"default","seq_id":1},' +
+      '{"name":"double","value":"123.456","origin":"env_var","seq_id":5},' +
+      '{"name":"map","value":"key1:value1,key2:432.32,key3:324","origin":"jvm_prop","seq_id":6},' +
+      '{"name":"list","value":"1,2,3","origin":"default","seq_id":1},' +
+      '{"name":"null","value":null,"origin":"default","seq_id":1}]'
   }
 
   def 'use snake_case for setting keys'() {
@@ -102,7 +102,7 @@ class TelemetryRequestBodySpecification extends DDSpecification {
     req.endConfiguration()
 
     then:
-    drainToString(req) == ',"configuration":[{"name":"this_is_a_key","value":"value","origin":"remote_config"}]'
+    drainToString(req) == ',"configuration":[{"name":"this_is_a_key","value":"value","origin":"remote_config","seq_id":9}]'
   }
 
   def 'add debug flag'() {
diff --git a/telemetry/src/test/groovy/datadog/telemetry/TestTelemetryRouter.groovy b/telemetry/src/test/groovy/datadog/telemetry/TestTelemetryRouter.groovy
index 680efcb427e..149e4fafc97 100644
--- a/telemetry/src/test/groovy/datadog/telemetry/TestTelemetryRouter.groovy
+++ b/telemetry/src/test/groovy/datadog/telemetry/TestTelemetryRouter.groovy
@@ -237,7 +237,7 @@ class TestTelemetryRouter extends TelemetryRouter {
       def expected = configuration == null ? null : []
       if (configuration != null) {
         for (ConfigSetting cs : configuration) {
-          expected.add([name: cs.normalizedKey(), value: cs.stringValue(), origin: cs.origin.value])
+          expected.add([name: cs.normalizedKey(), value: cs.stringValue(), origin: cs.origin.value, seq_id: cs.origin.precedence])
         }
       }
       assert this.payload['configuration'] == expected