Node.js Performance Hooks Module

// Import the entire module
const { performance, PerformanceObserver } = require('perf_hooks');
// Or using destructuring for specific parts
const { performance } = require('perf_hooks');

const { performance } = require('perf_hooks');
// Get the current high-resolution time
const startTime = performance.now();
// Perform some operation
let sum = 0;
for (let i = 0; i < 1000000; i++) {
 sum += i;
}
// Get the end time
const endTime = performance.now();
// Calculate and display the elapsed time in milliseconds
console.log(`Operation took ${(endTime - startTime).toFixed(2)} milliseconds`);

const { performance } = require('perf_hooks');
// Create marks at specific points in your code
performance.mark('startProcess');
// Simulate some work
let result = 0;
for (let i = 0; i < 1000000; i++) {
 result += Math.sqrt(i);
}
// Create another mark
performance.mark('endProcess');
// Get all the marks
console.log(performance.getEntriesByType('mark'));

const { performance } = require('perf_hooks');
// Create a start mark
performance.mark('start');
// Simulate some work
let result = 0;
for (let i = 0; i < 1000000; i++) {
 result += Math.sqrt(i);
}
// Create an end mark
performance.mark('end');
// Create a measure between the two marks
performance.measure('processTime', 'start', 'end');
// Get the measure
const measure = performance.getEntriesByName('processTime')[0];
console.log(`Process took ${measure.duration.toFixed(2)} milliseconds`);
// Clear marks and measures
performance.clearMarks();
performance.clearMeasures();

const { performance, PerformanceObserver } = require('perf_hooks');
// Create a performance observer
const obs = new PerformanceObserver((items) => {
 // Process all entries
 const entries = items.getEntries();
 entries.forEach((entry) => {
 console.log(`Name: ${entry.name}, Type: ${entry.entryType}, Duration: ${entry.duration.toFixed(2)}ms`);
 });
});
// Subscribe to specific entry types
obs.observe({ entryTypes: ['measure'] });
// First task
performance.mark('task1Start');
// Simulate work
setTimeout(() => {
 performance.mark('task1End');
 performance.measure('Task 1', 'task1Start', 'task1End');
 // Second task
 performance.mark('task2Start');
 setTimeout(() => {
 performance.mark('task2End');
 performance.measure('Task 2', 'task2Start', 'task2End');
 // Clean up
 performance.clearMarks();
 performance.clearMeasures();
 obs.disconnect();
 }, 1000);
}, 1000);

const { performance } = require('perf_hooks');
// Create some performance entries
performance.mark('mark1');
performance.mark('mark2');
let sum = 0;
for (let i = 0; i < 100000; i++) {
 sum += i;
}
performance.mark('mark3');
performance.measure('measure1', 'mark1', 'mark2');
performance.measure('measure2', 'mark2', 'mark3');
// Get all performance entries
console.log('All entries:');
console.log(performance.getEntries());
// Get entries by type
console.log('\nMarks:');
console.log(performance.getEntriesByType('mark'));
// Get entries by name
console.log('\nMeasure 1:');
console.log(performance.getEntriesByName('measure1'));

const { performance, monitorEventLoopDelay } = require('perf_hooks');
// 1. Date.now() - millisecond precision
const dateStart = Date.now();
const dateEnd = Date.now();
console.log(`Date.now() difference: ${dateEnd - dateStart}ms`);
// 2. process.hrtime() - nanosecond precision
const hrStart = process.hrtime();
const hrEnd = process.hrtime(hrStart);
console.log(`process.hrtime() difference: ${hrEnd[0]}s ${hrEnd[1]}ns`);
// 3. performance.now() - microsecond precision
const perfStart = performance.now();
const perfEnd = performance.now();
console.log(`performance.now() difference: ${(perfEnd - perfStart).toFixed(6)}ms`);
// 4. Event loop delay monitoring (available in Node.js 12.0.0+)
const histogram = monitorEventLoopDelay({ resolution: 20 });
histogram.enable();
setTimeout(() => {
 histogram.disable();
 console.log('Event loop delay metrics:');
 console.log(` Min: ${histogram.min}ns`);
 console.log(` Max: ${histogram.max}ns`);
 console.log(` Mean: ${histogram.mean.toFixed(2)}ns`);
 console.log(` Stddev: ${histogram.stddev.toFixed(2)}ns`);
 console.log(` Percentiles: 50=${histogram.percentile(50).toFixed(2)}ns, 99=${histogram.percentile(99).toFixed(2)}ns`);
}, 1000);

const { monitorEventLoopDelay } = require('perf_hooks');
// Create a histogram
const histogram = monitorEventLoopDelay({ resolution: 10 });
// Enable monitoring
histogram.enable();
// Simulate load on the event loop
const operations = [];
for (let i = 0; i < 10; i++) {
 operations.push(new Promise((resolve) => {
 setTimeout(() => {
 // Simulate CPU-intensive work
 let sum = 0;
 for (let j = 0; j < 10000000; j++) {
 sum += j;
 }
 resolve(sum);
 }, 100);
 }));
}
// After all operations complete
Promise.all(operations).then(() => {
 // Disable monitoring
 histogram.disable();
 // Print statistics
 console.log('Event Loop Delay Statistics:');
 console.log(` Min: ${histogram.min}ns`);
 console.log(` Max: ${histogram.max}ns`);
 console.log(` Mean: ${histogram.mean.toFixed(2)}ns`);
 console.log(` Stddev: ${histogram.stddev.toFixed(2)}ns`);
 // Percentiles
 console.log('\nPercentiles:');
 [1, 10, 50, 90, 99, 99.9].forEach((p) => {
 console.log(` p${p}: ${histogram.percentile(p).toFixed(2)}ns`);
 });
});

const { performance, PerformanceObserver } = require('perf_hooks');
const fs = require('fs');
// Create observer for the measures
const obs = new PerformanceObserver((items) => {
 items.getEntries().forEach((entry) => {
 console.log(`${entry.name}: ${entry.duration.toFixed(2)}ms`);
 });
});
obs.observe({ entryTypes: ['measure'] });
// Measure async file read operation
performance.mark('readStart');
fs.readFile(__filename, (err, data) => {
 if (err) throw err;
 performance.mark('readEnd');
 performance.measure('File Read', 'readStart', 'readEnd');
 // Measure async processing time
 performance.mark('processStart');
 // Simulate processing the file data
 setTimeout(() => {
 const lines = data.toString().split('\n').length;
 performance.mark('processEnd');
 performance.measure('File Processing', 'processStart', 'processEnd');
 console.log(`File has ${lines} lines`);
 // Clean up
 performance.clearMarks();
 performance.clearMeasures();
 }, 100);
});

const { performance, PerformanceObserver } = require('perf_hooks');
// Set up the observer
const obs = new PerformanceObserver((items) => {
 items.getEntries().forEach((entry) => {
 console.log(`${entry.name}: ${entry.duration.toFixed(2)}ms`);
 });
});
obs.observe({ entryTypes: ['measure'] });
// Function that returns a promise
function fetchData(delay) {
 return new Promise((resolve) => {
 setTimeout(() => {
 resolve({ data: 'Sample data' });
 }, delay);
 });
}
// Function to process data
function processData(data) {
 return new Promise((resolve) => {
 setTimeout(() => {
 resolve({ processed: data.data.toUpperCase() });
 }, 200);
 });
}
// Measure Promise chain
async function run() {
 performance.mark('fetchStart');
 const data = await fetchData(300);
 performance.mark('fetchEnd');
 performance.mark('processStart');
 const processed = await processData(data);
 performance.mark('processEnd');
 // Create measures
 performance.measure('Fetch Data', 'fetchStart', 'fetchEnd');
 performance.measure('Process Data', 'processStart', 'processEnd');
 performance.measure('Total Operation', 'fetchStart', 'processEnd');
 console.log('Result:', processed);
}
run().finally(() => {
 // Clear after execution
 performance.clearMarks();
 performance.clearMeasures();
});

const { performance } = require('perf_hooks');
// For accurate benchmarking, perform multiple runs
function benchmark(fn, iterations = 1000) {
 // Warm-up run (for JIT optimization)
 fn();
 const times = [];
 for (let i = 0; i < iterations; i++) {
 const start = performance.now();
 fn();
 const end = performance.now();
 times.push(end - start);
 }
 // Calculate statistics
 times.sort((a, b) => a - b);
 const sum = times.reduce((a, b) => a + b, 0);
 const avg = sum / times.length;
 const median = times[Math.floor(times.length / 2)];
 const min = times[0];
 const max = times[times.length - 1];
 return {
 average: avg,
 median: median,
 min: min,
 max: max,
 samples: times.length
 };
}
// Example usage
function testFunction() {
 // Function to benchmark
 let x = 0;
 for (let i = 0; i < 10000; i++) {
 x += i;
 }
 return x;
}
const results = benchmark(testFunction);
console.log('Benchmark Results:');
console.log(` Samples: ${results.samples}`);
console.log(` Average: ${results.average.toFixed(4)}ms`);
console.log(` Median: ${results.median.toFixed(4)}ms`);
console.log(` Min: ${results.min.toFixed(4)}ms`);
console.log(` Max: ${results.max.toFixed(4)}ms`);

const { performance, PerformanceObserver } = require('perf_hooks');
const express = require('express');
const app = express();
const port = 8080;
// Set up performance observer for logging
const obs = new PerformanceObserver((items) => {
 items.getEntries().forEach((entry) => {
 console.log(`[${new Date().toISOString()}] ${entry.name}: ${entry.duration.toFixed(2)}ms`);
 });
});
obs.observe({ entryTypes: ['measure'] });
// Middleware to track request processing time
app.use((req, res, next) => {
 const start = performance.now();
 const requestId = `${req.method} ${req.url} ${Date.now()}`;
 // Mark the start of request processing
 performance.mark(`${requestId}-start`);
 // Override end method to capture when response is sent
 const originalEnd = res.end;
 res.end = function(...args) {
 performance.mark(`${requestId}-end`);
 performance.measure(
 `Request ${req.method} ${req.url}`,
 `${requestId}-start`,
 `${requestId}-end`
 );
 // Clean up marks
 performance.clearMarks(`${requestId}-start`);
 performance.clearMarks(`${requestId}-end`);
 return originalEnd.apply(this, args);
};
next();
});
// API routes
app.get('/', (req, res) => {
 res.send('Hello World!');
});
app.get('/fast', (req, res) => {
 res.send('Fast response!');
});
app.get('/slow', (req, res) => {
 // Simulate a slow API endpoint
 setTimeout(() => {
 res.send('Slow response after delay');
 }, 500);
});
app.get('/process', (req, res) => {
 // Simulate CPU-intensive processing
 const requestId = `process-${Date.now()}`;
 performance.mark(`${requestId}-process-start`);
 let result = 0;
 for (let i = 0; i < 1000000; i++) {
 result += Math.sqrt(i);
 }
 performance.mark(`${requestId}-process-end`);
 performance.measure(
 'CPU Processing',
 `${requestId}-process-start`,
 `${requestId}-process-end`
);
res.send(`Processed result: ${result}`);
});
// Start server
app.listen(port, () => {
 console.log(`Performance monitoring example running at http://localhost:${port}`);
});

const { performance, PerformanceObserver } = require('perf_hooks');
const { performance: perf } = require('process');
class MemoryMonitor {
 constructor() {
 this.leakThreshold = 10 * 1024 * 1024; // 10MB
 this.checkInterval = 10000; // 10 seconds
 this.interval = null;
 this.lastMemoryUsage = process.memoryUsage();
 this.leakDetected = false;
 // Set up performance observer for GC events
 const obs = new PerformanceObserver((items) => {
 items.getEntries().forEach((entry) => {
 if (entry.name === 'gc') {
 this.checkMemoryLeak();
 }
 });
 });
 obs.observe({ entryTypes: ['gc'] });
 }
 start() {
 console.log('Memory monitoring started');
 this.interval = setInterval(() => this.checkMemoryLeak(), this.checkInterval);
 }
 stop() {
 if (this.interval) {
 clearInterval(this.interval);
 console.log('Memory monitoring stopped');
 }
 }
 checkMemoryLeak() {
 const current = process.memoryUsage();
 const heapDiff = current.heapUsed - this.lastMemoryUsage.heapUsed;
 if (heapDiff > this.leakThreshold) {
 this.leakDetected = true;
 console.warn(`⚠️ Possible memory leak detected: Heap increased by ${(heapDiff / 1024 / 1024).toFixed(2)}MB`);
 console.log('Memory snapshot:', {
 rss: this.formatMemory(current.rss),
 heapTotal: this.formatMemory(current.heapTotal),
 heapUsed: this.formatMemory(current.heapUsed),
 external: this.formatMemory(current.external)
 });
 // Take a heap snapshot if needed
 if (process.env.NODE_ENV === 'development') {
 this.takeHeapSnapshot();
 }
 }
 this.lastMemoryUsage = current;
 }
 formatMemory(bytes) {
 return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
 }
 takeHeapSnapshot() {
 const heapdump = require('heapdump');
 const filename = `heapdump-${Date.now()}.heapsnapshot`;
 heapdump.writeSnapshot(filename, (err, filename) => {
 if (err) {
 console.error('Failed to take heap snapshot:', err);
 } else {
 console.log(`Heap snapshot written to ${filename}`);
 }
 });
}
}
// Usage example
const monitor = new MemoryMonitor();
monitor.start();
// Simulate a memory leak
const leaks = [];
setInterval(() => {
 for (let i = 0; i < 1000; i++) {
 leaks.push(new Array(1000).fill('*'.repeat(100)));
 }
}, 1000);
// Stop monitoring after 1 minute
setTimeout(() => {
 monitor.stop();
 console.log('Memory monitoring completed');
}, 60000);

const { performance, PerformanceObserver, PerformanceEntry } = require('perf_hooks');
class PerformanceTracker {
 constructor() {
 this.metrics = new Map();
 this.observers = new Map();
 // Set up default observer for custom metrics
 this.setupDefaultObserver();
 }
 setupDefaultObserver() {
 const obs = new PerformanceObserver((items) => {
 items.getEntries().forEach((entry) => {
 if (!this.metrics.has(entry.name)) {
 this.metrics.set(entry.name, []);
 }
 this.metrics.get(entry.name).push(entry);
 // Log detailed metrics
 this.logMetric(entry);
 });
 });
 obs.observe({ entryTypes: ['measure'] });
 this.observers.set('default', obs);
 }
 startTimer(name) {
 performance.mark(`${name}-start`);
 }
 endTimer(name, attributes = {}) {
 performance.mark(`${name}-end`);
 performance.measure(name, {
 start: `${name}-start`,
 end: `${name}-end`,
 ...attributes
 });
 // Clean up marks
 performance.clearMarks(`${name}-start`);
 performance.clearMarks(`${name}-end`);
 }
 logMetric(entry) {
 const { name, duration, startTime, entryType, detail } = entry;
 console.log(`📊 [${new Date().toISOString()}] ${name}: ${duration.toFixed(2)}ms`);
 if (detail) {
 console.log(' Details:', JSON.stringify(detail, null, 2));
 }
 }
 getMetrics(name) {
 return this.metrics.get(name) || [];
 }
 getStats(name) {
 const metrics = this.getMetrics(name);
 if (metrics.length === 0) return null;
 const durations = metrics.map(m => m.duration);
 const sum = durations.reduce((a, b) => a + b, 0);
 const avg = sum / durations.length;
 return {
 count: durations.length,
 total: sum,
 average: avg,
 min: Math.min(...durations),
 max: Math.max(...durations),
 p90: this.percentile(durations, 90),
 p95: this.percentile(durations, 95),
 p99: this.percentile(durations, 99)
 };
 }
 percentile(arr, p) {
 if (!arr.length) return 0;
 const sorted = [...arr].sort((a, b) => a - b);
 const pos = (sorted.length - 1) * p / 100;
 const base = Math.floor(pos);
 const rest = pos - base;
 if (sorted[base + 1] !== undefined) {
 return sorted[base] + rest * (sorted[base + 1] - sorted[base]);
 } else {
 return sorted[base];
 }
}
}
// Usage example
const tracker = new PerformanceTracker();
// Track a simple operation
tracker.startTimer('database-query');
setTimeout(() => {
 tracker.endTimer('database-query', {
 detail: {
 query: 'SELECT * FROM users',
 params: { limit: 100 },
 success: true
 }
 });
 // Get statistics
 console.log('Stats:', tracker.getStats('database-query'));
}, 200);

const { performance, PerformanceObserver } = require('perf_hooks');
const crypto = require('crypto');
class Tracer {
 constructor(serviceName) {
 this.serviceName = serviceName;
 this.spans = new Map();
 this.exportInterval = setInterval(() => this.exportSpans(), 10000);
 }
 startSpan(name, parentSpanId = null) {
 const spanId = crypto.randomBytes(8).toString('hex');
 const traceId = parentSpanId ? this.spans.get(parentSpanId)?.traceId : crypto.randomBytes(16).toString('hex');
 const span = {
 id: spanId,
 traceId,
 parentSpanId,
 name,
 service: this.serviceName,
 startTime: performance.now(),
 endTime: null,
 duration: null,
 tags: {},
 logs: []
 };
 this.spans.set(spanId, span);
 return spanId;
 }
 endSpan(spanId, status = 'OK') {
 const span = this.spans.get(spanId);
 if (!span) return;
 span.endTime = performance.now();
 span.duration = span.endTime - span.startTime;
 span.status = status;
 // Auto-export if this is a root span
 if (!span.parentSpanId) {
 this.exportSpan(span);
 }
 return span;
 }
 addTag(spanId, key, value) {
 const span = this.spans.get(spanId);
 if (span) {
 span.tags[key] = value;
 }
 }
 log(spanId, message, data = {}) {
 const span = this.spans.get(spanId);
 if (span) {
 span.logs.push({
 timestamp: new Date().toISOString(),
 message,
 data: JSON.stringify(data)
 });
 }
 }
 exportSpan(span) {
 // In a real application, this would send the span to a tracing backend
 // like Jaeger, Zipkin, or AWS X-Ray
 console.log('Exporting span:', JSON.stringify(span, null, 2));
 // Clean up
 this.spans.delete(span.id);
 }
 exportSpans() {
 // Export any remaining spans that have ended
 for (const [id, span] of this.spans.entries()) {
 if (span.endTime) {
 this.exportSpan(span);
 }
 }
 }
 injectContext(spanId, headers = {}) {
 const span = this.spans.get(spanId);
 if (!span) return headers;
 return {
 ...headers,
 'x-trace-id': span.traceId,
 'x-span-id': span.id,
 'x-service': this.serviceName
 };
 }
 extractContext(headers) {
 const traceId = headers['x-trace-id'] || crypto.randomBytes(16).toString('hex');
 const parentSpanId = headers['x-span-id'] || null;
 return { traceId, parentSpanId };
 }
}
// Usage example
const tracer = new Tracer('user-service');
// Simulate a request
function handleRequest(req) {
 const { traceId, parentSpanId } = tracer.extractContext(req.headers);
 const spanId = tracer.startSpan('handle-request', parentSpanId);
 tracer.addTag(spanId, 'http.method', req.method);
 tracer.addTag(spanId, 'http.url', req.url);
 // Simulate work
 setTimeout(() => {
 // Call another service
 const childSpanId = tracer.startSpan('call-auth-service', spanId);
 setTimeout(() => {
 tracer.endSpan(childSpanId, 'OK');
 // End the request
 tracer.endSpan(spanId, 'OK');
 }, 100);
 }, 50);
 return { status: 'processing', traceId };
}
// Simulate an incoming request
const request = {
 method: 'GET',
 url: '/api/users/123',
 headers: {}
};
const response = handleRequest(request);
console.log('Response:', response);
// Wait for spans to complete
setTimeout(() => {}, 200);

const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const { performance, PerformanceObserver } = require('perf_hooks');
if (isMainThread) {
 // Main thread
 function runWorker(data) {
 return new Promise((resolve, reject) => {
 const start = performance.now();
 const worker = new Worker(__filename, {
 workerData: data
 });
 worker.on('message', (result) => {
 const duration = performance.now() - start;
 resolve({
 ...result,
 duration: `${duration.toFixed(2)}ms`
 });
 });
 worker.on('error', reject);
 worker.on('exit', (code) => {
 if (code !== 0) {
 reject(new Error(`Worker stopped with exit code ${code}`));
 }
 });
 });
 }
 // Example usage
 async function main() {
 try {
 const result = await runWorker({
 task: 'processData',
 data: Array(1000000).fill().map((_, i) => i)
 });
 console.log('Worker result:', result);
 } catch (err) {
 console.error('Worker error:', err);
 }
}
main();
} else {
// Worker thread
function processData(data) {
 // Simulate CPU-intensive work
 return data.map(x => Math.sqrt(x) * Math.PI);
}
try {
 const result = processData(workerData.data);
 parentPort.postMessage({
 task: workerData.task,
 resultLength: result.length,
 sample: result.slice(0, 5)
 });
} catch (err) {
parentPort.postMessage({ error: err.message });
}
}

const { Transform } = require('stream');
const { performance } = require('perf_hooks');
class ProcessingPipeline {
 constructor() {
 this.startTime = performance.now();
 this.processedItems = 0;
 }
 createTransformStream(transformFn) {
 return new Transform({
 objectMode: true,
 transform(chunk, encoding, callback) {
 try {
 const result = transformFn(chunk);
 this.processedItems++;
 callback(null, result);
 } catch (err) {
 callback(err);
 }
 }
 });
}
async processData(data, batchSize = 1000) {
 const batches = [];
 // Process in batches
 for (let i = 0; i < data.length; i += batchSize) {
 const batch = data.slice(i, i + batchSize);
 const processedBatch = await this.processBatch(batch);
 batches.push(processedBatch);
 // Log progress
 const progress = ((i + batchSize) / data.length * 100).toFixed(1);
 console.log(`Processed ${Math.min(i + batchSize, data.length)}/${data.length} (${progress}%)`);
 }
 return batches.flat();
}
processBatch(batch) {
 return new Promise((resolve) => {
 const results = [];
 // Create a transform stream for processing
 const processor = this.createTransformStream((item) => {
 // Simulate processing
 return {
 ...item,
 processed: true,
 timestamp: new Date().toISOString()
 };
 });
 // Collect results
 processor.on('data', (data) => {
 results.push(data);
 });
 processor.on('end', () => {
 resolve(results);
 });
 // Process each item in the batch
 for (const item of batch) {
 processor.write(item);
 }
 processor.end();
 });
}
getStats() {
 const endTime = performance.now();
 const duration = endTime - this.startTime;
 return {
 processedItems: this.processedItems,
 duration: `${duration.toFixed(2)}ms`,
 itemsPerSecond: (this.processedItems / (duration / 1000)).toFixed(2)
 };
}
}
// Example usage
async function main() {
 // Generate test data
 const testData = Array(10000).fill().map((_, i) => ({
 id: i,
 value: Math.random() * 1000
 }));
 console.log('Starting data processing...');
 const pipeline = new ProcessingPipeline();
 // Process data in batches
 const result = await pipeline.processData(testData, 1000);
 // Print statistics
 console.log('Processing complete!');
 console.log('Statistics:', pipeline.getStats());
 console.log('Sample result:', result[0]);
}
main().catch(console.error);