fix(coverage): improve memory usage by writing temporary files on file system

docs/config/index.md

@@ -1323,6 +1323,15 @@ See [istanbul documentation](https://github.com/istanbuljs/nyc#ignoring-methods)
 
 Watermarks for statements, lines, branches and functions. See [istanbul documentation](https://github.com/istanbuljs/nyc#high-and-low-watermarks) for more information.
 
+#### coverage.processingConcurrency
+
+- **Type:** `boolean`
+- **Default:** `Math.min(20, os.cpu().length)`
+- **Available for providers:** `'v8' | 'istanbul'`
+- **CLI:** `--coverage.processingConcurrency=<number>`
+
+Concurrency limit used when processing the coverage results.
+
 #### coverage.customProviderModule
 
 - **Type:** `string`

packages/coverage-istanbul/package.json

@@ -45,6 +45,7 @@
  "vitest": "^1.0.0-0"
  },
  "dependencies": {
+ "debug": "^4.3.4",
  "istanbul-lib-coverage": "^3.2.2",
  "istanbul-lib-instrument": "^6.0.1",
  "istanbul-lib-report": "^3.0.1",
@@ -55,6 +56,7 @@
  "test-exclude": "^6.0.0"
  },
  "devDependencies": {
+ "@types/debug": "^4.1.12",
  "@types/istanbul-lib-coverage": "^2.0.6",
  "@types/istanbul-lib-instrument": "^1.7.7",
  "@types/istanbul-lib-report": "^3.0.3",

packages/coverage-istanbul/src/provider.ts

@@ -5,9 +5,10 @@ import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/c
 import { BaseCoverageProvider } from 'vitest/coverage'
 import c from 'picocolors'
 import { parseModule } from 'magicast'
+import createDebug from 'debug'
 import libReport from 'istanbul-lib-report'
 import reports from 'istanbul-reports'
-import type { CoverageMap, CoverageMapData } from 'istanbul-lib-coverage'
+import type { CoverageMap } from 'istanbul-lib-coverage'
 import libCoverage from 'istanbul-lib-coverage'
 import libSourceMaps from 'istanbul-lib-source-maps'
 import { type Instrumenter, createInstrumenter } from 'istanbul-lib-instrument'
@@ -17,7 +18,8 @@ import _TestExclude from 'test-exclude'
 import { COVERAGE_STORE_KEY } from './constants'
 
 type Options = ResolvedCoverageOptions<'istanbul'>
-type CoverageByTransformMode = Record<AfterSuiteRunMeta['transformMode'], CoverageMapData[]>
+type Filename = string
+type CoverageFilesByTransformMode = Record<AfterSuiteRunMeta['transformMode'], Filename[]>
 type ProjectName = NonNullable<AfterSuiteRunMeta['projectName']> | typeof DEFAULT_PROJECT
 
 interface TestExclude {
@@ -35,6 +37,8 @@ interface TestExclude {
 }
 
 const DEFAULT_PROJECT = Symbol.for('default-project')
+const debug = createDebug('vitest:coverage')
+let uniqueId = 0
 
 export class IstanbulCoverageProvider extends BaseCoverageProvider implements CoverageProvider {
  name = 'istanbul'
@@ -44,13 +48,9 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
  instrumenter!: Instrumenter
  testExclude!: InstanceType<TestExclude>
 
- /**
- * Coverage objects collected from workers.
- * Some istanbul utilizers write these into file system instead of storing in memory.
- * If storing in memory causes issues, we can simply write these into fs in `onAfterSuiteRun`
- * and read them back when merging coverage objects in `onAfterAllFilesRun`.
- */
- coverages = new Map<ProjectName, CoverageByTransformMode>()
+ coverageFiles = new Map<ProjectName, CoverageFilesByTransformMode>()
+ coverageFilesDirectory!: string
+ pendingPromises: Promise<void>[] = []
 
  initialize(ctx: Vitest) {
  const config: CoverageIstanbulOptions = ctx.config.coverage
@@ -96,6 +96,8 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
  extension: this.options.extension,
  relativePath: !this.options.allowExternal,
  })
+
+ this.coverageFilesDirectory = resolve(this.options.reportsDirectory, '.tmp')
  }
 
  resolveOptions() {
@@ -121,43 +123,79 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
  * backwards compatibility is a breaking change.
  */
  onAfterSuiteRun({ coverage, transformMode, projectName }: AfterSuiteRunMeta) {
+ if (!coverage)
+ return
+
  if (transformMode !== 'web' && transformMode !== 'ssr')
  throw new Error(`Invalid transform mode: ${transformMode}`)
 
- let entry = this.coverages.get(projectName || DEFAULT_PROJECT)
+ let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT)
 
  if (!entry) {
  entry = { web: [], ssr: [] }
- this.coverages.set(projectName || DEFAULT_PROJECT, entry)
+ this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry)
  }
 
- entry[transformMode].push(coverage as CoverageMapData)
+ const filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`)
+ entry[transformMode].push(filename)
+
+ const promise = fs.writeFile(filename, JSON.stringify(coverage), 'utf-8')
+ this.pendingPromises.push(promise)
  }
 
  async clean(clean = true) {
  if (clean && existsSync(this.options.reportsDirectory))
  await fs.rm(this.options.reportsDirectory, { recursive: true, force: true, maxRetries: 10 })
 
- this.coverages = new Map()
+ if (existsSync(this.coverageFilesDirectory))
+ await fs.rm(this.coverageFilesDirectory, { recursive: true, force: true, maxRetries: 10 })
+
+ await fs.mkdir(this.coverageFilesDirectory, { recursive: true })
+
+ this.coverageFiles = new Map()
+ this.pendingPromises = []
  }
 
  async reportCoverage({ allTestsRun }: ReportContext = {}) {
- const coverageMaps = await Promise.all(
- Array.from(this.coverages.values()).map(coverages => [
- mergeAndTransformCoverage(coverages.ssr),
- mergeAndTransformCoverage(coverages.web),
- ]).flat(),
- )
+ const coverageMap = libCoverage.createCoverageMap({})
+ let index = 0
+ const total = this.pendingPromises.length
+
+ await Promise.all(this.pendingPromises)
+ this.pendingPromises = []
+
+ for (const coveragePerProject of this.coverageFiles.values()) {
+ for (const filenames of [coveragePerProject.ssr, coveragePerProject.web]) {
+ const coverageMapByTransformMode = libCoverage.createCoverageMap({})
+
+ for (const chunk of toSlices(filenames, this.options.processingConcurrency)) {
+ if (debug.enabled) {
+ index += chunk.length
+ debug('Covered files %d/%d', index, total)
+ }
+
+ await Promise.all(chunk.map(async (filename) => {
+ const contents = await fs.readFile(filename, 'utf-8')
+ const coverage = JSON.parse(contents) as CoverageMap
+
+ coverageMapByTransformMode.merge(coverage)
+ }))
+ }
+
+ // Source maps can change based on projectName and transform mode.
+ // Coverage transform re-uses source maps so we need to separate transforms from each other.
+ const transformedCoverage = await transformCoverage(coverageMapByTransformMode)
+ coverageMap.merge(transformedCoverage)
+ }
+ }
 
  if (this.options.all && allTestsRun) {
- const coveredFiles = coverageMaps.map(map => map.files()).flat()
+ const coveredFiles = coverageMap.files()
  const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(coveredFiles)
 
- coverageMaps.push(await mergeAndTransformCoverage([uncoveredCoverage]))
+ coverageMap.merge(await transformCoverage(uncoveredCoverage))
  }
 
- const coverageMap = mergeCoverageMaps(...coverageMaps)
-
  const context = libReport.createContext({
  dir: this.options.reportsDirectory,
  coverageMap,
@@ -206,6 +244,9 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
  })
  }
  }
+
+ await fs.rm(this.coverageFilesDirectory, { recursive: true })
+ this.coverageFiles = new Map()
  }
 
  async getCoverageMapForUncoveredFiles(coveredFiles: string[]) {
@@ -218,31 +259,31 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
 
  const coverageMap = libCoverage.createCoverageMap({})
 
- for (const filename of uncoveredFiles) {
+ // Note that these cannot be run parallel as synchronous instrumenter.lastFileCoverage
+ // returns the coverage of the last transformed file
+ for (const [index, filename] of uncoveredFiles.entries()) {
+ debug('Uncovered file %s %d/%d', filename, index, uncoveredFiles.length)
+
+ // Make sure file is not served from cache
+ // so that instrumenter loads up requested file coverage
+ if (this.ctx.vitenode.fetchCache.has(filename))
+ this.ctx.vitenode.fetchCache.delete(filename)
+
  await this.ctx.vitenode.transformRequest(filename)
 
  const lastCoverage = this.instrumenter.lastFileCoverage()
  coverageMap.addFileCoverage(lastCoverage)
  }
 
- return coverageMap.data
+ return coverageMap
  }
 }
 
-async function mergeAndTransformCoverage(coverages: CoverageMapData[]) {
- const mergedCoverage = mergeCoverageMaps(...coverages)
- includeImplicitElseBranches(mergedCoverage)
+async function transformCoverage(coverageMap: CoverageMap) {
+ includeImplicitElseBranches(coverageMap)
 
  const sourceMapStore = libSourceMaps.createSourceMapStore()
- return await sourceMapStore.transformCoverage(mergedCoverage)
-}
-
-function mergeCoverageMaps(...coverageMaps: (CoverageMap | CoverageMapData)[]) {
- return coverageMaps.reduce<CoverageMap>((coverage, previousCoverageMap) => {
- const map = libCoverage.createCoverageMap(coverage)
- map.merge(previousCoverageMap)
- return map
- }, libCoverage.createCoverageMap({}))
+ return await sourceMapStore.transformCoverage(coverageMap)
 }
 
 /**
@@ -302,3 +343,19 @@ function hasTerminalReporter(reporters: Options['reporter']) {
  || reporter === 'text-lcov'
  || reporter === 'teamcity')
 }
+
+function toSlices<T>(array: T[], size: number): T[][] {
+ return array.reduce<T[][]>((chunks, item) => {
+ const index = Math.max(0, chunks.length - 1)
+ const lastChunk = chunks[index] || []
+ chunks[index] = lastChunk
+
+ if (lastChunk.length >= size)
+ chunks.push([item])
+
+ else
+ lastChunk.push(item)
+
+ return chunks
+ }, [])
+}

packages/coverage-v8/package.json

@@ -47,6 +47,7 @@
  "dependencies": {
  "@ampproject/remapping": "^2.2.1",
  "@bcoe/v8-coverage": "^0.2.3",
+ "debug": "^4.3.4",
  "istanbul-lib-coverage": "^3.2.2",
  "istanbul-lib-report": "^3.0.1",
  "istanbul-lib-source-maps": "^4.0.1",
@@ -59,6 +60,7 @@
  "v8-to-istanbul": "^9.2.0"
  },
  "devDependencies": {
+ "@types/debug": "^4.1.12",
  "@types/istanbul-lib-coverage": "^2.0.6",
  "@types/istanbul-lib-report": "^3.0.3",
  "@types/istanbul-lib-source-maps": "^4.0.4",