| import { NormalModule } from 'next/dist/compiled/webpack/webpack' |
| import type { Span } from '../../../trace' |
| import type { webpack } from 'next/dist/compiled/webpack/webpack' |
| import path from 'path' |
|
|
| const pluginName = 'ProfilingPlugin' |
| export const spans = new WeakMap<webpack.Compilation | webpack.Compiler, Span>() |
| const moduleSpansByCompilation = new WeakMap< |
| webpack.Compilation, |
| WeakMap<webpack.Module, Span> |
| >() |
| const makeSpanByCompilation = new WeakMap<webpack.Compilation, Span>() |
| const sealSpanByCompilation = new WeakMap<webpack.Compilation, Span>() |
| export const webpackInvalidSpans = new WeakMap<any, Span>() |
|
|
| const TRACE_LABELS_SEAL = [ |
| 'module assets', |
| 'create chunk assets', |
| 'asset render', |
| 'asset emit', |
| 'store asset', |
| ] |
|
|
| function inTraceLabelsSeal(label: string) { |
| return TRACE_LABELS_SEAL.some((l) => label.startsWith(l)) |
| } |
|
|
| export class ProfilingPlugin { |
| compiler: any |
| runWebpackSpan: Span |
| rootDir: string |
|
|
| constructor({ |
| runWebpackSpan, |
| rootDir, |
| }: { |
| runWebpackSpan: Span |
| rootDir: string |
| }) { |
| this.runWebpackSpan = runWebpackSpan |
| this.rootDir = rootDir |
| } |
| apply(compiler: any) { |
| this.traceTopLevelHooks(compiler) |
| this.traceCompilationHooks(compiler) |
| this.compiler = compiler |
| } |
|
|
| traceHookPair( |
| spanName: string | (() => string), |
| startHook: any, |
| stopHook: any, |
| { |
| parentSpan, |
| attrs, |
| onStart, |
| onStop, |
| }: { |
| parentSpan?: (...params: any[]) => Span |
| attrs?: any |
| onStart?: (span: Span, ...params: any[]) => void |
| onStop?: (span: Span, ...params: any[]) => void |
| } = {} |
| ) { |
| let span: Span | undefined |
| startHook.tap( |
| { name: pluginName, stage: -Infinity }, |
| (...params: any[]) => { |
| const name = typeof spanName === 'function' ? spanName() : spanName |
| const attributes = attrs ? attrs(...params) : attrs |
| span = parentSpan |
| ? parentSpan(...params).traceChild(name, attributes) |
| : this.runWebpackSpan.traceChild(name, attributes) |
|
|
| if (onStart) onStart(span, ...params) |
| } |
| ) |
| stopHook.tap({ name: pluginName, stage: Infinity }, (...params: any[]) => { |
| |
| |
| |
| if (!span) { |
| return |
| } |
|
|
| if (onStop) onStop(span, ...params) |
| span.stop() |
| }) |
| } |
|
|
| traceTopLevelHooks(compiler: any) { |
| this.traceHookPair( |
| 'webpack-compilation', |
| compiler.hooks.compilation, |
| compiler.hooks.afterCompile, |
| { |
| parentSpan: () => |
| webpackInvalidSpans.get(compiler) || this.runWebpackSpan, |
| attrs: () => ({ name: compiler.name }), |
| onStart: (span, compilation) => { |
| spans.set(compilation, span) |
| spans.set(compiler, span) |
| moduleSpansByCompilation.set(compilation, new WeakMap()) |
| }, |
| } |
| ) |
|
|
| if (compiler.options.mode === 'development') { |
| this.traceHookPair( |
| () => `webpack-invalidated-${compiler.name}`, |
| compiler.hooks.invalid, |
| compiler.hooks.done, |
| { |
| onStart: (span) => webpackInvalidSpans.set(compiler, span), |
| onStop: () => webpackInvalidSpans.delete(compiler), |
| attrs: (fileName: any) => ({ |
| trigger: fileName |
| ? path.relative(this.rootDir, fileName).replaceAll(path.sep, '/') |
| : 'manual', |
| }), |
| } |
| ) |
| } |
| } |
|
|
| traceCompilationHooks(compiler: any) { |
| this.traceHookPair('emit', compiler.hooks.emit, compiler.hooks.afterEmit, { |
| parentSpan: () => |
| webpackInvalidSpans.get(compiler) || this.runWebpackSpan, |
| }) |
|
|
| this.traceHookPair('make', compiler.hooks.make, compiler.hooks.finishMake, { |
| parentSpan: (compilation) => { |
| const compilationSpan = spans.get(compilation) |
| if (!compilationSpan) { |
| return webpackInvalidSpans.get(compiler) || this.runWebpackSpan |
| } |
|
|
| return compilationSpan |
| }, |
| onStart: (span, compilation) => { |
| makeSpanByCompilation.set(compilation, span) |
| }, |
| onStop: (_span, compilation) => { |
| makeSpanByCompilation.delete(compilation) |
| }, |
| }) |
|
|
| compiler.hooks.compilation.tap( |
| { name: pluginName, stage: -Infinity }, |
| (compilation: any) => { |
| compilation.hooks.buildModule.tap(pluginName, (module: any) => { |
| const moduleType = (() => { |
| const r = module.userRequest |
| if (!r || r.endsWith('!')) { |
| return '' |
| } else { |
| const resource = r.split('!').pop() |
| const match = /^[^?]+\.([^?]+)$/.exec(resource) |
| return match ? match[1] : '' |
| } |
| })() |
|
|
| const issuerModule = compilation?.moduleGraph?.getIssuer(module) |
|
|
| let span: Span |
|
|
| const moduleSpans = moduleSpansByCompilation.get(compilation) |
| const spanName = `build-module${moduleType ? `-${moduleType}` : ''}` |
| const issuerSpan: Span | undefined = |
| issuerModule && moduleSpans?.get(issuerModule) |
| if (issuerSpan) { |
| span = issuerSpan.traceChild(spanName) |
| } else { |
| let parentSpan: Span | undefined |
| for (const incomingConnection of compilation.moduleGraph.getIncomingConnections( |
| module |
| )) { |
| const entrySpan = spans.get(incomingConnection.dependency) |
| if (entrySpan) { |
| parentSpan = entrySpan |
| break |
| } |
| } |
|
|
| if (!parentSpan) { |
| const compilationSpan = spans.get(compilation) |
| if (!compilationSpan) { |
| return |
| } |
|
|
| parentSpan = compilationSpan |
| } |
| span = parentSpan.traceChild(spanName) |
| } |
| span.setAttribute('name', module.userRequest) |
| span.setAttribute('layer', module.layer) |
| moduleSpans!.set(module, span) |
| }) |
|
|
| const moduleHooks = NormalModule.getCompilationHooks(compilation) |
| moduleHooks.readResource.for(undefined).intercept({ |
| register(tapInfo: any) { |
| const fn = tapInfo.fn |
| tapInfo.fn = (loaderContext: any, callback: any) => { |
| fn(loaderContext, (err: any, result: any) => { |
| callback(err, result) |
| }) |
| } |
| return tapInfo |
| }, |
| }) |
|
|
| moduleHooks.loader.tap( |
| pluginName, |
| (loaderContext: any, module: any) => { |
| const moduleSpan = moduleSpansByCompilation |
| .get(compilation) |
| ?.get(module) |
| loaderContext.currentTraceSpan = moduleSpan |
| } |
| ) |
|
|
| compilation.hooks.succeedModule.tap(pluginName, (module: any) => { |
| moduleSpansByCompilation?.get(compilation)?.get(module)?.stop() |
| }) |
| compilation.hooks.failedModule.tap(pluginName, (module: any) => { |
| moduleSpansByCompilation?.get(compilation)?.get(module)?.stop() |
| }) |
|
|
| this.traceHookPair( |
| 'seal', |
| compilation.hooks.seal, |
| compilation.hooks.afterSeal, |
| { |
| parentSpan: () => spans.get(compilation)!, |
| onStart(span) { |
| sealSpanByCompilation.set(compilation, span) |
| }, |
| onStop() { |
| sealSpanByCompilation.delete(compilation) |
| }, |
| } |
| ) |
|
|
| compilation.hooks.addEntry.tap(pluginName, (entry: any) => { |
| const parentSpan = |
| makeSpanByCompilation.get(compilation) || spans.get(compilation) |
| if (!parentSpan) { |
| return |
| } |
| const addEntrySpan = parentSpan.traceChild('add-entry') |
| addEntrySpan.setAttribute('request', entry.request) |
| spans.set(entry, addEntrySpan) |
| }) |
|
|
| compilation.hooks.succeedEntry.tap(pluginName, (entry: any) => { |
| spans.get(entry)?.stop() |
| spans.delete(entry) |
| }) |
| compilation.hooks.failedEntry.tap(pluginName, (entry: any) => { |
| spans.get(entry)?.stop() |
| spans.delete(entry) |
| }) |
|
|
| this.traceHookPair( |
| 'chunk-graph', |
| compilation.hooks.beforeChunks, |
| compilation.hooks.afterChunks, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'optimize', |
| compilation.hooks.optimize, |
| compilation.hooks.reviveModules, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'optimize-modules', |
| compilation.hooks.optimizeModules, |
| compilation.hooks.afterOptimizeModules, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'optimize-chunks', |
| compilation.hooks.optimizeChunks, |
| compilation.hooks.afterOptimizeChunks, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'optimize-tree', |
| compilation.hooks.optimizeTree, |
| compilation.hooks.afterOptimizeTree, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'optimize-chunk-modules', |
| compilation.hooks.optimizeChunkModules, |
| compilation.hooks.afterOptimizeChunkModules, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'module-hash', |
| compilation.hooks.beforeModuleHash, |
| compilation.hooks.afterModuleHash, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'code-generation', |
| compilation.hooks.beforeCodeGeneration, |
| compilation.hooks.afterCodeGeneration, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'hash', |
| compilation.hooks.beforeHash, |
| compilation.hooks.afterHash, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
| this.traceHookPair( |
| 'code-generation-jobs', |
| compilation.hooks.afterHash, |
| compilation.hooks.beforeModuleAssets, |
| { |
| parentSpan: () => |
| sealSpanByCompilation.get(compilation) || spans.get(compilation)!, |
| } |
| ) |
|
|
| const logs = new Map() |
| const originalTime = compilation.logger.time |
| const originalTimeEnd = compilation.logger.timeEnd |
|
|
| compilation.logger.time = (label: string) => { |
| if (!inTraceLabelsSeal(label)) { |
| return originalTime.call(compilation.logger, label) |
| } |
| const span = sealSpanByCompilation.get(compilation) |
| if (span) { |
| logs.set(label, span.traceChild(label.replace(/ /g, '-'))) |
| } |
| return originalTime.call(compilation.logger, label) |
| } |
| compilation.logger.timeEnd = (label: string) => { |
| if (!inTraceLabelsSeal(label)) { |
| return originalTimeEnd.call(compilation.logger, label) |
| } |
|
|
| const span = logs.get(label) |
| if (span) { |
| span.stop() |
| logs.delete(label) |
| } |
| return originalTimeEnd.call(compilation.logger, label) |
| } |
| } |
| ) |
| } |
| } |
|
|
