dd-trace 5.123.0 → 5.124.0

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

@@ -26,6 +26,15 @@ const finishedRegistry = createRegistry('finished')
 let OTEL_ENABLED = false
 const ALLOWED = new Set(['string', 'number', 'boolean'])
 
+/**
+ * @typedef {object} RecordedException
+ * @property {string} message
+ * @property {string} [name]
+ * @property {string} [stack]
+ * @typedef {string | number | boolean} SpanEventAttributeScalar
+ * @typedef {SpanEventAttributeScalar | string[] | number[] | boolean[]} SpanEventAttributeValue
+ */
+
 const integrationCounters = {
   spans_created: {},
   spans_finished: {},
@@ -306,6 +315,25 @@ class DatadogSpan {
     this._events.push(event)
   }
 
+  /**
+   * @param {RecordedException} exception
+   * @param {Record<string, SpanEventAttributeValue>} [attributes]
+   */
+  recordException (exception, attributes) {
+    const { message, name, stack } = exception
+    const eventAttributes = { ...attributes }
+    eventAttributes['exception.message'] ??= message
+
+    if (typeof name === 'string') {
+      eventAttributes['exception.type'] ??= name
+    }
+    if (typeof stack === 'string') {
+      eventAttributes['exception.stacktrace'] ??= stack
+    }
+
+    this.addEvent('exception', eventAttributes)
+  }
+
   finish (finishTime) {
     if (this._duration !== undefined) {
       return

package/packages/dd-trace/src/otel-thread-ctx.js

@@ -105,6 +105,10 @@ const THREAD_ID = String(threadId)
 //             time onEnter activates the span, and cleared on span finish, which
 //             is how a pendingEndpoints waiter recognizes a record it must no
 //             longer append to.
+//   webTags:  the web-server tag bag the record's endpoint comes from, or is
+//             waiting on; undefined while the span has no web-server ancestry.
+//             Distinguishes a stale announcement from a live one when a nearer
+//             web-server span takes over.
 const CachedSym = Symbol('OtelThreadCtx.cached')
 
 let started = false
@@ -137,6 +141,7 @@ function getOrBuildContext (span) {
     span[CachedSym] = cached
   }
   cached.context = new ThreadContext(traceId, spanId, attrs)
+  cached.webTags = webTags
   if (endpoint === undefined) awaitEndpoint(webTags, cached)
   return cached.context
 }
@@ -227,21 +232,34 @@ function onEndpointResolved (span) {
   if (endpoint === undefined) return
   pendingEndpoints.delete(webTags)
   for (const cached of waiting) {
-    if (cached.context !== undefined) appendEndpoint(cached.context, endpoint)
+    // A record whose span has since been attributed to a nearer web-server span
+    // enlisted again under that bag, and this one is no longer its endpoint.
+    if (cached.context !== undefined && cached.webTags === webTags) appendEndpoint(cached.context, endpoint)
   }
 }
 
-// A span whose record was built before it looked like a web-server span at all
-// has just been recognized as one, so it has no endpoint and never enlisted for
-// this request. Its ancestry can't have changed, only its own tags, so this is
-// only ever about the announced span's own record.
+// webTagsCache has changed which request it attributes this span to: the span
+// itself or an ancestor was recognized as a web-server span, giving a record
+// built without any web-server ancestry its first endpoint, or a nearer
+// web-server span superseded the one this record is showing. Give the record
+// the new request's endpoint if it has settled, or wait for its announcement.
 function onWebTagsResolved (span) {
   if (!started) return
   const cached = span[CachedSym]
   if (cached === undefined || cached.context === undefined) return
   const webTags = webTagsCache.getCachedWebTags(span)
+  if (webTags === cached.webTags) return
+  // Recorded so that an announcement for the bag this record was previously
+  // waiting on no longer applies to it.
+  cached.webTags = webTags
   const endpoint = finalEndpoint(webTags)
   if (endpoint === undefined) {
+    // A record that already shows the outer request's endpoint goes on showing
+    // it until the nearer one settles: the record buffer is append-only, so
+    // there is no way to take the attribute back, and rebuilding the
+    // ThreadContext would strand every async-context frame holding this one.
+    // The work is still nested in the outer request, which makes that the least
+    // wrong of the values available.
     awaitEndpoint(webTags, cached)
   } else {
     appendEndpoint(cached.context, endpoint)

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

@@ -165,6 +165,7 @@ module.exports = class PluginManager {
       codeOriginForSpans,
       dbmPropagationMode,
       dsmEnabled,
+      DD_TRACE_HTTP_CLIENT_ERROR_STATUSES,
       DD_TRACE_HTTP_SERVER_ERROR_STATUSES,
       clientIpEnabled,
       clientIpHeader,
@@ -195,6 +196,7 @@ module.exports = class PluginManager {
       site,
       url,
       headers: headerTags || [],
+      DD_TRACE_HTTP_CLIENT_ERROR_STATUSES,
       DD_TRACE_HTTP_SERVER_ERROR_STATUSES,
       clientIpHeader,
       DD_TEST_SESSION_NAME,

package/packages/dd-trace/src/plugins/util/status-validator.js

@@ -0,0 +1,98 @@
+'use strict'
+
+const log = require('../../log')
+
+const statusCodeRangesPattern = /^[1-5]\d{2}(?:-[1-5]\d{2})?(?:,[1-5]\d{2}(?:-[1-5]\d{2})?)*$/
+const whitespacePattern = /\s/g
+const MAX_HTTP_STATUS_CODE = 599
+
+const SERVER_ERROR_STATUSES = 'DD_TRACE_HTTP_SERVER_ERROR_STATUSES'
+const CLIENT_ERROR_STATUSES = 'DD_TRACE_HTTP_CLIENT_ERROR_STATUSES'
+
+/** @typedef {(code: number) => boolean} StatusValidator */
+
+/** @type {StatusValidator} */
+function isNotServerErrorCode (code) {
+  return code < 500
+}
+
+/** @type {StatusValidator} */
+function isNotClientErrorCode (code) {
+  return code < 400 || code >= 500
+}
+
+/**
+ * @param {{ validateStatus?: unknown, DD_TRACE_HTTP_SERVER_ERROR_STATUSES?: unknown }} config
+ * @returns {StatusValidator}
+ */
+function getServerStatusValidator (config) {
+  return getStatusValidator(config, SERVER_ERROR_STATUSES, '500-599', isNotServerErrorCode)
+}
+
+/**
+ * @param {{ validateStatus?: unknown, DD_TRACE_HTTP_CLIENT_ERROR_STATUSES?: unknown }} config
+ * @returns {StatusValidator}
+ */
+function getClientStatusValidator (config) {
+  return getStatusValidator(config, CLIENT_ERROR_STATUSES, '400-499', isNotClientErrorCode)
+}
+
+/**
+ * @param {Record<string, unknown>} config
+ * @param {string} optionName - Name of the configuration holding the error status ranges.
+ * @param {string} defaultRanges - Ranges covered by `defaultValidator`
+ * @param {StatusValidator} defaultValidator
+ * @returns {StatusValidator}
+ */
+function getStatusValidator (config, optionName, defaultRanges, defaultValidator) {
+  if (typeof config.validateStatus === 'function') {
+    return /** @type {StatusValidator} */ (config.validateStatus)
+  } else if (Object.hasOwn(config, 'validateStatus')) {
+    log.error('Expected `validateStatus` to be a function.')
+  }
+
+  const ranges = config[optionName]
+  if (ranges === undefined) return defaultValidator
+  if (typeof ranges !== 'string') {
+    log.error('Expected `%s` to be a string.', optionName)
+    return defaultValidator
+  }
+  if (ranges === defaultRanges) return defaultValidator
+
+  const normalized = ranges.replaceAll(whitespacePattern, '')
+  if (normalized === defaultRanges) return defaultValidator
+  if (!statusCodeRangesPattern.test(normalized)) {
+    log.error('`%s` must contain comma-separated status codes or ranges from 100 to 599.', optionName)
+    return defaultValidator
+  }
+
+  const errorStatusCodes = new Uint8Array(MAX_HTTP_STATUS_CODE + 1)
+  for (const range of normalized.split(',')) {
+    const separator = range.indexOf('-')
+    if (separator === -1) {
+      errorStatusCodes[Number(range)] = 1
+      continue
+    }
+
+    const first = Number(range.slice(0, separator))
+    const second = Number(range.slice(separator + 1))
+    const start = Math.min(first, second)
+    const end = Math.max(first, second)
+    errorStatusCodes.fill(1, start, end + 1)
+  }
+
+  /**
+   * @param {number} code
+   * @returns {boolean}
+   */
+  function isValidStatusCode (code) {
+    return errorStatusCodes[code] !== 1
+  }
+
+  return isValidStatusCode
+}
+
+module.exports = {
+  getClientStatusValidator,
+  getServerStatusValidator,
+}

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

@@ -541,6 +541,7 @@ module.exports = {
   getRelativeCoverageFiles,
   getLineCoverageBitmap,
   applySkippedCoverageToCoverage,
+  getTestCoverageLinesData,
   getTestCoverageLinesPercentage,
   resetCoverage,
   mergeCoverage,
@@ -1359,6 +1360,34 @@ function getLineCoverageBitmap (lineCoverage, onlyCoveredLines = false) {
   return bitmap
 }
 
+function getLineCoverageBitmaps (lineCoverage) {
+  let maxLine = 0
+  const entries = Object.entries(lineCoverage)
+
+  for (const [line] of entries) {
+    const lineNumber = Number(line)
+    if (Number.isSafeInteger(lineNumber) && lineNumber > maxLine) {
+      maxLine = lineNumber
+    }
+  }
+  if (maxLine === 0) return {}
+
+  const length = Math.ceil((maxLine + 1) / 8)
+  const coveredBitmap = Buffer.alloc(length)
+  const executableBitmap = Buffer.alloc(length)
+  for (const [line, hits] of entries) {
+    const lineNumber = Number(line)
+    if (!Number.isSafeInteger(lineNumber) || lineNumber <= 0) continue
+
+    const byteIndex = lineNumber >> 3
+    const bit = 1 << (lineNumber % 8)
+    executableBitmap[byteIndex] |= bit
+    if (hits) coveredBitmap[byteIndex] |= bit
+  }
+
+  return { coveredBitmap, executableBitmap }
+}
+
 function mergeCoverageBitmaps (targetBitmap, bitmap) {
   if (!targetBitmap) {
     return Buffer.from(bitmap)
@@ -1419,16 +1448,6 @@ function getCoverageFileBitmap (bitmap) {
   }
 }
 
-function addCoverageFilesToMap (files, targetMap, rootDir) {
-  for (const file of files) {
-    const bitmap = getCoverageFileBitmap(file.bitmap)
-    if (!bitmap) continue
-
-    const filename = rootDir ? getTestSuitePath(file.filename, rootDir) : file.filename
-    targetMap.set(filename, mergeCoverageBitmaps(targetMap.get(filename), bitmap))
-  }
-}
-
 function addSkippedCoverageToMap (skippedCoverage, targetMap) {
   if (!skippedCoverage) return
 
@@ -1439,23 +1458,57 @@ function addSkippedCoverageToMap (skippedCoverage, targetMap) {
   }
 }
 
-function getTestCoverageLinesPercentage (coverage, skippedCoverage, rootDir) {
-  const executableLinesByFile = new Map()
-  const coveredLinesByFile = new Map()
+/**
+ * Calculates line coverage and optionally returns executable-line coverage files in the same traversal.
+ * @param {object} coverage
+ * @param {object} [skippedCoverage]
+ * @param {string} [rootDir]
+ * @param {boolean} [includeExecutableFiles]
+ * @returns {{ percentage: number, executableFiles?: Array<{ filename: string, bitmap: Buffer }> }}
+ */
+function getTestCoverageLinesData (coverage, skippedCoverage, rootDir, includeExecutableFiles = false) {
+  const coverageMap = getCoverageMap(coverage)
+  const skippedCoverageByFilename = getSkippedCoverageByFilename(skippedCoverage)
+  const coverageByFilename = new Map()
+  const executableFiles = includeExecutableFiles ? [] : undefined
+
+  for (const filename of coverageMap.files()) {
+    const fileCoverage = coverageMap.fileCoverageFor(filename)
+    const { coveredBitmap, executableBitmap } = getLineCoverageBitmaps(fileCoverage.getLineCoverage())
+    if (!executableBitmap) continue
 
-  addCoverageFilesToMap(getExecutableFilesFromCoverage(coverage), executableLinesByFile, rootDir)
-  addCoverageFilesToMap(getCoveredFilesFromCoverage(coverage), coveredLinesByFile, rootDir)
-  addSkippedCoverageToMap(skippedCoverage, coveredLinesByFile)
+    const relativeFilename = rootDir ? getTestSuitePath(filename, rootDir) : filename
+    const existingCoverage = coverageByFilename.get(relativeFilename)
+    if (existingCoverage) {
+      existingCoverage.coveredBitmap = mergeCoverageBitmaps(existingCoverage.coveredBitmap, coveredBitmap)
+      existingCoverage.executableBitmap = mergeCoverageBitmaps(existingCoverage.executableBitmap, executableBitmap)
+    } else {
+      coverageByFilename.set(relativeFilename, { coveredBitmap, executableBitmap })
+    }
+  }
 
   let totalExecutableLines = 0
   let totalCoveredLines = 0
-
-  for (const [filename, executableLines] of executableLinesByFile) {
-    totalExecutableLines += countBitmapBits(executableLines)
-    totalCoveredLines += countCoveredExecutableBits(coveredLinesByFile.get(filename), executableLines)
+  for (const [filename, { coveredBitmap, executableBitmap }] of coverageByFilename) {
+    const skippedBitmap = skippedCoverageByFilename.get(filename)
+    const combinedCoveredBitmap = skippedBitmap
+      ? mergeCoverageBitmaps(coveredBitmap, skippedBitmap)
+      : coveredBitmap
+    totalExecutableLines += countBitmapBits(executableBitmap)
+    totalCoveredLines += countCoveredExecutableBits(combinedCoveredBitmap, executableBitmap)
+    if (executableFiles) {
+      executableFiles.push({ filename, bitmap: executableBitmap })
+    }
   }
 
-  return totalExecutableLines === 0 ? 0 : Math.floor((totalCoveredLines / totalExecutableLines) * 10_000) / 100
+  const percentage = totalExecutableLines === 0
+    ? 0
+    : Math.floor((totalCoveredLines / totalExecutableLines) * 10_000) / 100
+  return { percentage, executableFiles }
+}
+
+function getTestCoverageLinesPercentage (coverage, skippedCoverage, rootDir) {
+  return getTestCoverageLinesData(coverage, skippedCoverage, rootDir).percentage
 }
 
 function isLineCoveredByBitmap (bitmap, line) {

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

@@ -13,6 +13,7 @@ const { storage } = require('../../../../datadog-core')
 const legacyStorage = storage('legacy')
 const urlFilter = require('./urlfilter')
 const { createInferredProxySpan, finishInferredProxySpan } = require('./inferred_proxy')
+const { getServerStatusValidator } = require('./status-validator')
 const { extractURL, obfuscateQs, getQsObfuscator, calculateHttpEndpoint } = require('./url')
 const { NETWORK_PEER_ADDRESS } = require('./http-otel-semantics')
 
@@ -35,11 +36,6 @@ const MANUAL_DROP = tags.MANUAL_DROP
 
 const contexts = new WeakMap()
 const requests = new WeakMap()
-const statusCodeRangesPattern = /^[1-5]\d{2}(?:-[1-5]\d{2})?(?:,[1-5]\d{2}(?:-[1-5]\d{2})?)*$/
-const whitespacePattern = /\s/g
-const MAX_HTTP_STATUS_CODE = 599
-
-/** @typedef {(code: number) => boolean} StatusValidator */
 
 // TODO: change this to no longer rely on creating a dummy plugin to be able to access startSpan
 function createWebPlugin (tracer, config = {}) {
@@ -65,7 +61,7 @@ const web = {
   // Ensure the configuration has the correct structure and defaults.
   normalizeConfig (config) {
     const headers = getHeadersToRecord(config)
-    const validateStatus = getStatusValidator(config)
+    const validateStatus = getServerStatusValidator(config)
     const hooks = getHooks(config)
     const filter = urlFilter.getFilter(config)
     const middleware = getMiddlewareSetting(config)
@@ -563,65 +559,6 @@ function getHeadersToRecord (config) {
   return []
 }
 
-function isNot500ErrorCode (code) {
-  return code < 500
-}
-
-/**
- * @param {{ validateStatus?: unknown, DD_TRACE_HTTP_SERVER_ERROR_STATUSES?: unknown }} config
- * @returns {StatusValidator}
- */
-function getStatusValidator (config) {
-  if (typeof config.validateStatus === 'function') {
-    return /** @type {StatusValidator} */ (config.validateStatus)
-  } else if (config.hasOwnProperty('validateStatus')) {
-    log.error('Expected `validateStatus` to be a function.')
-  }
-
-  const { DD_TRACE_HTTP_SERVER_ERROR_STATUSES } = config
-  if (DD_TRACE_HTTP_SERVER_ERROR_STATUSES === undefined) return isNot500ErrorCode
-  if (typeof DD_TRACE_HTTP_SERVER_ERROR_STATUSES !== 'string') {
-    log.error('Expected `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` to be a string.')
-    return isNot500ErrorCode
-  }
-  if (DD_TRACE_HTTP_SERVER_ERROR_STATUSES === '500-599') return isNot500ErrorCode
-
-  const normalized = DD_TRACE_HTTP_SERVER_ERROR_STATUSES.replaceAll(whitespacePattern, '')
-  if (normalized === '500-599') return isNot500ErrorCode
-  if (!statusCodeRangesPattern.test(normalized)) {
-    log.error(
-      '`DD_TRACE_HTTP_SERVER_ERROR_STATUSES` must contain comma-separated status codes or ranges from 100 to 599.'
-    )
-    return isNot500ErrorCode
-  }
-
-  const errorStatusCodes = new Uint8Array(MAX_HTTP_STATUS_CODE + 1)
-  const ranges = normalized.split(',')
-  for (const range of ranges) {
-    const separator = range.indexOf('-')
-    if (separator === -1) {
-      errorStatusCodes[Number(range)] = 1
-      continue
-    }
-
-    const first = Number(range.slice(0, separator))
-    const second = Number(range.slice(separator + 1))
-    const start = Math.min(first, second)
-    const end = Math.max(first, second)
-    errorStatusCodes.fill(1, start, end + 1)
-  }
-
-  /**
-   * @param {number} code
-   * @returns {boolean}
-   */
-  function isValidStatusCode (code) {
-    return errorStatusCodes[code] !== 1
-  }
-
-  return isValidStatusCode
-}
-
 const noop = () => {}
 
 function getHooks (config) {

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

@@ -56,16 +56,17 @@ function strategiesToCallbackMode (strategies, callbackMode) {
 function buildExportCommand (exporters, tags) {
   const tagString = [...Object.entries(tags),
     ['snapshot', snapshotKinds.ON_OUT_OF_MEMORY]].map(([key, value]) => `${key}:${value}`).join(',')
-  const urls = []
+  let urls = ''
   for (const exporter of exporters) {
     const url = exporter.getExportUrl()
     if (url !== undefined) {
-      urls.push(url.toString())
+      if (urls) urls += ','
+      urls += url.toString()
     }
   }
   return [process.execPath,
     path.join(__dirname, 'exporter_cli.js'),
-    urls.join(','), tagString, 'space']
+    urls, tagString, 'space']
 }
 
 module.exports = { oomExportStrategies, ensureOOMExportStrategies, strategiesToCallbackMode, buildExportCommand }

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

@@ -95,6 +95,10 @@ class Profiler extends EventEmitter {
     for (const key of keys) {
       this.#customLabelKeys.add(key)
     }
+    this.#applyCustomLabelKeys()
+  }
+
+  #applyCustomLabelKeys () {
     if (this.#profilers) {
       for (const profiler of this.#profilers) {
         profiler.setCustomLabelKeys?.(this.#customLabelKeys)
@@ -180,6 +184,9 @@ class Profiler extends EventEmitter {
     this.#profilers = profilers
     this.#uploadCompression = uploadCompression
     this.#systemInfoReport = systemInfoReport
+    if (this.#customLabelKeys.size > 0) {
+      this.#applyCustomLabelKeys()
+    }
 
     this._setInterval()
     // Log errors if the source map finder fails, but don't prevent the rest

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -124,13 +124,13 @@ class GCDecorator {
     }
     let reasonLabel = this.reasonLabels[flags]
     if (!reasonLabel) {
-      const reasons = []
+      let reasonStr = ''
       for (const [key, value] of Object.entries(this.flagObj)) {
         if (value & flags) {
-          reasons.push(key)
+          if (reasonStr) reasonStr += ','
+          reasonStr += key
         }
       }
-      const reasonStr = reasons.join(',')
       reasonLabel = labelFromStr(this.stringTable, this.reasonLabelKey, reasonStr)
       this.reasonLabels[flags] = reasonLabel
     }

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -138,7 +138,7 @@ class NativeWallProfiler {
 
     this.#pprof.time.start({
       collectCpuTime: this.#cpuProfilingEnabled,
-      columnNumbers: 'pack',
+      columnNumbers: 'emit',
       durationMillis: this.#flushIntervalMillis,
       intervalMicros: this.#samplingIntervalMicros,
       lineNumbers: false,
@@ -168,8 +168,8 @@ class NativeWallProfiler {
         spanFinishCh.subscribe(this.#boundSpanFinished)
         if (this.#endpointCollectionEnabled) {
           // Web-tags cache publishes once per span at the moment its
-          // walk-result transitions from undefined to a real value —
-          // exactly when we need to refresh the ProfilingContext snapshot.
+          // walk-result changes — exactly when we need to refresh the
+          // ProfilingContext snapshot.
           webTagsCache.resolvedCh.subscribe(this.#boundSpanTagsUpdated)
           // Turn on the cache's own tagsUpdate subscription — it's
           // ref-counted, so this composes with any other active consumer.
@@ -229,13 +229,12 @@ class NativeWallProfiler {
         } else if (current !== sampleContext) {
           this.#pprof.time.setContext(sampleContext)
         }
-      // Every setContext() call in ACF mode allocates a fresh contextHolder
-      // (a node::ObjectWrap with its own v8::Global<v8::Value>) in the native
-      // profiler. Skip the call if the CPED already holds this sampleContext,
-      // which is the common case when the same span is repeatedly activated:
-      // #getProfilingContext caches profilingContext on span[ProfilingContext],
-      // so identity comparison short-circuits.
       } else if (current !== sampleContext) {
+        // Every setContext() call in ACF mode allocates a fresh contextHolder
+        // (a node::ObjectWrap with its own v8::Global<v8::Value>) in the native
+        // profiler. We're only incurring the cost when current !== sampleContext
+        // and skip it when current === sampleContext, which is the common case
+        // when the same span is repeatedly activated.
         this.#pprof.time.setContext(sampleContext)
       }
     } else {
@@ -266,8 +265,8 @@ class NativeWallProfiler {
       }
 
       // webTags is snapshotted into the sample context at getProfilingContext
-      // time; if the answer turns out to be undefined and the span later gets
-      // web-server tags, #spanTagsUpdated refreshes this field via the shared
+      // time; if the answer changes later — the span or an ancestor becomes a
+      // web-server span — #spanTagsUpdated refreshes this field via the shared
       // cache (see web-tags-cache.js).
       const webTags = this.#endpointCollectionEnabled ? webTagsCache.getCachedWebTags(span) : undefined
 
@@ -291,9 +290,10 @@ class NativeWallProfiler {
   }
 
   // Invoked (via webTagsCache.resolvedCh) once per span at the moment the
-  // shared cache promotes a previously-undefined webTags answer into a
-  // real value. Refresh the ProfilingContext snapshot so future samples
-  // pick it up.
+  // shared cache changes its webTags answer: an empty one promoted into a real
+  // value, or an outer request's tag bag replaced by a nearer one. Refresh the
+  // ProfilingContext snapshot in place so samples already holding it — including
+  // those of a span that stays active across the promotion — pick it up.
   #spanTagsUpdated (span) {
     if (!this.#started) return
     const profilingContext = span[ProfilingContext]