dd-trace 5.82.0 → 5.84.0

package/packages/dd-trace/src/{config.js → config/index.js}

@@ -4,28 +4,28 @@ const fs = require('fs')
 const os = require('os')
 const { URL } = require('url')
 const path = require('path')
-const uuid = require('../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
-
-const set = require('../../datadog-core/src/utils/src/set')
-const { DD_MAJOR } = require('../../../version')
-const log = require('./log')
-const tagger = require('./tagger')
-const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('./util')
-const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
-const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
-  require('./git_properties')
-const { updateConfig } = require('./telemetry')
-const telemetryMetrics = require('./telemetry/metrics')
+const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
+
+const set = require('../../../datadog-core/src/utils/src/set')
+const { DD_MAJOR } = require('../../../../version')
+const log = require('../log')
+const tagger = require('../tagger')
+const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('../util')
+const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
+const { updateConfig } = require('../telemetry')
+const telemetryMetrics = require('../telemetry/metrics')
 const {
   isInServerlessEnvironment,
   getIsGCPFunction,
   getIsAzureFunction,
   enableGCPPubSubPushSubscription
-} = require('./serverless')
-const { ORIGIN_KEY } = require('./constants')
-const { appendRules } = require('./payload-tagging/config')
-const { getEnvironmentVariable: getEnv, getEnvironmentVariables } = require('./config-helper')
-const defaults = require('./config_defaults')
+} = require('../serverless')
+const { ORIGIN_KEY } = require('../constants')
+const { appendRules } = require('../payload-tagging/config')
+const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
+  require('./git_properties')
+const { getEnvironmentVariable: getEnv, getEnvironmentVariables, getStableConfigSources } = require('./helper')
+const defaults = require('./defaults')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -276,9 +276,12 @@ class Config {
 
   constructor (options = {}) {
     if (!isInServerlessEnvironment()) {
-      // Bail out early if we're in a serverless environment, stable config isn't supported
-      const StableConfig = require('./config_stable')
-      this.stableConfig = new StableConfig()
+      const configEnvSources = getStableConfigSources()
+      this.stableConfig = {
+        fleetEntries: configEnvSources.fleetStableConfig,
+        localEntries: configEnvSources.localStableConfig,
+        warnings: configEnvSources.stableConfigWarnings
+      }
     }
 
     options = {
@@ -328,7 +331,6 @@ class Config {
     this.#applyStableConfig(this.stableConfig?.fleetEntries ?? {}, this.#fleetStableConfig)
     this.#applyOptions(options)
     this.#applyCalculated()
-    this.#applyRemote({})
     this.#merge()
 
     tagger.add(this.tags, {
@@ -353,15 +355,38 @@ class Config {
     return this.#parsedDdTags
   }
 
-  // Supports only a subset of options for now.
-  configure (options, remote) {
-    if (remote) {
-      this.#applyRemote(options)
-    } else {
-      this.#applyOptions(options)
+  /**
+   * Set the configuration with remote config settings.
+   * Applies remote configuration, recalculates derived values, and merges all configuration sources.
+   *
+   * @param {import('./config/remote_config').RemoteConfigOptions|null} options - Configurations received via Remote
+   *   Config or null to reset all remote configuration
+   */
+  setRemoteConfig (options) {
+    // Clear all RC-managed fields to ensure previous values don't persist.
+    // State is instead managed by the `RCClientLibConfigManager` class
+    this.#remote = {}
+    this.#remoteUnprocessed = {}
+
+    // Special case: if options is null, nothing to apply
+    // This happens when all remote configs are removed
+    if (options !== null) {
+      this.#applyRemoteConfig(options)
     }
 
-    // TODO: test
+    this.#applyCalculated()
+    this.#merge()
+  }
+
+  // TODO: Remove the `updateOptions` method. We don't want to support updating the config this way
+  /**
+   * Updates the configuration with new programmatic options.
+   *
+   * @deprecated This method should not be used and will be removed in a future version.
+   * @param {object} options - Configuration options to apply (same format as tracer init options)
+   */
+  updateOptions (options) {
+    this.#applyOptions(options)
     this.#applyCalculated()
     this.#merge()
   }
@@ -478,6 +503,7 @@ class Config {
       DD_IAST_STACK_TRACE_ENABLED,
       DD_INJECTION_ENABLED,
       DD_INJECT_FORCE,
+      DD_ENABLE_NX_SERVICE_NAME,
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
@@ -574,6 +600,7 @@ class Config {
       OTEL_TRACES_SAMPLER,
       OTEL_TRACES_SAMPLER_ARG,
       DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED,
+      DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS,
       OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
       OTEL_EXPORTER_OTLP_LOGS_HEADERS,
       OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
@@ -591,7 +618,8 @@ class Config {
       OTEL_BSP_SCHEDULE_DELAY,
       OTEL_BSP_MAX_EXPORT_BATCH_SIZE,
       OTEL_BSP_MAX_QUEUE_SIZE,
-      OTEL_METRIC_EXPORT_INTERVAL
+      OTEL_METRIC_EXPORT_INTERVAL,
+      NX_TASK_TARGET_PROJECT
     } = source
 
     const tags = {}
@@ -749,7 +777,15 @@ class Config {
       maybeFloat(DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS)
     unprocessedTarget['dynamicInstrumentation.uploadInterval'] = DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS
     this.#setString(target, 'env', DD_ENV || tags.env)
-    this.#setBoolean(target, 'experimental.flaggingProvider.enabled', DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED)
+    this.#setBoolean(
+      target,
+      'experimental.flaggingProvider.enabled',
+      DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED
+    )
+    if (DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS != null) {
+      target['experimental.flaggingProvider.initializationTimeoutMs'] =
+        maybeInt(DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS)
+    }
     this.#setBoolean(target, 'traceEnabled', DD_TRACE_ENABLED)
     this.#setBoolean(target, 'experimental.aiguard.enabled', DD_AI_GUARD_ENABLED)
     this.#setString(target, 'experimental.aiguard.endpoint', DD_AI_GUARD_ENDPOINT)
@@ -862,7 +898,22 @@ class Config {
     this.#setSamplingRule(target, 'sampler.rules', safeJsonParse(DD_TRACE_SAMPLING_RULES))
     unprocessedTarget['sampler.rules'] = DD_TRACE_SAMPLING_RULES
     this.#setString(target, 'scope', DD_TRACE_SCOPE)
-    this.#setString(target, 'service', DD_SERVICE || tags.service || OTEL_SERVICE_NAME)
+    // Priority:
+    // DD_SERVICE > tags.service > OTEL_SERVICE_NAME > NX_TASK_TARGET_PROJECT (if DD_ENABLE_NX_SERVICE_NAME) > default
+    let serviceName = DD_SERVICE || tags.service || OTEL_SERVICE_NAME
+    if (!serviceName && NX_TASK_TARGET_PROJECT) {
+      if (isTrue(DD_ENABLE_NX_SERVICE_NAME)) {
+        serviceName = NX_TASK_TARGET_PROJECT
+      } else if (DD_MAJOR < 6) {
+        // Warn about v6 behavior change for Nx projects
+        log.warn(
+          'NX_TASK_TARGET_PROJECT is set but no service name was configured. ' +
+          'In v6, NX_TASK_TARGET_PROJECT will be used as the default service name. ' +
+          'Set DD_ENABLE_NX_SERVICE_NAME=true to opt-in to this behavior now, or set a service name explicitly.'
+        )
+      }
+    }
+    this.#setString(target, 'service', serviceName)
     if (DD_SERVICE_MAPPING) {
       target.serviceMapping = Object.fromEntries(
         DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
@@ -1070,6 +1121,11 @@ class Config {
     this.#setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this.#setString(opts, 'experimental.exporter', options.experimental?.exporter)
     this.#setBoolean(opts, 'experimental.flaggingProvider.enabled', options.experimental?.flaggingProvider?.enabled)
+    opts['experimental.flaggingProvider.initializationTimeoutMs'] = maybeInt(
+      options.experimental?.flaggingProvider?.initializationTimeoutMs
+    )
+    this.#optsUnprocessed['experimental.flaggingProvider.initializationTimeoutMs'] =
+      options.experimental?.flaggingProvider?.initializationTimeoutMs
     opts.flushInterval = maybeInt(options.flushInterval)
     this.#optsUnprocessed.flushInterval = options.flushInterval
     opts.flushMinSpans = maybeInt(options.flushMinSpans)
@@ -1287,31 +1343,36 @@ class Config {
     }
   }
 
-  #applyRemote (options) {
+  /**
+   * Applies remote configuration options from APM_TRACING configs.
+   *
+   * @param {import('./config/remote_config').RemoteConfigOptions} options - Configurations received via Remote Config
+   */
+  #applyRemoteConfig (options) {
     const opts = this.#remote
-    const tags = {}
-    const headerTags = options.tracing_header_tags
-      ? options.tracing_header_tags.map(tag => {
-        return tag.tag_name ? `${tag.header}:${tag.tag_name}` : tag.header
-      })
-      : undefined
-
-    tagger.add(tags, options.tracing_tags)
-    if (Object.keys(tags).length) tags['runtime-id'] = runtimeId
 
+    this.#setBoolean(opts, 'dynamicInstrumentation.enabled', options.dynamic_instrumentation_enabled)
+    this.#setBoolean(opts, 'codeOriginForSpans.enabled', options.code_origin_enabled)
     this.#setUnit(opts, 'sampleRate', options.tracing_sampling_rate)
     this.#setBoolean(opts, 'logInjection', options.log_injection_enabled)
-    opts.headerTags = headerTags
-    this.#setTags(opts, 'tags', tags)
     this.#setBoolean(opts, 'tracing', options.tracing_enabled)
     this.#remoteUnprocessed['sampler.rules'] = options.tracing_sampling_rules
-    this.#setSamplingRule(opts, 'sampler.rules', this.#reformatTags(options.tracing_sampling_rules))
+    this.#setSamplingRule(opts, 'sampler.rules', this.#reformatTagsFromRC(options.tracing_sampling_rules))
+
+    opts.headerTags = options.tracing_header_tags?.map(tag => {
+      return tag.tag_name ? `${tag.header}:${tag.tag_name}` : tag.header
+    })
+
+    const tags = {}
+    tagger.add(tags, options.tracing_tags)
+    if (Object.keys(tags).length) tags['runtime-id'] = runtimeId
+    this.#setTags(opts, 'tags', tags)
   }
 
-  #reformatTags (samplingRules) {
+  #reformatTagsFromRC (samplingRules) {
     for (const rule of (samplingRules || [])) {
-      const reformattedTags = {}
       if (rule.tags) {
+        const reformattedTags = {}
         for (const tag of rule.tags) {
           reformattedTags[tag.key] = tag.value_glob
         }

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

@@ -1,34 +1,203 @@
 'use strict'
 
 const RemoteConfigCapabilities = require('../remote_config/capabilities')
+const log = require('../log')
+
+module.exports = {
+  enable
+}
+
+/**
+ * @typedef {object} RemoteConfigOptions
+ * @property {boolean} [dynamic_instrumentation_enabled] - Enable Dynamic Instrumentation
+ * @property {boolean} [code_origin_enabled] - Enable code origin tagging for spans
+ * @property {Array<{header: string, tag_name?: string}>} [tracing_header_tags] - HTTP headers to tag
+ * @property {Array<string>} [tracing_tags] - Global tags (format: "key:value")
+ * @property {number} [tracing_sampling_rate] - Global sampling rate (0.0-1.0)
+ * @property {boolean} [log_injection_enabled] - Enable trace context log injection
+ * @property {boolean} [tracing_enabled] - Enable/disable tracing globally
+ * @property {Array<object>} [tracing_sampling_rules] - Trace sampling rules configuration
+ */
+
+/**
+ * @typedef {ReturnType<import('../config')>} Config
+ */
+
+/**
+ * Manages multiple APM_TRACING configurations with priority-based merging
+ */
+class RCClientLibConfigManager {
+  /**
+   * @param {string} currentService - Current service name
+   * @param {string} currentEnv - Current environment name
+   */
+  constructor (currentService, currentEnv) {
+    this.configs = new Map() // config_id -> { conf, priority }
+    this.currentService = currentService
+    this.currentEnv = currentEnv
+  }
+
+  /**
+   * Calculate priority based on target specificity. Higher values take precedence.
+   * Priority order (highest → lowest):
+   *   Service+Env (5) > Service (4) > Env (3) > Cluster (2) > Org (1)
+   *
+   * @param {object} conf - Remote config object with service_target and k8s_target_v2 properties
+   * @returns {number} Priority value from 1 (org-level) to 5 (service+env specific)
+   */
+  calculatePriority (conf) {
+    const serviceTarget = conf.service_target
+    const k8sTarget = conf.k8s_target_v2
+
+    if (serviceTarget) {
+      const service = serviceTarget.service
+      const env = serviceTarget.env
+
+      const hasSpecificService = service && service !== '*'
+      const hasSpecificEnv = env && env !== '*'
+
+      if (hasSpecificService && hasSpecificEnv) return 5
+      if (hasSpecificService) return 4
+      if (hasSpecificEnv) return 3
+    }
+
+    if (k8sTarget) return 2
+
+    return 1 // Org level
+  }
+
+  /**
+   * Check if config matches current service/env
+   *
+   * @param {object} conf - Remote config object with service_target property
+   * @returns {boolean} True if config matches current service/env or has no filter
+   */
+  matchesCurrentServiceEnv (conf) {
+    const serviceTarget = conf.service_target
+    if (!serviceTarget) return true // No filter means match all
+
+    const service = serviceTarget.service
+    const env = serviceTarget.env
+
+    // Check service match
+    if (service && service !== '*' && service !== this.currentService) {
+      log.debug('[config/remote_config] Ignoring config for service: %s (current: %s)',
+        service, this.currentService)
+      return false
+    }
+
+    // Check env match
+    if (env && env !== '*' && env !== this.currentEnv) {
+      log.debug('[config/remote_config] Ignoring config for env: %s (current: %s)',
+        env, this.currentEnv)
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Add or update a config
+   *
+   * @param {string} configId - Unique identifier for the config
+   * @param {object} conf - Remote config object to add
+   */
+  addConfig (configId, conf) {
+    if (!this.matchesCurrentServiceEnv(conf)) {
+      return
+    }
+
+    const priority = this.calculatePriority(conf)
+    this.configs.set(configId, { conf, priority })
+
+    log.debug('[config/remote_config] Added config %s with priority %d', configId, priority)
+  }
+
+  /**
+   * Remove a config
+   *
+   * @param {string} configId - Unique identifier for the config to remove
+   */
+  removeConfig (configId) {
+    const removed = this.configs.delete(configId)
+    if (removed) {
+      log.debug('[config/remote_config] Removed config %s', configId)
+    }
+  }
+
+  /**
+   * Get merged lib_config with higher priority configs overriding lower priority ones
+   *
+   * @returns {RemoteConfigOptions|null} Merged config object or null if no configs present
+   */
+  getMergedLibConfig () {
+    if (this.configs.size === 0) return null
+
+    let hasLibConfig = false
+
+    const merged = [...this.configs.values()]
+      .sort((a, b) => a.priority - b.priority)
+      .reduce((merged, { conf }) => {
+        if (conf.lib_config != null) hasLibConfig = true
+        return Object.assign(merged, conf.lib_config)
+      }, {})
+
+    return hasLibConfig ? merged : null
+  }
+}
 
 /**
  * Configures remote config for core APM tracing functionality
  *
- * @param {object} rc - RemoteConfig instance
- * @param {object} config - Tracer config
- * @param {Function} enableOrDisableTracing - Function to enable/disable tracing based on config
+ * @param {import('../remote_config')} rc - RemoteConfig instance
+ * @param {Config} config - Tracer config
+ * @param {() => void} onConfigUpdated - Function to call when config is updated
  */
-function enable (rc, config, enableOrDisableTracing) {
-  // Register core APM tracing capabilities
+function enable (rc, config, onConfigUpdated) {
+  // This tracer supports receiving config subsets via the APM_TRACING product handler.
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_MULTICONFIG, true)
+
+  // Tracing
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLED, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RATE, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RULES, true)
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_CUSTOM_TAGS, true)
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_HTTP_HEADER_TAGS, true)
+
+  // Log Management
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_LOGS_INJECTION, true)
-  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RATE, true)
-  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLED, true)
-  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RULES, true)
 
-  // APM_TRACING product handler - manages tracer configuration
-  rc.setProductHandler('APM_TRACING', (action, conf) => {
-    if (action === 'unapply') {
-      config.configure({}, true)
-    } else {
-      config.configure(conf.lib_config, true)
+  // Debugger
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_LIVE_DEBUGGING, true)
+
+  // Code Origin
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_CODE_ORIGIN, true)
+
+  const rcClientLibConfigManager = new RCClientLibConfigManager(config.service, config.env)
+
+  // Subscribe to APM_TRACING product (setBatchHandler used below doesn't automatically subscribe)
+  rc.subscribeProducts('APM_TRACING')
+
+  // Use a batch handler to process all changes before updating the config. This is important in case there's
+  // conflicting configs between, for example, the org and service level.
+  rc.setBatchHandler(['APM_TRACING'], (transaction) => {
+    const { toUnapply, toApply, toModify } = transaction
+
+    for (const item of toUnapply) {
+      rcClientLibConfigManager.removeConfig(item.id)
+      transaction.ack(item.path)
     }
-    enableOrDisableTracing(config, rc)
-  })
-}
 
-module.exports = {
-  enable
+    for (const item of [...toApply, ...toModify]) {
+      rcClientLibConfigManager.addConfig(item.id, item.file)
+      transaction.ack(item.path)
+    }
+
+    // Get merged config and apply it
+    const mergedLibConfig = rcClientLibConfigManager.getMergedLibConfig()
+    config.setRemoteConfig(mergedLibConfig)
+
+    onConfigUpdated()
+  })
 }

package/packages/dd-trace/src/{config_stable.js → config/stable.js}

@@ -2,7 +2,7 @@
 
 const os = require('os')
 const fs = require('fs')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
+const { getEnvironmentVariable } = require('./helper')
 
 class StableConfig {
   constructor () {
@@ -11,14 +11,10 @@ class StableConfig {
     this.fleetEntries = {}
     this.wasm_loaded = false
 
-    const { localConfigPath, fleetConfigPath } = this._getStableConfigPaths()
-    if (!fs.existsSync(localConfigPath) && !fs.existsSync(fleetConfigPath)) {
-      // Bail out early if files don't exist to avoid unnecessary library loading
-      return
-    }
+    const { localConfigPath, fleetConfigPath } = this.#getStableConfigPaths()
 
-    const localConfig = this._readConfigFromPath(localConfigPath)
-    const fleetConfig = this._readConfigFromPath(fleetConfigPath)
+    const localConfig = this.#readConfigFromPath(localConfigPath)
+    const fleetConfig = this.#readConfigFromPath(fleetConfigPath)
     if (!localConfig && !fleetConfig) {
       // Bail out early if files are empty or we can't read them to avoid unnecessary library loading
       return
@@ -47,7 +43,7 @@ class StableConfig {
       // eslint-disable-next-line eslint-rules/eslint-process-env
       configurator.set_envp(Object.entries(process.env).map(([key, value]) => `${key}=${value}`))
       configurator.set_args(process.argv)
-      configurator.get_configuration(localConfig.toString(), fleetConfig.toString()).forEach((entry) => {
+      configurator.get_configuration(localConfig, fleetConfig).forEach((entry) => {
         if (entry.source === 'local_stable_config') {
           this.localEntries[entry.name] = entry.value
         } else if (entry.source === 'fleet_stable_config') {
@@ -59,43 +55,35 @@ class StableConfig {
     }
   }
 
-  _readConfigFromPath (path) {
+  #readConfigFromPath (path) {
     try {
       return fs.readFileSync(path, 'utf8')
     } catch (err) {
       if (err.code !== 'ENOENT') {
         this.warnings.push(`Error reading config file at ${path}. ${err.code}: ${err.message}`)
       }
-      return '' // Always return a string to avoid undefined.toString() errors
+      return '' // Always return a string for configurator.get_configuration()
     }
   }
 
-  _getStableConfigPaths () {
-    let localConfigPath = ''
-    let fleetConfigPath = ''
-    switch (os.type().toLowerCase()) {
-      case 'linux':
-        localConfigPath = '/etc/datadog-agent/application_monitoring.yaml'
-        fleetConfigPath = '/etc/datadog-agent/managed/datadog-agent/stable/application_monitoring.yaml'
-        break
+  #getStableConfigPaths () {
+    // TODO(BridgeAR): Remove these environment variables once we have a proper way to test the stable config.
+    // Allow overriding the paths for testing
+    let localConfigPath = getEnvironmentVariable('DD_TEST_LOCAL_CONFIG_PATH')
+    let fleetConfigPath = getEnvironmentVariable('DD_TEST_FLEET_CONFIG_PATH')
+    switch (os.platform()) {
       case 'darwin':
-        localConfigPath = '/opt/datadog-agent/etc/application_monitoring.yaml'
-        fleetConfigPath = '/opt/datadog-agent/etc/managed/datadog-agent/stable/application_monitoring.yaml'
+        localConfigPath ??= '/opt/datadog-agent/etc/application_monitoring.yaml'
+        fleetConfigPath ??= '/opt/datadog-agent/etc/managed/datadog-agent/stable/application_monitoring.yaml'
         break
       case 'win32':
-        localConfigPath = String.raw`C:\ProgramData\Datadog\application_monitoring.yaml`
-        fleetConfigPath = String.raw`C:\ProgramData\Datadog\managed\datadog-agent\stable\application_monitoring.yaml`
+        localConfigPath ??= String.raw`C:\ProgramData\Datadog\application_monitoring.yaml`
+        fleetConfigPath ??= String.raw`C:\ProgramData\Datadog\managed\datadog-agent\stable\application_monitoring.yaml`
         break
       default:
-        break
-    }
-
-    // Allow overriding the paths for testing
-    if (getEnvironmentVariable('DD_TEST_LOCAL_CONFIG_PATH') !== undefined) {
-      localConfigPath = getEnvironmentVariable('DD_TEST_LOCAL_CONFIG_PATH')
-    }
-    if (getEnvironmentVariable('DD_TEST_FLEET_CONFIG_PATH') !== undefined) {
-      fleetConfigPath = getEnvironmentVariable('DD_TEST_FLEET_CONFIG_PATH')
+        // Linux and other platforms as fallback
+        localConfigPath ??= '/etc/datadog-agent/application_monitoring.yaml'
+        fleetConfigPath ??= '/etc/datadog-agent/managed/datadog-agent/stable/application_monitoring.yaml'
     }
 
     return { localConfigPath, fleetConfigPath }

package/packages/dd-trace/src/{supported-configurations.json → config/supported-configurations.json}

@@ -73,11 +73,11 @@
     "DD_ENV": ["A"],
     "DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": ["A"],
+    "DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS": ["A"],
     "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_DIR": ["A"],
     "DD_EXTERNAL_ENV": ["A"],
-    "DD_FLAGGING_PROVIDER_ENABLED": ["A"],
     "DD_GIT_BRANCH": ["A"],
     "DD_GIT_COMMIT_AUTHOR_DATE": ["A"],
     "DD_GIT_COMMIT_AUTHOR_EMAIL": ["A"],
@@ -93,6 +93,7 @@
     "DD_GIT_TAG": ["A"],
     "DD_GIT_PULL_REQUEST_BASE_BRANCH": ["A"],
     "DD_GIT_PULL_REQUEST_BASE_BRANCH_SHA": ["A"],
+    "DD_GIT_COMMIT_HEAD_SHA": ["A"],
     "DD_GRPC_CLIENT_ERROR_STATUSES": ["A"],
     "DD_GRPC_SERVER_ERROR_STATUSES": ["A"],
     "DD_HEAP_SNAPSHOT_COUNT": ["A"],
@@ -112,6 +113,7 @@
     "DD_IAST_TELEMETRY_VERBOSITY": ["A"],
     "DD_INJECT_FORCE": ["A"],
     "DD_INJECTION_ENABLED": ["A"],
+    "DD_ENABLE_NX_SERVICE_NAME": ["A"],
     "DD_INSTRUMENTATION_CONFIG_ID": ["A"],
     "DD_INSTRUMENTATION_INSTALL_ID": ["A"],
     "DD_INSTRUMENTATION_INSTALL_TIME": ["A"],

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -1,13 +1,11 @@
 'use strict'
 
-const { URL } = require('url')
-
 // Load binding first to not import other modules if it throws
 const libdatadog = require('@datadog/libdatadog')
 const binding = libdatadog.load('crashtracker')
 
 const log = require('../log')
-const defaults = require('../config_defaults')
+const { getAgentUrl } = require('../agent/url')
 const pkg = require('../../../../package.json')
 const processTags = require('../process-tags')
 
@@ -52,8 +50,7 @@ class Crashtracker {
 
   // TODO: Send only configured values when defaults are fixed.
   #getConfig (config) {
-    const { hostname = defaults.hostname, port = defaults.port } = config
-    const url = config.url || new URL(`http://${hostname}:${port}`)
+    const url = getAgentUrl(config)
 
     return {
       additional_files: [],

package/packages/dd-trace/src/datastreams/processor.js

@@ -156,7 +156,7 @@ class DataStreamsProcessor {
       this.timer = setInterval(this.onInterval.bind(this), flushInterval)
       this.timer.unref()
     }
-    process.once('beforeExit', () => this.onInterval())
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(this.onInterval.bind(this))
   }
 
   onInterval () {

package/packages/dd-trace/src/datastreams/writer.js

@@ -1,12 +1,11 @@
 'use strict'
 
-const { URL, format } = require('url')
 const zlib = require('zlib')
 const pkg = require('../../../../package.json')
 const log = require('../log')
 const request = require('../exporters/common/request')
 const { MsgpackEncoder } = require('../msgpack')
-const defaults = require('../config_defaults')
+const { getAgentUrl } = require('../agent/url')
 
 const msgpack = new MsgpackEncoder()
 
@@ -32,12 +31,7 @@ function makeRequest (data, url, cb) {
 
 class DataStreamsWriter {
   constructor (config) {
-    const { hostname = defaults.hostname, port = defaults.port, url } = config
-    this._url = url || new URL(format({
-      protocol: 'http:',
-      hostname,
-      port
-    }))
+    this._url = getAgentUrl(config)
   }
 
   flush (payload) {

package/packages/dd-trace/src/debugger/devtools_client/condition.js

@@ -206,7 +206,7 @@ function isTypedArray (variable) {
 }
 
 function isInstanceOfCoreType (type, variable, fallback = `${variable} instanceof ${type}`) {
-  return `(process[Symbol.for('datadog:node:util:types')]?.is${type}?.(${variable}) ?? ${fallback})`
+  return `(globalThis[Symbol.for('dd-trace')].utilTypes?.is${type}?.(${variable}) ?? ${fallback})`
 }
 
 function getSize (variable) {