dd-trace 5.124.0 → 5.126.0

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

@@ -68,6 +68,7 @@ const finishWrappedContexts = new WeakSet()
 const runFilesWrappedPrototypes = new WeakSet()
 const activeRunFilesContexts = new WeakSet()
 const runErrorsByContext = new WeakMap()
+const typecheckPoolWorkerRequests = new WeakMap()
 let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let isEarlyFlakeDetectionEnabled = false
@@ -148,6 +149,10 @@ function getTypecheckerExport (vitestPackage) {
   return findExportByName(vitestPackage, 'Typechecker')
 }
 
+function getTypecheckPoolWorkerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'TypecheckPoolWorker')
+}
+
 function getForksPoolWorkerExport (vitestPackage) {
   return findExportByName(vitestPackage, 'ForksPoolWorker')
 }
@@ -1207,7 +1212,6 @@ function getFinishWrapper (exitOrClose) {
       status: runError ? 'fail' : (areAllSuitesSkipped ? 'skip' : getSessionStatus(this.state)),
       testCodeCoverageLinesTotal,
       error,
-      isTestSessionFinalizationError: Boolean(runError),
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
@@ -1691,9 +1695,9 @@ async function reportTypecheckFile (file, sessionConfiguration, frameworkVersion
   })
 }
 
-async function reportTypecheckResults (result, frameworkVersion, ctx, typechecker) {
+async function reportTypecheckResults (result, frameworkVersion, ctx, typechecker, files = result?.files) {
   if (!testSuiteFinishCh.hasSubscribers) return
-  if (!Array.isArray(result?.files)) return
+  if (!Array.isArray(result?.files) || !Array.isArray(files)) return
 
   const setupState = ctx && mainProcessSetupStates.get(ctx)
   if (
@@ -1703,7 +1707,7 @@ async function reportTypecheckResults (result, frameworkVersion, ctx, typechecke
     await ensureMainProcessSetup(
       ctx,
       frameworkVersion,
-      result.files,
+      files,
       false,
       !setupState || setupState.disableTestImpactAnalysis
     )
@@ -1713,7 +1717,7 @@ async function reportTypecheckResults (result, frameworkVersion, ctx, typechecke
     ? await getChannelPromise(testSessionConfigurationCh, { frameworkVersion }) || {}
     : {}
 
-  await Promise.all(result.files.map(file => reportTypecheckFile(
+  await Promise.all(files.map(file => reportTypecheckFile(
     file,
     sessionConfiguration,
     frameworkVersion,
@@ -1742,6 +1746,51 @@ function getTypecheckerWrapper (vitestPackage, frameworkVersion) {
   return vitestPackage
 }
 
+function wrapTypecheckPoolWorker (TypecheckPoolWorker, frameworkVersion) {
+  if (!TypecheckPoolWorker?.prototype?.send || !TypecheckPoolWorker.prototype.on) return
+
+  shimmer.wrap(TypecheckPoolWorker.prototype, 'send', send => function (message) {
+    typecheckPoolWorkerRequests.set(this, {
+      type: message?.type,
+      filepaths: new Set(message?.context?.files?.map(file => file.filepath)),
+    })
+    return send.apply(this, arguments)
+  })
+  shimmer.wrap(TypecheckPoolWorker.prototype, 'on', on => function (event, callback) {
+    if (event !== 'message') return on.apply(this, arguments)
+
+    const worker = this
+    arguments[1] = shimmer.wrapFunction(callback, callback => function (message) {
+      const typechecker = worker.project?.typechecker
+      const request = typecheckPoolWorkerRequests.get(worker)
+      if (
+        message?.type !== 'testfileFinished' ||
+        request?.type !== 'run' ||
+        !typechecker
+      ) {
+        return callback.apply(this, arguments)
+      }
+
+      const result = typechecker.getResult?.()
+      const files = result?.files?.filter(file => request.filepaths.has(file.filepath))
+      return reportTypecheckResults(
+        result,
+        frameworkVersion,
+        worker.project?.vitest,
+        typechecker,
+        files
+      ).then(
+        () => callback.apply(this, arguments),
+        (error) => {
+          log.error('Could not report Vitest typecheck results: %s', error?.message)
+          return callback.apply(this, arguments)
+        }
+      )
+    })
+    return on.apply(this, arguments)
+  })
+}
+
 function getCreateCliWrapper (vitestPackage, frameworkVersion) {
   const createCliExport = findExportByName(vitestPackage, 'createCLI')
   if (!createCliExport) {
@@ -1963,14 +2012,23 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   }
   const startVitestExport = findExportByName(cliApiPackage, 'startVitest')
   shimmer.wrap(cliApiPackage, startVitestExport.key, getCliOrStartVitestWrapper(frameworkVersion))
+  const createVitestExport = findExportByName(cliApiPackage, 'createVitest')
+  if (createVitestExport) {
+    shimmer.wrap(cliApiPackage, createVitestExport.key, getCliOrStartVitestWrapper(frameworkVersion))
+  }
   wrapMessagePortOn()
 
-  const vitest = getVitestExport(cliApiPackage)
+  wrapVitestInternals(cliApiPackage, frameworkVersion)
+  return cliApiPackage
+}
+
+function wrapVitestInternals (vitestPackage, frameworkVersion) {
+  const vitest = getVitestExport(vitestPackage)
   if (vitest) {
     wrapVitestRunFiles(vitest.value, frameworkVersion)
   }
 
-  const forksPoolWorker = getForksPoolWorkerExport(cliApiPackage)
+  const forksPoolWorker = getForksPoolWorkerExport(vitestPackage)
   if (forksPoolWorker) {
     // function is async
     shimmer.wrap(forksPoolWorker.value.prototype, 'start', start => function (...args) {
@@ -1982,7 +2040,7 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
     shimmer.wrap(forksPoolWorker.value.prototype, 'on', getWrappedOn)
   }
 
-  const threadsPoolWorker = getThreadsPoolWorkerExport(cliApiPackage)
+  const threadsPoolWorker = getThreadsPoolWorkerExport(vitestPackage)
   if (threadsPoolWorker) {
     // function is async
     shimmer.wrap(threadsPoolWorker.value.prototype, 'start', start => function (...args) {
@@ -1992,7 +2050,6 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
     })
     shimmer.wrap(threadsPoolWorker.value.prototype, 'on', getWrappedOn)
   }
-  return cliApiPackage
 }
 
 addHook({
@@ -2082,6 +2139,32 @@ addHook({
   return coveragePackage
 })
 
+// Vitest 5 moved the core and pool worker exports out of cli-api into an index chunk.
+addHook({
+  name: 'vitest',
+  versions: ['>=5.0.0'],
+  filePattern: 'dist/chunks/index.*',
+}, (vitestPackage, frameworkVersion) => {
+  if (!getVitestExport(vitestPackage)) return vitestPackage
+
+  wrapVitestInternals(vitestPackage, frameworkVersion)
+
+  const typecheckPoolWorker = getTypecheckPoolWorkerExport(vitestPackage)
+  if (typecheckPoolWorker) {
+    wrapTypecheckPoolWorker(typecheckPoolWorker.value, frameworkVersion)
+  }
+
+  const baseSequencer = getBaseSequencerExport(vitestPackage)
+  if (baseSequencer) {
+    shimmer.wrap(
+      baseSequencer.value.prototype,
+      'sort',
+      sort => getSortWrapper(sort, frameworkVersion)
+    )
+  }
+  return vitestPackage
+})
+
 addHook({
   name: 'vitest',
   versions: ['>=3.0.0 <3.0.9'],

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const fs = require('node:fs')
 const path = require('node:path')
 const { performance } = require('node:perf_hooks')
 const { fileURLToPath } = require('node:url')
@@ -244,7 +245,17 @@ function wrapVitestCoverageRpc () {
       if (property !== 'onAfterSuiteRun' || typeof value !== 'function') return value
 
       return function (metadata) {
-        vitestCoverageSnapshot = metadata?.coverage
+        const coverage = metadata?.coverage
+        if (typeof coverage === 'string') {
+          try {
+            vitestCoverageSnapshot = JSON.parse(fs.readFileSync(coverage, 'utf8'))
+          } catch (error) {
+            log.warn('Could not read Vitest V8 coverage: %s', error?.message)
+            vitestCoverageSnapshot = undefined
+          }
+        } else {
+          vitestCoverageSnapshot = coverage
+        }
         return value.apply(this, arguments)
       }
     },
@@ -891,22 +902,36 @@ function wrapVitestTestRunner (VitestTestRunner) {
 }
 
 function captureRunnerFunctions (pkg) {
-  if (vitestGetFn) return
   const getFnExport = findExportByName(pkg, 'getFn')
   const setFnExport = findExportByName(pkg, 'setFn')
-  if (getFnExport && setFnExport) {
+  if (!vitestGetFn && getFnExport) {
     vitestGetFn = getFnExport.value
+  }
+  if (!vitestSetFn && setFnExport) {
     vitestSetFn = setFnExport.value
   }
   const getHooksExport = findExportByName(pkg, 'getHooks')
-  if (getHooksExport) {
+  if (!vitestGetHooks && getHooksExport) {
     vitestGetHooks = getHooksExport.value
   }
 }
 
+function installTestScopedRunTask (VitestTestRunner) {
+  if (VitestTestRunner.prototype.runTask) return
+
+  VitestTestRunner.prototype.runTask = function (task) {
+    const fn = vitestGetFn?.(task)
+    if (!fn) {
+      throw new Error('Test function is not found. Did you add it using setFn?')
+    }
+    const testFn = wrapTestScopedFn(task, fn)
+    return testFn()
+  }
+}
+
 addHook({
   name: 'vitest',
-  versions: ['>=4.0.0'],
+  versions: ['>=4.0.0 <5.0.0'],
   filePattern: 'dist/chunks/test.*',
 }, (testPackage) => {
   const testRunner = getTestRunnerExport(testPackage)
@@ -920,6 +945,30 @@ addHook({
   return testPackage
 })
 
+// Vitest 5 bundled the former @vitest/runner implementation into separate index and run chunks.
+addHook({
+  name: 'vitest',
+  versions: ['>=5.0.0'],
+  filePattern: 'dist/chunks/index.*',
+}, (testPackage) => {
+  const testRunner = getTestRunnerExport(testPackage)
+  if (testRunner) {
+    wrapVitestTestRunner(testRunner.value)
+    installTestScopedRunTask(testRunner.value)
+  }
+  return testPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=5.0.0'],
+  filePattern: 'dist/chunks/run.*',
+}, (runnerPackage, frameworkVersion) => {
+  captureRunnerFunctions(runnerPackage)
+  wrapStartTests(runnerPackage, frameworkVersion)
+  return runnerPackage
+})
+
 addHook({
   name: '@vitest/runner',
   versions: ['>=1.6.0'],
@@ -946,13 +995,8 @@ addHook({
   return vitestPackage
 })
 
-// test suite start and finish
-// only relevant for workers
-addHook({
-  name: '@vitest/runner',
-  versions: ['>=1.6.0'],
-}, (vitestPackage, frameworkVersion) => {
-  shimmer.wrap(vitestPackage, 'startTests', startTests => async function (testPaths) {
+function getStartTestsWrapper (frameworkVersion) {
+  return startTests => async function (testPaths) {
     let testSuiteError = null
     if (!testSuiteFinishCh.hasSubscribers) {
       return startTests.apply(this, arguments)
@@ -1166,7 +1210,20 @@ addHook({
     })
 
     return startTestsResponse
-  })
+  }
+}
 
+function wrapStartTests (vitestPackage, frameworkVersion) {
+  const startTests = findExportByName(vitestPackage, 'startTests')
+  if (startTests) {
+    shimmer.wrap(vitestPackage, startTests.key, getStartTestsWrapper(frameworkVersion))
+  }
   return vitestPackage
-})
+}
+
+// test suite start and finish
+// only relevant for workers
+addHook({
+  name: '@vitest/runner',
+  versions: ['>=1.6.0'],
+}, wrapStartTests)