perf(coverage): reduce RPC data and unnecessary serializations (#10781)

Author: AriPerkkio

packages/coverage-istanbul/package.json

@@ -28,6 +28,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
     "./*": "./*"
   },
   "main": "./dist/index.js",

packages/coverage-istanbul/rollup.config.js

@@ -12,6 +12,7 @@ const pkg = require('./package.json')
 
 const entries = {
   index: 'src/index.ts',
+  browser: 'src/browser.ts',
   provider: 'src/provider.ts',
 }
 

packages/coverage-istanbul/src/base.ts

@@ -0,0 +1,48 @@
+import type { CoverageMapData } from 'istanbul-lib-coverage'
+import type { IstanbulCoverageProvider } from './provider'
+import { COVERAGE_STORE_KEY } from './constants'
+
+export const BaseCoverageProviderModule = {
+  takeCoverage(): CoverageMapData | undefined {
+    // @ts-expect-error -- untyped global
+    return globalThis[COVERAGE_STORE_KEY]
+  },
+
+  // Reset coverage map to prevent duplicate results if this is called twice in row
+  startCoverage(): void {
+    // @ts-expect-error -- untyped global
+    const coverageMap = globalThis[COVERAGE_STORE_KEY] as CoverageMapData
+
+    // When isolated, there are no previous results
+    if (!coverageMap) {
+      return
+    }
+
+    for (const filename in coverageMap) {
+      const branches = coverageMap[filename].b
+
+      for (const key in branches) {
+        branches[key] = branches[key].map(() => 0)
+      }
+
+      for (const metric of ['f', 's'] as const) {
+        const entry = coverageMap[filename][metric]
+
+        for (const key in entry) {
+          entry[key] = 0
+        }
+      }
+    }
+  },
+
+  async getProvider(): Promise<IstanbulCoverageProvider> {
+    // to not bundle the provider
+    const providerPath = './provider.js'
+    const { IstanbulCoverageProvider } = (await import(
+      /* @vite-ignore */
+      providerPath,
+    )) as typeof import('./provider')
+
+    return new IstanbulCoverageProvider()
+  },
+}

packages/coverage-istanbul/src/browser.ts

@@ -0,0 +1,28 @@
+import type { CoverageProviderModule } from 'vitest/node'
+import { BaseCoverageProviderModule } from './base'
+
+function triggerCommand(command: string, args: any[] = []): Promise<any> {
+  return (globalThis as any).__vitest_browser_runner__?.commands?.triggerCommand?.(command, args)
+}
+
+const mod: CoverageProviderModule = {
+  takeCoverage() {
+    const coverage = BaseCoverageProviderModule.takeCoverage()
+
+    if (!coverage) {
+      return
+    }
+
+    return triggerCommand('__vitest_writeCoverageFile', [coverage])
+  },
+
+  startCoverage() {
+    BaseCoverageProviderModule.startCoverage()
+  },
+
+  getProvider() {
+    return BaseCoverageProviderModule.getProvider()
+  },
+}
+
+export default mod

packages/coverage-istanbul/src/commands.ts

@@ -0,0 +1,38 @@
+import type { BrowserCommand } from 'vitest/node'
+import type { IstanbulCoverageProvider } from './provider'
+import { randomUUID } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import { resolve } from 'pathe'
+
+export const commands: Record<string, BrowserCommand<any[]>> = {
+  writeCoverageFile(context, coverage: unknown) {
+    const provider = context.project.vitest.coverageProvider as IstanbulCoverageProvider
+
+    return writeCoverageFile(provider.coverageFilesDirectory, coverage)
+  },
+}
+
+export async function writeCoverageFile(coverageFilesDirectory: string, coverage: unknown): Promise<string> {
+  // Write results on file system directly and transfer only the filename over RPC
+  const filename = resolve(
+    coverageFilesDirectory,
+    `coverage-${randomUUID()}.json`,
+  )
+
+  try {
+    await writeFile(filename, JSON.stringify(coverage), 'utf-8')
+  }
+  catch (error) {
+    if (!existsSync(coverageFilesDirectory)) {
+      throw new Error(
+        `Something removed the coverage directory "${coverageFilesDirectory}" Vitest created earlier. Make sure you are not running multiple Vitests with the same "coverage.reportsDirectory" at the same time.`,
+        { cause: error },
+      )
+    }
+
+    throw error
+  }
+
+  return filename
+}

packages/coverage-istanbul/src/index.ts

@@ -1,50 +1,29 @@
-import type { CoverageMapData } from 'istanbul-lib-coverage'
 import type { CoverageProviderModule } from 'vitest/node'
-import type { IstanbulCoverageProvider } from './provider'
-import { COVERAGE_STORE_KEY } from './constants'
+import assert from 'node:assert'
+import { BaseCoverageProviderModule } from './base'
+import { writeCoverageFile } from './commands'
 
 const mod: CoverageProviderModule = {
-  takeCoverage() {
-    // @ts-expect-error -- untyped global
-    return globalThis[COVERAGE_STORE_KEY]
-  },
-
-  // Reset coverage map to prevent duplicate results if this is called twice in row
-  startCoverage() {
-    // @ts-expect-error -- untyped global
-    const coverageMap = globalThis[COVERAGE_STORE_KEY] as CoverageMapData
+  takeCoverage(options) {
+    const coverage = BaseCoverageProviderModule.takeCoverage()
 
-    // When isolated, there are no previous results
-    if (!coverageMap) {
+    if (!coverage) {
       return
     }
 
-    for (const filename in coverageMap) {
-      const branches = coverageMap[filename].b
-
-      for (const key in branches) {
-        branches[key] = branches[key].map(() => 0)
-      }
-
-      for (const metric of ['f', 's'] as const) {
-        const entry = coverageMap[filename][metric]
+    const coverageFilesDirectory = options?.coverageFilesDirectory
+    assert(coverageFilesDirectory, 'coverageFilesDirectory is required')
 
-        for (const key in entry) {
-          entry[key] = 0
-        }
-      }
-    }
+    return writeCoverageFile(coverageFilesDirectory, coverage)
   },
 
-  async getProvider(): Promise<IstanbulCoverageProvider> {
-    // to not bundle the provider
-    const providerPath = './provider.js'
-    const { IstanbulCoverageProvider } = (await import(
-      /* @vite-ignore */
-      providerPath,
-    )) as typeof import('./provider')
+  startCoverage() {
+    BaseCoverageProviderModule.startCoverage()
+  },
 
-    return new IstanbulCoverageProvider()
+  getProvider() {
+    return BaseCoverageProviderModule.getProvider()
   },
 }
+
 export default mod

packages/coverage-istanbul/src/provider.ts

@@ -17,6 +17,7 @@ import { createDebug } from 'obug'
 import c from 'tinyrainbow'
 import { BaseCoverageProvider, isCSSRequest } from 'vitest/node'
 import { version } from '../package.json' with { type: 'json' }
+import { commands } from './commands'
 import { COVERAGE_STORE_KEY } from './constants'
 
 const debug = createDebug('vitest:coverage')
@@ -31,6 +32,14 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
   initialize(ctx: Vitest): void {
     this._initialize(ctx)
 
+    for (const project of ctx.projects) {
+      if (project.isBrowserEnabled() && project.browser) {
+        for (const [name, command] of Object.entries(commands)) {
+          project.browser.registerCommand(`__vitest_${name}` as any, command)
+        }
+      }
+    }
+
     if (this.options.instrumenter) {
       this.instrumenter = this.options.instrumenter({
         coverageVariable: COVERAGE_STORE_KEY,

packages/coverage-v8/src/browser.ts

@@ -1,12 +1,9 @@
-import type { Profiler } from 'node:inspector'
 import type { CoverageProviderModule } from 'vitest/node'
 import type { V8CoverageProvider } from './provider'
 import { loadProvider } from './load-provider'
 
 let enabled = false
 
-type ScriptCoverage = Profiler.TakePreciseCoverageReturnType
-
 function triggerCommand(command: string, args: any[] = []): Promise<any> {
   return (globalThis as any).__vitest_browser_runner__.commands.triggerCommand(command, args)
 }
@@ -22,21 +19,8 @@ const mod: CoverageProviderModule = {
     await triggerCommand('__vitest_startV8Coverage')
   },
 
-  async takeCoverage(): Promise<{ result: any[] }> {
-    const coverage: ScriptCoverage = await triggerCommand('__vitest_takeV8Coverage')
-    const result: typeof coverage.result = []
-
-    // Reduce amount of data sent over rpc by doing some early result filtering
-    for (const entry of coverage.result) {
-      if (filterResult(entry)) {
-        result.push({
-          ...entry,
-          url: decodeURIComponent(entry.url.replace(window.location.origin, '')),
-        })
-      }
-    }
-
-    return { result }
+  async takeCoverage(): Promise<unknown> {
+    return triggerCommand('__vitest_takeV8Coverage', [window.location.href])
   },
 
   stopCoverage() {
@@ -48,35 +32,3 @@ const mod: CoverageProviderModule = {
   },
 }
 export default mod
-
-function filterResult(coverage: ScriptCoverage['result'][number]): boolean {
-  if (!coverage.url.startsWith(window.location.origin)) {
-    return false
-  }
-
-  if (coverage.url.includes('/node_modules/')) {
-    return false
-  }
-
-  if (coverage.url.includes('__vitest_browser__')) {
-    return false
-  }
-
-  if (coverage.url.includes('__vitest__/assets')) {
-    return false
-  }
-
-  if (coverage.url === window.location.href) {
-    return false
-  }
-
-  if (coverage.url.includes('/@id/@vitest/')) {
-    return false
-  }
-
-  if (coverage.url.includes('/@vite/client')) {
-    return false
-  }
-
-  return true
-}

packages/coverage-v8/src/commands.ts

@@ -1,7 +1,12 @@
 import type { CDPSession } from '@vitest/browser-playwright'
 import type { BrowserCommand, BrowserCommandContext } from 'vitest/node'
+import type { V8CoverageProvider } from './provider'
+import { randomUUID } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import { resolve } from 'pathe'
 
-export const commands: Record<string, BrowserCommand> = {
+export const commands: Record<string, BrowserCommand<any[]>> = {
   startV8Coverage,
   takeV8Coverage,
 }
@@ -15,7 +20,77 @@ async function startV8Coverage(context: BrowserCommandContext): Promise<void> {
   })
 }
 
-async function takeV8Coverage(context: BrowserCommandContext): Promise<any> {
+async function takeV8Coverage(context: BrowserCommandContext, pageUrl: string): Promise<string> {
   const session: CDPSession = await context.__ensureCDPHandler()
-  return session.send('Profiler.takePreciseCoverage')
+  const coverage = await session.send('Profiler.takePreciseCoverage')
+
+  const origin = new URL(pageUrl).origin
+  const result: typeof coverage.result = []
+
+  for (const entry of coverage.result) {
+    if (filterResult(entry.url, origin, pageUrl)) {
+      entry.url = decodeURIComponent(entry.url.replace(origin, ''))
+      result.push(entry)
+    }
+  }
+
+  const provider = context.project.vitest.coverageProvider as V8CoverageProvider
+
+  return await writeCoverageFile(provider.coverageFilesDirectory, { result })
+}
+
+export async function writeCoverageFile(coverageFilesDirectory: string, coverage: unknown): Promise<string> {
+  // Write results on file system directly and transfer only the filename over RPC
+  const filename = resolve(
+    coverageFilesDirectory,
+    `coverage-${randomUUID()}.json`,
+  )
+
+  try {
+    await writeFile(filename, JSON.stringify(coverage), 'utf-8')
+  }
+  catch (error) {
+    if (!existsSync(coverageFilesDirectory)) {
+      throw new Error(
+        `Something removed the coverage directory "${coverageFilesDirectory}" Vitest created earlier. Make sure you are not running multiple Vitests with the same "coverage.reportsDirectory" at the same time.`,
+        { cause: error },
+      )
+    }
+
+    throw error
+  }
+
+  return filename
+}
+
+function filterResult(url: string, origin: string, pageUrl: string): boolean {
+  if (!url.startsWith(origin)) {
+    return false
+  }
+
+  if (url.includes('/node_modules/')) {
+    return false
+  }
+
+  if (url.includes('__vitest_browser__')) {
+    return false
+  }
+
+  if (url.includes('__vitest__/assets')) {
+    return false
+  }
+
+  if (url === pageUrl) {
+    return false
+  }
+
+  if (url.includes('/@id/@vitest/')) {
+    return false
+  }
+
+  if (url.includes('/@vite/client')) {
+    return false
+  }
+
+  return true
 }