next/dist/esm/lib/memory/trace.js

The React Framework

import v8 from 'v8';
import { info, warn } from '../../build/output/log';
import { trace } from '../../trace';
import { bold, italic } from '../picocolors';
import { join } from 'path';
import { traceGlobals } from '../../trace/shared';
const HEAP_SNAPSHOT_THRESHOLD_PERCENT = 70;
let alreadyGeneratedHeapSnapshot = false;
const TRACE_MEMORY_USAGE_TIMER_MS = 20000;
let traceMemoryUsageTimer;
const allMemoryUsage = [];
/**
 * Begins a timer that will record memory usage periodically to understand
 * memory usage across the lifetime of the process.
 */ export function startPeriodicMemoryUsageTracing() {
    traceMemoryUsageTimer = setTimeout(()=>{
        traceMemoryUsage('periodic memory snapshot');
        startPeriodicMemoryUsageTracing();
    }, TRACE_MEMORY_USAGE_TIMER_MS);
}
export function stopPeriodicMemoryUsageTracing() {
    if (traceMemoryUsageTimer) {
        clearTimeout(traceMemoryUsageTimer);
    }
}
/**
 * Returns the list of all recorded memory usage snapshots from the process.
 */ export function getAllMemoryUsageSpans() {
    return allMemoryUsage;
}
/**
 * Records a snapshot of memory usage at this moment in time to the .next/trace
 * file.
 */ export function traceMemoryUsage(description, parentSpan) {
    const memoryUsage = process.memoryUsage();
    const v8HeapStatistics = v8.getHeapStatistics();
    const heapUsed = v8HeapStatistics.used_heap_size;
    const heapMax = v8HeapStatistics.heap_size_limit;
    const tracedMemoryUsage = {
        'memory.rss': memoryUsage.rss,
        'memory.heapUsed': heapUsed,
        'memory.heapTotal': memoryUsage.heapTotal,
        'memory.heapMax': heapMax
    };
    allMemoryUsage.push(tracedMemoryUsage);
    const tracedMemoryUsageAsStrings = Object.fromEntries(Object.entries(tracedMemoryUsage).map(([key, value])=>[
            key,
            String(value)
        ]));
    if (parentSpan) {
        parentSpan.traceChild('memory-usage', tracedMemoryUsageAsStrings);
    } else {
        trace('memory-usage', undefined, tracedMemoryUsageAsStrings);
    }
    if (process.env.EXPERIMENTAL_DEBUG_MEMORY_USAGE) {
        const percentageHeapUsed = 100 * heapUsed / heapMax;
        info('');
        info('***************************************');
        info(`Memory usage report at "${description}":`);
        info(` - RSS: ${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`);
        info(` - Heap Used: ${(heapUsed / 1024 / 1024).toFixed(2)} MB`);
        info(` - Heap Total Allocated: ${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`);
        info(` - Heap Max: ${(heapMax / 1024 / 1024).toFixed(2)} MB`);
        info(` - Percentage Heap Used: ${percentageHeapUsed.toFixed(2)}%`);
        info('***************************************');
        info('');
        if (percentageHeapUsed > HEAP_SNAPSHOT_THRESHOLD_PERCENT) {
            const distDir = traceGlobals.get('distDir');
            const heapFilename = join(distDir, `${description.replace(' ', '-')}.heapsnapshot`);
            warn(bold(`Heap usage is close to the limit. ${percentageHeapUsed.toFixed(2)}% of heap has been used.`));
            if (!alreadyGeneratedHeapSnapshot) {
                warn(bold(`Saving heap snapshot to ${heapFilename}.  ${italic('Note: this will take some time.')}`));
                v8.writeHeapSnapshot(heapFilename);
                alreadyGeneratedHeapSnapshot = true;
            } else {
                warn('Skipping heap snapshot generation since heap snapshot has already been generated.');
            }
        }
    }
}

//# sourceMappingURL=trace.js.map