dd-trace 5.99.1 → 5.101.0

package/packages/datadog-instrumentations/src/router.js

@@ -1,9 +1,9 @@
 'use strict'
 
 const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
-const pathToRegExp = require('../../../vendor/dist/path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
+const { getCompileToRegexp } = require('./path-to-regexp')
 
 const {
   getRouterMountPaths,
@@ -19,15 +19,22 @@ const {
 } = require('./helpers/router-helper')
 
 function isFastStar (layer, matchers) {
-  return layer.regexp?.fast_star ?? matchers.some(matcher => matcher.path === '*')
+  return layer.regexp?.fast_star ?? matchers.hasStarPath
 }
 
 function isFastSlash (layer, matchers) {
-  return layer.regexp?.fast_slash ?? matchers.some(matcher => matcher.path === '/')
+  return layer.regexp?.fast_slash ?? matchers.hasSlashPath
 }
 
 // TODO: Move this function to a shared file between Express and Router
-function createWrapRouterMethod (name) {
+/**
+ * @param {string} name Channel namespace (`apm:<name>:middleware:*`).
+ * @param {((pattern: string | RegExp) => RegExp | undefined) | undefined} compile
+ *   Host-resolved path-to-regexp compile adapter, or undefined when the host
+ *   instance ships no path-to-regexp. Captured here so each express/router
+ *   instance keeps the dialect it actually loaded.
+ */
+function createWrapRouterMethod (name, compile) {
   const enterChannel = channel(`apm:${name}:middleware:enter`)
   const exitChannel = channel(`apm:${name}:middleware:exit`)
   const finishChannel = channel(`apm:${name}:middleware:finish`)
@@ -35,8 +42,6 @@ function createWrapRouterMethod (name) {
   const nextChannel = channel(`apm:${name}:middleware:next`)
   const routeAddedChannel = channel(`apm:${name}:route:added`)
 
-  const regexpCache = Object.create(null)
-
   function wrapLayerHandle (layer, original) {
     original._name = original._name || layer.name
 
@@ -55,13 +60,16 @@ function createWrapRouterMethod (name) {
 
       let route
 
-      if (matchers) {
-        // Try to guess which path actually matched
-        for (const matcher of matchers) {
-          if (matcher.test(layer)) {
-            route = matcher.path
-
-            break
+      if (matchers?.length && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
+        if (matchers.length === 1) {
+          // The host already matched this layer; the lone pattern is the route.
+          route = matchers[0].path
+        } else {
+          for (const matcher of matchers) {
+            if (matcher.regex?.test(layer.path)) {
+              route = matcher.path
+              break
+            }
           }
         }
       }
@@ -124,25 +132,35 @@ function createWrapRouterMethod (name) {
       return []
     }
 
-    return arg.map(pattern => ({
-      path: pattern instanceof RegExp ? `(${pattern})` : pattern,
-      test: layer => {
-        const matchers = getLayerMatchers(layer)
-        return !isFastStar(layer, matchers) &&
-          !isFastSlash(layer, matchers) &&
-          cachedPathToRegExp(pattern).test(layer.path)
-      },
-    }))
-  }
-
-  function cachedPathToRegExp (pattern) {
-    const maybeCached = regexpCache[pattern]
-    if (maybeCached) {
-      return maybeCached
+    if (arg.length === 1) {
+      const pattern = arg[0]
+      const path = pattern instanceof RegExp ? `(${pattern})` : pattern
+      const matchers = [{ path }]
+      matchers.hasStarPath = path === '*'
+      matchers.hasSlashPath = path === '/'
+      return matchers
     }
-    const regexp = pathToRegExp(pattern)
-    regexpCache[pattern] = regexp
-    return regexp
+
+    // hasStarPath/hasSlashPath cache the lookups isFastStar/isFastSlash
+    // would otherwise re-run on every request.
+    let hasStarPath = false
+    let hasSlashPath = false
+    const matchers = arg.map(pattern => {
+      const isRegExp = pattern instanceof RegExp
+      const path = isRegExp ? `(${pattern})` : pattern
+      if (path === '*') {
+        hasStarPath = true
+      } else if (path === '/') {
+        hasSlashPath = true
+      }
+      return {
+        path,
+        regex: isRegExp ? pattern : compile?.(pattern),
+      }
+    })
+    matchers.hasStarPath = hasStarPath
+    matchers.hasSlashPath = hasSlashPath
+    return matchers
   }
 
   function wrapMethod (original) {
@@ -218,9 +236,9 @@ function createWrapRouterMethod (name) {
   return wrapMethod
 }
 
-const wrapRouterMethod = createWrapRouterMethod('router')
-
 addHook({ name: 'router', versions: ['>=1 <2'] }, Router => {
+  const wrapRouterMethod = createWrapRouterMethod('router', getCompileToRegexp())
+
   shimmer.wrap(Router.prototype, 'use', wrapRouterMethod)
   shimmer.wrap(Router.prototype, 'route', wrapRouterMethod)
 
@@ -230,6 +248,8 @@ addHook({ name: 'router', versions: ['>=1 <2'] }, Router => {
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 addHook({ name: 'router', versions: ['>=2'] }, Router => {
+  const wrapRouterMethod = createWrapRouterMethod('router', getCompileToRegexp())
+
   const WrappedRouter = shimmer.wrapFunction(Router, function (originalRouter) {
     return function wrappedMethod () {
       const router = originalRouter.apply(this, arguments)

package/packages/datadog-instrumentations/src/vitest.js

@@ -11,8 +11,11 @@ const {
   VITEST_WORKER_TRACE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
   DYNAMIC_NAME_RE,
-  collectDynamicNamesFromTraces,
-  logDynamicNamesWarning,
+  getTestSuitePath,
+  recordAttemptToFixExecution,
+  collectTestOptimizationSummariesFromTraces,
+  logAttemptToFixTestExecution,
+  logTestOptimizationSummary,
 } = require('../../dd-trace/src/plugins/util/test')
 const { addHook, channel } = require('./helpers/instrument')
 
@@ -49,6 +52,7 @@ const codeCoverageReportCh = channel('ci:vitest:coverage-report')
 
 const taskToCtx = new WeakMap()
 const taskToStatuses = new WeakMap()
+const attemptToFixTaskToStatuses = new WeakMap()
 const originalHookFns = new WeakMap()
 const newTasks = new WeakSet()
 const dynamicNameTasks = new WeakSet()
@@ -57,6 +61,8 @@ const disabledTasks = new WeakSet()
 const quarantinedTasks = new WeakSet()
 const attemptToFixTasks = new WeakSet()
 const modifiedTasks = new WeakSet()
+const attemptToFixExecutions = new Map()
+const loggedAttemptToFixTests = new Set()
 let isRetryReasonEfd = false
 let isRetryReasonAttemptToFix = false
 const switchedStatuses = new WeakSet()
@@ -255,6 +261,29 @@ function getTestName (task) {
   return testName
 }
 
+function getFinalAttemptToFixStatus (task, state, isSwitchedStatus, testCtx) {
+  if (isSwitchedStatus && attemptToFixTasks.has(task) && testCtx?.status) {
+    return testCtx.status
+  }
+
+  return state === 'fail' ? 'fail' : 'pass'
+}
+
+function recordFinalAttemptToFixExecution (task, status, providedContext) {
+  const statuses = attemptToFixTaskToStatuses.get(task)
+  if (statuses && statuses.length <= providedContext.testManagementAttemptToFixRetries) {
+    statuses.push(status)
+  }
+
+  recordAttemptToFixExecution(attemptToFixExecutions, {
+    testSuite: getTestSuitePath(task.file.filepath, process.cwd()),
+    testName: getTestName(task),
+    status,
+    isDisabled: disabledTasks.has(task),
+    isQuarantined: quarantinedTasks.has(task),
+  })
+}
+
 /**
  * Wraps a function so it runs inside the current test span context.
  * @param {object} task
@@ -480,7 +509,8 @@ function getFinishWrapper (exitOrClose) {
       onFinish,
     })
 
-    logDynamicNamesWarning(newTestsWithDynamicNames)
+    logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
+    loggedAttemptToFixTests.clear()
 
     await flushPromise
 
@@ -542,7 +572,10 @@ function threadHandler (thread) {
   workerProcess.on('message', (message) => {
     if (message.__tinypool_worker_message__ && message.data) {
       if (message.interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
-        collectDynamicNamesFromTraces(message.data, newTestsWithDynamicNames)
+        collectTestOptimizationSummariesFromTraces(message.data, {
+          newTestsWithDynamicNames,
+          attemptToFixExecutions,
+        })
         workerReportTraceCh.publish(message.data)
       } else if (message.interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
         workerReportLogsCh.publish(message.data)
@@ -584,7 +617,10 @@ function getWrappedOn (on) {
       if (message.type !== 'Buffer' && Array.isArray(message)) {
         const [interprocessCode, data] = message
         if (interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
-          collectDynamicNamesFromTraces(data, newTestsWithDynamicNames)
+          collectTestOptimizationSummariesFromTraces(data, {
+            newTestsWithDynamicNames,
+            attemptToFixExecutions,
+          })
           workerReportTraceCh.publish(data)
         } else if (interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
           workerReportLogsCh.publish(data)
@@ -658,7 +694,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
             isRetryReasonAttemptToFix = task.repeats !== testManagementAttemptToFixRetries
             task.repeats = testManagementAttemptToFixRetries
             attemptToFixTasks.add(task)
-            taskToStatuses.set(task, [])
+            attemptToFixTaskToStatuses.set(task, [])
           }
         },
       })
@@ -726,15 +762,17 @@ function wrapVitestTestRunner (VitestTestRunner) {
 
     if (isTestManagementTestsEnabled) {
       const isAttemptingToFix = attemptToFixTasks.has(task)
-      const isDisabled = disabledTasks.has(task)
       const isQuarantined = quarantinedTasks.has(task)
 
-      if (isAttemptingToFix && (isDisabled || isQuarantined)) {
-        if (task.result.state === 'fail') {
+      if (isAttemptingToFix) {
+        const statuses = attemptToFixTaskToStatuses.get(task)
+        if (task.result.state === 'pass' && statuses?.includes('fail')) {
           switchedStatuses.add(task)
+          task.result.state = 'fail'
         }
-        task.result.state = 'pass'
-      } else if (isQuarantined) {
+      }
+
+      if (!isAttemptingToFix && isQuarantined) {
         if (task.result.state === 'fail') {
           switchedStatuses.add(task)
         }
@@ -822,10 +860,9 @@ function wrapVitestTestRunner (VitestTestRunner) {
 
     const lastExecutionStatus = task.result.state
     const isAtf = attemptToFixTasks.has(task)
-    const isQuarantinedOrDisabledAtf = isAtf && (quarantinedTasks.has(task) || disabledTasks.has(task))
     const shouldTrackStatuses = isEarlyFlakeDetectionEnabled || isAtf
-    const shouldFlipStatus = isEarlyFlakeDetectionEnabled || isQuarantinedOrDisabledAtf
-    const statuses = taskToStatuses.get(task)
+    const shouldFlipStatus = isEarlyFlakeDetectionEnabled || isAtf
+    const statuses = isAtf ? attemptToFixTaskToStatuses.get(task) : taskToStatuses.get(task)
 
     // These clauses handle task.repeats, whether EFD is enabled or not
     // The only thing that EFD does is to forcefully pass the test if it has passed at least once
@@ -842,7 +879,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         } else {
           testPassCh.publish({ task, ...ctx.currentStore })
         }
-        if (shouldTrackStatuses) {
+        if (shouldTrackStatuses && statuses) {
           statuses.push(lastExecutionStatus)
         }
         if (shouldFlipStatus) {
@@ -855,7 +892,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         }
       }
     } else if (numRepetition === task.repeats) {
-      if (shouldTrackStatuses) {
+      if (shouldTrackStatuses && statuses) {
         statuses.push(lastExecutionStatus)
       }
 
@@ -893,6 +930,14 @@ function wrapVitestTestRunner (VitestTestRunner) {
     }
     taskToCtx.set(task, ctx)
 
+    if (attemptToFixTasks.has(task)) {
+      logAttemptToFixTestExecution(
+        getTestSuitePath(task.file.filepath, process.cwd()),
+        testName,
+        loggedAttemptToFixTests
+      )
+    }
+
     testStartCh.runStores(ctx, () => {})
 
     // Wrap the test function so it runs inside the test span context.
@@ -960,11 +1005,11 @@ function wrapVitestTestRunner (VitestTestRunner) {
       let attemptToFixPassed = false
       let attemptToFixFailed = false
       if (attemptToFixTasks.has(task)) {
-        const statuses = taskToStatuses.get(task)
+        const statuses = attemptToFixTaskToStatuses.get(task)
         if (statuses.length === testManagementAttemptToFixRetries) {
-          if (statuses.every(status => status === 'pass')) {
+          if (status === 'pass' && statuses.every(status => status === 'pass')) {
             attemptToFixPassed = true
-          } else if (statuses.includes('fail')) {
+          } else if (status === 'fail' || statuses.includes('fail')) {
             attemptToFixFailed = true
           }
         }
@@ -1165,9 +1210,16 @@ addHook({
       // We have to trick vitest into thinking that the test has passed
       // but we want to report it as failed if it did fail
       const isSwitchedStatus = switchedStatuses.has(task)
+      const providedContext = getProvidedContext()
 
       if (result) {
         const { state, duration, errors } = result
+        const testError = errors?.[0]
+        if (attemptToFixTasks.has(task)) {
+          const status = getFinalAttemptToFixStatus(task, state, isSwitchedStatus, testCtx)
+          recordFinalAttemptToFixExecution(task, status, providedContext)
+        }
+
         if (state === 'skip') { // programmatic skip
           testSkipCh.publish({
             testName: getTestName(task),
@@ -1177,24 +1229,19 @@ addHook({
           })
         } else if (state === 'pass' && !isSwitchedStatus) {
           if (testCtx) {
+            const isSkippedByTestManagement =
+              !attemptToFixTasks.has(task) && (disabledTasks.has(task) || quarantinedTasks.has(task))
             testPassCh.publish({
               task,
-              finalStatus:
-                disabledTasks.has(task) || quarantinedTasks.has(task) ? 'skip' : 'pass',
+              finalStatus: isSkippedByTestManagement ? 'skip' : 'pass',
               ...testCtx.currentStore,
             })
           }
         } else if (state === 'fail' || isSwitchedStatus) {
-          let testError
-
-          if (errors?.length) {
-            testError = errors[0]
-          }
-
           let hasFailedAllRetries = false
           let attemptToFixFailed = false
           if (attemptToFixTasks.has(task)) {
-            const statuses = taskToStatuses.get(task)
+            const statuses = attemptToFixTaskToStatuses.get(task)
             if (statuses.includes('fail')) {
               attemptToFixFailed = true
             }
@@ -1204,7 +1251,6 @@ addHook({
           }
 
           // Check if all EFD retries failed
-          const providedContext = getProvidedContext()
           const isEfdRetry =
             providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))
           if (isEfdRetry) {
@@ -1232,7 +1278,7 @@ addHook({
 
             let finalStatus
             if (isSwitchedStatus) {
-              if (disabledTasks.has(task) || quarantinedTasks.has(task)) {
+              if (!attemptToFixTasks.has(task) && (disabledTasks.has(task) || quarantinedTasks.has(task))) {
                 finalStatus = 'skip'
               } else if (isAtrRetry || isEfdRetry) {
                 finalStatus = hasFailedAllRetries ? 'fail' : 'pass'

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -149,7 +149,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
         }
         this.addResponseTags(span, response)
 
-        if (this._tracerConfig?.trace?.aws?.addSpanPointers) {
+        if (this._tracerConfig?.DD_TRACE_AWS_ADD_SPAN_POINTERS) {
           this.addSpanPointers(span, response)
         }
       })

package/packages/datadog-plugin-aws-sdk/src/services/dynamodb.js

@@ -118,7 +118,7 @@ class DynamoDb extends BaseAwsSdkPlugin {
       return this.dynamoPrimaryKeyConfig
     }
 
-    const configStr = this._tracerConfig?.trace?.dynamoDb?.tablePrimaryKeys
+    const configStr = this._tracerConfig?.DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS
     if (!configStr) {
       log.warn(
         // eslint-disable-next-line @stylistic/max-len

package/packages/datadog-plugin-bullmq/src/consumer.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const log = require('../../dd-trace/src/log')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
 const { getMessageSize } = require('../../dd-trace/src/datastreams')
 
@@ -68,13 +69,13 @@ class BullmqConsumerPlugin extends ConsumerPlugin {
       const ddCarrier = metadata._datadog
       if (!ddCarrier) return
 
-      // Clean up only our _datadog key, preserve other metadata
-      delete metadata._datadog
+      // Avoid `delete`'s hidden-class transition; JSON.stringify also omits undefined values.
+      metadata._datadog = undefined
       job.opts.telemetry.metadata = JSON.stringify(metadata)
 
       return ddCarrier
-    } catch {
-      // Ignore malformed metadata
+    } catch (error) {
+      log.warn('bullmq: skipping _datadog extract on malformed telemetry.metadata: %s', error.message)
     }
   }
 }

package/packages/datadog-plugin-bullmq/src/producer.js

@@ -1,8 +1,22 @@
 'use strict'
 
+const log = require('../../dd-trace/src/log')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
 const { DsmPathwayCodec, getMessageSize } = require('../../dd-trace/src/datastreams')
 
+// Customer-controlled metadata may be malformed JSON. Returning a fresh `{}`
+// on parse failure keeps the publish path alive instead of throwing into
+// `Queue.add` / `Queue.addBulk`.
+function parseTelemetryMetadata (raw) {
+  if (!raw) return {}
+  try {
+    return JSON.parse(raw)
+  } catch (error) {
+    log.warn('bullmq: ignoring malformed telemetry.metadata: %s', error.message)
+    return {}
+  }
+}
+
 class BaseBullmqProducerPlugin extends ProducerPlugin {
   static id = 'bullmq'
 
@@ -42,12 +56,14 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
     throw new Error('injectTraceContext must be implemented by subclass')
   }
 
+  // Returned so setProducerCheckpoint can mutate it without a second parse.
   _injectIntoOpts (span, opts) {
     const carrier = {}
     this.tracer.inject(span, 'text_map', carrier)
-    const existing = opts.telemetry?.metadata ? JSON.parse(opts.telemetry.metadata) : {}
-    existing._datadog = carrier
-    opts.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+    const metadata = parseTelemetryMetadata(opts.telemetry?.metadata)
+    metadata._datadog = carrier
+    opts.telemetry = { metadata: JSON.stringify(metadata), omitContext: true }
+    return metadata
   }
 
   setProducerCheckpoint (span, ctx) {
@@ -56,10 +72,10 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
     const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
 
     if (optsTarget && typeof optsTarget === 'object') {
-      const existing = optsTarget.telemetry?.metadata ? JSON.parse(optsTarget.telemetry.metadata) : {}
-      DsmPathwayCodec.encode(dataStreamsContext, existing._datadog || existing)
-      if (!existing._datadog) existing._datadog = {}
-      optsTarget.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+      const metadata = ctx._ddMetadata ?? parseTelemetryMetadata(optsTarget.telemetry?.metadata)
+      DsmPathwayCodec.encode(dataStreamsContext, metadata._datadog || metadata)
+      if (!metadata._datadog) metadata._datadog = {}
+      optsTarget.telemetry = { metadata: JSON.stringify(metadata), omitContext: true }
     }
   }
 
@@ -96,7 +112,7 @@ class QueueAddPlugin extends BaseBullmqProducerPlugin {
 
   injectTraceContext (span, ctx) {
     const opts = this.#ensureOpts(ctx)
-    this._injectIntoOpts(span, opts)
+    ctx._ddMetadata = this._injectIntoOpts(span, opts)
   }
 
   getDsmData (ctx) {
@@ -132,39 +148,31 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
     const jobs = ctx.arguments?.[0]
     if (!Array.isArray(jobs)) return
 
-    for (const job of jobs) {
+    const cache = []
+    for (let i = 0; i < jobs.length; i++) {
+      const job = jobs[i]
       if (!job) continue
       job.opts = job.opts || {}
-      this._injectIntoOpts(span, job.opts)
-    }
-  }
-
-  getDsmData (ctx) {
-    const jobs = ctx.arguments?.[0] || []
-    const payloadSize = jobs.reduce((total, job) => {
-      return total + (job?.data ? getMessageSize(job.data) : 0)
-    }, 0)
-    return {
-      queueName: ctx.self?.name || 'bullmq',
-      payloadSize,
-      optsTarget: jobs[0]?.opts,
+      cache[i] = this._injectIntoOpts(span, job.opts)
     }
+    ctx._ddMetadata = cache
   }
 
   setProducerCheckpoint (span, ctx) {
     const jobs = ctx.arguments?.[0] || []
     const queueName = ctx.self?.name || 'bullmq'
     const edgeTags = ['direction:out', `topic:${queueName}`, 'type:bullmq']
+    const cache = ctx._ddMetadata
 
-    for (const job of jobs) {
+    for (let i = 0; i < jobs.length; i++) {
+      const job = jobs[i]
       if (!job?.data) continue
       const payloadSize = getMessageSize(job.data)
       const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
-      job.opts = job.opts || {}
-      const existing = job.opts.telemetry?.metadata ? JSON.parse(job.opts.telemetry.metadata) : {}
-      DsmPathwayCodec.encode(dataStreamsContext, existing._datadog || existing)
-      if (!existing._datadog) existing._datadog = {}
-      job.opts.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+      const metadata = cache?.[i] ?? parseTelemetryMetadata(job.opts.telemetry?.metadata)
+      DsmPathwayCodec.encode(dataStreamsContext, metadata._datadog || metadata)
+      if (!metadata._datadog) metadata._datadog = {}
+      job.opts.telemetry = { metadata: JSON.stringify(metadata), omitContext: true }
     }
   }
 }
@@ -187,7 +195,7 @@ class FlowProducerAddPlugin extends BaseBullmqProducerPlugin {
     const flow = ctx.arguments?.[0]
     if (!flow) return
     flow.opts = flow.opts || {}
-    this._injectIntoOpts(span, flow.opts)
+    ctx._ddMetadata = this._injectIntoOpts(span, flow.opts)
   }
 
   getDsmData (ctx) {