dd-trace 6.8.0 → 6.9.0

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

@@ -8,14 +8,20 @@ const { performance } = require('node:perf_hooks')
 const satisfies = require('../../../vendor/dist/semifies')
 
 const shimmer = require('../../datadog-shimmer')
+const {
+  EMPTY_EFD_RETRY_POLICY,
+  getEfdRetryCountForDuration,
+  hasEfdRetries,
+  shouldSkipEfdRetry,
+} = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
 const {
   parseAnnotations,
   getTestSuitePath,
+  PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
   DYNAMIC_NAME_RE,
-  getEfdRetryCount,
-  getMaxEfdRetryCount,
+  recordTestManagementExecution,
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
   logTestOptimizationSummary,
@@ -50,6 +56,7 @@ const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 
 const workerReportCh = channel('ci:playwright:worker:report')
+const workerReportTelemetryCh = channel('ci:playwright:worker-report:telemetry')
 const testPageGotoCh = channel('ci:playwright:test:page-goto')
 
 const dispatcherRunCh = tracingChannel('orchestrion:playwright:Dispatcher_run')
@@ -66,6 +73,7 @@ const testSuiteToCtx = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
+const activeRumPages = new Set()
 
 const RUM_FLUSH_WAIT_TIME = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')
 const DD_PROPERTIES_TIMEOUT = 5000
@@ -89,8 +97,7 @@ const STATUS_TO_TEST_STATUS = {
 let remainingTestsByFile = {}
 let isKnownTestsEnabled = false
 let isEarlyFlakeDetectionEnabled = false
-let earlyFlakeDetectionNumRetries = 0
-let earlyFlakeDetectionSlowTestRetries = {}
+let earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
 let isEarlyFlakeDetectionFaulty = false
 let earlyFlakeDetectionFaultyThreshold = 0
 let isFlakyTestRetriesEnabled = false
@@ -102,6 +109,7 @@ let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let modifiedFiles = {}
 let quarantinedButNotAttemptToFixFqns = new Set()
+let recordedTestOptimizationExecutions = new Set()
 let testsReportedInGenerateSummary = new Set()
 const newTestsWithDynamicNames = new Set()
 const attemptToFixExecutions = new Map()
@@ -205,16 +213,8 @@ function getTestEfdKey (test) {
   return [projectKey, repeatEachKey, testFqn].filter(Boolean).join(' ')
 }
 
-function getConfiguredEfdRetryCount () {
-  if (!earlyFlakeDetectionSlowTestRetries || !Object.keys(earlyFlakeDetectionSlowTestRetries).length) {
-    return earlyFlakeDetectionNumRetries
-  }
-  return getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
-}
-
 function markEfdManagedTest (test) {
   test._ddIsEfdManagedTest = true
-  test._ddEfdSlowTestRetries = earlyFlakeDetectionSlowTestRetries
   efdManagedTestKeys.add(getTestEfdKey(test))
 }
 
@@ -237,15 +237,18 @@ function registerEfdRetryTest (test) {
   })
 }
 
-function getTestEfdSlowTestRetries (test) {
-  return test._ddEfdSlowTestRetries || earlyFlakeDetectionSlowTestRetries
+/**
+ * @returns {boolean}
+ */
+function shouldRunEarlyFlakeDetection () {
+  return isEarlyFlakeDetectionEnabled && hasEfdRetries(earlyFlakeDetectionRetryPolicy)
 }
 
 function isTestEfdManaged (test) {
   return !!test._ddIsEfdManagedTest || (
     (test._ddIsNew || test._ddIsModified) &&
     !test._ddIsAttemptToFix &&
-    isEarlyFlakeDetectionEnabled
+    shouldRunEarlyFlakeDetection()
   )
 }
 
@@ -261,7 +264,8 @@ function getEfdRetryRepeatEachIndex (fileSuite, projectSuite, retryIndex, retryC
 }
 
 function getEfdRetryCountForTest (test) {
-  return efdRetryCountByTestKey.get(getTestEfdKey(test)) ?? getConfiguredEfdRetryCount()
+  return efdRetryCountByTestKey.get(getTestEfdKey(test)) ??
+    earlyFlakeDetectionRetryPolicy.schedulingRetryCount
 }
 
 function setEfdRetryCountForTest (test, retryCount) {
@@ -395,12 +399,12 @@ function waitForEfdRetryCount (test) {
   })
 }
 
-function shouldSkipEfdRetry (test) {
+function shouldSkipEfdRetryTest (test) {
   if (!test._ddIsEfdRetry) {
     return false
   }
   const retryCount = test._ddEfdRetryCount ?? efdRetryCountByTestKey.get(getTestEfdKey(test))
-  return retryCount !== undefined && test._ddEfdRetryIndex > retryCount
+  return shouldSkipEfdRetry(test._ddEfdRetryIndex, retryCount)
 }
 
 function getTestProperties (test) {
@@ -682,7 +686,7 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return
   }
-  if (shouldSkipEfdRetry(test)) {
+  if (shouldSkipEfdRetryTest(test)) {
     test._ddShouldSkipEfdRetry = true
     return
   }
@@ -731,6 +735,33 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
   }
 }
 
+/**
+ * Records a skipped managed test for the end-of-session report.
+ *
+ * @param {object} test
+ * @param {string} testSuiteAbsolutePath
+ * @returns {void}
+ */
+function recordSkippedTestOptimizationExecution (test, testSuiteAbsolutePath) {
+  if (recordedTestOptimizationExecutions.has(test) ||
+    !test._ddIsAttemptToFix && !test._ddIsDisabled) return
+
+  const execution = {
+    testSuite: getTestSuitePath(testSuiteAbsolutePath, rootDir),
+    testName: getTestFullname(test),
+    status: 'skip',
+    isDisabled: test._ddIsDisabled,
+    isQuarantined: test._ddIsQuarantined,
+  }
+
+  if (test._ddIsAttemptToFix) {
+    recordAttemptToFixExecution(attemptToFixExecutions, execution)
+  } else {
+    recordTestManagementExecution(execution)
+  }
+  recordedTestOptimizationExecutions.add(test)
+}
+
 function finishTestSuiteIfDone (testSuiteAbsolutePath, projects) {
   if (!shouldFinishTestSuite(testSuiteAbsolutePath)) {
     return
@@ -741,6 +772,7 @@ function finishTestSuiteIfDone (testSuiteAbsolutePath, projects) {
 
   for (const test of skippedTests) {
     const browserName = getBrowserNameFromProjects(projects, test)
+    recordSkippedTestOptimizationExecution(test, testSuiteAbsolutePath)
     testSkipCh.publish({
       testName: getTestFullname(test),
       testSuiteAbsolutePath,
@@ -799,7 +831,7 @@ function testEndHandler ({
     return
   }
 
-  if (test._ddShouldSkipEfdRetry || shouldSkipEfdRetry(test)) {
+  if (test._ddShouldSkipEfdRetry || shouldSkipEfdRetryTest(test)) {
     test._ddShouldSkipEfdRetry = true
     remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
       .filter(currentTest => currentTest !== test)
@@ -825,7 +857,7 @@ function testEndHandler ({
   if (isEfdManagedTest && !test._ddIsEfdRetry && !efdRetryCountByTestKey.has(testEfdKey)) {
     const testResult = results.at(-1)
     const duration = testResult?.duration > 0 ? testResult.duration : performance.now() - test._ddStartTime
-    const retryCount = getEfdRetryCount(duration, getTestEfdSlowTestRetries(test))
+    const retryCount = getEfdRetryCountForDuration(duration, earlyFlakeDetectionRetryPolicy)
     setEfdRetryCountForTest(test, retryCount)
     if (retryCount === 0) {
       efdSlowAbortedTests.add(testEfdKey)
@@ -833,21 +865,40 @@ function testEndHandler ({
   }
 
   const testProperties = getTestProperties(test)
+  const hasRecordedTestOptimizationExecution = recordedTestOptimizationExecutions.has(test)
 
-  if (testProperties.attemptToFix) {
-    test._ddHasFailedAttemptToFixRetries = false
-    test._ddHasFailedAllRetries = false
-    test._ddHasPassedAttemptToFixRetries = false
-
-    recordAttemptToFixExecution(attemptToFixExecutions, {
+  if (!hasRecordedTestOptimizationExecution) {
+    recordTestManagementExecution({
       testSuite: getTestSuitePath(test._requireFile, rootDir),
       testName: getTestFullname(test),
       status: testStatus,
+      isAttemptToFix: testProperties.attemptToFix,
       isDisabled: testProperties.disabled,
       isQuarantined: testProperties.quarantined,
     })
   }
 
+  if (testProperties.attemptToFix) {
+    test._ddHasFailedAttemptToFixRetries = false
+    test._ddHasFailedAllRetries = false
+    test._ddHasPassedAttemptToFixRetries = false
+
+    if (!hasRecordedTestOptimizationExecution) {
+      recordAttemptToFixExecution(attemptToFixExecutions, {
+        testSuite: getTestSuitePath(test._requireFile, rootDir),
+        testName: getTestFullname(test),
+        status: testStatus,
+        isDisabled: testProperties.disabled,
+        isQuarantined: testProperties.quarantined,
+      })
+    }
+  }
+
+  if (!hasRecordedTestOptimizationExecution &&
+    (testProperties.attemptToFix || testProperties.disabled || testProperties.quarantined)) {
+    recordedTestOptimizationExecutions.add(test)
+  }
+
   if (testStatuses.length === testManagementAttemptToFixRetries + 1 && testProperties.attemptToFix) {
     if (testStatuses.includes('fail')) {
       test._ddHasFailedAttemptToFixRetries = true
@@ -1000,7 +1051,7 @@ function prepareDispatcherRun (dispatcher, args) {
     testGroups = testGroups.filter(group => group.tests.length > 0)
   }
 
-  if (isEarlyFlakeDetectionEnabled) {
+  if (shouldRunEarlyFlakeDetection()) {
     testGroups = deferEfdRetryGroups(testGroups)
   }
 
@@ -1221,8 +1272,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       if (!err) {
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
-        earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
-        earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
+        earlyFlakeDetectionRetryPolicy = libraryConfig.earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
         earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
@@ -1382,6 +1432,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     startedSuites = []
     remainingTestsByFile = {}
     quarantinedButNotAttemptToFixFqns = new Set()
+    recordedTestOptimizationExecutions = new Set()
     testsReportedInGenerateSummary = new Set()
     efdManagedTestKeys.clear()
     efdRetryCountByTestKey.clear()
@@ -1589,6 +1640,30 @@ addHook({
   return suiteUtilsPackage
 })
 
+/**
+ * @typedef {Record<string, unknown>} PlaywrightTest
+ */
+
+/**
+ * @typedef {Record<string, unknown>} PlaywrightSuite
+ */
+
+/**
+ * @typedef {{ _fullProject: unknown, _addSuite: (suite: unknown) => void }} PlaywrightProjectSuite
+ */
+
+/**
+ * @typedef {(
+ *   copiedTest: PlaywrightTest, originalTest: PlaywrightTest, repeatEachIndex: number
+ * ) => void} ConfigureCopiedTest
+ */
+
+/**
+ * @typedef {(
+ *   fileSuite: PlaywrightSuite, projectSuite: PlaywrightProjectSuite, repeatEachIndex: number, numRetries: number
+ * ) => number} GetRetryRepeatEachIndex
+ */
+
 /**
  * We could repeat the logic of `applyRepeatEachIndex` here, but it'd be more risky
  * as playwright could change it at any time.
@@ -1602,6 +1677,13 @@ addHook({
  * - we clone each of these file suites for each repeat index
  * - we execute `applyRepeatEachIndex` for each of these cloned file suites
  * - we add the cloned file suites to the project suite
+ *
+ * @param {Map<PlaywrightSuite, PlaywrightProjectSuite>} fileSuitesWithTestsToRetry
+ * @param {(test: PlaywrightTest) => unknown} filterTest
+ * @param {Array<string | ((test: PlaywrightTest) => unknown)>} tagsToApply
+ * @param {number} numRetries
+ * @param {ConfigureCopiedTest} [configureCopiedTest]
+ * @param {GetRetryRepeatEachIndex} [getRetryRepeatEachIndex]
  */
 function applyRetriesToTests (
   fileSuitesWithTestsToRetry,
@@ -1709,7 +1791,7 @@ function processRootSuite (createRootSuiteReturnValue) {
     const fileSuitesWithImpactedTestsToProjects = new Map()
     for (const impactedTest of impactedTests) {
       impactedTest._ddIsModified = true
-      if (isEarlyFlakeDetectionEnabled && impactedTest.expectedStatus !== 'skipped') {
+      if (shouldRunEarlyFlakeDetection() && impactedTest.expectedStatus !== 'skipped') {
         markEfdManagedTest(impactedTest)
         const fileSuite = getSuiteType(impactedTest, 'file')
         if (!fileSuitesWithImpactedTestsToProjects.has(fileSuite)) {
@@ -1726,7 +1808,7 @@ function processRootSuite (createRootSuiteReturnValue) {
         '_ddIsEfdRetry',
         (test) => (isKnownTestsEnabled && isNewTest(test) ? '_ddIsNew' : null),
       ],
-      getConfiguredEfdRetryCount(),
+      earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
       (copiedTest, originalTest, retryIndex) => {
         markEfdRetryTest(copiedTest, retryIndex, originalTest)
         markEfdManagedTest(copiedTest)
@@ -1752,8 +1834,8 @@ function processRootSuite (createRootSuiteReturnValue) {
       const fileSuitesWithNewTestsToProjects = new Map()
       for (const newTest of newTests) {
         newTest._ddIsNew = true
-        if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
-          // Prevent ATR or `--retries` from retrying new tests if EFD is enabled
+        if (shouldRunEarlyFlakeDetection() && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
+          // Prevent ATR or `--retries` from retrying tests that EFD manages.
           newTest.retries = 0
           markEfdManagedTest(newTest)
           const fileSuite = getSuiteType(newTest, 'file')
@@ -1767,7 +1849,7 @@ function processRootSuite (createRootSuiteReturnValue) {
         fileSuitesWithNewTestsToProjects,
         isNewTest,
         ['_ddIsNew', '_ddIsEfdRetry'],
-        getConfiguredEfdRetryCount(),
+        earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
         (copiedTest, originalTest, retryIndex) => {
           markEfdRetryTest(copiedTest, retryIndex, originalTest)
           markEfdManagedTest(copiedTest)
@@ -1831,6 +1913,8 @@ function finishProcessHostStartRunner (processHost) {
         serializedTraces: message[1],
         screenshots: processHost[kDdPlaywrightFailureScreenshots]?.shift(),
       })
+    } else if (Array.isArray(message) && message[0] === PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE) {
+      workerReportTelemetryCh.publish(message[1])
     }
   })
 }
@@ -1879,6 +1963,8 @@ async function handlePageGoto (page) {
     return
   }
 
+  activeRumPages.add(page)
+
   let browserVersion
   try {
     browserVersion = page.context().browser()?.version()
@@ -1915,6 +2001,54 @@ async function handlePageGoto (page) {
   }
 }
 
+/**
+ * Stops a RUM session and expires its correlation cookie.
+ *
+ * @param {import('playwright-core').Page} page
+ * @returns {Promise<void>}
+ */
+async function cleanupRumPage (page) {
+  try {
+    const isRumActive = await page.evaluate(stopRumSession)
+
+    if (!isRumActive) {
+      return
+    }
+
+    // Give some time RUM to flush data, similar to what we do in selenium
+    await new Promise(resolve => realSetTimeout(resolve, RUM_FLUSH_WAIT_TIME))
+    const url = page.url()
+    if (url) {
+      const domain = new URL(url).hostname
+      await page.context().addCookies([{
+        name: RUM_COOKIE_NAME,
+        value: '',
+        domain,
+        path: '/',
+        expires: 0,
+      }])
+    } else {
+      log.error('RUM is active but page.url() is not available')
+    }
+  } catch (error) {
+    // Cleanup must not change the test result.
+    log.error('afterEach hook error', error)
+  }
+}
+
+/**
+ * Stops RUM sessions and expires correlation cookies for pages visited by the current test.
+ *
+ * @returns {Promise<void[]>|undefined}
+ */
+function cleanupRumPages () {
+  if (activeRumPages.size === 0) return
+
+  const cleanupPromises = Array.from(activeRumPages, cleanupRumPage)
+  activeRumPages.clear()
+  return Promise.all(cleanupPromises)
+}
+
 addHook({
   name: 'playwright-core',
   file: 'lib/client/page.js',
@@ -1955,7 +2089,7 @@ function instrumentWorkerMainMethods (workerMain) {
       test.expectedStatus = 'skipped'
     }
     await waitForEfdRetryCount(test)
-    if (shouldSkipEfdRetry(test)) {
+    if (shouldSkipEfdRetryTest(test)) {
       test._ddShouldSkipEfdRetry = true
       test.expectedStatus = 'skipped'
     }
@@ -1964,6 +2098,7 @@ function instrumentWorkerMainMethods (workerMain) {
     }
     test._ddStartTime = performance.now()
     steps = []
+    activeRumPages.clear()
 
     const {
       _requireFile: testSuiteAbsolutePath,
@@ -2027,34 +2162,7 @@ function instrumentWorkerMainMethods (workerMain) {
       if (!existAfterEachHook) {
         test.parent._hooks.push({
           type: 'afterEach',
-          fn: async function ({ page }) {
-            try {
-              if (page) {
-                const isRumActive = await page.evaluate(stopRumSession)
-
-                if (isRumActive) {
-                  // Give some time RUM to flush data, similar to what we do in selenium
-                  await new Promise(resolve => realSetTimeout(resolve, RUM_FLUSH_WAIT_TIME))
-                  const url = page.url()
-                  if (url) {
-                    const domain = new URL(url).hostname
-                    await page.context().addCookies([{
-                      name: RUM_COOKIE_NAME,
-                      value: '',
-                      domain,
-                      path: '/',
-                      expires: 0,
-                    }])
-                  } else {
-                    log.error('RUM is active but page.url() is not available')
-                  }
-                }
-              }
-            } catch (e) {
-              // ignore errors
-              log.error('afterEach hook error', e)
-            }
-          },
+          fn: cleanupRumPages,
           title: 'afterEach hook',
           _ddHook: true,
         })
@@ -2067,21 +2175,6 @@ function instrumentWorkerMainMethods (workerMain) {
     await res
 
     const { status, error, annotations, retry, testId } = testInfo
-    const testEfdKey = getTestEfdKey(test)
-    const isEfdManagedTest = isTestEfdManaged(test)
-    if (isEfdManagedTest && !test._ddIsEfdRetry && !efdRetryCountByTestKey.has(testEfdKey)) {
-      const duration = test.results?.at(-1)?.duration > 0
-        ? test.results.at(-1).duration
-        : performance.now() - test._ddStartTime
-      const retryCount = getEfdRetryCount(
-        duration,
-        getTestEfdSlowTestRetries(test)
-      )
-      setEfdRetryCountForTest(test, retryCount)
-      if (retryCount === 0) {
-        efdSlowAbortedTests.add(testEfdKey)
-      }
-    }
 
     if (!hasDdProperties && process.send) {
       process.send({
@@ -2213,6 +2306,7 @@ function generateSummaryWrapper (generateSummary) {
         } = test
         const browserName = getBrowserNameFromProjects(sessionProjects, test)
 
+        recordSkippedTestOptimizationExecution(test, testSuiteAbsolutePath)
         testSkipCh.publish({
           testName: getTestFullname(test),
           testSuiteAbsolutePath,

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

@@ -7,9 +7,9 @@ const { wrapThen } = require('./helpers/promise')
 addHook({
   name: 'promise-js',
   versions: ['>=0.0.3'],
-}, Promise => {
-  if (Promise !== global.Promise) {
-    shimmer.wrap(Promise.prototype, 'then', wrapThen)
+}, LibraryPromise => {
+  if (LibraryPromise !== global.Promise) {
+    shimmer.wrap(LibraryPromise.prototype, 'then', wrapThen)
   }
-  return Promise
+  return LibraryPromise
 })

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

@@ -8,7 +8,7 @@ addHook({
   name: 'promise',
   file: 'lib/core.js',
   versions: ['>=7'],
-}, Promise => {
-  shimmer.wrap(Promise.prototype, 'then', wrapThen)
-  return Promise
+}, LibraryPromise => {
+  shimmer.wrap(LibraryPromise.prototype, 'then', wrapThen)
+  return LibraryPromise
 })