dd-trace 5.82.0 → 5.83.0

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

@@ -1,34 +1,202 @@
 '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)
+
+  // 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}

@@ -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

@@ -7,7 +7,7 @@ const libdatadog = require('@datadog/libdatadog')
 const binding = libdatadog.load('crashtracker')
 
 const log = require('../log')
-const defaults = require('../config_defaults')
+const defaults = require('../config/defaults')
 const pkg = require('../../../../package.json')
 const processTags = require('../process-tags')
 

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

@@ -6,7 +6,7 @@ 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 defaults = require('../config/defaults')
 
 const msgpack = new MsgpackEncoder()
 

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) {

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

@@ -2,7 +2,7 @@
 
 const { workerData: { config: parentConfig, parentThreadId, configPort } } = require('node:worker_threads')
 const { format } = require('node:url')
-const defaults = require('../../config_defaults')
+const defaults = require('../../config/defaults')
 const log = require('./log')
 
 const config = module.exports = {

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

@@ -6,7 +6,7 @@ const { stringify } = require('querystring')
 const request = require('../../exporters/common/request')
 const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('../../plugins/util/tags')
 const { version } = require('../../../../../package.json')
-const { getEnvironmentVariable } = require('../../config-helper')
+const { getValueFromEnvSources } = require('../../config/helper')
 const log = require('./log')
 const JSONBuffer = require('./json-buffer')
 const config = require('./config')
@@ -23,8 +23,8 @@ const hostname = getHostname()
 const service = config.service
 
 const ddtags = [
-  ['env', getEnvironmentVariable('DD_ENV')],
-  ['version', getEnvironmentVariable('DD_VERSION')],
+  ['env', getValueFromEnvSources('DD_ENV')],
+  ['version', getValueFromEnvSources('DD_VERSION')],
   ['debugger_version', version],
   ['host_name', hostname],
   [GIT_COMMIT_SHA, config.commitSHA],

package/packages/dd-trace/src/debugger/devtools_client/snapshot/constants.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { getEnvironmentVariable } = require('../../../config-helper')
+const { getEnvironmentVariable } = require('../../../config/helper')
 
 const largeObjectSkipThreshold = Number(
   getEnvironmentVariable('_DD_DYNAMIC_INSTRUMENTATION_EXPERIMENTAL_LARGE_OBJECT_SKIP_THRESHOLD')

package/packages/dd-trace/src/debugger/index.js

@@ -10,26 +10,49 @@ const getDebuggerConfig = require('./config')
 let worker = null
 let configChannel = null
 let ackId = 0
+let rcAckCallbacks = null
+let rc = null
 
 // eslint-disable-next-line eslint-rules/eslint-process-env
 const { NODE_OPTIONS, ...env } = process.env
 
 module.exports = {
+  isStarted,
   start,
-  configure
+  configure,
+  stop
 }
 
-function start (config, rc) {
+/**
+ * Check if the Debugger worker is currently running
+ *
+ * @returns {boolean} True if the worker is started, false otherwise
+ */
+function isStarted () {
+  return worker !== null
+}
+
+/**
+ * Start the Debugger worker thread.
+ * Creates a worker thread, sets up message channels, and registers
+ * the LIVE_DEBUGGING product handler with remote config.
+ * Does nothing if the worker is already started.
+ *
+ * @param {object} config - The tracer configuration object
+ * @param {object} rcInstance - The RemoteConfig instance
+ */
+function start (config, rcInstance) {
   if (worker !== null) return
 
   log.debug('[debugger] Starting Dynamic Instrumentation client...')
 
-  const rcAckCallbacks = new Map()
+  rc = rcInstance
+  rcAckCallbacks = new Map()
   const probeChannel = new MessageChannel()
   const logChannel = new MessageChannel()
   configChannel = new MessageChannel()
 
-  process[Symbol.for('datadog:node:util:types')] = types
+  globalThis[Symbol.for('dd-trace')].utilTypes = types
 
   readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
     const action = 'apply'
@@ -84,19 +107,10 @@ function start (config, rc) {
   worker.on('error', (err) => log.error('[debugger] worker thread error', err))
   worker.on('messageerror', (err) => log.error('[debugger] received "messageerror" from worker', err))
 
-  worker.on('exit', (code) => {
+  worker.once('exit', (code) => {
     const error = new Error(`Dynamic Instrumentation worker thread exited unexpectedly with code ${code}`)
-
     log.error('[debugger] worker thread exited unexpectedly', error)
-
-    // Be nice, clean up now that the worker thread encountered an issue and we can't continue
-    rc.removeProductHandler('LIVE_DEBUGGING')
-    worker.removeAllListeners()
-    configChannel = null
-    for (const ackId of rcAckCallbacks.keys()) {
-      rcAckCallbacks.get(ackId)(error)
-      rcAckCallbacks.delete(ackId)
-    }
+    cleanup(error) // Be nice, clean up now that the worker thread encountered an issue and we can't continue
   })
 
   worker.unref()
@@ -108,11 +122,65 @@ function start (config, rc) {
   configChannel.port2.unref()
 }
 
+/**
+ * Reconfigure the Debugger worker with updated settings.
+ * Sends the new configuration to the worker thread via the config channel.
+ * Does nothing if the worker is not started.
+ *
+ * @param {object} config - The updated tracer configuration object
+ */
 function configure (config) {
   if (configChannel === null) return
   configChannel.port2.postMessage(getDebuggerConfig(config))
 }
 
+/**
+ * Stop the Debugger worker thread.
+ * Terminates the worker and cleans up resources.
+ * Safe to call even if the worker is not started.
+ */
+function stop () {
+  if (worker === null) return
+
+  log.debug('[debugger] Stopping Dynamic Instrumentation client...')
+
+  try {
+    worker.terminate()
+    cleanup() // Graceful shutdown - termination succeeded
+  } catch (err) {
+    log.error('[debugger] Error terminating worker', err)
+    cleanup(err) // Cleanup with error - termination failed
+  }
+}
+
+/**
+ * Internal cleanup function to reset all debugger resources.
+ * Called when stopping the debugger or when the worker exits unexpectedly.
+ *
+ * @param {Error} [error] - Optional error to pass to pending ack callbacks (for unexpected exits)
+ */
+function cleanup (error) {
+  if (rc) {
+    rc.removeProductHandler('LIVE_DEBUGGING')
+    rc = null
+  }
+  if (worker) {
+    worker.removeAllListeners()
+    worker = null
+  }
+  configChannel = null
+
+  // Call any pending ack callbacks
+  // Pass error for unexpected exits, or undefined for graceful shutdown
+  if (rcAckCallbacks) {
+    for (const ackId of rcAckCallbacks.keys()) {
+      rcAckCallbacks.get(ackId)(error)
+      rcAckCallbacks.delete(ackId)
+    }
+    rcAckCallbacks = null
+  }
+}
+
 function readProbeFile (path, cb) {
   if (!path) return
 

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

@@ -8,7 +8,7 @@ const { URL, format } = require('url')
 const request = require('./exporters/common/request')
 const log = require('./log')
 const Histogram = require('./histogram')
-const defaults = require('./config_defaults')
+const defaults = require('./config/defaults')
 
 const MAX_BUFFER_SIZE = 1024 // limit from the agent
 
@@ -360,7 +360,7 @@ class CustomMetrics {
     // TODO(bengl) this magic number should be configurable
     setInterval(flush, 10 * 1000).unref()
 
-    process.once('beforeExit', flush)
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(flush)
   }
 
   increment (stat, value = 1, tags) {

package/packages/dd-trace/src/encode/0.4.js

@@ -4,7 +4,7 @@ const { MsgpackChunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
 const { isTrue } = require('../util')
 const { memoize } = require('../log/utils')
-const { getEnvironmentVariable } = require('../config-helper')
+const { getValueFromEnvSources } = require('../config/helper')
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
@@ -31,7 +31,7 @@ class AgentEncoder {
     this._stringBytes = new MsgpackChunk()
     this._writer = writer
     this._reset()
-    this._debugEncoding = isTrue(getEnvironmentVariable('DD_TRACE_ENCODING_DEBUG'))
+    this._debugEncoding = isTrue(getValueFromEnvSources('DD_TRACE_ENCODING_DEBUG'))
     this._config = this._writer?._config
   }
 

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

@@ -2,7 +2,7 @@
 
 const fs = require('fs')
 const exporters = require('../../../ext/exporters')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const constants = require('./constants')
 
 module.exports = function getExporter (name) {

package/packages/dd-trace/src/exporters/agent/index.js

@@ -2,7 +2,7 @@
 
 const { URL, format } = require('url')
 const log = require('../../log')
-const defaults = require('../../config_defaults')
+const defaults = require('../../config/defaults')
 const Writer = require('./writer')
 
 class AgentExporter {
@@ -31,9 +31,7 @@ class AgentExporter {
       config
     })
 
-    process.once('beforeExit', () => {
-      this.flush()
-    })
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(this.flush.bind(this))
   }
 
   setUrl (url) {