dd-trace 5.114.0 → 5.116.0

package/packages/dd-trace/src/opentracing/propagation/log.js

@@ -8,8 +8,13 @@ class LogPropagator {
     this._config = config
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, unknown>} [carrier]
+   * @returns {Record<string, unknown> | undefined}
+   */
   inject (spanContext, carrier) {
-    if (!carrier) return
+    if (carrier === null) return
 
     const dd = {}
     let hasField = false
@@ -35,7 +40,11 @@ class LogPropagator {
       hasField = true
     }
 
-    if (hasField) carrier.dd = dd
+    if (!hasField) return
+
+    carrier ??= {}
+    carrier.dd = dd
+    return carrier
   }
 
   extract (carrier) {

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -8,6 +8,7 @@ const log = require('../../log')
 const tags = require('../../../../../ext/tags')
 const { getConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
+const { hasTraceSourcePropagationTag } = require('../../standalone/tracesource')
 const telemetryMetrics = require('../../telemetry/metrics')
 const { DD_MAJOR } = require('../../../../../version')
 
@@ -119,22 +120,35 @@ class TextMapPropagator {
     return this.#baggageTagKeysSet
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   inject (spanContext, carrier) {
-    if (!carrier) return
-    this._injectBaggageItems(spanContext, carrier)
-    if (!spanContext) return
+    if (carrier === null) return
+    let injectedCarrier = this._injectBaggageItems(spanContext, carrier)
+    if (!spanContext) return injectedCarrier
 
-    this._injectDatadog(spanContext, carrier)
-    this._injectB3MultipleHeaders(spanContext, carrier)
-    this._injectB3SingleHeader(spanContext, carrier)
-    this._injectTraceparent(spanContext, carrier)
-
-    if (injectCh.hasSubscribers) {
-      injectCh.publish({ spanContext, carrier })
+    const injectTraceContext = this._config.apmTracingEnabled !== false ||
+      hasTraceSourcePropagationTag(spanContext._trace.tags)
+    if (injectTraceContext) {
+      injectedCarrier = this._injectDatadog(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
+      injectedCarrier = this._injectB3MultipleHeaders(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
+      injectedCarrier = this._injectB3SingleHeader(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
     }
+    injectedCarrier = this
+      ._injectTraceparent(spanContext, injectedCarrier ?? carrier, injectTraceContext) ?? injectedCarrier
+
+    if (injectedCarrier === undefined) return
+
+    carrier = injectedCarrier
+    if (injectCh.hasSubscribers) injectCh.publish({ spanContext, carrier })
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   }
 
   extract (carrier) {
@@ -156,15 +170,23 @@ class TextMapPropagator {
     return spanContext
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectDatadog (spanContext, carrier) {
     if (!this._hasPropagationStyle('inject', 'datadog')) return
 
+    carrier ??= {}
     carrier[traceKey] = spanContext.toTraceId()
     carrier[spanKey] = spanContext.toSpanId()
 
     this._injectOrigin(spanContext, carrier)
     this._injectSamplingPriority(spanContext, carrier)
     this._injectTags(spanContext, carrier)
+
+    return carrier
   }
 
   _injectOrigin (spanContext, carrier) {
@@ -183,7 +205,13 @@ class TextMapPropagator {
     }
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectBaggageItems (spanContext, carrier) {
+    let injectedCarrier
     if (this._config.legacyBaggageEnabled) {
       const baggageItems = spanContext?._baggageItems
       if (baggageItems) {
@@ -202,7 +230,8 @@ class TextMapPropagator {
           if (invalidHeaderValueCharExpr.test(headerValue)) {
             headerValue = encodeURIComponent(headerValue)
           }
-          carrier[headerName] = headerValue
+          injectedCarrier ??= carrier ?? {}
+          injectedCarrier[headerName] = headerValue
         }
       }
     }
@@ -213,7 +242,6 @@ class TextMapPropagator {
       let byteCounter = 0
 
       const baggageItems = getAllBaggageItems()
-      if (!baggageItems) return
       for (const key of Object.keys(baggageItems)) {
         const baggageKey = key.trim()
         if (!baggageTokenExpr.test(baggageKey)) continue
@@ -242,10 +270,13 @@ class TextMapPropagator {
 
       baggage = baggage.slice(0, -1)
       if (baggage) {
-        carrier.baggage = baggage
+        injectedCarrier ??= carrier ?? {}
+        injectedCarrier.baggage = baggage
         tracerMetrics.count('context_header_style.injected', ['header_style:baggage']).inc()
       }
     }
+
+    return injectedCarrier
   }
 
   _injectTags (spanContext, carrier) {
@@ -278,12 +309,18 @@ class TextMapPropagator {
     }
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectB3MultipleHeaders (spanContext, carrier) {
     // v5 also accepts the legacy `'b3'` spelling for multi; v6 routes `'b3'` to single-header.
     const hasB3multi = this._hasPropagationStyle('inject', 'b3multi') ||
       (DD_MAJOR < 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3multi) return
 
+    carrier ??= {}
     carrier[b3TraceKey] = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
     carrier[b3SampledKey] = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
@@ -295,14 +332,22 @@ class TextMapPropagator {
     if (spanContext._parentId) {
       carrier[b3ParentKey] = spanContext._parentId.toString(16)
     }
+
+    return carrier
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectB3SingleHeader (spanContext, carrier) {
     // v6 keeps `'b3 single header'` as a back-compat alias for callers that bypass parser normalisation.
     const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header') ||
       (DD_MAJOR >= 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3SingleHeader) return
 
+    carrier ??= {}
     const traceId = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     const spanId = spanContext._spanId.toString(16)
     const sampled = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
@@ -311,11 +356,30 @@ class TextMapPropagator {
     if (spanContext._parentId) {
       carrier[b3HeaderKey] += '-' + spanContext._parentId.toString(16)
     }
+
+    return carrier
   }
 
-  _injectTraceparent (spanContext, carrier) {
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string> | undefined} carrier
+   * @param {boolean} injectTraceContext
+   * @returns {Record<string, string> | undefined}
+   */
+  _injectTraceparent (spanContext, carrier, injectTraceContext) {
     if (!this._hasPropagationStyle('inject', 'tracecontext')) return
 
+    if (!injectTraceContext) {
+      const tracestate = TraceState.fromString(spanContext._tracestate?.toString())
+      tracestate.delete('dd')
+      const header = tracestate.toString()
+      if (!header) return
+      carrier ??= {}
+      carrier.tracestate = header
+      return carrier
+    }
+
+    carrier ??= {}
     const {
       _sampling: { priority, mechanism },
       _tracestate: ts = new TraceState(),
@@ -363,6 +427,8 @@ class TextMapPropagator {
     })
 
     carrier.tracestate = ts.toString()
+
+    return carrier
   }
 
   _hasPropagationStyle (mode, name) {

package/packages/dd-trace/src/opentracing/propagation/text_map_dsm.js

@@ -13,13 +13,22 @@ class DSMTextMapPropagator {
     this.config = config
   }
 
+  /**
+   * @param {object} ctx DSM pathway context.
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   inject (ctx, carrier) {
     if (!this.config.dsmEnabled) return
 
-    DsmPathwayCodec.encode(ctx, carrier)
+    const injectedCarrier = DsmPathwayCodec.encode(ctx, carrier)
+    if (injectedCarrier === undefined) return
 
+    carrier = injectedCarrier
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   }
 
   extract (carrier) {

package/packages/dd-trace/src/opentracing/tracer.js

@@ -101,6 +101,12 @@ class DatadogTracer {
     return span
   }
 
+  /**
+   * @param {Span|SpanContext} context
+   * @param {string} format
+   * @param {object} [carrier]
+   * @returns {object | undefined}
+   */
   inject (context, format, carrier) {
     if (context instanceof Span) {
       context = context.context()
@@ -110,7 +116,7 @@ class DatadogTracer {
       if (format !== 'text_map_dsm' && format !== formats.LOG) {
         this._prioritySampler.sample(context)
       }
-      this._propagators[format].inject(context, carrier)
+      return this._propagators[format].inject(context, carrier)
     } catch (e) {
       log.error('Error injecting trace', e)
       runtimeMetrics.increment('datadog.tracer.node.inject.errors', true)

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -181,6 +181,9 @@ module.exports = class CiPlugin extends Plugin {
       }
       this.tracer._exporter.getLibraryConfiguration(this.testConfiguration, (err, libraryConfig) => {
         if (err) {
+          this.libraryConfig = undefined
+          this.itrCorrelationId = undefined
+          this.skippableSuitesCoverage = undefined
           log.error('Library configuration could not be fetched. %s', err.message)
           this._addRequestErrorTag(DD_CI_LIBRARY_CONFIGURATION_ERROR_SETTINGS, err)
         } else {
@@ -955,17 +958,28 @@ module.exports = class CiPlugin extends Plugin {
     }
     log.debug('Removing all Dynamic Instrumentation probes')
     const promises = []
-    for (const fileLine of this.fileLineToProbeId.keys()) {
-      const [file, line] = fileLine.split(':')
-      promises.push(this.removeDiProbe({ file, line }))
+    for (const [activeProbeKey, probeId] of this.fileLineToProbeId) {
+      promises.push(this.#removeDiProbe(activeProbeKey, probeId))
     }
     return Promise.all(promises)
   }
 
+  /**
+   * @param {{ file: string, line: number }} location
+   */
   removeDiProbe ({ file, line }) {
-    const probeId = this.fileLineToProbeId.get(`${file}:${line}`)
-    log.warn('Removing probe from %s:%s, with id: %s', file, line, probeId)
-    this.fileLineToProbeId.delete(probeId)
+    const activeProbeKey = `${file}:${line}`
+    const probeId = this.fileLineToProbeId.get(activeProbeKey)
+    return this.#removeDiProbe(activeProbeKey, probeId)
+  }
+
+  /**
+   * @param {string} activeProbeKey
+   * @param {string|undefined} probeId
+   */
+  #removeDiProbe (activeProbeKey, probeId) {
+    log.warn('Removing probe from %s, with id: %s', activeProbeKey, probeId)
+    this.fileLineToProbeId.delete(activeProbeKey)
     return this.di.removeProbe(probeId)
   }
 

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

@@ -13,6 +13,7 @@ const {
   TELEMETRY_GIT_COMMAND_ERRORS,
 } = require('../../ci-visibility/telemetry')
 const { storage } = require('../../../../datadog-core')
+const { getSegment } = require('../../util')
 const {
   GIT_COMMIT_SHA,
   GIT_BRANCH,
@@ -251,7 +252,7 @@ function getGitRemoteName () {
   )
 
   if (upstreamRemote) {
-    return upstreamRemote.split('/')[0]
+    return getSegment(upstreamRemote, '/', 0)
   }
 
   const remotes = sanitizedExec(
@@ -263,7 +264,7 @@ function getGitRemoteName () {
     false
   )
 
-  return remotes.split('\n')[0] || 'origin'
+  return getSegment(remotes, '\n', 0) || 'origin'
 }
 
 function getSourceBranch () {

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

@@ -26,14 +26,27 @@ const supportedProxies = {
   'aws-apigateway': {
     spanName: 'aws.apigateway',
     component: 'aws-apigateway',
+    providesTimestamp: true,
   },
   'aws-httpapi': {
     spanName: 'aws.httpapi',
     component: 'aws-httpapi',
+    providesTimestamp: true,
   },
   'azure-apim': {
     spanName: 'azure.apim',
     component: 'azure-apim',
+    providesTimestamp: true,
+  },
+  'azure-gw': {
+    spanName: 'azure.app-gateway',
+    component: 'azure-gw',
+    providesTimestamp: false,
+  },
+  'azure-fd': {
+    spanName: 'azure.frontdoor',
+    component: 'azure-fd',
+    providesTimestamp: false,
   },
 }
 
@@ -109,21 +122,32 @@ function setInferredProxySpanTags (span, proxyContext) {
 }
 
 function extractInferredProxyContext (headers) {
-  if (!(PROXY_HEADER_START_TIME_MS in headers)) {
+  if (!(PROXY_HEADER_SYSTEM in headers)) {
+    return null
+  }
+  if (!Object.hasOwn(supportedProxies, headers[PROXY_HEADER_SYSTEM])) {
+    log.debug('Received headers to create inferred proxy span but headers include an unsupported proxy type: %s',
+      headers[PROXY_HEADER_SYSTEM])
+
     return null
   }
 
-  if (!(PROXY_HEADER_SYSTEM in headers && headers[PROXY_HEADER_SYSTEM] in supportedProxies)) {
-    log.debug('Received headers to create inferred proxy span but headers include an unsupported proxy type', headers)
+  const detectedProxy = supportedProxies[headers[PROXY_HEADER_SYSTEM]]
+
+  if (detectedProxy.providesTimestamp && !headers[PROXY_HEADER_START_TIME_MS]) {
     return null
   }
 
   return {
     requestTime: headers[PROXY_HEADER_START_TIME_MS]
       ? Number.parseInt(headers[PROXY_HEADER_START_TIME_MS], 10)
-      : null,
+      : Date.now(),
     method: headers[PROXY_HEADER_HTTPMETHOD],
-    path: headers[PROXY_HEADER_PATH],
+    path: headers[PROXY_HEADER_PATH]
+      ? (headers[PROXY_HEADER_PATH].startsWith('/')
+          ? headers[PROXY_HEADER_PATH]
+          : '/' + headers[PROXY_HEADER_PATH])
+      : headers[PROXY_HEADER_PATH],
     stage: headers[PROXY_HEADER_STAGE],
     domainName: headers[PROXY_HEADER_DOMAIN],
     proxySystemName: headers[PROXY_HEADER_SYSTEM],

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

@@ -6,6 +6,7 @@ const { URL } = require('url')
 const { getLageTestSessionName } = require('../../ci-visibility/lage')
 const log = require('../../log')
 const { getEnvironmentVariable } = require('../../config/helper')
+const { getSegment } = require('../../util')
 const satisfies = require('../../../../../vendor/dist/semifies')
 
 const istanbul = require('../../../../../vendor/dist/istanbul-lib-coverage')
@@ -77,6 +78,11 @@ const {
  *
  * @typedef {{ service?: string, isServiceUserProvided?: boolean }} TestEnvironmentConfig
  * @typedef {Record<string, string|number|undefined>} TestEnvironmentMetadata
+ * @typedef {{
+ *   isRumActive?: boolean,
+ *   browserVersion?: string,
+ *   testExecutionId?: string
+ * }} RumTestCorrelationContext
  */
 
 // session tags
@@ -130,7 +136,7 @@ const CI_APP_ORIGIN = 'ciapp-test'
 // - Math.random() float values (10+ decimal digits after 0.)
 const DYNAMIC_NAME_RE = new RegExp(
   String.raw`\b1[6-9]\d{8,11}\b|` +
-  String.raw`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|` +
+  '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|' +
   String.raw`\b\d{4}-\d{2}-\d{2}|` +
   String.raw`(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d{4,5}\b|` +
   String.raw`\b0\.\d{10,}`,
@@ -434,6 +440,8 @@ module.exports = {
   TEST_PARAMETERS,
   TEST_SKIP_REASON,
   TEST_IS_RUM_ACTIVE,
+  setRumTestCorrelation,
+  setRumTestTags,
   TEST_SOURCE_FILE,
   TEST_FAILURE_SCREENSHOT_UPLOADED,
   TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR,
@@ -567,7 +575,7 @@ module.exports = {
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
 function getPkgManager () {
   try {
-    return getEnvironmentVariable('npm_config_user_agent').split(' ')[0].replace('/', '-')
+    return getSegment(getEnvironmentVariable('npm_config_user_agent'), ' ', 0).replace('/', '-')
   } catch {
     return ''
   }
@@ -798,6 +806,9 @@ function getTestTypeFromFramework (testFramework) {
   return 'test'
 }
 
+/**
+ * @param {import('../../opentracing/span')} span
+ */
 function finishAllTraceSpans (span) {
   for (const traceSpan of span.context()._trace.started) {
     if (traceSpan !== span) {
@@ -806,6 +817,49 @@ function finishAllTraceSpans (span) {
   }
 }
 
+/**
+ * @param {import('../../opentracing/span')} testSpan
+ * @param {boolean|undefined} isRumActive
+ * @param {string} [browserVersion]
+ * @returns {void}
+ */
+function setRumTestTags (testSpan, isRumActive, browserVersion) {
+  if (isRumActive) {
+    testSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
+  }
+  if (browserVersion) {
+    testSpan.setTag(TEST_BROWSER_VERSION, browserVersion)
+  }
+}
+
+/**
+ * @param {RumTestCorrelationContext} context
+ * @param {import('../../opentracing/span')|undefined} activeSpan
+ * @returns {import('../../opentracing/span')|undefined}
+ */
+function setRumTestCorrelation (context, activeSpan) {
+  if (!activeSpan) return
+
+  const activeContext = activeSpan.context()
+  let testSpan
+  if (activeContext.getTag(SPAN_TYPE) === 'test') {
+    testSpan = activeSpan
+  } else {
+    for (const traceSpan of activeContext._trace.started) {
+      if (traceSpan.context().getTag(SPAN_TYPE) === 'test') {
+        testSpan = traceSpan
+        break
+      }
+    }
+  }
+
+  if (!testSpan) return
+
+  context.testExecutionId = testSpan.context().toTraceId()
+  setRumTestTags(testSpan, context.isRumActive, context.browserVersion)
+  return testSpan
+}
+
 function getTestParentSpan (tracer) {
   return tracer.extract('text_map', {
     'x-datadog-trace-id': id().toString(10),
@@ -1360,7 +1414,6 @@ function resetCoverage (coverage) {
 
   return coverageMap
     .files()
-    // eslint-disable-next-line unicorn/no-array-for-each
     .forEach(filename => {
       const fileCoverage = coverageMap.fileCoverageFor(filename)
       fileCoverage.resetHits()
@@ -1371,7 +1424,6 @@ function mergeCoverage (coverage, targetCoverage) {
   const coverageMap = istanbul.createCoverageMap(coverage)
   return coverageMap
     .files()
-    // eslint-disable-next-line unicorn/no-array-for-each
     .forEach(filename => {
       const fileCoverage = coverageMap.fileCoverageFor(filename)
 
@@ -1454,7 +1506,7 @@ function parseAnnotations (annotations) {
  * 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 }
+ * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
  * @returns {number}
  */
 function getEfdRetryCount (durationMs, slowTestRetries) {
@@ -1469,12 +1521,17 @@ function getEfdRetryCount (durationMs, slowTestRetries) {
 /**
  * Returns the maximum retry count configured by the backend for EFD.
  *
- * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
- * @returns {number}
+ * @param {Record<string, number> | undefined} slowTestRetries
+ * @returns {number | undefined}
  */
 function getMaxEfdRetryCount (slowTestRetries) {
+  if (slowTestRetries === undefined) return
+
+  const retryCounts = Object.values(slowTestRetries)
+  if (retryCounts.length === 0) return
+
   let maxRetries = 0
-  for (const retryCount of Object.values(slowTestRetries || {})) {
+  for (const retryCount of retryCounts) {
     if (retryCount > maxRetries) {
       maxRetries = retryCount
     }

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

@@ -185,6 +185,18 @@ const web = {
     return context
   },
 
+  // Key an existing context on the underlying `Http2Stream` so a second request
+  // backed by the same stream resolves to it via the `req.stream` lookup in
+  // `patch`. Only a mixed HTTP/2 server (raw-stream + 'request' listeners) needs
+  // this: it creates the span from a throwaway stream adapter, then the
+  // compatibility layer synthesizes the real `Http2ServerRequest` off the same
+  // stream and must reuse the adapter's span rather than open an orphan context.
+  // Confined to that path so the common single-listener request pays no extra
+  // per-request map write.
+  linkContextToStream (stream, context) {
+    contexts.set(stream, context)
+  },
+
   // Return the request root span.
   root (req) {
     const context = contexts.get(req)