dd-trace 6.20.1 → 6.21.0

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

@@ -26,6 +26,7 @@ const shimmer = require('../../../datadog-shimmer')
 const testStartCh = channel('ci:mocha:test:start')
 const testFinishCh = channel('ci:mocha:test:finish')
 const testDiWaitCh = channel('ci:mocha:test:di:wait')
+const testAfterEachFinishCh = channel('ci:mocha:after-each:finish')
 // after a test has failed, we'll publish to this channel
 const testRetryCh = channel('ci:mocha:test:retry')
 const errorCh = channel('ci:mocha:test:error')
@@ -54,6 +55,7 @@ const testsQuarantined = new Set()
 const testsStatuses = new Map()
 const efdRetryCountByTestFullName = new Map()
 const efdSlowAbortedTests = new Set()
+const suiteHookFailureSuites = new Set()
 let dynamicAtrRetryCountByTest = new WeakMap()
 const attemptToFixExecutions = new Map()
 const isMochaWorker = !!getEnvironmentVariable('MOCHA_WORKER_ID')
@@ -343,6 +345,7 @@ function resetRunState (rootSuite) {
   testsStatuses.clear()
   efdRetryCountByTestFullName.clear()
   efdSlowAbortedTests.clear()
+  suiteHookFailureSuites.clear()
   dynamicAtrRetryCountByTest = new WeakMap()
   attemptToFixExecutions.clear()
   loggedAttemptToFixTests.clear()
@@ -379,7 +382,9 @@ function resetRunState (rootSuite) {
       delete test._ddTestFinishPublished
       delete test._ddIsFinalAttempt
       delete test._ddHookFailed
+      delete test._ddSuppressSyntheticTestLifecycle
       delete test._ddPendingRetry
+      delete test._ddPendingHookFailureFinish
       delete test._ddReporterStartFailed
       delete test._ddReporterTerminalFailed
       originalTests.push(test)
@@ -439,6 +444,21 @@ function recordTestAttempt (testsByFullName, test) {
   }
 }
 
+function recordRetryTrackedAttempt (test) {
+  const {
+    _ddIsAttemptToFix: isAttemptToFix,
+    _ddIsModified: isModified,
+    _ddIsNew: isNew,
+  } = test
+
+  if (isNew) {
+    recordTestAttempt(newTests, test)
+  }
+  if (!isAttemptToFix && (isNew || isModified)) {
+    recordTestAttempt(efdTests, test)
+  }
+}
+
 function getTestStatus (test) {
   if (test.isPending()) {
     return 'skip'
@@ -476,6 +496,15 @@ function startTestFinish (test) {
   return true
 }
 
+function hasHandledHookFailure (test) {
+  return test._ddHookFailed && (test._ddTestFinishPublished || test._ddPendingHookFailureFinish)
+}
+
+function suppressSyntheticTestLifecycle (test) {
+  test._ddSuppressSyntheticTestLifecycle = true
+  test._ddTestFinishPublished = true
+}
+
 /**
  * Copies Test Management metadata from Mocha's original runnable to its native retry clone.
  * @param {{
@@ -571,6 +600,14 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
       }
     }
 
+    const failedTestReplayPromise = (isTestHook || this.type === 'test') &&
+      test._retriedTest?._ddFailedTestReplayPromise
+    if (failedTestReplayPromise) {
+      delete test._retriedTest._ddFailedTestReplayPromise
+      const runRunnable = () => run.apply(this, args)
+      return failedTestReplayPromise.then(runRunnable, runRunnable)
+    }
+
     return run.apply(this, args)
   })
   return RunnablePackage
@@ -578,6 +615,8 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
 
 function getOnTestHandler (isMain) {
   return function (test) {
+    if (test._ddSuppressSyntheticTestLifecycle || hasHandledHookFailure(test)) return
+
     const testStartLine = testToStartLine.get(test)
 
     // This may be a retry. If this is the case, `test.fn` is already wrapped,
@@ -586,6 +625,12 @@ function getOnTestHandler (isMain) {
 
     inheritDatadogPropertiesFromRetriedTest(test)
 
+    if (isInFailedSuite(test.parent)) {
+      recordRetryTrackedAttempt(test)
+      suppressSyntheticTestLifecycle(test)
+      return
+    }
+
     const {
       file: testSuiteAbsolutePath,
       title,
@@ -636,13 +681,8 @@ function getOnTestHandler (isMain) {
         loggedAttemptToFixTests
       )
     }
-    // We want to store the result of the new tests
-    if (isNew) {
-      recordTestAttempt(newTests, test)
-    }
-    if (!isAttemptToFix && (isNew || isModified)) {
-      recordTestAttempt(efdTests, test)
-    }
+    // Keep retry accounting aligned with Mocha's runner failure counts.
+    recordRetryTrackedAttempt(test)
 
     if (!isAttemptToFix && isDisabled) {
       if (!originalPendingByTest.has(test)) {
@@ -657,6 +697,14 @@ function getOnTestHandler (isMain) {
   }
 }
 
+function isInFailedSuite (suite) {
+  while (suite) {
+    if (suiteHookFailureSuites.has(suite)) return true
+    suite = suite.parent
+  }
+  return false
+}
+
 function getFinalStatus ({
   status,
   hasFailedAllRetries,
@@ -842,7 +890,7 @@ function getTestFinishInfo (test, status, config, error) {
 
 function getOnTestEndHandler (config, finalAttemptHandlers) {
   return async function (test) {
-    if (test._ddShouldSkipEfdRetry) {
+    if (test._ddShouldSkipEfdRetry || test._ddSuppressSyntheticTestLifecycle || hasHandledHookFailure(test)) {
       return
     }
     const shouldWaitForHitProbe = test._retriedTest?._ddShouldWaitForHitProbe
@@ -880,24 +928,33 @@ function getOnTestEndHandler (config, finalAttemptHandlers) {
       finalAttemptHandlers?.onStart?.(test)
     }
 
-    if (shouldWaitForHitProbe) {
-      await waitForHitProbe()
-    }
+    const finish = () => {
+      if (shouldFinishTest) {
+        test._ddTestFinishPublished = true
+        testFinishCh.publish({
+          status,
+          hasBeenRetried: isMochaRetry(test),
+          isLastRetry: getIsLastRetry(test),
+          ...testFinishInfo,
+          ...ctx.currentStore,
+        })
+      }
 
-    if (shouldFinishTest) {
-      test._ddTestFinishPublished = true
-      testFinishCh.publish({
-        status,
-        hasBeenRetried: isMochaRetry(test),
-        isLastRetry: getIsLastRetry(test),
-        ...testFinishInfo,
-        ...ctx.currentStore,
-      })
+      if (isFinalAttempt) {
+        finalAttemptHandlers?.onFinish?.(test)
+      }
     }
 
-    if (isFinalAttempt) {
-      finalAttemptHandlers?.onFinish?.(test)
+    if (shouldWaitForHitProbe) {
+      const waitForHitProbePromise = waitForHitProbe()
+      if (shouldFinishTest && config.isTestFailureVideosEnabled && !test.isPending()) {
+        // Mocha does not await test-end listeners. Its hookUp continuation must wait even without teardown hooks.
+        test._ddDeferredHookEnd = { waitForHitProbePromise, publishTestFinish: finish }
+        return
+      }
+      await waitForHitProbePromise
     }
+    finish()
   }
 }
 
@@ -978,17 +1035,30 @@ function finishDeferredHookEnd (test) {
  * @returns {unknown}
  */
 function runFailedTestReplayHookUpCallback (fn, test, failedTestReplayPromise, hookThis, args) {
+  if (test._ddPendingHookFailureFinish) {
+    // Mocha restarts teardown at the failed suite's parent. Only the last hookUp completes the attempt.
+    const failedSuite = /** @type {import('mocha').Suite|undefined} */ (args[1])
+    if (args[0] && failedSuite?.parent) return fn.apply(hookThis, /** @type {unknown[]} */ (args))
+    const finish = test._ddPendingHookFailureFinish
+    delete test._ddPendingHookFailureFinish
+    finish()
+  }
   const pendingRetry = test._ddPendingRetry
   if (pendingRetry) {
     delete test._ddPendingRetry
     failedTestReplayPromise = pendingRetry()
   }
+  const continueAfterCapture = () => {
+    const context = { onDone: () => fn.apply(hookThis, args), isWaiting: false }
+    testAfterEachFinishCh.publish(context)
+    return context.isWaiting ? undefined : context.onDone()
+  }
   const continueAfterProbe = () => {
     const deferredHookEndPromise = finishDeferredHookEnd(test)
     if (deferredHookEndPromise) {
-      return deferredHookEndPromise.then(() => fn.apply(hookThis, args), () => fn.apply(hookThis, args))
+      return deferredHookEndPromise.then(continueAfterCapture, continueAfterCapture)
     }
-    return fn.apply(hookThis, args)
+    return continueAfterCapture()
   }
 
   if (failedTestReplayPromise) {
@@ -1037,15 +1107,23 @@ function getOnFailHandler (isMain, config) {
     const testFile = testOrHook.file
     let test = testOrHook
     const isHook = testOrHook.type === 'hook'
+    const isBeforeEachHook = isHook && testOrHook.parent?._beforeEach?.includes(testOrHook)
+    const isAfterEachHook = isHook && testOrHook.parent?._afterEach?.includes(testOrHook)
+    const isTestHook = isBeforeEachHook || isAfterEachHook
+    if (isHook && !isTestHook && testOrHook.parent) {
+      suiteHookFailureSuites.add(testOrHook.parent)
+    }
     if (isHook && testOrHook.ctx) {
       test = testOrHook.ctx.currentTest
     }
     let testContext
     if (test) {
+      if (!isHook && (test._ddSuppressSyntheticTestLifecycle || hasHandledHookFailure(test))) return
+
       testContext = getTestContext(test)
     }
     if (testContext) {
-      if (isHook && startTestFinish(test)) {
+      if (isTestHook && startTestFinish(test)) {
         delete test._ddPendingRetry
         const hookError = new Error(`${testOrHook.fullTitle()}: ${err.message}`, { cause: err })
         hookError.name = err.name
@@ -1054,17 +1132,27 @@ function getOnFailHandler (isMain, config) {
         errorCh.runStores(testContext, () => {})
         // Mocha marks the hook failed, so record the test failure before computing final metadata.
         test._ddHookFailed = true
-        const testFinishInfo = getTestFinishInfo(test, 'fail', config, hookError)
-        if (testFinishInfo.finalStatus !== undefined) {
-          test._ddIsFinalAttempt = true
+        if (isBeforeEachHook && testOrHook.parent) {
+          suiteHookFailureSuites.add(testOrHook.parent)
+        }
+        const finish = () => {
+          const testFinishInfo = getTestFinishInfo(test, 'fail', config, testContext.err)
+          if (testFinishInfo.finalStatus !== undefined) {
+            test._ddIsFinalAttempt = true
+          }
+          test._ddTestFinishPublished = true
+          testFinishCh.publish({
+            status: 'fail',
+            hasBeenRetried: isMochaRetry(test),
+            ...testFinishInfo,
+            ...testContext.currentStore,
+          })
+        }
+        if (config.isTestFailureVideosEnabled) {
+          test._ddPendingHookFailureFinish = finish
+        } else {
+          finish()
         }
-        test._ddTestFinishPublished = true
-        testFinishCh.publish({
-          status: 'fail',
-          hasBeenRetried: isMochaRetry(test),
-          ...testFinishInfo,
-          ...testContext.currentStore,
-        })
       } else {
         testContext.err = err
         errorCh.runStores(testContext, () => {})
@@ -1105,7 +1193,7 @@ function getOnTestRetryHandler (config) {
       test._retries = dynamicCount
     }
 
-    if (config.isFlakyTestRetriesEnabled && getAfterEachHooks(test).length) {
+    if ((config.isFlakyTestRetriesEnabled || config.isTestFailureVideosEnabled) && getAfterEachHooks(test).length) {
       // Mocha queues retries before afterEach; a hook failure can still cancel the retry.
       test._ddPendingRetry = () => publishTestRetry(test, err, config)
       return

package/packages/datadog-instrumentations/src/mocha/webdriverio-protocol.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { clearTimeout, setTimeout } = require('node:timers')
+
 const {
   createWebdriverioWorkerMessage,
   WEBDRIVERIO_WORKER_ENV,
@@ -11,6 +13,9 @@ const { FINAL_FLUSH_TIMEOUT } = require('../../../dd-trace/src/ci-visibility/fin
 const SCREENSHOT_UPLOAD = 'dd:test-optimization:webdriverio:screenshot:upload'
 const SCREENSHOT_UPLOAD_RESPONSE = 'dd:test-optimization:webdriverio:screenshot:upload:response'
 const SCREENSHOT_UPLOAD_TIMEOUT_MS = FINAL_FLUSH_TIMEOUT + 5000
+const VIDEO_UPLOAD = 'dd:test-optimization:webdriverio:video:upload'
+const VIDEO_UPLOAD_RESPONSE = 'dd:test-optimization:webdriverio:video:upload:response'
+const VIDEO_UPLOAD_TIMEOUT_MS = 5 * FINAL_FLUSH_TIMEOUT + 5000
 
 /**
  * Sends a message over WebdriverIO's worker IPC envelope.
@@ -34,95 +39,113 @@ function sendWebdriverioWorkerMessage (message, onError, onDone) {
   })
 }
 
-let screenshotUploadRequestId = 0
-const screenshotUploadRequests = new Map()
+let mediaUploadRequestId = 0
+const mediaUploadRequests = new Map()
 
 /**
- * Removes shared screenshot response listeners when there are no pending requests.
+ * Removes shared media response listeners when there are no pending requests.
  *
  */
-function removeScreenshotUploadListeners () {
-  if (screenshotUploadRequests.size !== 0) return
+function removeMediaUploadListeners () {
+  if (mediaUploadRequests.size !== 0) return
 
-  process.off('message', onScreenshotUploadResponse)
-  process.off('disconnect', onScreenshotUploadDisconnect)
+  process.off('message', onMediaUploadResponse)
+  process.off('disconnect', onMediaUploadDisconnect)
 }
 
 /**
- * Completes one pending screenshot upload request.
+ * Completes one pending media upload request.
  *
  * @param {string} requestId
  * @param {Error} [error]
  */
-function finishScreenshotUploadRequest (requestId, error) {
-  const request = screenshotUploadRequests.get(requestId)
+function finishMediaUploadRequest (requestId, error) {
+  const request = mediaUploadRequests.get(requestId)
   if (!request) return
 
-  screenshotUploadRequests.delete(requestId)
+  mediaUploadRequests.delete(requestId)
   clearTimeout(request.timeout)
-  removeScreenshotUploadListeners()
+  removeMediaUploadListeners()
   request.onDone(error)
 }
 
 /**
- * Dispatches one coordinator screenshot response to its pending request.
+ * Dispatches one coordinator media response to its pending request.
  *
  * @param {object} message
  */
-function onScreenshotUploadResponse (message) {
-  if (message?.name !== SCREENSHOT_UPLOAD_RESPONSE) return
+function onMediaUploadResponse (message) {
+  if (message?.name !== SCREENSHOT_UPLOAD_RESPONSE && message?.name !== VIDEO_UPLOAD_RESPONSE) return
 
   const { error: errorMessage, requestId } = message.content || {}
   if (!requestId) return
 
-  finishScreenshotUploadRequest(requestId, errorMessage ? new Error(errorMessage) : undefined)
+  finishMediaUploadRequest(requestId, errorMessage ? new Error(errorMessage) : undefined)
 }
 
 /**
- * Fails every pending screenshot upload after coordinator disconnect.
+ * Fails every pending media upload after coordinator disconnect.
  *
  */
-function onScreenshotUploadDisconnect () {
-  for (const requestId of screenshotUploadRequests.keys()) {
-    finishScreenshotUploadRequest(
+function onMediaUploadDisconnect () {
+  for (const requestId of mediaUploadRequests.keys()) {
+    finishMediaUploadRequest(
       requestId,
-      new Error('WebdriverIO coordinator disconnected during screenshot upload')
+      new Error('WebdriverIO coordinator disconnected during media upload')
     )
   }
 }
 
 /**
- * Requests one screenshot upload from the WebdriverIO coordinator.
+ * Requests one media upload from the WebdriverIO coordinator.
  *
- * @param {object} content - Screenshot upload metadata
+ * @param {object} content - Upload metadata
+ * @param {'screenshot'|'video'} kind
  * @param {(error?: Error) => void} onDone - Upload completion callback
  */
-function requestWebdriverioScreenshotUpload (content, onDone) {
-  const requestId = `${process.pid}-${++screenshotUploadRequestId}`
+function requestWebdriverioMediaUpload (content, kind, onDone) {
+  const requestId = `${process.pid}-${++mediaUploadRequestId}`
   const timeout = setTimeout(() => {
-    finishScreenshotUploadRequest(requestId, new Error('WebdriverIO screenshot upload timed out'))
-  }, SCREENSHOT_UPLOAD_TIMEOUT_MS)
+    finishMediaUploadRequest(requestId, new Error(`WebdriverIO ${kind} upload timed out`))
+  }, kind === 'video' ? VIDEO_UPLOAD_TIMEOUT_MS : SCREENSHOT_UPLOAD_TIMEOUT_MS)
   timeout.unref?.()
-  if (screenshotUploadRequests.size === 0) {
-    process.on('message', onScreenshotUploadResponse)
-    process.once('disconnect', onScreenshotUploadDisconnect)
+  if (mediaUploadRequests.size === 0) {
+    process.on('message', onMediaUploadResponse)
+    process.once('disconnect', onMediaUploadDisconnect)
   }
-  screenshotUploadRequests.set(requestId, { onDone, timeout })
+  mediaUploadRequests.set(requestId, { onDone, timeout })
   sendWebdriverioWorkerMessage({
     origin: 'datadog',
-    name: SCREENSHOT_UPLOAD,
+    name: kind === 'video' ? VIDEO_UPLOAD : SCREENSHOT_UPLOAD,
     content: { ...content, requestId },
-  }, error => finishScreenshotUploadRequest(
+  }, error => finishMediaUploadRequest(
     requestId,
-    error || new Error('WebdriverIO screenshot upload IPC failed')
+    error || new Error(`WebdriverIO ${kind} upload IPC failed`)
   ))
 }
 
+/**
+ * @param {object} content
+ * @param {(error?: Error) => void} onDone
+ */
+function requestWebdriverioScreenshotUpload (content, onDone) {
+  requestWebdriverioMediaUpload(content, 'screenshot', onDone)
+}
+
+/**
+ * @param {object} content
+ * @param {(error?: Error) => void} onDone
+ */
+function requestWebdriverioVideoUpload (content, onDone) {
+  requestWebdriverioMediaUpload(content, 'video', onDone)
+}
+
 module.exports = {
   CONFIGURATION_REQUEST: 'dd:test-optimization:webdriverio:configuration:request',
   CONFIGURATION_RESPONSE: 'dd:test-optimization:webdriverio:configuration:response',
   createWebdriverioWorkerMessage,
   requestWebdriverioScreenshotUpload,
+  requestWebdriverioVideoUpload,
   SCREENSHOT_UPLOAD,
   SCREENSHOT_UPLOAD_RESPONSE,
   SCREENSHOT_UPLOAD_TIMEOUT_MS,
@@ -130,6 +153,10 @@ module.exports = {
   SUITE_FINISH: 'dd:test-optimization:webdriverio:test-suite:finish',
   WORKER_READY: 'dd:test-optimization:webdriverio:worker:ready',
   WORKER_READY_RESPONSE: 'dd:test-optimization:webdriverio:worker:ready:response',
+  VIDEO_UPLOAD_FLUSH: 'dd:test-optimization:webdriverio:video:flush',
+  VIDEO_UPLOAD,
+  VIDEO_UPLOAD_RESPONSE,
+  VIDEO_UPLOAD_TIMEOUT_MS,
   WEBDRIVERIO_WORKER_ENV,
   WEBDRIVERIO_WORKER_EVENT,
   WEBDRIVERIO_WORKER_ORIGIN,

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

@@ -416,7 +416,7 @@ function wrapMochaRun (Mocha, frameworkVersion) {
         })
       }
       filterSkippedFiles(runner, skippedFiles)
-      if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled) {
+      if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled || config.isTestFailureVideosEnabled) {
         patchFailedTestReplayHookUp(runner.constructor)
       }
       configurationReady = true
@@ -453,7 +453,7 @@ addHook({
     if (!workerFinishCh.hasSubscribers) {
       return run.apply(this, args)
     }
-    if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled) {
+    if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled || config.isTestFailureVideosEnabled) {
       patchFailedTestReplayHookUp(Runner)
     }
     if (isWebdriverioWorker) {
@@ -469,7 +469,10 @@ addHook({
     const onRunDone = args[0]
     if (isWebdriverioWorker && typeof onRunDone === 'function') {
       args[0] = (...onRunDoneArgs) => {
-        finishWebdriverioWorker(this, () => onRunDone(...onRunDoneArgs))
+        const adjustedFailures = Number.isFinite(this.failures)
+          ? Math.max(0, this.failures)
+          : onRunDoneArgs[0]
+        finishWebdriverioWorker(this, () => onRunDone(adjustedFailures, ...onRunDoneArgs.slice(1)))
       }
     } else {
       // Flush after the worker finishes its Mocha run, including grouped spec files.

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

@@ -2657,11 +2657,14 @@ function instrumentWorkerMainMethods (workerMain) {
       }
 
       // In cases where there is no afterEach hook with _ddHook, we need to add one
+      // Playwright 1.64 builds the hook step stack from hook.location, so an undefined
+      // location ends up as [undefined] and breaks trace writing
       if (!existAfterEachHook) {
         test.parent._hooks.push({
           type: 'afterEach',
           fn: cleanupRumPages,
           title: 'afterEach hook',
+          location: test.location,
           _ddHook: true,
         })
       }

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

@@ -2239,8 +2239,6 @@ addHook({
   versions: ['>=5.0.0'],
   filePattern: 'dist/chunks/index.*',
 }, (vitestPackage, frameworkVersion) => {
-  if (!getVitestExport(vitestPackage)) return vitestPackage
-
   wrapVitestInternals(vitestPackage, frameworkVersion)
 
   const typecheckPoolWorker = getTypecheckPoolWorkerExport(vitestPackage)