dd-trace 5.55.0 → 5.57.0

package/packages/dd-trace/src/config.js

@@ -8,8 +8,6 @@ const log = require('./log')
 const pkg = require('./pkg')
 const coalesce = require('koalas')
 const tagger = require('./tagger')
-const get = require('../../datadog-core/src/utils/src/get')
-const has = require('../../datadog-core/src/utils/src/has')
 const set = require('../../datadog-core/src/utils/src/set')
 const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
@@ -17,12 +15,16 @@ const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./
 const { updateConfig } = require('./telemetry')
 const telemetryMetrics = require('./telemetry/metrics')
 const { isInServerlessEnvironment, getIsGCPFunction, getIsAzureFunction } = require('./serverless')
-const { ORIGIN_KEY, GRPC_CLIENT_ERROR_STATUSES, GRPC_SERVER_ERROR_STATUSES } = require('./constants')
+const {
+  ORIGIN_KEY, GRPC_CLIENT_ERROR_STATUSES, GRPC_SERVER_ERROR_STATUSES, INSTRUMENTED_BY_SSI
+} = require('./constants')
 const { appendRules } = require('./payload-tagging/config')
 const { getEnvironmentVariable, getEnvironmentVariables } = require('./config-helper')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
+const changeTracker = {}
+
 const telemetryCounters = {
   'otel.env.hiding': {},
   'otel.env.invalid': {}
@@ -121,12 +123,12 @@ function validateEnvVarType (envVar) {
 function checkIfBothOtelAndDdEnvVarSet () {
   for (const [otelEnvVar, ddEnvVar] of Object.entries(otelDdEnvMapping)) {
     if (ddEnvVar && getEnvironmentVariable(ddEnvVar) && getEnvironmentVariable(otelEnvVar)) {
-      log.warn(`both ${ddEnvVar} and ${otelEnvVar} environment variables are set`)
+      log.warn('both %s and %s environment variables are set', ddEnvVar, otelEnvVar)
       getCounter('otel.env.hiding', ddEnvVar, otelEnvVar).inc()
     }
 
     if (getEnvironmentVariable(otelEnvVar) && !validateEnvVarType(otelEnvVar)) {
-      log.warn(`unexpected value for ${otelEnvVar} environment variable`)
+      log.warn('unexpected value for %s environment variable', otelEnvVar)
       getCounter('otel.env.invalid', ddEnvVar, otelEnvVar).inc()
     }
   }
@@ -149,6 +151,16 @@ function maybeFile (filepath) {
   }
 }
 
+function maybeJsonFile (filepath) {
+  const file = maybeFile(filepath)
+  if (!file) return
+  try {
+    return JSON.parse(file)
+  } catch (e) {
+    log.error('Error parsing JSON file %s', filepath, e)
+  }
+}
+
 function safeJsonParse (input) {
   try {
     return JSON.parse(input)
@@ -163,9 +175,7 @@ function validateNamingVersion (versionString) {
     return defaultNamingVersion
   }
   if (!namingVersions.has(versionString)) {
-    log.warn(
-      `Unexpected input for config.spanAttributeSchema, picked default ${defaultNamingVersion}`
-    )
+    log.warn('Unexpected input for config.spanAttributeSchema, picked default', defaultNamingVersion)
     return defaultNamingVersion
   }
   return versionString
@@ -231,6 +241,16 @@ function reformatSpanSamplingRules (rules) {
   })
 }
 
+const sourcesOrder = [
+  { containerProperty: '_remote', origin: 'remote_config', unprocessedProperty: '_remoteUnprocessed' },
+  { containerProperty: '_options', origin: 'code', unprocessedProperty: '_optsUnprocessed' },
+  { containerProperty: '_fleetStableConfig', origin: 'fleet_stable_config' },
+  { containerProperty: '_env', origin: 'env_var', unprocessedProperty: '_envUnprocessed' },
+  { containerProperty: '_localStableConfig', origin: 'local_stable_config' },
+  { containerProperty: '_calculated', origin: 'calculated' },
+  { containerProperty: '_defaults', origin: 'default' }
+]
+
 class Config {
   constructor (options = {}) {
     if (!isInServerlessEnvironment()) {
@@ -274,9 +294,8 @@ class Config {
       getEnvironmentVariable('DD_TRACE_PROPAGATION_STYLE_EXTRACT')
     )) {
       log.warn(
-        'Use either the DD_TRACE_PROPAGATION_STYLE environment variable or separate ' +
-        'DD_TRACE_PROPAGATION_STYLE_INJECT and DD_TRACE_PROPAGATION_STYLE_EXTRACT ' +
-        'environment variables'
+        // eslint-disable-next-line @stylistic/max-len
+        'Use either the DD_TRACE_PROPAGATION_STYLE environment variable or separate DD_TRACE_PROPAGATION_STYLE_INJECT and DD_TRACE_PROPAGATION_STYLE_EXTRACT environment variables'
       )
     }
     const PROPAGATION_STYLE_INJECT = propagationStyle(
@@ -292,6 +311,18 @@ class Config {
       }
     }
 
+    if (typeof options.runtimeMetrics === 'boolean') {
+      options.runtimeMetrics = {
+        enabled: options.runtimeMetrics
+      }
+    }
+
+    if (typeof options.runtimeMetrics?.gc === 'boolean') {
+      options.runtimeMetrics.gc = {
+        enabled: options.runtimeMetrics.gc
+      }
+    }
+
     const DD_INSTRUMENTATION_INSTALL_ID = coalesce(
       getEnvironmentVariable('DD_INSTRUMENTATION_INSTALL_ID'),
       null
@@ -449,150 +480,155 @@ class Config {
 
     const defaults = setHiddenProperty(this, '_defaults', {})
 
-    this._setBoolean(defaults, 'apmTracingEnabled', true)
-    this._setValue(defaults, 'appsec.apiSecurity.enabled', true)
-    this._setValue(defaults, 'appsec.apiSecurity.sampleDelay', 30)
-    this._setValue(defaults, 'appsec.blockedTemplateGraphql')
-    this._setValue(defaults, 'appsec.blockedTemplateHtml')
-    this._setValue(defaults, 'appsec.blockedTemplateJson')
-    this._setValue(defaults, 'appsec.enabled')
-    this._setValue(defaults, 'appsec.eventTracking.mode', 'identification')
-    this._setValue(defaults, 'appsec.extendedHeadersCollection.enabled', false)
-    this._setValue(defaults, 'appsec.extendedHeadersCollection.redaction', true)
-    this._setValue(defaults, 'appsec.extendedHeadersCollection.maxHeaders', 50)
-    this._setValue(defaults, 'appsec.obfuscatorKeyRegex', defaultWafObfuscatorKeyRegex)
-    this._setValue(defaults, 'appsec.obfuscatorValueRegex', defaultWafObfuscatorValueRegex)
-    this._setValue(defaults, 'appsec.rasp.enabled', true)
-    this._setValue(defaults, 'appsec.rasp.bodyCollection', false)
-    this._setValue(defaults, 'appsec.rateLimit', 100)
-    this._setValue(defaults, 'appsec.rules')
-    this._setValue(defaults, 'appsec.sca.enabled', null)
-    this._setValue(defaults, 'appsec.stackTrace.enabled', true)
-    this._setValue(defaults, 'appsec.stackTrace.maxDepth', 32)
-    this._setValue(defaults, 'appsec.stackTrace.maxStackTraces', 2)
-    this._setValue(defaults, 'appsec.wafTimeout', 5e3) // µs
-    this._setValue(defaults, 'baggageMaxBytes', 8192)
-    this._setValue(defaults, 'baggageMaxItems', 64)
-    this._setValue(defaults, 'baggageTagKeys', 'user.id,session.id,account.id')
-    this._setValue(defaults, 'ciVisibilityTestSessionName', '')
-    this._setValue(defaults, 'clientIpEnabled', false)
-    this._setValue(defaults, 'clientIpHeader', null)
-    this._setValue(defaults, 'crashtracking.enabled', true)
-    this._setValue(defaults, 'codeOriginForSpans.enabled', true)
-    this._setValue(defaults, 'codeOriginForSpans.experimental.exit_spans.enabled', false)
-    this._setValue(defaults, 'dbmPropagationMode', 'disabled')
-    this._setValue(defaults, 'dogstatsd.hostname', '127.0.0.1')
-    this._setValue(defaults, 'dogstatsd.port', '8125')
-    this._setValue(defaults, 'dsmEnabled', false)
-    this._setValue(defaults, 'dynamicInstrumentation.enabled', false)
-    this._setValue(defaults, 'dynamicInstrumentation.redactedIdentifiers', [])
-    this._setValue(defaults, 'dynamicInstrumentation.redactionExcludedIdentifiers', [])
-    this._setValue(defaults, 'env')
-    this._setValue(defaults, 'experimental.enableGetRumData', false)
-    this._setValue(defaults, 'experimental.exporter')
-    this._setValue(defaults, 'experimental.runtimeId', false)
-    this._setValue(defaults, 'flushInterval', 2000)
-    this._setValue(defaults, 'flushMinSpans', 1000)
-    this._setValue(defaults, 'gitMetadataEnabled', true)
-    this._setValue(defaults, 'graphqlErrorExtensions', [])
-    this._setValue(defaults, 'grpc.client.error.statuses', GRPC_CLIENT_ERROR_STATUSES)
-    this._setValue(defaults, 'grpc.server.error.statuses', GRPC_SERVER_ERROR_STATUSES)
-    this._setValue(defaults, 'headerTags', [])
-    this._setValue(defaults, 'hostname', '127.0.0.1')
-    this._setValue(defaults, 'iast.dbRowsToTaint', 1)
-    this._setValue(defaults, 'iast.deduplicationEnabled', true)
-    this._setValue(defaults, 'iast.enabled', false)
-    this._setValue(defaults, 'iast.maxConcurrentRequests', 2)
-    this._setValue(defaults, 'iast.maxContextOperations', 2)
-    this._setValue(defaults, 'iast.redactionEnabled', true)
-    this._setValue(defaults, 'iast.redactionNamePattern', null)
-    this._setValue(defaults, 'iast.redactionValuePattern', null)
-    this._setValue(defaults, 'iast.requestSampling', 30)
-    this._setValue(defaults, 'iast.securityControlsConfiguration', null)
-    this._setValue(defaults, 'iast.telemetryVerbosity', 'INFORMATION')
-    this._setValue(defaults, 'iast.stackTrace.enabled', true)
-    this._setValue(defaults, 'injectionEnabled', [])
-    this._setValue(defaults, 'isAzureFunction', false)
-    this._setValue(defaults, 'isCiVisibility', false)
-    this._setValue(defaults, 'isEarlyFlakeDetectionEnabled', false)
-    this._setValue(defaults, 'isFlakyTestRetriesEnabled', false)
-    this._setValue(defaults, 'flakyTestRetriesCount', 5)
-    this._setValue(defaults, 'isGCPFunction', false)
-    this._setValue(defaults, 'isGitUploadEnabled', false)
-    this._setValue(defaults, 'isIntelligentTestRunnerEnabled', false)
-    this._setValue(defaults, 'isManualApiEnabled', false)
-    this._setValue(defaults, 'langchain.spanCharLimit', 128)
-    this._setValue(defaults, 'langchain.spanPromptCompletionSampleRate', 1)
-    this._setValue(defaults, 'llmobs.agentlessEnabled')
-    this._setValue(defaults, 'llmobs.enabled', false)
-    this._setValue(defaults, 'llmobs.mlApp')
-    this._setValue(defaults, 'ciVisibilityTestSessionName', '')
-    this._setValue(defaults, 'ciVisAgentlessLogSubmissionEnabled', false)
-    this._setValue(defaults, 'legacyBaggageEnabled', true)
-    this._setValue(defaults, 'isTestDynamicInstrumentationEnabled', false)
-    this._setValue(defaults, 'isServiceUserProvided', false)
-    this._setValue(defaults, 'testManagementAttemptToFixRetries', 20)
-    this._setValue(defaults, 'isTestManagementEnabled', false)
-    this._setValue(defaults, 'isImpactedTestsEnabled', false)
-    this._setValue(defaults, 'logInjection', false)
-    this._setValue(defaults, 'lookup')
-    this._setValue(defaults, 'inferredProxyServicesEnabled', false)
-    this._setValue(defaults, 'memcachedCommandEnabled', false)
-    this._setValue(defaults, 'middlewareTracingEnabled', true)
-    this._setValue(defaults, 'openAiLogsEnabled', false)
-    this._setValue(defaults, 'openai.spanCharLimit', 128)
-    this._setValue(defaults, 'peerServiceMapping', {})
-    this._setValue(defaults, 'plugins', true)
-    this._setValue(defaults, 'port', '8126')
-    this._setValue(defaults, 'profiling.enabled')
-    this._setValue(defaults, 'profiling.exporters', 'agent')
-    this._setValue(defaults, 'profiling.sourceMap', true)
-    this._setValue(defaults, 'profiling.longLivedThreshold')
-    this._setValue(defaults, 'protocolVersion', '0.4')
-    this._setValue(defaults, 'queryStringObfuscation', qsRegex)
-    this._setValue(defaults, 'remoteConfig.enabled', true)
-    this._setValue(defaults, 'remoteConfig.pollInterval', 5) // seconds
-    this._setValue(defaults, 'reportHostname', false)
-    this._setValue(defaults, 'runtimeMetrics', false)
-    this._setValue(defaults, 'sampleRate')
-    this._setValue(defaults, 'sampler.rateLimit', 100)
-    this._setValue(defaults, 'sampler.rules', [])
-    this._setValue(defaults, 'sampler.spanSamplingRules', [])
-    this._setValue(defaults, 'scope')
-    this._setValue(defaults, 'service', service)
-    this._setValue(defaults, 'serviceMapping', {})
-    this._setValue(defaults, 'site', 'datadoghq.com')
-    this._setValue(defaults, 'spanAttributeSchema', 'v0')
-    this._setValue(defaults, 'spanComputePeerService', false)
-    this._setValue(defaults, 'spanLeakDebug', 0)
-    this._setValue(defaults, 'spanRemoveIntegrationFromService', false)
-    this._setValue(defaults, 'startupLogs', false)
-    this._setValue(defaults, 'stats.enabled', false)
-    this._setValue(defaults, 'tags', {})
-    this._setValue(defaults, 'tagsHeaderMaxLength', 512)
-    this._setValue(defaults, 'telemetry.debug', false)
-    this._setValue(defaults, 'telemetry.dependencyCollection', true)
-    this._setValue(defaults, 'telemetry.enabled', true)
-    this._setValue(defaults, 'telemetry.heartbeatInterval', 60_000)
-    this._setValue(defaults, 'telemetry.logCollection', true)
-    this._setValue(defaults, 'telemetry.metrics', true)
-    this._setValue(defaults, 'traceEnabled', true)
-    this._setValue(defaults, 'traceId128BitGenerationEnabled', true)
-    this._setValue(defaults, 'traceId128BitLoggingEnabled', true)
-    this._setValue(defaults, 'tracePropagationExtractFirst', false)
-    this._setValue(defaults, 'tracePropagationBehaviorExtract', 'continue')
-    this._setValue(defaults, 'tracePropagationStyle.inject', ['datadog', 'tracecontext', 'baggage'])
-    this._setValue(defaults, 'tracePropagationStyle.extract', ['datadog', 'tracecontext', 'baggage'])
-    this._setValue(defaults, 'tracePropagationStyle.otelPropagators', false)
-    this._setValue(defaults, 'tracing', true)
-    this._setValue(defaults, 'url')
-    this._setValue(defaults, 'version', pkg.version)
-    this._setValue(defaults, 'instrumentation_config_id')
-    this._setValue(defaults, 'vertexai.spanCharLimit', 128)
-    this._setValue(defaults, 'vertexai.spanPromptCompletionSampleRate', 1)
-    this._setValue(defaults, 'trace.aws.addSpanPointers', true)
-    this._setValue(defaults, 'trace.dynamoDb.tablePrimaryKeys')
-    this._setValue(defaults, 'trace.nativeSpanEvents', false)
+    defaults.apmTracingEnabled = true
+    defaults['appsec.apiSecurity.enabled'] = true
+    defaults['appsec.apiSecurity.sampleDelay'] = 30
+    defaults['appsec.blockedTemplateGraphql'] = undefined
+    defaults['appsec.blockedTemplateHtml'] = undefined
+    defaults['appsec.blockedTemplateJson'] = undefined
+    defaults['appsec.enabled'] = undefined
+    defaults['appsec.eventTracking.mode'] = 'identification'
+    defaults['appsec.extendedHeadersCollection.enabled'] = false
+    defaults['appsec.extendedHeadersCollection.redaction'] = true
+    defaults['appsec.extendedHeadersCollection.maxHeaders'] = 50
+    defaults['appsec.obfuscatorKeyRegex'] = defaultWafObfuscatorKeyRegex
+    defaults['appsec.obfuscatorValueRegex'] = defaultWafObfuscatorValueRegex
+    defaults['appsec.rasp.enabled'] = true
+    defaults['appsec.rasp.bodyCollection'] = false
+    defaults['appsec.rateLimit'] = 100
+    defaults['appsec.rules'] = undefined
+    defaults['appsec.sca.enabled'] = null
+    defaults['appsec.stackTrace.enabled'] = true
+    defaults['appsec.stackTrace.maxDepth'] = 32
+    defaults['appsec.stackTrace.maxStackTraces'] = 2
+    defaults['appsec.wafTimeout'] = 5e3 // µs
+    defaults.baggageMaxBytes = 8192
+    defaults.baggageMaxItems = 64
+    defaults.baggageTagKeys = 'user.id,session.id,account.id'
+    defaults.ciVisibilityTestSessionName = ''
+    defaults.clientIpEnabled = false
+    defaults.clientIpHeader = null
+    defaults['crashtracking.enabled'] = true
+    defaults['codeOriginForSpans.enabled'] = true
+    defaults['codeOriginForSpans.experimental.exit_spans.enabled'] = false
+    defaults.dbmPropagationMode = 'disabled'
+    defaults['dogstatsd.hostname'] = '127.0.0.1'
+    defaults['dogstatsd.port'] = '8125'
+    defaults.dsmEnabled = false
+    defaults['dynamicInstrumentation.enabled'] = false
+    defaults['dynamicInstrumentation.redactedIdentifiers'] = []
+    defaults['dynamicInstrumentation.redactionExcludedIdentifiers'] = []
+    defaults['dynamicInstrumentation.uploadIntervalSeconds'] = 1
+    defaults.env = undefined
+    defaults['experimental.enableGetRumData'] = false
+    defaults['experimental.exporter'] = undefined
+    defaults.flushInterval = 2000
+    defaults.flushMinSpans = 1000
+    defaults.gitMetadataEnabled = true
+    defaults.graphqlErrorExtensions = []
+    defaults['grpc.client.error.statuses'] = GRPC_CLIENT_ERROR_STATUSES
+    defaults['grpc.server.error.statuses'] = GRPC_SERVER_ERROR_STATUSES
+    defaults.headerTags = []
+    defaults.hostname = '127.0.0.1'
+    defaults['iast.dbRowsToTaint'] = 1
+    defaults['iast.deduplicationEnabled'] = true
+    defaults['iast.enabled'] = false
+    defaults['iast.maxConcurrentRequests'] = 2
+    defaults['iast.maxContextOperations'] = 2
+    defaults['iast.redactionEnabled'] = true
+    defaults['iast.redactionNamePattern'] = null
+    defaults['iast.redactionValuePattern'] = null
+    defaults['iast.requestSampling'] = 30
+    defaults['iast.securityControlsConfiguration'] = null
+    defaults['iast.telemetryVerbosity'] = 'INFORMATION'
+    defaults['iast.stackTrace.enabled'] = true
+    defaults.injectionEnabled = []
+    defaults.instrumentationSource = 'manual'
+    defaults.injectForce = null
+    defaults.isAzureFunction = false
+    defaults.isCiVisibility = false
+    defaults.isEarlyFlakeDetectionEnabled = false
+    defaults.isFlakyTestRetriesEnabled = false
+    defaults.flakyTestRetriesCount = 5
+    defaults.isGCPFunction = false
+    defaults.isGitUploadEnabled = false
+    defaults.isIntelligentTestRunnerEnabled = false
+    defaults.isManualApiEnabled = false
+    defaults['langchain.spanCharLimit'] = 128
+    defaults['langchain.spanPromptCompletionSampleRate'] = 1
+    defaults['llmobs.agentlessEnabled'] = undefined
+    defaults['llmobs.enabled'] = false
+    defaults['llmobs.mlApp'] = undefined
+    defaults.ciVisibilityTestSessionName = ''
+    defaults.ciVisAgentlessLogSubmissionEnabled = false
+    defaults.legacyBaggageEnabled = true
+    defaults.isTestDynamicInstrumentationEnabled = false
+    defaults.isServiceUserProvided = false
+    defaults.testManagementAttemptToFixRetries = 20
+    defaults.isTestManagementEnabled = false
+    defaults.isImpactedTestsEnabled = false
+    defaults.logInjection = 'structured'
+    defaults.lookup = undefined
+    defaults.inferredProxyServicesEnabled = false
+    defaults.memcachedCommandEnabled = false
+    defaults.middlewareTracingEnabled = true
+    defaults.openAiLogsEnabled = false
+    defaults['openai.spanCharLimit'] = 128
+    defaults.peerServiceMapping = {}
+    defaults.plugins = true
+    defaults.port = '8126'
+    defaults['profiling.enabled'] = undefined
+    defaults['profiling.exporters'] = 'agent'
+    defaults['profiling.sourceMap'] = true
+    defaults['profiling.longLivedThreshold'] = undefined
+    defaults.protocolVersion = '0.4'
+    defaults.queryStringObfuscation = qsRegex
+    defaults['remoteConfig.enabled'] = true
+    defaults['remoteConfig.pollInterval'] = 5 // seconds
+    defaults.reportHostname = false
+    defaults['runtimeMetrics.enabled'] = false
+    defaults['runtimeMetrics.eventLoop'] = true
+    defaults['runtimeMetrics.gc'] = true
+    defaults.runtimeMetricsRuntimeId = false
+    defaults.sampleRate = undefined
+    defaults['sampler.rateLimit'] = 100
+    defaults['sampler.rules'] = []
+    defaults['sampler.spanSamplingRules'] = []
+    defaults.scope = undefined
+    defaults.service = service
+    defaults.serviceMapping = {}
+    defaults.site = 'datadoghq.com'
+    defaults.spanAttributeSchema = 'v0'
+    defaults.spanComputePeerService = false
+    defaults.spanLeakDebug = 0
+    defaults.spanRemoveIntegrationFromService = false
+    defaults.startupLogs = false
+    defaults['stats.enabled'] = false
+    defaults.tags = {}
+    defaults.tagsHeaderMaxLength = 512
+    defaults['telemetry.debug'] = false
+    defaults['telemetry.dependencyCollection'] = true
+    defaults['telemetry.enabled'] = true
+    defaults['telemetry.heartbeatInterval'] = 60_000
+    defaults['telemetry.logCollection'] = true
+    defaults['telemetry.metrics'] = true
+    defaults.traceEnabled = true
+    defaults.traceId128BitGenerationEnabled = true
+    defaults.traceId128BitLoggingEnabled = true
+    defaults.tracePropagationExtractFirst = false
+    defaults.tracePropagationBehaviorExtract = 'continue'
+    defaults['tracePropagationStyle.inject'] = ['datadog', 'tracecontext', 'baggage']
+    defaults['tracePropagationStyle.extract'] = ['datadog', 'tracecontext', 'baggage']
+    defaults['tracePropagationStyle.otelPropagators'] = false
+    defaults.tracing = true
+    defaults.url = undefined
+    defaults.version = pkg.version
+    defaults.instrumentation_config_id = undefined
+    defaults['vertexai.spanCharLimit'] = 128
+    defaults['vertexai.spanPromptCompletionSampleRate'] = 1
+    defaults['trace.aws.addSpanPointers'] = true
+    defaults['trace.dynamoDb.tablePrimaryKeys'] = undefined
+    defaults['trace.nativeSpanEvents'] = false
   }
 
   _applyLocalStableConfig () {
@@ -629,7 +665,7 @@ class Config {
     this._setBoolean(obj, 'logInjection', DD_LOGS_INJECTION)
     const profilingEnabled = normalizeProfilingEnabledValue(DD_PROFILING_ENABLED)
     this._setString(obj, 'profiling.enabled', profilingEnabled)
-    this._setBoolean(obj, 'runtimeMetrics', DD_RUNTIME_METRICS_ENABLED)
+    this._setBoolean(obj, 'runtimeMetrics.enabled', DD_RUNTIME_METRICS_ENABLED)
     this._setString(obj, 'service', DD_SERVICE)
     this._setString(obj, 'version', DD_VERSION)
   }
@@ -670,6 +706,7 @@ class Config {
       DD_DYNAMIC_INSTRUMENTATION_ENABLED,
       DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS,
       DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS,
+      DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS,
       DD_ENV,
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED,
       DD_PROFILING_ENABLED,
@@ -689,6 +726,7 @@ class Config {
       DD_IAST_TELEMETRY_VERBOSITY,
       DD_IAST_STACK_TRACE_ENABLED,
       DD_INJECTION_ENABLED,
+      DD_INJECT_FORCE,
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
@@ -705,6 +743,8 @@ class Config {
       DD_REMOTE_CONFIGURATION_ENABLED,
       DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS,
       DD_RUNTIME_METRICS_ENABLED,
+      DD_RUNTIME_METRICS_EVENT_LOOP_ENABLED,
+      DD_RUNTIME_METRICS_GC_ENABLED,
       DD_SERVICE,
       DD_SERVICE_MAPPING,
       DD_SITE,
@@ -730,7 +770,7 @@ class Config {
       DD_TRACE_ENABLED,
       DD_TRACE_EXPERIMENTAL_EXPORTER,
       DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED,
-      DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED,
+      DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED,
       DD_TRACE_GIT_METADATA_ENABLED,
       DD_TRACE_GLOBAL_TAGS,
       DD_TRACE_GRAPHQL_ERROR_EXTENSIONS,
@@ -785,11 +825,11 @@ class Config {
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED && isFalse(DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED)
     ))
     this._setBoolean(env, 'appsec.apiSecurity.enabled', DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED))
-    this._setValue(env, 'appsec.apiSecurity.sampleDelay', maybeFloat(DD_API_SECURITY_SAMPLE_DELAY))
-    this._setValue(env, 'appsec.blockedTemplateGraphql', maybeFile(DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON))
-    this._setValue(env, 'appsec.blockedTemplateHtml', maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML))
+    env['appsec.apiSecurity.sampleDelay'] = maybeFloat(DD_API_SECURITY_SAMPLE_DELAY)
+    env['appsec.blockedTemplateGraphql'] = maybeFile(DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON)
+    env['appsec.blockedTemplateHtml'] = maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML)
     this._envUnprocessed['appsec.blockedTemplateHtml'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML
-    this._setValue(env, 'appsec.blockedTemplateJson', maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON))
+    env['appsec.blockedTemplateJson'] = maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON)
     this._envUnprocessed['appsec.blockedTemplateJson'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON
     this._setBoolean(env, 'appsec.enabled', DD_APPSEC_ENABLED)
     this._setString(env, 'appsec.eventTracking.mode', DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE)
@@ -799,27 +839,27 @@ class Config {
       'appsec.extendedHeadersCollection.redaction',
       DD_APPSEC_HEADER_COLLECTION_REDACTION_ENABLED
     )
-    this._setValue(env, 'appsec.extendedHeadersCollection.maxHeaders', maybeInt(DD_APPSEC_MAX_COLLECTED_HEADERS))
+    env['appsec.extendedHeadersCollection.maxHeaders'] = maybeInt(DD_APPSEC_MAX_COLLECTED_HEADERS)
     this._envUnprocessed['appsec.extendedHeadersCollection.maxHeaders'] = DD_APPSEC_MAX_COLLECTED_HEADERS
     this._setString(env, 'appsec.obfuscatorKeyRegex', DD_APPSEC_OBFUSCATION_PARAMETER_KEY_REGEXP)
     this._setString(env, 'appsec.obfuscatorValueRegex', DD_APPSEC_OBFUSCATION_PARAMETER_VALUE_REGEXP)
     this._setBoolean(env, 'appsec.rasp.enabled', DD_APPSEC_RASP_ENABLED)
     this._setBoolean(env, 'appsec.rasp.bodyCollection', DD_APPSEC_RASP_COLLECT_REQUEST_BODY)
-    this._setValue(env, 'appsec.rateLimit', maybeInt(DD_APPSEC_TRACE_RATE_LIMIT))
+    env['appsec.rateLimit'] = maybeInt(DD_APPSEC_TRACE_RATE_LIMIT)
     this._envUnprocessed['appsec.rateLimit'] = DD_APPSEC_TRACE_RATE_LIMIT
     this._setString(env, 'appsec.rules', DD_APPSEC_RULES)
     // DD_APPSEC_SCA_ENABLED is never used locally, but only sent to the backend
     this._setBoolean(env, 'appsec.sca.enabled', DD_APPSEC_SCA_ENABLED)
     this._setBoolean(env, 'appsec.stackTrace.enabled', DD_APPSEC_STACK_TRACE_ENABLED)
-    this._setValue(env, 'appsec.stackTrace.maxDepth', maybeInt(DD_APPSEC_MAX_STACK_TRACE_DEPTH))
+    env['appsec.stackTrace.maxDepth'] = maybeInt(DD_APPSEC_MAX_STACK_TRACE_DEPTH)
     this._envUnprocessed['appsec.stackTrace.maxDepth'] = DD_APPSEC_MAX_STACK_TRACE_DEPTH
-    this._setValue(env, 'appsec.stackTrace.maxStackTraces', maybeInt(DD_APPSEC_MAX_STACK_TRACES))
+    env['appsec.stackTrace.maxStackTraces'] = maybeInt(DD_APPSEC_MAX_STACK_TRACES)
     this._envUnprocessed['appsec.stackTrace.maxStackTraces'] = DD_APPSEC_MAX_STACK_TRACES
-    this._setValue(env, 'appsec.wafTimeout', maybeInt(DD_APPSEC_WAF_TIMEOUT))
+    env['appsec.wafTimeout'] = maybeInt(DD_APPSEC_WAF_TIMEOUT)
     this._envUnprocessed['appsec.wafTimeout'] = DD_APPSEC_WAF_TIMEOUT
-    this._setValue(env, 'baggageMaxBytes', DD_TRACE_BAGGAGE_MAX_BYTES)
-    this._setValue(env, 'baggageMaxItems', DD_TRACE_BAGGAGE_MAX_ITEMS)
-    this._setValue(env, 'baggageTagKeys', DD_TRACE_BAGGAGE_TAG_KEYS)
+    env.baggageMaxBytes = DD_TRACE_BAGGAGE_MAX_BYTES
+    env.baggageMaxItems = DD_TRACE_BAGGAGE_MAX_ITEMS
+    env.baggageTagKeys = DD_TRACE_BAGGAGE_TAG_KEYS
     this._setBoolean(env, 'clientIpEnabled', DD_TRACE_CLIENT_IP_ENABLED)
     this._setString(env, 'clientIpHeader', DD_TRACE_CLIENT_IP_HEADER?.toLowerCase())
     this._setBoolean(env, 'crashtracking.enabled', coalesce(
@@ -843,44 +883,44 @@ class Config {
       'dynamicInstrumentation.redactionExcludedIdentifiers',
       DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS
     )
+    env['dynamicInstrumentation.uploadIntervalSeconds'] = maybeFloat(DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS)
+    this._envUnprocessed['dynamicInstrumentation.uploadInterval'] = DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS
     this._setString(env, 'env', DD_ENV || tags.env)
     this._setBoolean(env, 'traceEnabled', DD_TRACE_ENABLED)
     this._setBoolean(env, 'experimental.enableGetRumData', DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED)
     this._setString(env, 'experimental.exporter', DD_TRACE_EXPERIMENTAL_EXPORTER)
-    this._setBoolean(env, 'experimental.runtimeId', DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED)
-    if (AWS_LAMBDA_FUNCTION_NAME) this._setValue(env, 'flushInterval', 0)
-    this._setValue(env, 'flushMinSpans', maybeInt(DD_TRACE_PARTIAL_FLUSH_MIN_SPANS))
+    if (AWS_LAMBDA_FUNCTION_NAME) env.flushInterval = 0
+    env.flushMinSpans = maybeInt(DD_TRACE_PARTIAL_FLUSH_MIN_SPANS)
     this._envUnprocessed.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this._setBoolean(env, 'gitMetadataEnabled', DD_TRACE_GIT_METADATA_ENABLED)
     this._setIntegerRangeSet(env, 'grpc.client.error.statuses', DD_GRPC_CLIENT_ERROR_STATUSES)
     this._setIntegerRangeSet(env, 'grpc.server.error.statuses', DD_GRPC_SERVER_ERROR_STATUSES)
     this._setArray(env, 'headerTags', DD_TRACE_HEADER_TAGS)
     this._setString(env, 'hostname', DD_AGENT_HOST)
-    this._setValue(env, 'iast.dbRowsToTaint', maybeInt(DD_IAST_DB_ROWS_TO_TAINT))
+    env['iast.dbRowsToTaint'] = maybeInt(DD_IAST_DB_ROWS_TO_TAINT)
     this._setBoolean(env, 'iast.deduplicationEnabled', DD_IAST_DEDUPLICATION_ENABLED)
     this._setBoolean(env, 'iast.enabled', DD_IAST_ENABLED)
-    this._setValue(env, 'iast.maxConcurrentRequests', maybeInt(DD_IAST_MAX_CONCURRENT_REQUESTS))
+    env['iast.maxConcurrentRequests'] = maybeInt(DD_IAST_MAX_CONCURRENT_REQUESTS)
     this._envUnprocessed['iast.maxConcurrentRequests'] = DD_IAST_MAX_CONCURRENT_REQUESTS
-    this._setValue(env, 'iast.maxContextOperations', maybeInt(DD_IAST_MAX_CONTEXT_OPERATIONS))
+    env['iast.maxContextOperations'] = maybeInt(DD_IAST_MAX_CONTEXT_OPERATIONS)
     this._envUnprocessed['iast.maxContextOperations'] = DD_IAST_MAX_CONTEXT_OPERATIONS
     this._setBoolean(env, 'iast.redactionEnabled', DD_IAST_REDACTION_ENABLED && !isFalse(DD_IAST_REDACTION_ENABLED))
     this._setString(env, 'iast.redactionNamePattern', DD_IAST_REDACTION_NAME_PATTERN)
     this._setString(env, 'iast.redactionValuePattern', DD_IAST_REDACTION_VALUE_PATTERN)
     const iastRequestSampling = maybeInt(DD_IAST_REQUEST_SAMPLING)
     if (iastRequestSampling > -1 && iastRequestSampling < 101) {
-      this._setValue(env, 'iast.requestSampling', iastRequestSampling)
+      env['iast.requestSampling'] = iastRequestSampling
     }
     this._envUnprocessed['iast.requestSampling'] = DD_IAST_REQUEST_SAMPLING
     this._setString(env, 'iast.securityControlsConfiguration', DD_IAST_SECURITY_CONTROLS_CONFIGURATION)
     this._setString(env, 'iast.telemetryVerbosity', DD_IAST_TELEMETRY_VERBOSITY)
     this._setBoolean(env, 'iast.stackTrace.enabled', DD_IAST_STACK_TRACE_ENABLED)
     this._setArray(env, 'injectionEnabled', DD_INJECTION_ENABLED)
+    this._setBoolean(env, 'injectForce', DD_INJECT_FORCE)
     this._setBoolean(env, 'isAzureFunction', getIsAzureFunction())
     this._setBoolean(env, 'isGCPFunction', getIsGCPFunction())
-    this._setValue(env, 'langchain.spanCharLimit', maybeInt(DD_LANGCHAIN_SPAN_CHAR_LIMIT))
-    this._setValue(
-      env, 'langchain.spanPromptCompletionSampleRate', maybeFloat(DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE)
-    )
+    env['langchain.spanCharLimit'] = maybeInt(DD_LANGCHAIN_SPAN_CHAR_LIMIT)
+    env['langchain.spanPromptCompletionSampleRate'] = maybeFloat(DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE)
     this._setBoolean(env, 'legacyBaggageEnabled', DD_TRACE_LEGACY_BAGGAGE_ENABLED)
     this._setBoolean(env, 'llmobs.agentlessEnabled', DD_LLMOBS_AGENTLESS_ENABLED)
     this._setBoolean(env, 'llmobs.enabled', DD_LLMOBS_ENABLED)
@@ -890,12 +930,12 @@ class Config {
     this._setBoolean(env, 'memcachedCommandEnabled', DD_TRACE_MEMCACHED_COMMAND_ENABLED)
     this._setBoolean(env, 'middlewareTracingEnabled', DD_TRACE_MIDDLEWARE_TRACING_ENABLED)
     this._setBoolean(env, 'openAiLogsEnabled', DD_OPENAI_LOGS_ENABLED)
-    this._setValue(env, 'openai.spanCharLimit', maybeInt(DD_OPENAI_SPAN_CHAR_LIMIT))
+    env['openai.spanCharLimit'] = maybeInt(DD_OPENAI_SPAN_CHAR_LIMIT)
     this._envUnprocessed.openaiSpanCharLimit = DD_OPENAI_SPAN_CHAR_LIMIT
     if (DD_TRACE_PEER_SERVICE_MAPPING) {
-      this._setValue(env, 'peerServiceMapping', Object.fromEntries(
+      env.peerServiceMapping = Object.fromEntries(
         DD_TRACE_PEER_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
-      ))
+      )
       this._envUnprocessed.peerServiceMapping = DD_TRACE_PEER_SERVICE_MAPPING
     }
     this._setString(env, 'port', DD_TRACE_AGENT_PORT)
@@ -910,7 +950,7 @@ class Config {
     this._setBoolean(env, 'profiling.sourceMap', DD_PROFILING_SOURCE_MAP && !isFalse(DD_PROFILING_SOURCE_MAP))
     if (DD_INTERNAL_PROFILING_LONG_LIVED_THRESHOLD) {
       // This is only used in testing to not have to wait 30s
-      this._setValue(env, 'profiling.longLivedThreshold', Number(DD_INTERNAL_PROFILING_LONG_LIVED_THRESHOLD))
+      env['profiling.longLivedThreshold'] = Number(DD_INTERNAL_PROFILING_LONG_LIVED_THRESHOLD)
     }
 
     this._setString(env, 'protocolVersion', DD_TRACE_AGENT_PROTOCOL_VERSION)
@@ -919,30 +959,33 @@ class Config {
       DD_REMOTE_CONFIGURATION_ENABLED,
       !this._isInServerlessEnvironment()
     ))
-    this._setValue(env, 'remoteConfig.pollInterval', maybeFloat(DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS))
+    env['remoteConfig.pollInterval'] = maybeFloat(DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS)
     this._envUnprocessed['remoteConfig.pollInterval'] = DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS
     this._setBoolean(env, 'reportHostname', DD_TRACE_REPORT_HOSTNAME)
     // only used to explicitly set runtimeMetrics to false
     const otelSetRuntimeMetrics = String(OTEL_METRICS_EXPORTER).toLowerCase() === 'none'
       ? false
       : undefined
-    this._setBoolean(env, 'runtimeMetrics', DD_RUNTIME_METRICS_ENABLED ||
+    this._setBoolean(env, 'runtimeMetrics.enabled', DD_RUNTIME_METRICS_ENABLED ||
     otelSetRuntimeMetrics)
+    this._setBoolean(env, 'runtimeMetrics.eventLoop', DD_RUNTIME_METRICS_EVENT_LOOP_ENABLED)
+    this._setBoolean(env, 'runtimeMetrics.gc', DD_RUNTIME_METRICS_GC_ENABLED)
+    this._setBoolean(env, 'runtimeMetricsRuntimeId', DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED)
     this._setArray(env, 'sampler.spanSamplingRules', reformatSpanSamplingRules(coalesce(
-      safeJsonParse(maybeFile(DD_SPAN_SAMPLING_RULES_FILE)),
+      maybeJsonFile(DD_SPAN_SAMPLING_RULES_FILE),
       safeJsonParse(DD_SPAN_SAMPLING_RULES)
     )))
     this._setUnit(env, 'sampleRate', DD_TRACE_SAMPLE_RATE ||
     getFromOtelSamplerMap(OTEL_TRACES_SAMPLER, OTEL_TRACES_SAMPLER_ARG))
-    this._setValue(env, 'sampler.rateLimit', DD_TRACE_RATE_LIMIT)
+    env['sampler.rateLimit'] = DD_TRACE_RATE_LIMIT
     this._setSamplingRule(env, 'sampler.rules', safeJsonParse(DD_TRACE_SAMPLING_RULES))
     this._envUnprocessed['sampler.rules'] = DD_TRACE_SAMPLING_RULES
     this._setString(env, 'scope', DD_TRACE_SCOPE)
     this._setString(env, 'service', DD_SERVICE || tags.service || OTEL_SERVICE_NAME)
     if (DD_SERVICE_MAPPING) {
-      this._setValue(env, 'serviceMapping', Object.fromEntries(
+      env.serviceMapping = Object.fromEntries(
         DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
-      ))
+      )
     }
     this._setString(env, 'site', DD_SITE)
     if (DD_TRACE_SPAN_ATTRIBUTE_SCHEMA) {
@@ -950,11 +993,11 @@ class Config {
       this._envUnprocessed.spanAttributeSchema = DD_TRACE_SPAN_ATTRIBUTE_SCHEMA
     }
     // 0: disabled, 1: logging, 2: garbage collection + logging
-    this._setValue(env, 'spanLeakDebug', maybeInt(DD_TRACE_SPAN_LEAK_DEBUG))
+    env.spanLeakDebug = maybeInt(DD_TRACE_SPAN_LEAK_DEBUG)
     this._setBoolean(env, 'spanRemoveIntegrationFromService', DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED)
     this._setBoolean(env, 'startupLogs', DD_TRACE_STARTUP_LOGS)
     this._setTags(env, 'tags', tags)
-    this._setValue(env, 'tagsHeaderMaxLength', DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH)
+    env.tagsHeaderMaxLength = DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH
     this._setBoolean(env, 'telemetry.enabled', coalesce(
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       !(this._isInServerlessEnvironment() || JEST_WORKER_ID)
@@ -962,7 +1005,7 @@ class Config {
     this._setString(env, 'instrumentation_config_id', DD_INSTRUMENTATION_CONFIG_ID)
     this._setBoolean(env, 'telemetry.debug', DD_TELEMETRY_DEBUG)
     this._setBoolean(env, 'telemetry.dependencyCollection', DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED)
-    this._setValue(env, 'telemetry.heartbeatInterval', maybeInt(Math.floor(DD_TELEMETRY_HEARTBEAT_INTERVAL * 1000)))
+    env['telemetry.heartbeatInterval'] = maybeInt(Math.floor(DD_TELEMETRY_HEARTBEAT_INTERVAL * 1000))
     this._envUnprocessed['telemetry.heartbeatInterval'] = DD_TELEMETRY_HEARTBEAT_INTERVAL * 1000
     this._setBoolean(env, 'telemetry.logCollection', DD_TELEMETRY_LOG_COLLECTION_ENABLED)
     this._setBoolean(env, 'telemetry.metrics', DD_TELEMETRY_METRICS_ENABLED)
@@ -970,10 +1013,10 @@ class Config {
     this._setBoolean(env, 'traceId128BitLoggingEnabled', DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED)
     this._setBoolean(env, 'tracePropagationExtractFirst', DD_TRACE_PROPAGATION_EXTRACT_FIRST)
     const stringPropagationBehaviorExtract = String(DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT)
-    this._setValue(env, 'tracePropagationBehaviorExtract',
+    env.tracePropagationBehaviorExtract =
       VALID_PROPAGATION_BEHAVIOR_EXTRACT.has(stringPropagationBehaviorExtract)
         ? stringPropagationBehaviorExtract
-        : 'continue')
+        : 'continue'
     this._setBoolean(env, 'tracePropagationStyle.otelPropagators',
       DD_TRACE_PROPAGATION_STYLE ||
       DD_TRACE_PROPAGATION_STYLE_INJECT ||
@@ -987,12 +1030,8 @@ class Config {
     this._setString(env, 'trace.dynamoDb.tablePrimaryKeys', DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS)
     this._setArray(env, 'graphqlErrorExtensions', DD_TRACE_GRAPHQL_ERROR_EXTENSIONS)
     this._setBoolean(env, 'trace.nativeSpanEvents', DD_TRACE_NATIVE_SPAN_EVENTS)
-    this._setValue(
-      env,
-      'vertexai.spanPromptCompletionSampleRate',
-      maybeFloat(DD_VERTEXAI_SPAN_PROMPT_COMPLETION_SAMPLE_RATE)
-    )
-    this._setValue(env, 'vertexai.spanCharLimit', maybeInt(DD_VERTEXAI_SPAN_CHAR_LIMIT))
+    env['vertexai.spanPromptCompletionSampleRate'] = maybeFloat(DD_VERTEXAI_SPAN_PROMPT_COMPLETION_SAMPLE_RATE)
+    env['vertexai.spanCharLimit'] = maybeInt(DD_VERTEXAI_SPAN_CHAR_LIMIT)
   }
 
   _applyOptions (options) {
@@ -1009,10 +1048,10 @@ class Config {
       options.experimental?.appsec?.standalone && !options.experimental.appsec.standalone.enabled
     ))
     this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec?.apiSecurity?.enabled)
-    this._setValue(opts, 'appsec.blockedTemplateGraphql', maybeFile(options.appsec?.blockedTemplateGraphql))
-    this._setValue(opts, 'appsec.blockedTemplateHtml', maybeFile(options.appsec?.blockedTemplateHtml))
+    opts['appsec.blockedTemplateGraphql'] = maybeFile(options.appsec?.blockedTemplateGraphql)
+    opts['appsec.blockedTemplateHtml'] = maybeFile(options.appsec?.blockedTemplateHtml)
     this._optsUnprocessed['appsec.blockedTemplateHtml'] = options.appsec?.blockedTemplateHtml
-    this._setValue(opts, 'appsec.blockedTemplateJson', maybeFile(options.appsec?.blockedTemplateJson))
+    opts['appsec.blockedTemplateJson'] = maybeFile(options.appsec?.blockedTemplateJson)
     this._optsUnprocessed['appsec.blockedTemplateJson'] = options.appsec?.blockedTemplateJson
     this._setBoolean(opts, 'appsec.enabled', options.appsec?.enabled)
     this._setString(opts, 'appsec.eventTracking.mode', options.appsec?.eventTracking?.mode)
@@ -1026,29 +1065,26 @@ class Config {
       'appsec.extendedHeadersCollection.redaction',
       options.appsec?.extendedHeadersCollection?.redaction
     )
-    this._setValue(opts,
-      'appsec.extendedHeadersCollection.maxHeaders',
-      options.appsec?.extendedHeadersCollection?.maxHeaders
-    )
+    opts['appsec.extendedHeadersCollection.maxHeaders'] = options.appsec?.extendedHeadersCollection?.maxHeaders
     this._setString(opts, 'appsec.obfuscatorKeyRegex', options.appsec?.obfuscatorKeyRegex)
     this._setString(opts, 'appsec.obfuscatorValueRegex', options.appsec?.obfuscatorValueRegex)
     this._setBoolean(opts, 'appsec.rasp.enabled', options.appsec?.rasp?.enabled)
     this._setBoolean(opts, 'appsec.rasp.bodyCollection', options.appsec?.rasp?.bodyCollection)
-    this._setValue(opts, 'appsec.rateLimit', maybeInt(options.appsec?.rateLimit))
+    opts['appsec.rateLimit'] = maybeInt(options.appsec?.rateLimit)
     this._optsUnprocessed['appsec.rateLimit'] = options.appsec?.rateLimit
     this._setString(opts, 'appsec.rules', options.appsec?.rules)
     this._setBoolean(opts, 'appsec.stackTrace.enabled', options.appsec?.stackTrace?.enabled)
-    this._setValue(opts, 'appsec.stackTrace.maxDepth', maybeInt(options.appsec?.stackTrace?.maxDepth))
+    opts['appsec.stackTrace.maxDepth'] = maybeInt(options.appsec?.stackTrace?.maxDepth)
     this._optsUnprocessed['appsec.stackTrace.maxDepth'] = options.appsec?.stackTrace?.maxDepth
-    this._setValue(opts, 'appsec.stackTrace.maxStackTraces', maybeInt(options.appsec?.stackTrace?.maxStackTraces))
+    opts['appsec.stackTrace.maxStackTraces'] = maybeInt(options.appsec?.stackTrace?.maxStackTraces)
     this._optsUnprocessed['appsec.stackTrace.maxStackTraces'] = options.appsec?.stackTrace?.maxStackTraces
-    this._setValue(opts, 'appsec.wafTimeout', maybeInt(options.appsec?.wafTimeout))
+    opts['appsec.wafTimeout'] = maybeInt(options.appsec?.wafTimeout)
     this._optsUnprocessed['appsec.wafTimeout'] = options.appsec?.wafTimeout
     this._setBoolean(opts, 'clientIpEnabled', options.clientIpEnabled)
     this._setString(opts, 'clientIpHeader', options.clientIpHeader?.toLowerCase())
-    this._setValue(opts, 'baggageMaxBytes', options.baggageMaxBytes)
-    this._setValue(opts, 'baggageMaxItems', options.baggageMaxItems)
-    this._setValue(opts, 'baggageTagKeys', options.baggageTagKeys)
+    opts.baggageMaxBytes = options.baggageMaxBytes
+    opts.baggageMaxItems = options.baggageMaxItems
+    opts.baggageTagKeys = options.baggageTagKeys
     this._setBoolean(opts, 'codeOriginForSpans.enabled', options.codeOriginForSpans?.enabled)
     this._setBoolean(
       opts,
@@ -1072,45 +1108,51 @@ class Config {
       'dynamicInstrumentation.redactionExcludedIdentifiers',
       options.dynamicInstrumentation?.redactionExcludedIdentifiers
     )
+    opts['dynamicInstrumentation.uploadIntervalSeconds'] =
+      maybeFloat(options.dynamicInstrumentation?.uploadIntervalSeconds)
+    this._optsUnprocessed['dynamicInstrumentation.uploadIntervalSeconds'] =
+      options.dynamicInstrumentation?.uploadIntervalSeconds
     this._setString(opts, 'env', options.env || tags.env)
     this._setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this._setString(opts, 'experimental.exporter', options.experimental?.exporter)
-    this._setBoolean(opts, 'experimental.runtimeId', options.experimental?.runtimeId)
-    this._setValue(opts, 'flushInterval', maybeInt(options.flushInterval))
+    this._setBoolean(opts, 'runtimeMetricsRuntimeId', options.runtimeMetricsRuntimeId)
+    opts.flushInterval = maybeInt(options.flushInterval)
     this._optsUnprocessed.flushInterval = options.flushInterval
-    this._setValue(opts, 'flushMinSpans', maybeInt(options.flushMinSpans))
+    opts.flushMinSpans = maybeInt(options.flushMinSpans)
     this._optsUnprocessed.flushMinSpans = options.flushMinSpans
     this._setArray(opts, 'headerTags', options.headerTags)
     this._setString(opts, 'hostname', options.hostname)
-    this._setValue(opts, 'iast.dbRowsToTaint', maybeInt(options.iast?.dbRowsToTaint))
+    opts['iast.dbRowsToTaint'] = maybeInt(options.iast?.dbRowsToTaint)
     this._setBoolean(opts, 'iast.deduplicationEnabled', options.iast && options.iast.deduplicationEnabled)
     this._setBoolean(opts, 'iast.enabled',
       options.iast && (options.iast === true || options.iast.enabled === true))
-    this._setValue(opts, 'iast.maxConcurrentRequests',
-      maybeInt(options.iast?.maxConcurrentRequests))
+    opts['iast.maxConcurrentRequests'] = maybeInt(options.iast?.maxConcurrentRequests)
     this._optsUnprocessed['iast.maxConcurrentRequests'] = options.iast?.maxConcurrentRequests
-    this._setValue(opts, 'iast.maxContextOperations', maybeInt(options.iast?.maxContextOperations))
+    opts['iast.maxContextOperations'] = maybeInt(options.iast?.maxContextOperations)
     this._optsUnprocessed['iast.maxContextOperations'] = options.iast?.maxContextOperations
     this._setBoolean(opts, 'iast.redactionEnabled', options.iast?.redactionEnabled)
     this._setString(opts, 'iast.redactionNamePattern', options.iast?.redactionNamePattern)
     this._setString(opts, 'iast.redactionValuePattern', options.iast?.redactionValuePattern)
     const iastRequestSampling = maybeInt(options.iast?.requestSampling)
     if (iastRequestSampling > -1 && iastRequestSampling < 101) {
-      this._setValue(opts, 'iast.requestSampling', iastRequestSampling)
+      opts['iast.requestSampling'] = iastRequestSampling
       this._optsUnprocessed['iast.requestSampling'] = options.iast?.requestSampling
     }
-    this._setValue(opts, 'iast.securityControlsConfiguration', options.iast?.securityControlsConfiguration)
+    opts['iast.securityControlsConfiguration'] = options.iast?.securityControlsConfiguration
     this._setBoolean(opts, 'iast.stackTrace.enabled', options.iast?.stackTrace?.enabled)
     this._setString(opts, 'iast.telemetryVerbosity', options.iast && options.iast.telemetryVerbosity)
+    if (options[INSTRUMENTED_BY_SSI]) {
+      this._setString(opts, 'instrumentationSource', options[INSTRUMENTED_BY_SSI])
+    }
     this._setBoolean(opts, 'isCiVisibility', options.isCiVisibility)
     this._setBoolean(opts, 'legacyBaggageEnabled', options.legacyBaggageEnabled)
     this._setBoolean(opts, 'llmobs.agentlessEnabled', options.llmobs?.agentlessEnabled)
     this._setString(opts, 'llmobs.mlApp', options.llmobs?.mlApp)
     this._setBoolean(opts, 'logInjection', options.logInjection)
-    this._setValue(opts, 'lookup', options.lookup)
+    opts.lookup = options.lookup
     this._setBoolean(opts, 'middlewareTracingEnabled', options.middlewareTracingEnabled)
     this._setBoolean(opts, 'openAiLogsEnabled', options.openAiLogsEnabled)
-    this._setValue(opts, 'peerServiceMapping', options.peerServiceMapping)
+    opts.peerServiceMapping = options.peerServiceMapping
     this._setBoolean(opts, 'plugins', options.plugins)
     this._setString(opts, 'port', options.port)
     const strProfiling = String(options.profiling)
@@ -1119,18 +1161,21 @@ class Config {
     }
     this._setString(opts, 'protocolVersion', options.protocolVersion)
     if (options.remoteConfig) {
-      this._setValue(opts, 'remoteConfig.pollInterval', maybeFloat(options.remoteConfig.pollInterval))
+      opts['remoteConfig.pollInterval'] = maybeFloat(options.remoteConfig.pollInterval)
       this._optsUnprocessed['remoteConfig.pollInterval'] = options.remoteConfig.pollInterval
     }
     this._setBoolean(opts, 'reportHostname', options.reportHostname)
-    this._setBoolean(opts, 'runtimeMetrics', options.runtimeMetrics)
+    this._setBoolean(opts, 'runtimeMetrics.enabled', options.runtimeMetrics?.enabled)
+    this._setBoolean(opts, 'runtimeMetrics.eventLoop', options.runtimeMetrics?.eventLoop)
+    this._setBoolean(opts, 'runtimeMetrics.gc', options.runtimeMetrics?.gc?.enabled)
+    this._setBoolean(opts, 'runtimeMetricsRuntimeId', options.runtimeMetricsRuntimeId)
     this._setArray(opts, 'sampler.spanSamplingRules', reformatSpanSamplingRules(options.spanSamplingRules))
     this._setUnit(opts, 'sampleRate', coalesce(options.sampleRate, options.ingestion.sampleRate))
     const ingestion = options.ingestion || {}
-    this._setValue(opts, 'sampler.rateLimit', coalesce(options.rateLimit, ingestion.rateLimit))
+    opts['sampler.rateLimit'] = coalesce(options.rateLimit, ingestion.rateLimit)
     this._setSamplingRule(opts, 'sampler.rules', options.samplingRules)
     this._setString(opts, 'service', options.service || tags.service)
-    this._setValue(opts, 'serviceMapping', options.serviceMapping)
+    opts.serviceMapping = options.serviceMapping
     this._setString(opts, 'site', options.site)
     if (options.spanAttributeSchema) {
       this._setString(opts, 'spanAttributeSchema', validateNamingVersion(options.spanAttributeSchema))
@@ -1261,17 +1306,15 @@ class Config {
       DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED
     } = getEnvironmentVariables()
 
-    if (DD_CIVISIBILITY_AGENTLESS_URL) {
-      this._setValue(calc, 'url', new URL(DD_CIVISIBILITY_AGENTLESS_URL))
-    } else {
-      this._setValue(calc, 'url', getAgentUrl(this._getTraceAgentUrl(), this._optionsArg))
-    }
+    calc.url = DD_CIVISIBILITY_AGENTLESS_URL
+      ? new URL(DD_CIVISIBILITY_AGENTLESS_URL)
+      : getAgentUrl(this._getTraceAgentUrl(), this._optionsArg)
     if (this._isCiVisibility()) {
       this._setBoolean(calc, 'isEarlyFlakeDetectionEnabled',
         coalesce(DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED, true))
       this._setBoolean(calc, 'isFlakyTestRetriesEnabled',
         coalesce(DD_CIVISIBILITY_FLAKY_RETRY_ENABLED, true))
-      this._setValue(calc, 'flakyTestRetriesCount', coalesce(maybeInt(DD_CIVISIBILITY_FLAKY_RETRY_COUNT), 5))
+      calc.flakyTestRetriesCount = coalesce(maybeInt(DD_CIVISIBILITY_FLAKY_RETRY_COUNT), 5)
       this._setBoolean(calc, 'isIntelligentTestRunnerEnabled', isTrue(this._isCiVisibilityItrEnabled()))
       this._setBoolean(calc, 'isManualApiEnabled', !isFalse(this._isCiVisibilityManualApiEnabled()))
       this._setString(calc, 'ciVisibilityTestSessionName', DD_TEST_SESSION_NAME)
@@ -1279,26 +1322,23 @@ class Config {
       this._setBoolean(calc, 'isTestDynamicInstrumentationEnabled', !isFalse(DD_TEST_FAILED_TEST_REPLAY_ENABLED))
       this._setBoolean(calc, 'isServiceUserProvided', !!this._env.service)
       this._setBoolean(calc, 'isTestManagementEnabled', !isFalse(DD_TEST_MANAGEMENT_ENABLED))
-      this._setValue(calc,
-        'testManagementAttemptToFixRetries',
-        coalesce(maybeInt(DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES), 20)
-      )
+      calc.testManagementAttemptToFixRetries = coalesce(maybeInt(DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES), 20)
       this._setBoolean(calc, 'isImpactedTestsEnabled', !isFalse(DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED))
     }
-    this._setString(calc, 'dogstatsd.hostname', this._getHostname())
+    calc['dogstatsd.hostname'] = this._getHostname()
     this._setBoolean(calc, 'isGitUploadEnabled',
       calc.isIntelligentTestRunnerEnabled && !isFalse(this._isCiVisibilityGitUploadEnabled()))
     this._setBoolean(calc, 'spanComputePeerService', this._getSpanComputePeerService())
     this._setBoolean(calc, 'stats.enabled', this._isTraceStatsComputationEnabled())
     const defaultPropagationStyle = this._getDefaultPropagationStyle(this._optionsArg)
-    this._setValue(calc, 'tracePropagationStyle.inject', propagationStyle(
+    calc['tracePropagationStyle.inject'] = propagationStyle(
       'inject',
       this._optionsArg.tracePropagationStyle
-    ))
-    this._setValue(calc, 'tracePropagationStyle.extract', propagationStyle(
+    )
+    calc['tracePropagationStyle.extract'] = propagationStyle(
       'extract',
       this._optionsArg.tracePropagationStyle
-    ))
+    )
     if (defaultPropagationStyle.length > 2) {
       calc['tracePropagationStyle.inject'] = calc['tracePropagationStyle.inject'] || defaultPropagationStyle
       calc['tracePropagationStyle.extract'] = calc['tracePropagationStyle.extract'] || defaultPropagationStyle
@@ -1320,7 +1360,7 @@ class Config {
 
     this._setUnit(opts, 'sampleRate', options.tracing_sampling_rate)
     this._setBoolean(opts, 'logInjection', options.log_injection_enabled)
-    this._setArray(opts, 'headerTags', headerTags)
+    opts.headerTags = headerTags
     this._setTags(opts, 'tags', tags)
     this._setBoolean(opts, 'tracing', options.tracing_enabled)
     this._remoteUnprocessed['sampler.rules'] = options.tracing_sampling_rules
@@ -1342,30 +1382,32 @@ class Config {
 
   _setBoolean (obj, name, value) {
     if (value === undefined || value === null) {
-      this._setValue(obj, name, value)
+      obj[name] = value
     } else if (isTrue(value)) {
-      this._setValue(obj, name, true)
+      obj[name] = true
     } else if (isFalse(value)) {
-      this._setValue(obj, name, false)
+      obj[name] = false
     }
   }
 
   _setUnit (obj, name, value) {
     if (value === null || value === undefined) {
-      return this._setValue(obj, name, value)
+      obj[name] = value
+      return
     }
 
     value = Number.parseFloat(value)
 
     if (!Number.isNaN(value)) {
       // TODO: Ignore out of range values instead of normalizing them.
-      this._setValue(obj, name, Math.min(Math.max(value, 0), 1))
+      obj[name] = Math.min(Math.max(value, 0), 1)
     }
   }
 
   _setArray (obj, name, value) {
     if (value == null) {
-      return this._setValue(obj, name, null)
+      obj[name] = null
+      return
     }
 
     if (typeof value === 'string') {
@@ -1377,13 +1419,14 @@ class Config {
     }
 
     if (Array.isArray(value)) {
-      this._setValue(obj, name, value)
+      obj[name] = value
     }
   }
 
   _setIntegerRangeSet (obj, name, value) {
     if (value == null) {
-      return this._setValue(obj, name, null)
+      obj[name] = null
+      return
     }
     value = value.split(',')
     const result = []
@@ -1398,12 +1441,13 @@ class Config {
         result.push(Number(val))
       }
     })
-    this._setValue(obj, name, result)
+    obj[name] = result
   }
 
   _setSamplingRule (obj, name, value) {
     if (value == null) {
-      return this._setValue(obj, name, null)
+      obj[name] = null
+      return
     }
 
     if (typeof value === 'string') {
@@ -1416,7 +1460,7 @@ class Config {
           sample_rate: 'sampleRate'
         })
       })
-      this._setValue(obj, name, value)
+      obj[name] = value
     }
   }
 
@@ -1426,37 +1470,31 @@ class Config {
 
   _setTags (obj, name, value) {
     if (!value || Object.keys(value).length === 0) {
-      return this._setValue(obj, name, null)
+      obj[name] = null
+      return
     }
 
-    this._setValue(obj, name, value)
-  }
-
-  _setValue (obj, name, value) {
     obj[name] = value
   }
 
-  _getContainersAndOriginsOrdered () {
-    const containers = [
-      this._remote,
-      this._options,
-      this._fleetStableConfig,
-      this._env,
-      this._localStableConfig,
-      this._calculated,
-      this._defaults
-    ]
-    const origins = [
-      'remote_config',
-      'code',
-      'fleet_stable_config',
-      'env_var',
-      'local_stable_config',
-      'calculated',
-      'default'
-    ]
-
-    return { containers, origins }
+  _setAndTrackChange ({ name, value, origin, unprocessedValue, changes }) {
+    set(this, name, value)
+
+    if (!changeTracker[name]) {
+      changeTracker[name] = {}
+    }
+
+    const originExists = origin in changeTracker[name]
+    const oldValue = changeTracker[name][origin]
+
+    if (!originExists || oldValue !== value) {
+      changeTracker[name][origin] = value
+      changes.push({
+        name,
+        value: unprocessedValue || value,
+        origin
+      })
+    }
   }
 
   // TODO: Report origin changes and errors to telemetry.
@@ -1465,51 +1503,35 @@ class Config {
   // for telemetry reporting, `name`s in `containers` need to be keys from:
   // https://github.com/DataDog/dd-go/blob/prod/trace/apps/tracer-telemetry-intake/telemetry-payload/static/config_norm_rules.json
   _merge () {
-    const { containers, origins } = this._getContainersAndOriginsOrdered()
-    const unprocessedValues = [
-      this._remoteUnprocessed,
-      this._optsUnprocessed,
-      {},
-      this._envUnprocessed,
-      {},
-      {},
-      {}
-    ]
     const changes = []
 
     for (const name in this._defaults) {
-      for (let i = 0; i < containers.length; i++) {
-        const container = containers[i]
+      // Use reverse order for merge (lowest priority first)
+      for (let i = sourcesOrder.length - 1; i >= 0; i--) {
+        const { containerProperty, origin, unprocessedProperty } = sourcesOrder[i]
+        const container = this[containerProperty]
         const value = container[name]
-
-        if ((value !== null && value !== undefined) || container === this._defaults) {
-          if (get(this, name) === value && has(this, name)) break
-
-          set(this, name, value)
-
-          changes.push({
+        if (value != null || container === this._defaults) {
+          this._setAndTrackChange({
             name,
-            value: unprocessedValues[i][name] || value,
-            origin: origins[i]
+            value,
+            origin,
+            unprocessedValue: unprocessedProperty === undefined ? undefined : this[unprocessedProperty][name],
+            changes
           })
-
-          break
         }
       }
     }
-
     this.sampler.sampleRate = this.sampleRate
     updateConfig(changes, this)
   }
 
   getOrigin (name) {
-    const { containers, origins } = this._getContainersAndOriginsOrdered()
-
-    for (let i = 0; i < containers.length; i++) {
-      const container = containers[i]
+    for (const { containerProperty, origin } of sourcesOrder) {
+      const container = this[containerProperty]
       const value = container[name]
       if (value != null || container === this._defaults) {
-        return origins[i]
+        return origin
       }
     }
   }