dd-trace 5.99.0 → 5.100.0

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

@@ -12,7 +12,9 @@ const {
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
   DYNAMIC_NAME_RE,
-  logDynamicNamesWarning,
+  recordAttemptToFixExecution,
+  logAttemptToFixTestExecution,
+  logTestOptimizationSummary,
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 const {
@@ -76,9 +78,10 @@ let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let modifiedFiles = {}
-const quarantinedOrDisabledTestsAttemptToFix = []
 let quarantinedButNotAttemptToFixFqns = new Set()
 const newTestsWithDynamicNames = new Set()
+const attemptToFixExecutions = new Map()
+const loggedAttemptToFixTests = new Set()
 let rootDir = ''
 let sessionProjects = []
 
@@ -290,6 +293,32 @@ function testWillRetry (test, testStatus) {
   return testStatus === 'fail' && test.results.length <= test.retries
 }
 
+function getFinalStatus ({
+  isFinalExecution,
+  isDisabled,
+  isQuarantined,
+  isAtrRetry,
+  isEfdManagedTest,
+  isAttemptToFix,
+  hasFailedAllRetries,
+  hasFailedAttemptToFixRetries,
+  testStatus,
+}) {
+  if (!isFinalExecution) {
+    return
+  }
+  if (isDisabled || isQuarantined || testStatus === 'skip') {
+    return 'skip'
+  }
+  if (isAtrRetry || isEfdManagedTest) {
+    return hasFailedAllRetries ? 'fail' : 'pass'
+  }
+  if (isAttemptToFix) {
+    return hasFailedAttemptToFixRetries ? 'fail' : 'pass'
+  }
+  return testStatus
+}
+
 function getTestFullname (test) {
   let parent = test.parent
   const names = [test.title]
@@ -337,6 +366,11 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
   // We disable retries by default if attemptToFix is true
   if (getTestProperties(test).attemptToFix) {
     test.retries = 0
+    logAttemptToFixTestExecution(
+      getTestSuitePath(testSuiteAbsolutePath, rootDir),
+      getTestFullname(test),
+      loggedAttemptToFixTests
+    )
   }
 
   // this handles tests that do not go through the worker process (because they're skipped)
@@ -399,6 +433,20 @@ function testEndHandler ({
 
   const testProperties = getTestProperties(test)
 
+  if (testProperties.attemptToFix) {
+    test._ddHasFailedAttemptToFixRetries = false
+    test._ddHasFailedAllRetries = false
+    test._ddHasPassedAttemptToFixRetries = false
+
+    recordAttemptToFixExecution(attemptToFixExecutions, {
+      testSuite: getTestSuitePath(test._requireFile, rootDir),
+      testName: getTestFullname(test),
+      status: testStatus,
+      isDisabled: testProperties.disabled,
+      isQuarantined: testProperties.quarantined,
+    })
+  }
+
   if (testStatuses.length === testManagementAttemptToFixRetries + 1 && testProperties.attemptToFix) {
     if (testStatuses.includes('fail')) {
       test._ddHasFailedAttemptToFixRetries = true
@@ -431,10 +479,26 @@ function testEndHandler ({
   if (shouldCreateTestSpan) {
     const testResult = results.at(-1)
     const testCtx = testToCtx.get(test)
+    const isEfdManagedTest = (test._ddIsNew || test._ddIsModified) &&
+      !test._ddIsAttemptToFix &&
+      isEarlyFlakeDetectionEnabled
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
+
+    const finalStatus = getFinalStatus({
+      isFinalExecution: !testWillRetry(test, testStatus),
+      isDisabled: test._ddIsDisabled,
+      isQuarantined: test._ddIsQuarantined,
+      isAtrRetry,
+      isEfdManagedTest,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      testStatus,
+    })
+
     // if there is no testCtx, the skipped test will be created later
     if (testCtx) {
       testFinishCh.publish({
@@ -454,6 +518,7 @@ function testEndHandler ({
         hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
         isAtrRetry,
         isModified: test._ddIsModified,
+        finalStatus,
         ...testCtx.currentStore,
       })
     }
@@ -597,11 +662,12 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 
       const isTimeout = status === 'timedOut'
       const shouldCreateTestSpan = test.expectedStatus === 'skipped'
+      const testStatus = STATUS_TO_TEST_STATUS[status]
       testEndHandler(
         {
           test,
           annotations,
-          testStatus: STATUS_TO_TEST_STATUS[status],
+          testStatus,
           error: errors && errors[0],
           isTimeout,
           shouldCreateTestSpan,
@@ -613,6 +679,27 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
         isFlakyTestRetriesEnabled &&
         !test._ddIsAttemptToFix &&
         !test._ddIsEfdRetry
+
+      // EFD retries (new or modified tests) are implemented as clones with retries=0,
+      // so testWillRetry always returns false for them. Instead, we track how many
+      // executions have been reported via testsToTestStatuses (updated by testEndHandler
+      // above) and mark the execution final once the count reaches the expected total.
+      // This mirrors how ATF finality is detected and centralizes the decision in the
+      // main process, so workers only need to act on the _ddIsFinalExecution flag.
+      const isEfdManagedTest = (test._ddIsNew || test._ddIsModified) &&
+        !test._ddIsAttemptToFix &&
+        isEarlyFlakeDetectionEnabled
+      let isFinalExecution
+      if (isEfdManagedTest) {
+        const testFqn = getTestFullyQualifiedName(test)
+        const efdTestStatuses = testsToTestStatuses.get(testFqn) || []
+        isFinalExecution = efdTestStatuses.length === earlyFlakeDetectionNumRetries + 1
+      } else if (test._ddIsAttemptToFix) {
+        isFinalExecution = !!(test._ddHasPassedAttemptToFixRetries || test._ddHasFailedAttemptToFixRetries)
+      } else {
+        isFinalExecution = !testWillRetry(test, testStatus)
+      }
+
       // We want to send the ddProperties to the worker
       worker.process.send({
         type: 'ddProperties',
@@ -629,6 +716,8 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
           _ddHasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
           _ddIsAtrRetry: isAtrRetry,
           _ddIsModified: test._ddIsModified,
+          _ddIsFinalExecution: isFinalExecution,
+          _ddIsEfdManagedTest: isEfdManagedTest,
         },
       })
     })
@@ -766,7 +855,6 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
     if (isTestManagementTestsEnabled && sessionStatus === 'failed') {
       let totalFailedTestCount = 0
-      let totalAttemptToFixFailedTestCount = 0
       let totalPureQuarantinedFailedTestCount = 0
 
       for (const [fqn, testStatuses] of testsToTestStatuses.entries()) {
@@ -780,16 +868,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
         }
       }
 
-      for (const test of quarantinedOrDisabledTestsAttemptToFix) {
-        const testFqn = getTestFullyQualifiedName(test)
-        const testStatuses = testsToTestStatuses.get(testFqn)
-        // Only count as failed if the final status (after retries) is 'fail'
-        if (testStatuses && testStatuses[testStatuses.length - 1] === 'fail') {
-          totalAttemptToFixFailedTestCount += 1
-        }
-      }
-
-      const totalIgnorableFailures = totalAttemptToFixFailedTestCount + totalPureQuarantinedFailedTestCount
+      const totalIgnorableFailures = totalPureQuarantinedFailedTestCount
 
       if (totalFailedTestCount > 0 && totalFailedTestCount === totalIgnorableFailures) {
         runAllTestsReturn = 'passed'
@@ -797,7 +876,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       }
     }
 
-    logDynamicNamesWarning(newTestsWithDynamicNames)
+    logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
+    loggedAttemptToFixTests.clear()
 
     const flushWait = new Promise(resolve => {
       onDone = resolve
@@ -975,9 +1055,6 @@ addHook({
           if (!fileSuitesWithManagedTestsToProjects.has(fileSuite)) {
             fileSuitesWithManagedTestsToProjects.set(fileSuite, getSuiteType(test, 'project'))
           }
-          if (testProperties.disabled || testProperties.quarantined) {
-            quarantinedOrDisabledTestsAttemptToFix.push(test)
-          }
         }
       }
       applyRetriesToTests(
@@ -1275,6 +1352,18 @@ addHook({
     // Wait for the properties to be received
     await ddPropertiesPromise
 
+    const finalStatus = getFinalStatus({
+      isFinalExecution: test._ddIsFinalExecution,
+      isDisabled: test._ddIsDisabled,
+      isQuarantined: test._ddIsQuarantined,
+      isAtrRetry: test._ddIsAtrRetry,
+      isEfdManagedTest: test._ddIsEfdManagedTest,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      testStatus: STATUS_TO_TEST_STATUS[status],
+    })
+
     testFinishCh.publish({
       testStatus: STATUS_TO_TEST_STATUS[status],
       steps: steps.filter(step => step.testId === testId),
@@ -1294,6 +1383,7 @@ addHook({
       isAtrRetry: test._ddIsAtrRetry,
       isModified: test._ddIsModified,
       onDone,
+      finalStatus,
       ...testCtx.currentStore,
     })
 

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')
 
@@ -73,8 +74,8 @@ class BullmqConsumerPlugin extends ConsumerPlugin {
       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)
     }
   }
 }