dd-trace 5.86.0 → 5.88.0

package/packages/dd-trace/src/plugins/util/inferred_proxy.js

@@ -14,12 +14,17 @@ const PROXY_HEADER_PATH = 'x-dd-proxy-path'
 const PROXY_HEADER_HTTPMETHOD = 'x-dd-proxy-httpmethod'
 const PROXY_HEADER_DOMAIN = 'x-dd-proxy-domain-name'
 const PROXY_HEADER_STAGE = 'x-dd-proxy-stage'
+const PROXY_HEADER_REGION = 'x-dd-proxy-region'
 
 const supportedProxies = {
   'aws-apigateway': {
     spanName: 'aws.apigateway',
     component: 'aws-apigateway',
   },
+  'azure-apim': {
+    spanName: 'azure.apim',
+    component: 'azure-apim',
+  },
 }
 
 function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, config, startSpanHelper) {
@@ -53,6 +58,7 @@ function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, co
       [HTTP_METHOD]: proxyContext.method,
       [HTTP_URL]: proxyContext.domainName + proxyContext.path,
       stage: proxyContext.stage,
+      region: proxyContext.region,
     },
   }, traceCtx, config)
 
@@ -91,6 +97,7 @@ function extractInferredProxyContext (headers) {
     stage: headers[PROXY_HEADER_STAGE],
     domainName: headers[PROXY_HEADER_DOMAIN],
     proxySystemName: headers[PROXY_HEADER_SYSTEM],
+    region: headers[PROXY_HEADER_REGION],
   }
 }
 

package/packages/dd-trace/src/plugins/util/test.js

@@ -145,6 +145,10 @@ const DD_CAPABILITIES_TEST_MANAGEMENT_QUARANTINE = '_dd.library_capabilities.tes
 const DD_CAPABILITIES_TEST_MANAGEMENT_DISABLE = '_dd.library_capabilities.test_management.disable'
 const DD_CAPABILITIES_TEST_MANAGEMENT_ATTEMPT_TO_FIX = '_dd.library_capabilities.test_management.attempt_to_fix'
 const DD_CAPABILITIES_FAILED_TEST_REPLAY = '_dd.library_capabilities.failed_test_replay'
+
+// Library configuration request error tag
+const DD_CI_LIBRARY_CONFIGURATION_ERROR = '_dd.ci.library_configuration_error'
+
 const UNSUPPORTED_TIA_FRAMEWORKS = new Set(['playwright', 'vitest'])
 const UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE = new Set(['cucumber', 'mocha'])
 const MINIMUM_FRAMEWORK_VERSION_FOR_EFD = {
@@ -202,6 +206,22 @@ const TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED = 'test.test_management.attempt_to_f
 const POSSIBLE_BASE_BRANCHES = ['main', 'master', 'preprod', 'prod', 'dev', 'development', 'trunk']
 const BASE_LIKE_BRANCH_FILTER = /^(main|master|preprod|prod|dev|development|trunk|release\/.*|hotfix\/.*)$/
 
+/**
+ * Returns request error tags from a test session span for propagation to child events.
+ * @param {{ context: () => { _tags?: Record<string, string> } } | undefined} sessionSpan
+ * @returns {Record<string, string>}
+ */
+function getSessionRequestErrorTags (sessionSpan) {
+  const tags = sessionSpan?.context()._tags
+  if (!tags || typeof tags !== 'object') return {}
+  if (tags[DD_CI_LIBRARY_CONFIGURATION_ERROR] === 'true') {
+    return {
+      [DD_CI_LIBRARY_CONFIGURATION_ERROR]: 'true',
+    }
+  }
+  return {}
+}
+
 module.exports = {
   TEST_CODE_OWNERS,
   TEST_SESSION_NAME,
@@ -278,6 +298,7 @@ module.exports = {
   removeInvalidMetadata,
   parseAnnotations,
   getIsFaultyEarlyFlakeDetection,
+  getEfdRetryCount,
   TEST_BROWSER_DRIVER,
   TEST_BROWSER_DRIVER_VERSION,
   TEST_BROWSER_NAME,
@@ -308,6 +329,8 @@ module.exports = {
   TEST_MANAGEMENT_ENABLED,
   TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
   getLibraryCapabilitiesTags,
+  getSessionRequestErrorTags,
+  DD_CI_LIBRARY_CONFIGURATION_ERROR,
   checkShaDiscrepancies,
   getPullRequestDiff,
   getPullRequestBaseBranch,
@@ -846,6 +869,31 @@ function parseAnnotations (annotations) {
   }, {})
 }
 
+/**
+ * Given a test's first-execution duration (ms) and the slow_test_retries map
+ * from the backend, return how many EFD retries to run.
+ *
+ * Returns 0 when the test is too slow to retry (≥ 5 min).
+ *
+ * @param {number} durationMs
+ * @param {Record<string, number>} slowTestRetries  e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+ * @returns {number}
+ */
+function getEfdRetryCount (durationMs, slowTestRetries) {
+  const thresholds = [
+    { limitMs: 5 * 1000, key: '5s' },
+    { limitMs: 10 * 1000, key: '10s' },
+    { limitMs: 30 * 1000, key: '30s' },
+    { limitMs: 5 * 60 * 1000, key: '5m' },
+  ]
+  for (const { limitMs, key } of thresholds) {
+    if (durationMs < limitMs) {
+      return slowTestRetries[key] ?? 0
+    }
+  }
+  return 0 // ≥ 5 min — abort
+}
+
 function getIsFaultyEarlyFlakeDetection (projectSuites, testsBySuiteName, faultyThresholdPercentage) {
   let newSuites = 0
   for (const suite of projectSuites) {

package/packages/dd-trace/src/plugins/util/web.js

@@ -119,7 +119,7 @@ const web = {
       context.span.context()._name = name
       span = context.span
     } else {
-      span = web.startChildSpan(tracer, config, name, req, traceCtx)
+      span = web.startServerlessSpanWithInferredProxy(tracer, config, name, req, traceCtx)
     }
 
     context.tracer = tracer
@@ -275,7 +275,7 @@ const web = {
     return context.middleware.at(-1)
   },
 
-  startChildSpan (tracer, config, name, req, traceCtx) {
+  startServerlessSpanWithInferredProxy (tracer, config, name, req, traceCtx) {
     const headers = req.headers
     const reqCtx = contexts.get(req)
     const { storage } = require('../../../../datadog-core')
@@ -338,12 +338,12 @@ const web = {
     }
   },
 
-  finishSpan (context) {
+  finishSpan (context, spanType) {
     const { req, res } = context
 
     if (context.finished && !req.stream) return
 
-    addRequestTags(context, this.TYPE)
+    addRequestTags(context, spanType)
     addResponseTags(context)
 
     context.config.hooks.request(context.span, req, res)
@@ -353,14 +353,14 @@ const web = {
     context.finished = true
   },
 
-  finishAll (context) {
+  finishAll (context, spanType) {
     for (const beforeEnd of context.beforeEnd) {
       beforeEnd()
     }
 
     web.finishMiddleware(context)
 
-    web.finishSpan(context)
+    web.finishSpan(context, spanType)
 
     finishInferredProxySpan(context)
   },
@@ -457,12 +457,13 @@ function reactivate (req, fn) {
 function addRequestTags (context, spanType) {
   const { req, span, inferredProxySpan, config } = context
   const url = extractURL(req)
+  const type = spanType ?? WEB
 
   span.addTags({
     [HTTP_URL]: obfuscateQs(config, url),
     [HTTP_METHOD]: req.method,
     [SPAN_KIND]: SERVER,
-    [SPAN_TYPE]: spanType,
+    [SPAN_TYPE]: type,
     [HTTP_USERAGENT]: req.headers['user-agent'],
   })
 

package/packages/dd-trace/src/profiling/exporter_cli.js

@@ -17,6 +17,7 @@ function exporterFromURL (url) {
   if (url.protocol === 'file:') {
     return new FileExporter({ pprofPrefix: fileURLToPath(url) })
   }
+  // TODO: Why is DD_INJECTION_ENABLED a comma separated list?
   const injectionEnabled = (getValueFromEnvSources('DD_INJECTION_ENABLED') ?? '').split(',')
   const libraryInjected = injectionEnabled.length > 0
   const profilingEnabled = (getValueFromEnvSources('DD_PROFILING_ENABLED') ?? '').toLowerCase()

package/packages/dd-trace/src/propagation-hash/index.js

@@ -0,0 +1,145 @@
+'use strict'
+
+const { fnv64 } = require('../datastreams/fnv')
+const log = require('../log')
+
+/**
+ * PropagationHashManager is a singleton that manages the propagation hash computation.
+ * The propagation hash is an FNV-1a 64-bit hash combining:
+ * - Process tags (entrypoint info, package.json name, etc.)
+ * - Container tags hash (received from the Datadog agent)
+ *
+ * This hash is used to correlate traces with database operations (DBM) and
+ * data stream pathways (DSM) for enhanced observability.
+ */
+class PropagationHashManager {
+  _containerTagsHash = null
+  _cachedHash = null
+  _cachedHashString = null
+  _cachedHashBase64 = null
+  _config = null
+
+  /**
+   * Configure the propagation hash manager with tracer config
+   * @param {object} config - Tracer configuration
+   */
+  configure (config) {
+    this._config = config
+  }
+
+  /**
+   * Check if process tags propagation is enabled
+   * @returns {boolean}
+   */
+  isEnabled () {
+    return this._config?.propagateProcessTags?.enabled === true
+  }
+
+  /**
+   * Update the container tags hash received from the agent
+   * @param {string} hash - Container tags hash from agent response
+   */
+  updateContainerTagsHash (hash) {
+    if (hash !== this._containerTagsHash) {
+      log.debug('Updating container tags hash: %s', hash)
+      this._containerTagsHash = hash
+      this._invalidateCache()
+    }
+  }
+
+  /**
+   * Get the propagation hash as a BigInt
+   * @returns {bigint | null} The propagation hash or null if disabled/unavailable
+   */
+  getHash () {
+    if (!this.isEnabled()) {
+      return null
+    }
+    if (this._cachedHash) {
+      return this._cachedHash
+    }
+    this._computeHash()
+    return this._cachedHash
+  }
+
+  /**
+   * Get the propagation hash as a hexadecimal string
+   * @returns {string|null} The propagation hash in hex format or null if disabled/unavailable
+   */
+  getHashString () {
+    const hash = this.getHash()
+    if (!hash) {
+      return null
+    }
+    if (!this._cachedHashString) {
+      this._cachedHashString = hash.toString(16)
+    }
+    return this._cachedHashString
+  }
+
+  /**
+   * Get the propagation hash as a base64 string
+   * @returns {string|null} The propagation hash in base64 format or null if disabled/unavailable
+   */
+  getHashBase64 () {
+    const hash = this.getHash()
+    if (!hash) {
+      return null
+    }
+    if (!this._cachedHashBase64) {
+      // Convert BigInt to 8-byte buffer (64-bit hash)
+      const buffer = Buffer.allocUnsafe(8)
+      // Write as big-endian 64-bit unsigned integer
+      buffer.writeBigUInt64BE(hash, 0)
+      this._cachedHashBase64 = buffer.toString('base64')
+    }
+    return this._cachedHashBase64
+  }
+
+  /**
+   * Compute the propagation hash using FNV-1a algorithm
+   * @private
+   */
+  _computeHash () {
+    try {
+      const processTags = require('../process-tags')
+
+      // Combine process tags and container tags hash
+      // Process tags are already serialized as a comma-separated string
+      const input = processTags.serialized + (this._containerTagsHash || '')
+
+      if (!input) {
+        // If both are empty, don't compute a hash
+        this._cachedHash = null
+        this._cachedHashString = null
+        this._cachedHashBase64 = null
+        return
+      }
+
+      // Compute FNV-1a 64-bit hash
+      this._cachedHash = fnv64(input)
+      this._cachedHashString = null // Will be computed on demand
+      this._cachedHashBase64 = null // Will be computed on demand
+
+      log.debug('Computed propagation hash from input (length=%s): "%s"', input.length, this._cachedHash.toString(16))
+    } catch (e) {
+      log.error('Error computing propagation hash', e)
+      this._cachedHash = null
+      this._cachedHashString = null
+      this._cachedHashBase64 = null
+    }
+  }
+
+  /**
+   * Invalidate the cached hash
+   * @private
+   */
+  _invalidateCache () {
+    this._cachedHash = null
+    this._cachedHashString = null
+    this._cachedHashBase64 = null
+  }
+}
+
+// Export singleton instance
+module.exports = new PropagationHashManager()

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

@@ -102,6 +102,10 @@ class Tracer extends NoopProxy {
     try {
       const config = getConfig(options) // TODO: support dynamic code config
 
+      // Configure propagation hash manager for process tags + container tags
+      const propagationHash = require('./propagation-hash')
+      propagationHash.configure(config)
+
       if (config.crashtracking.enabled) {
         require('./crashtracking').start(config)
       }

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

@@ -238,7 +238,7 @@ function captureHeapSpace () {
   const stats = v8.getHeapSpaceStatistics()
 
   for (let i = 0, l = stats.length; i < l; i++) {
-    const tags = [`space:${stats[i].space_name}`]
+    const tags = [`heap_space:${stats[i].space_name}`]
 
     client.gauge('runtime.node.heap.size.by.space', stats[i].space_size, tags)
     client.gauge('runtime.node.heap.used_size.by.space', stats[i].space_used_size, tags)

package/packages/dd-trace/src/startup-log.js

@@ -4,7 +4,7 @@ const os = require('os')
 const { inspect } = require('util')
 const tracerVersion = require('../../../package.json').version
 const { getAgentUrl } = require('./agent/url')
-const { info, warn } = require('./log/writer')
+const { warn } = require('./log/writer')
 
 const errors = {}
 let config
@@ -29,7 +29,7 @@ function startupLog (agentError) {
     out.agent_error = agentError.message
   }
 
-  info('DATADOG TRACER CONFIGURATION - ' + out)
+  warn('DATADOG TRACER CONFIGURATION - ' + out)
   if (agentError) {
     warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
     errors.agentError = {
@@ -74,7 +74,7 @@ function tracerInfo () {
     runtime_metrics_enabled: !!config.runtimeMetrics,
     profiling_enabled: config.profiling?.enabled === 'true' || config.profiling?.enabled === 'auto',
     integrations_loaded: Object.keys(pluginManager._pluginsByName),
-    appsec_enabled: !!config.appsec.enabled,
+    appsec_enabled: config.appsec.enabled,
     data_streams_enabled: !!config.dsmEnabled,
   }
 

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/bullmq.json

@@ -1,106 +0,0 @@
-[
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/cjs/classes/queue.js"
-    },
-    "functionQuery": {
-      "methodName": "add",
-      "className": "Queue",
-      "kind": "Async"
-    },
-    "channelName": "Queue_add"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/cjs/classes/queue.js"
-    },
-    "functionQuery": {
-      "methodName": "addBulk",
-      "className": "Queue",
-      "kind": "Async"
-    },
-    "channelName": "Queue_addBulk"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/cjs/classes/worker.js"
-    },
-    "functionQuery": {
-      "methodName": "callProcessJob",
-      "className": "Worker",
-      "kind": "Async"
-    },
-    "channelName": "Worker_callProcessJob"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/cjs/classes/flow-producer.js"
-    },
-    "functionQuery": {
-      "methodName": "add",
-      "className": "FlowProducer",
-      "kind": "Async"
-    },
-    "channelName": "FlowProducer_add"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/esm/classes/queue.js"
-    },
-    "functionQuery": {
-      "methodName": "add",
-      "className": "Queue",
-      "kind": "Async"
-    },
-    "channelName": "Queue_add"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/esm/classes/queue.js"
-    },
-    "functionQuery": {
-      "methodName": "addBulk",
-      "className": "Queue",
-      "kind": "Async"
-    },
-    "channelName": "Queue_addBulk"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/esm/classes/worker.js"
-    },
-    "functionQuery": {
-      "methodName": "callProcessJob",
-      "className": "Worker",
-      "kind": "Async"
-    },
-    "channelName": "Worker_callProcessJob"
-  },
-  {
-    "module": {
-      "name": "bullmq",
-      "versionRange": ">=5.66.0",
-      "filePath": "dist/esm/classes/flow-producer.js"
-    },
-    "functionQuery": {
-      "methodName": "add",
-      "className": "FlowProducer",
-      "kind": "Async"
-    },
-    "channelName": "FlowProducer_add"
-  }
-]