dd-trace 5.43.0 → 5.45.0

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -3,7 +3,9 @@
 const {
   getTestSuitePath,
   removeEfdStringFromTestName,
-  addEfdStringToTestName
+  addEfdStringToTestName,
+  addAttemptToFixStringToTestName,
+  removeAttemptToFixStringFromTestName
 } = require('../../../dd-trace/src/plugins/util/test')
 const { channel, AsyncResource } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
@@ -26,7 +28,9 @@ const testToStartLine = new WeakMap()
 const testFileToSuiteAr = new Map()
 const wrappedFunctions = new WeakSet()
 const newTests = {}
+const testsAttemptToFix = new Set()
 const testsQuarantined = new Set()
+const testsStatuses = new Map()
 
 function getAfterEachHooks (testOrHook) {
   const hooks = []
@@ -44,10 +48,10 @@ function getTestProperties (test, testManagementTests) {
   const testSuite = getTestSuitePath(test.file, process.cwd())
   const testName = test.fullTitle()
 
-  const { disabled: isDisabled, quarantined: isQuarantined } =
+  const { attempt_to_fix: isAttemptToFix, disabled: isDisabled, quarantined: isQuarantined } =
     testManagementTests?.mocha?.suites?.[testSuite]?.tests?.[testName]?.properties || {}
 
-  return { isDisabled, isQuarantined }
+  return { isAttemptToFix, isDisabled, isQuarantined }
 }
 
 function isNewTest (test, knownTests) {
@@ -57,15 +61,18 @@ function isNewTest (test, knownTests) {
   return !testsForSuite.includes(testName)
 }
 
-function retryTest (test, earlyFlakeDetectionNumRetries) {
+function retryTest (test, numRetries, modifyTestName, tags) {
   const originalTestName = test.title
   const suite = test.parent
-  for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+  for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
     const clonedTest = test.clone()
-    clonedTest.title = addEfdStringToTestName(originalTestName, retryIndex + 1)
+    clonedTest.title = modifyTestName(originalTestName, retryIndex + 1)
     suite.addTest(clonedTest)
-    clonedTest._ddIsNew = true
-    clonedTest._ddIsEfdRetry = true
+    tags.forEach(tag => {
+      if (tag) {
+        clonedTest[tag] = true
+      }
+    })
   }
 }
 
@@ -102,7 +109,10 @@ function getIsLastRetry (test) {
 }
 
 function getTestFullName (test) {
-  return `mocha.${getTestSuitePath(test.file, process.cwd())}.${removeEfdStringFromTestName(test.fullTitle())}`
+  const testName = removeEfdStringFromTestName(
+    removeAttemptToFixStringFromTestName(test.fullTitle())
+  )
+  return `mocha.${getTestSuitePath(test.file, process.cwd())}.${testName}`
 }
 
 function getTestStatus (test) {
@@ -195,12 +205,15 @@ function getOnTestHandler (isMain) {
       title,
       _ddIsNew: isNew,
       _ddIsEfdRetry: isEfdRetry,
+      _ddIsAttemptToFix: isAttemptToFix,
       _ddIsDisabled: isDisabled,
       _ddIsQuarantined: isQuarantined
     } = test
 
+    const testName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(test.fullTitle()))
+
     const testInfo = {
-      testName: test.fullTitle(),
+      testName,
       testSuiteAbsolutePath,
       title,
       testStartLine
@@ -212,6 +225,7 @@ function getOnTestHandler (isMain) {
 
     testInfo.isNew = isNew
     testInfo.isEfdRetry = isEfdRetry
+    testInfo.isAttemptToFix = isAttemptToFix
     testInfo.isDisabled = isDisabled
     testInfo.isQuarantined = isQuarantined
     // We want to store the result of the new tests
@@ -224,7 +238,7 @@ function getOnTestHandler (isMain) {
       }
     }
 
-    if (isDisabled) {
+    if (!isAttemptToFix && isDisabled) {
       test.pending = true
     }
 
@@ -234,7 +248,7 @@ function getOnTestHandler (isMain) {
   }
 }
 
-function getOnTestEndHandler () {
+function getOnTestEndHandler (config) {
   return async function (test) {
     const asyncResource = getTestAsyncResource(test)
     const status = getTestStatus(test)
@@ -249,13 +263,40 @@ function getOnTestEndHandler () {
       })
     }
 
+    let hasFailedAllRetries = false
+    let attemptToFixPassed = false
+
+    const testName = getTestFullName(test)
+
+    if (!testsStatuses.get(testName)) {
+      testsStatuses.set(testName, [status])
+    } else {
+      testsStatuses.get(testName).push(status)
+    }
+    const testStatuses = testsStatuses.get(testName)
+
+    const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
+
+    if (test._ddIsAttemptToFix && isLastAttempt) {
+      if (testStatuses.every(status => status === 'fail')) {
+        hasFailedAllRetries = true
+      } else if (testStatuses.every(status => status === 'pass')) {
+        attemptToFixPassed = true
+      }
+    }
+
+    const isAttemptToFixRetry = test._ddIsAttemptToFix && testStatuses.length > 1
+
     // if there are afterEach to be run, we don't finish the test yet
     if (asyncResource && !getAfterEachHooks(test).length) {
       asyncResource.runInAsyncScope(() => {
         testFinishCh.publish({
           status,
           hasBeenRetried: isMochaRetry(test),
-          isLastRetry: getIsLastRetry(test)
+          isLastRetry: getIsLastRetry(test),
+          hasFailedAllRetries,
+          attemptToFixPassed,
+          isAttemptToFixRetry
         })
       })
     }
@@ -374,33 +415,50 @@ function getOnPendingHandler () {
   }
 }
 
-// Hook to add retries to tests if EFD is enabled
+// Hook to add retries to tests if Test Management or EFD is enabled
 function getRunTestsWrapper (runTests, config) {
-  return function (suite, fn) {
+  return function (suite) {
+    if (config.isTestManagementTestsEnabled) {
+      suite.tests.forEach((test) => {
+        const { isAttemptToFix, isDisabled, isQuarantined } = getTestProperties(test, config.testManagementTests)
+        if (isAttemptToFix && !test.isPending()) {
+          test._ddIsAttemptToFix = true
+          test._ddIsDisabled = isDisabled
+          test._ddIsQuarantined = isQuarantined
+          // This is needed to know afterwards which ones have been retried to ignore its result
+          testsAttemptToFix.add(test)
+          retryTest(
+            test,
+            config.testManagementAttemptToFixRetries,
+            addAttemptToFixStringToTestName,
+            ['_ddIsAttemptToFix', isDisabled && '_ddIsDisabled', isQuarantined && '_ddIsQuarantined']
+          )
+        } else if (isDisabled) {
+          test._ddIsDisabled = true
+        } else if (isQuarantined) {
+          testsQuarantined.add(test)
+          test._ddIsQuarantined = true
+        }
+      })
+    }
+
     if (config.isKnownTestsEnabled) {
       // by the time we reach `this.on('test')`, it is too late. We need to add retries here
       suite.tests.forEach(test => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true
           if (config.isEarlyFlakeDetectionEnabled) {
-            retryTest(test, config.earlyFlakeDetectionNumRetries)
+            retryTest(
+              test,
+              config.earlyFlakeDetectionNumRetries,
+              addEfdStringToTestName,
+              ['_ddIsNew', '_ddIsEfdRetry']
+            )
           }
         }
       })
     }
 
-    if (config.isTestManagementTestsEnabled) {
-      suite.tests.forEach(test => {
-        const { isDisabled, isQuarantined } = getTestProperties(test, config.testManagementTests)
-        if (isDisabled) {
-          test._ddIsDisabled = true
-        } else if (isQuarantined) {
-          testsQuarantined.add(test)
-          test._ddIsQuarantined = true
-        }
-      })
-    }
-
     return runTests.apply(this, arguments)
   }
 }
@@ -408,7 +466,6 @@ function getRunTestsWrapper (runTests, config) {
 module.exports = {
   isNewTest,
   getTestProperties,
-  retryTest,
   getSuitesByTestFile,
   isMochaRetry,
   getTestFullName,
@@ -427,5 +484,7 @@ module.exports = {
   testFileToSuiteAr,
   getRunTestsWrapper,
   newTests,
-  testsQuarantined
+  testsQuarantined,
+  testsAttemptToFix,
+  testsStatuses
 }

package/packages/datadog-instrumentations/src/mocha/worker.js

@@ -36,6 +36,8 @@ addHook({
     }
     if (this.options._ddIsTestManagementTestsEnabled) {
       config.isTestManagementTestsEnabled = true
+      // TODO: attempt to fix does not work in parallel mode yet
+      // config.testManagementAttemptToFixRetries = this.options._ddTestManagementAttemptToFixRetries
       config.testManagementTests = this.options._ddTestManagementTests
       delete this.options._ddIsTestManagementTestsEnabled
       delete this.options._ddTestManagementTests
@@ -64,7 +66,7 @@ addHook({
     })
     this.on('test', getOnTestHandler(false))
 
-    this.on('test end', getOnTestEndHandler())
+    this.on('test end', getOnTestEndHandler(config))
 
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
     this.on('hook end', getOnHookEndHandler())

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

@@ -22,6 +22,7 @@ const testToAr = new WeakMap()
 const testSuiteToAr = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
+const testsToTestStatuses = new Map()
 const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
 let applyRepeatEachIndex = null
@@ -43,7 +44,9 @@ let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let knownTests = {}
 let isTestManagementTestsEnabled = false
+let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
+const quarantinedOrDisabledTestsAttemptToFix = []
 let rootDir = ''
 const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0'
 
@@ -51,10 +54,9 @@ function getTestProperties (test) {
   const testName = getTestFullname(test)
   const testSuite = getTestSuitePath(test._requireFile, rootDir)
 
-  const { disabled, quarantined } =
+  const { attempt_to_fix: attemptToFix, disabled, quarantined } =
     testManagementTests?.playwright?.suites?.[testSuite]?.tests?.[testName]?.properties || {}
-
-  return { disabled, quarantined }
+  return { attemptToFix, disabled, quarantined }
 }
 
 function isNewTest (test) {
@@ -73,16 +75,19 @@ function getSuiteType (test, type) {
 }
 
 // Copy of Suite#_deepClone but with a function to filter tests
-function deepCloneSuite (suite, filterTest) {
+function deepCloneSuite (suite, filterTest, tags = []) {
   const copy = suite._clone()
   for (const entry of suite._entries) {
     if (entry.constructor.name === 'Suite') {
-      copy._addSuite(deepCloneSuite(entry, filterTest))
+      copy._addSuite(deepCloneSuite(entry, filterTest, tags))
     } else {
       if (filterTest(entry)) {
         const copiedTest = entry._clone()
-        copiedTest._ddIsNew = true
-        copiedTest._ddIsEfdRetry = true
+        tags.forEach(tag => {
+          if (tag) {
+            copiedTest[tag] = true
+          }
+        })
         copy._addTest(copiedTest)
       }
     }
@@ -276,6 +281,11 @@ function testBeginHandler (test, browserName) {
     })
   }
 
+  // We disable retries by default if attemptToFix is true
+  if (getTestProperties(test).attemptToFix) {
+    test.retries = 0
+  }
+
   const testAsyncResource = new AsyncResource('bound-anonymous-fn')
   testToAr.set(test, testAsyncResource)
   testAsyncResource.runInAsyncScope(() => {
@@ -288,7 +298,6 @@ function testBeginHandler (test, browserName) {
     })
   })
 }
-
 function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   let annotationTags
   if (annotations.length) {
@@ -305,6 +314,27 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
     return
   }
 
+  const testFullName = getTestFullname(test)
+  const testFqn = `${testSuiteAbsolutePath} ${testFullName}`
+  const testStatuses = testsToTestStatuses.get(testFqn) || []
+
+  if (testStatuses.length === 0) {
+    testsToTestStatuses.set(testFqn, [testStatus])
+  } else {
+    testStatuses.push(testStatus)
+  }
+
+  let hasFailedAllRetries = false
+  let hasPassedAttemptToFixRetries = false
+
+  if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
+    if (testStatuses.every(status => status === 'fail')) {
+      hasFailedAllRetries = true
+    } else if (testStatuses.every(status => status === 'pass')) {
+      hasPassedAttemptToFixRetries = true
+    }
+  }
+
   const testResult = results[results.length - 1]
   const testAsyncResource = testToAr.get(test)
   testAsyncResource.runInAsyncScope(() => {
@@ -315,8 +345,12 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
       error,
       extraTags: annotationTags,
       isNew: test._ddIsNew,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
       isQuarantined: test._ddIsQuarantined,
-      isEfdRetry: test._ddIsEfdRetry
+      isEfdRetry: test._ddIsEfdRetry,
+      hasFailedAllRetries,
+      hasPassedAttemptToFixRetries
     })
   })
 
@@ -338,7 +372,6 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   // Last test, we finish the suite
   if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
     const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
-
     let testSuiteStatus = 'pass'
     if (testStatuses.some(status => status === 'fail')) {
       testSuiteStatus = 'fail'
@@ -445,6 +478,7 @@ function runnerHook (runnerExport, playwrightVersion) {
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
+        testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
       }
     } catch (e) {
       isEarlyFlakeDetectionEnabled = false
@@ -485,7 +519,10 @@ function runnerHook (runnerExport, playwrightVersion) {
 
     const projects = getProjectsFromRunner(this)
 
-    if (isFlakyTestRetriesEnabled && flakyTestRetriesCount > 0) {
+    const shouldSetRetries = isFlakyTestRetriesEnabled &&
+      flakyTestRetriesCount > 0 &&
+      !isTestManagementTestsEnabled
+    if (shouldSetRetries) {
       projects.forEach(project => {
         if (project.retries === 0) { // Only if it hasn't been set by the user
           project.retries = flakyTestRetriesCount
@@ -493,7 +530,7 @@ function runnerHook (runnerExport, playwrightVersion) {
       })
     }
 
-    const runAllTestsReturn = await runAllTests.apply(this, arguments)
+    let runAllTestsReturn = await runAllTests.apply(this, arguments)
 
     Object.values(remainingTestsByFile).forEach(tests => {
       // `tests` should normally be empty, but if it isn't,
@@ -508,6 +545,26 @@ function runnerHook (runnerExport, playwrightVersion) {
 
     const sessionStatus = runAllTestsReturn.status || runAllTestsReturn
 
+    if (isTestManagementTestsEnabled && sessionStatus === 'failed') {
+      let totalFailedTestCount = 0
+      let totalAttemptToFixFailedTestCount = 0
+
+      for (const testStatuses of testsToTestStatuses.values()) {
+        totalFailedTestCount += testStatuses.filter(status => status === 'fail').length
+      }
+
+      for (const test of quarantinedOrDisabledTestsAttemptToFix) {
+        const fullname = getTestFullname(test)
+        const fqn = `${test._requireFile} ${fullname}`
+        const testStatuses = testsToTestStatuses.get(fqn)
+        totalAttemptToFixFailedTestCount += testStatuses.filter(status => status === 'fail').length
+      }
+
+      if (totalFailedTestCount === totalAttemptToFixFailedTestCount) {
+        runAllTestsReturn = 'passed'
+      }
+    }
+
     const flushWait = new Promise(resolve => {
       onDone = resolve
     })
@@ -608,9 +665,28 @@ addHook({
         const testProperties = getTestProperties(test)
         if (testProperties.disabled) {
           test._ddIsDisabled = true
-          test.expectedStatus = 'skipped'
         } else if (testProperties.quarantined) {
           test._ddIsQuarantined = true
+        }
+        if (testProperties.attemptToFix) {
+          test._ddIsAttemptToFix = true
+          const fileSuite = getSuiteType(test, 'file')
+          const projectSuite = getSuiteType(test, 'project')
+          const isAttemptToFix = test => getTestProperties(test).attemptToFix
+          for (let repeatEachIndex = 1; repeatEachIndex <= testManagementAttemptToFixRetries; repeatEachIndex++) {
+            const copyFileSuite = deepCloneSuite(fileSuite, isAttemptToFix, [
+              testProperties.disabled && '_ddIsDisabled',
+              testProperties.quarantined && '_ddIsQuarantined',
+              '_ddIsAttemptToFix',
+              '_ddIsAttemptToFixRetry'
+            ])
+            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
+            projectSuite._addSuite(copyFileSuite)
+          }
+          if (testProperties.disabled || testProperties.quarantined) {
+            quarantinedOrDisabledTestsAttemptToFix.push(test)
+          }
+        } else if (testProperties.disabled || testProperties.quarantined) {
           test.expectedStatus = 'skipped'
         }
       }
@@ -619,18 +695,22 @@ addHook({
     if (isKnownTestsEnabled) {
       const newTests = allTests.filter(isNewTest)
 
-      newTests.forEach(newTest => {
+      for (const newTest of newTests) {
+        // No need to filter out attempt to fix tests here because attempt to fix tests are never new
         newTest._ddIsNew = true
         if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped') {
           const fileSuite = getSuiteType(newTest, 'file')
           const projectSuite = getSuiteType(newTest, 'project')
-          for (let repeatEachIndex = 0; repeatEachIndex < earlyFlakeDetectionNumRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isNewTest)
+          for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
+            const copyFileSuite = deepCloneSuite(fileSuite, isNewTest, [
+              '_ddIsNew',
+              '_ddIsEfdRetry'
+            ])
             applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
             projectSuite._addSuite(copyFileSuite)
           }
         }
-      })
+      }
     }
 
     return rootSuite

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

@@ -5,6 +5,7 @@ const pathToRegExp = require('path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
 
+// TODO: Move this function to a shared file between Express and Router
 function createWrapRouterMethod (name) {
   const enterChannel = channel(`apm:${name}:middleware:enter`)
   const exitChannel = channel(`apm:${name}:middleware:exit`)

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

@@ -16,7 +16,7 @@ addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {
       return makeRequest.apply(this, arguments)
     }
 
-    const queryOrProcedure = getQueryOrProcedure(request)
+    const [queryOrProcedure, queryParent, queryField] = getQueryOrProcedure(request)
 
     if (!queryOrProcedure) {
       return makeRequest.apply(this, arguments)
@@ -28,7 +28,9 @@ addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {
     const connectionConfig = this.config
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ queryOrProcedure, connectionConfig })
+      const payload = { queryOrProcedure, connectionConfig }
+      startCh.publish(payload)
+      queryParent[queryField] = payload.sql
 
       const cb = callbackResource.bind(request.callback, request)
       request.callback = asyncResource.bind(function (error) {
@@ -53,14 +55,15 @@ addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {
   return tedious
 })
 
+// returns [queryOrProcedure, parentObjectToSet, propertyNameToSet]
 function getQueryOrProcedure (request) {
-  if (!request.parameters) return
-
-  const statement = request.parametersByName.statement || request.parametersByName.stmt
-
-  if (!statement) {
-    return request.sqlTextOrProcedure
+  if (!request.parameters) return [null]
+
+  if (request.parametersByName.statement) {
+    return [request.parametersByName.statement.value, request.parametersByName.statement, 'value']
+  } else if (request.parametersByName.stmt) {
+    return [request.parametersByName.stmt.value, request.parametersByName.stmt, 'value']
+  } else {
+    return [request.sqlTextOrProcedure, request, 'sqlTextOrProcedure']
   }
-
-  return statement.value
 }