dd-trace 6.15.0 → 6.17.0

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

@@ -121,6 +121,23 @@ const transformers = {
     }
     return configValue
   },
+  /**
+   * @param {string} value
+   * @param {string} optionName
+   * @param {string} source
+   * @returns {number | 'auto' | undefined}
+   */
+  normalizeProfilingHeapLimitExtensionSize (value, optionName, source) {
+    if (value.toLowerCase() === 'auto') {
+      return 'auto'
+    }
+
+    const parsed = parsers.INT(value)
+    if (parsed === undefined) {
+      warnInvalidValue(value, optionName, source, 'Heap limit extension size must be an integer or "auto"')
+    }
+    return parsed
+  },
   /**
    * Parses DD_PROFILING_DEBUG_UPLOAD_COMPRESSION ('on' | 'off' | 'gzip[-1..9]' | 'zstd[-1..22]')
    * into the codec and level the profiler uploads with. The value's shape is already range-checked
@@ -199,6 +216,17 @@ const transformers = {
       return new URL(value)
     } catch {}
   },
+  /**
+   * @param {string} value
+   * @param {string} optionName
+   * @param {string} source
+   * @returns {string | undefined}
+   */
+  validateHttpUrl (value, optionName, source) {
+    const url = transformers.toURL(value)
+    if (url?.protocol === 'http:' || url?.protocol === 'https:') return value
+    warnInvalidValue(value, optionName, source, 'Invalid HTTP URL')
+  },
   validatePropagationStyles (value, optionName) {
     value = transformers.toLowerCase(value)
     for (let index = 0; index < value.length; index++) {
@@ -261,28 +289,28 @@ const parsers = {
     }
     return parsed
   },
-  ARRAY (raw) {
+  ARRAY (raw, optionName) {
     // TODO: Make the parsing a helper that is reused everywhere.
     const result = []
     if (!raw) {
       return result
     }
+    // Dynamic ATR buckets are positional; retain empty slots for downstream validation.
+    const preserveEmptyEntries = optionName === 'DD_CIVISIBILITY_DYNAMIC_ATR_BUCKETS'
     let valueStart = 0
     for (let i = 0; i < raw.length; i++) {
       const char = raw[i]
       if (char === ',') {
         const value = raw.slice(valueStart, i).trim()
-        // Auto filter empty entries.
-        if (value.length > 0) {
+        if (value.length > 0 || preserveEmptyEntries) {
           result.push(value)
         }
         valueStart = i + 1
       }
     }
-    if (valueStart < raw.length) {
+    if (valueStart < raw.length || preserveEmptyEntries) {
       const value = raw.slice(valueStart).trim()
-      // Auto filter empty entries.
-      if (value.length > 0) {
+      if (value.length > 0 || preserveEmptyEntries) {
         result.push(value)
       }
     }

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

@@ -2,38 +2,25 @@
 
 const RemoteConfigCapabilities = require('../remote_config/capabilities')
 const log = require('../log')
-const tagger = require('../tagger')
 
 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
+ * Manages multiple remote configurations with priority-based merging
  */
-class RCClientLibConfigManager {
+class RCClientManager {
   /**
    * @param {string} currentService - Current service name
    * @param {string} currentEnv - Current environment name
    */
   constructor (currentService, currentEnv) {
-    this.configs = new Map() // config_id -> { conf, priority }
+    this.configs = new Map() // config_id -> { priority, sdkConfig }
     this.currentService = currentService
     this.currentEnv = currentEnv
   }
@@ -44,7 +31,6 @@ class RCClientLibConfigManager {
    *   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
@@ -71,7 +57,6 @@ class RCClientLibConfigManager {
    * 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
@@ -108,8 +93,10 @@ class RCClientLibConfigManager {
       return
     }
 
+    const sdkConfig = conf.sdk_config?.config
+
     const priority = this.calculatePriority(conf)
-    this.configs.set(configId, { conf, priority })
+    this.configs.set(configId, { priority, sdkConfig })
 
     log.debug('[config/remote_config] Added config %s with priority %d', configId, priority)
   }
@@ -127,23 +114,25 @@ class RCClientLibConfigManager {
   }
 
   /**
-   * Get merged lib_config with higher priority configs overriding lower priority ones
+   * Get merged config with higher priority configs overriding lower priority ones
    *
-   * @returns {RemoteConfigOptions|null} Merged config object or null if no configs present
+   * @returns {Partial<Record<import('./helper').SupportedEnvKey, string>>|null} Merged config object or
+   *   null if no configs present
    */
-  getMergedLibConfig () {
+  getMergedConfig () {
     if (this.configs.size === 0) return null
 
-    let hasLibConfig = false
+    let hasConfig = 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)
+      .reduce((merged, { sdkConfig }) => {
+        if (sdkConfig == null) return merged
+        hasConfig = true
+        return Object.assign(merged, sdkConfig)
       }, {})
 
-    return hasLibConfig ? merged : null
+    return hasConfig ? merged : null
   }
 }
 
@@ -155,106 +144,33 @@ class RCClientLibConfigManager {
  * @param {() => void} onConfigUpdated - Function to call when config is updated
  */
 function enable (rc, config, onConfigUpdated) {
-  // This tracer supports receiving config subsets via the APM_TRACING product handler.
+  // This tracer supports receiving multiple simultaneous targeted sdk_config payloads under the
+  // APM_TRACING product (e.g. an org-level and a service-level config) and merges them by priority.
   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)
-
-  // Debugger
-  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION, true)
-  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_LIVE_DEBUGGING, true)
+  // This tracer supports receiving the full SDK_CONFIGURATION settings map, env-var-keyed.
+  rc.updateCapabilities(RemoteConfigCapabilities.SDK_CONFIGURATION, true)
 
-  // Code Origin
-  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_CODE_ORIGIN, true)
+  const sdkConfigManager = new RCClientManager(config.service, config.env)
 
-  const rcClientLibConfigManager = new RCClientLibConfigManager(config.service, config.env)
-
-  // Subscribe to APM_TRACING product (setBatchHandler used below doesn't automatically subscribe)
+  // SDK_CONFIGURATION is delivered as a flat sdk_config map under the APM_TRACING product.
   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)
+      sdkConfigManager.removeConfig(item.id)
       transaction.ack(item.path)
     }
 
     for (const item of [...toApply, ...toModify]) {
-      rcClientLibConfigManager.addConfig(item.id, item.file)
+      sdkConfigManager.addConfig(item.id, item.file)
       transaction.ack(item.path)
     }
 
-    /** @type {import('../config').TracerOptions|null|RemoteConfigOptions} */
-    let mergedLibConfig = rcClientLibConfigManager.getMergedLibConfig()
-
-    if (mergedLibConfig) {
-      mergedLibConfig = transformRemoteConfigToLocalOption(mergedLibConfig)
-    }
-
-    config.setRemoteConfig(mergedLibConfig)
+    config.setRemoteConfig(sdkConfigManager.getMergedConfig())
 
     onConfigUpdated()
   })
 }
-
-/**
- * @param {RemoteConfigOptions} libConfig
- * @returns {import('../config').TracerOptions}
- */
-function transformRemoteConfigToLocalOption (libConfig) {
-  const normalizedConfig = {}
-  for (const [name, value] of Object.entries(libConfig)) {
-    if (value !== null) {
-      normalizedConfig[optionLookupTable[name] ?? name] = transformers[name]?.(value) ?? value
-    }
-  }
-  return normalizedConfig
-}
-
-// This is intermediate solution until remote config is reworked to handle all known entries with proper names
-const optionLookupTable = {
-  dynamic_instrumentation_enabled: 'dynamicInstrumentation.enabled',
-  code_origin_enabled: 'codeOriginForSpans.enabled',
-  tracing_sampling_rate: 'sampleRate',
-  log_injection_enabled: 'logInjection',
-  tracing_enabled: 'DD_TRACE_ENABLED',
-  tracing_sampling_rules: 'samplingRules',
-  tracing_header_tags: 'headerTags',
-  tracing_tags: 'tags',
-}
-
-const transformers = {
-  tracing_sampling_rules (samplingRules) {
-    for (const rule of samplingRules) {
-      if (rule.tags) {
-        const reformattedTags = {}
-        for (const tag of rule.tags) {
-          reformattedTags[tag.key] = tag.value_glob
-        }
-        rule.tags = reformattedTags
-      }
-    }
-    return samplingRules
-  },
-  tracing_header_tags (headerTags) {
-    return headerTags?.map(tag => {
-      return tag.tag_name ? `${tag.header}:${tag.tag_name}` : tag.header
-    })
-  },
-  tracing_tags (tags) {
-    const normalizedTags = {}
-    tagger.add(normalizedTags, tags)
-    return normalizedTags
-  },
-}