Performance Profiling

Performance Profiling Fundamentals

Performance profiling is the process of analyzing and measuring the performance characteristics of an application to identify bottlenecks, optimize resource usage, and improve overall efficiency. Understanding profiling fundamentals is crucial for building high-performance applications.

// Node.js CPU profiling
const { performance } = require('perf_hooks');
const v8 = require('v8-profiler-next');

// Start CPU profiling
function startCPUProfiling(name = 'cpu-profile') {
    console.log('Starting CPU profiling...');
    v8.setGenerateType(1); // Generate type information
    v8.startProfiling(name, true);
    return name;
}

// Stop CPU profiling and save
function stopCPUProfiling(name) {
    console.log('Stopping CPU profiling...');
    const profile = v8.stopProfiling(name);
    profile.export((error, result) => {
        if (error) {
            console.error('Error exporting profile:', error);
            return;
        }

        require('fs').writeFileSync(`${name}.cpuprofile`, result);
        console.log(`CPU profile saved to ${name}.cpuprofile`);
        profile.delete();
    });
}

// Usage example
const profileName = startCPUProfiling('my-app-profile');

// Simulate some work
function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Run CPU-intensive task
console.time('fibonacci-calculation');
const result = fibonacci(40);
console.timeEnd('fibonacci-calculation');

stopCPUProfiling(profileName);

// Chrome DevTools CPU profiling
// 1. Open Chrome DevTools (F12)
// 2. Go to Performance tab
// 3. Click record button
// 4. Perform actions to profile
// 5. Stop recording
// 6. Analyze flame graph and timelines

// Node.js memory profiling
const memwatch = require('memwatch-next');

// Monitor memory usage
function monitorMemory() {
    const usage = process.memoryUsage();

    console.log('Memory Usage:');
    console.log(`RSS: ${Math.round(usage.rss / 1024 / 1024)} MB`);
    console.log(`Heap Used: ${Math.round(usage.heapUsed / 1024 / 1024)} MB`);
    console.log(`Heap Total: ${Math.round(usage.heapTotal / 1024 / 1024)} MB`);
    console.log(`External: ${Math.round(usage.external / 1024 / 1024)} MB`);
}

// Track memory leaks
let hd = new memwatch.HeapDiff();

function startMemoryTracking() {
    hd = new memwatch.HeapDiff();
    console.log('Started memory tracking');
}

function endMemoryTracking() {
    const diff = hd.end();
    console.log('Memory diff:', JSON.stringify(diff, null, 2));

    // Analyze changes
    if (diff.change.size_bytes > 0) {
        console.log(`⚠️  Memory leak detected: +${diff.change.size_bytes} bytes`);
    } else {
        console.log(`✅ Memory usage decreased by ${Math.abs(diff.change.size_bytes)} bytes`);
    }
}

// Memory leak detection
memwatch.on('leak', (info) => {
    console.error('Memory leak detected:', info);
});

memwatch.on('stats', (stats) => {
    console.log('GC stats:', stats);
});

// Usage example
startMemoryTracking();

// Create objects that might leak
const objects = [];
for (let i = 0; i < 10000; i++) {
    objects.push({
        data: 'x'.repeat(1000),
        timestamp: Date.now()
    });
}

// Force garbage collection (if available)
if (global.gc) {
    global.gc();
} else {
    console.log('Run with --expose-gc to enable manual GC');
}

monitorMemory();
endMemoryTracking();

// Chrome DevTools Memory profiling
// 1. Open Chrome DevTools
// 2. Go to Memory tab
// 3. Select Heap snapshot
// 4. Take initial snapshot
// 5. Perform actions
// 6. Take another snapshot
// 7. Compare snapshots to find leaks

// Network request profiling
async function profileNetworkRequest(url, options = {}) {
    const startTime = performance.now();

    try {
        const response = await fetch(url, options);
        const endTime = performance.now();

        const metrics = {
            url,
            method: options.method || 'GET',
            status: response.status,
            responseTime: endTime - startTime,
            contentLength: response.headers.get('content-length'),
            contentType: response.headers.get('content-type'),
            cacheHit: response.headers.get('x-cache') === 'HIT'
        };

        console.log('Network Request Profile:', metrics);

        // Read response to measure total time
        const responseStart = performance.now();
        await response.text();
        const responseEnd = performance.now();

        metrics.totalTime = responseEnd - startTime;
        metrics.responseReadTime = responseEnd - responseStart;

        return metrics;

    } catch (error) {
        const endTime = performance.now();
        console.error('Network request failed:', {
            url,
            error: error.message,
            responseTime: endTime - startTime
        });
        throw error;
    }
}

// API endpoint profiling
async function profileAPIEndpoint(baseUrl, endpoints) {
    const results = [];

    for (const endpoint of endpoints) {
        console.log(`\nProfiling ${endpoint}...`);

        try {
            const metrics = await profileNetworkRequest(`${baseUrl}${endpoint}`);
            results.push({ endpoint, ...metrics });
        } catch (error) {
            results.push({
                endpoint,
                error: error.message,
                status: 'FAILED'
            });
        }

        // Small delay between requests
        await new Promise(resolve => setTimeout(resolve, 100));
    }

    // Analyze results
    const successful = results.filter(r => r.status !== 'FAILED');
    const avgResponseTime = successful.reduce((sum, r) => sum + r.responseTime, 0) / successful.length;

    console.log('\n=== API Profiling Summary ===');
    console.log(`Total endpoints: ${endpoints.length}`);
    console.log(`Successful requests: ${successful.length}`);
    console.log(`Failed requests: ${results.length - successful.length}`);
    console.log(`Average response time: ${avgResponseTime.toFixed(2)}ms`);

    return results;
}

// Usage
const endpoints = [
    '/api/users',
    '/api/products',
    '/api/orders',
    '/api/analytics'
];

profileAPIEndpoint('https://api.example.com', endpoints);

// Browser Network profiling
// 1. Open Chrome DevTools (F12)
// 2. Go to Network tab
// 3. Enable Preserve log
// 4. Perform actions
// 5. Analyze waterfall chart
// 6. Check response times, sizes, and status codes

// File I/O profiling
const fs = require('fs').promises;
const { performance } = require('perf_hooks');

async function profileFileOperation(operation, ...args) {
    const startTime = performance.now();

    try {
        const result = await operation(...args);
        const endTime = performance.now();

        return {
            operation: operation.name,
            args: args.map(arg => typeof arg === 'string' && arg.length > 50 ?
                arg.substring(0, 50) + '...' : arg),
            duration: endTime - startTime,
            success: true,
            resultSize: result ? result.length : 0
        };
    } catch (error) {
        const endTime = performance.now();

        return {
            operation: operation.name,
            args: args,
            duration: endTime - startTime,
            success: false,
            error: error.message
        };
    }
}

// Profile various file operations
async function profileFileOperations() {
    const results = [];

    // Create test file
    const testFile = './test-file.txt';
    const testData = 'x'.repeat(1024 * 1024); // 1MB of data

    // Write operation
    console.log('Profiling file write...');
    let result = await profileFileOperation(fs.writeFile, testFile, testData);
    results.push(result);

    // Read operation
    console.log('Profiling file read...');
    result = await profileFileOperation(fs.readFile, testFile, 'utf8');
    results.push(result);

    // Stat operation
    console.log('Profiling file stat...');
    result = await profileFileOperation(fs.stat, testFile);
    results.push(result);

    // Delete operation
    console.log('Profiling file delete...');
    result = await profileFileOperation(fs.unlink, testFile);
    results.push(result);

    // Analyze results
    console.log('\n=== File I/O Profiling Results ===');
    results.forEach(result => {
        console.log(`${result.operation}: ${result.duration.toFixed(2)}ms ${result.success ? '✅' : '❌'}`);
    });

    const avgDuration = results.reduce((sum, r) => sum + r.duration, 0) / results.length;
    console.log(`Average operation time: ${avgDuration.toFixed(2)}ms`);

    return results;
}

// Database query profiling
async function profileDatabaseQuery(query, params = []) {
    const startTime = performance.now();

    try {
        const result = await db.query(query, params);
        const endTime = performance.now();

        return {
            query: query.substring(0, 100) + (query.length > 100 ? '...' : ''),
            params: params,
            duration: endTime - startTime,
            rowCount: result.rowCount || result.length,
            success: true
        };
    } catch (error) {
        const endTime = performance.now();

        return {
            query: query.substring(0, 100),
            params: params,
            duration: endTime - startTime,
            success: false,
            error: error.message
        };
    }
}

// Usage
profileFileOperations();

// Example database profiling
async function profileDatabaseOperations() {
    const operations = [
        profileDatabaseQuery('SELECT * FROM users LIMIT 100'),
        profileDatabaseQuery('SELECT COUNT(*) FROM orders'),
        profileDatabaseQuery('INSERT INTO logs (message, level) VALUES (?, ?)', ['Test log', 'info'])
    ];

    const results = await Promise.all(operations);

    console.log('\n=== Database Profiling Results ===');
    results.forEach(result => {
        console.log(`${result.query}: ${result.duration.toFixed(2)}ms ${result.success ? '✅' : '❌'}`);
    });
}

Profiling Tools & Techniques

// Chrome DevTools Performance API
// Measure function execution time
function measureExecutionTime(fn, ...args) {
    const startMark = `start-${fn.name}`;
    const endMark = `end-${fn.name}`;

    performance.mark(startMark);
    const result = fn(...args);
    performance.mark(endMark);

    performance.measure(`${fn.name}-execution`, startMark, endMark);

    const measure = performance.getEntriesByName(`${fn.name}-execution`)[0];
    console.log(`${fn.name} took ${measure.duration.toFixed(2)}ms`);

    return result;
}

// User Timing API for custom measurements
function startTiming(name) {
    performance.mark(`${name}-start`);
}

function endTiming(name) {
    performance.mark(`${name}-end`);
    performance.measure(name, `${name}-start`, `${name}-end`);

    const measure = performance.getEntriesByName(name)[0];
    console.log(`${name}: ${measure.duration.toFixed(2)}ms`);
}

// Usage
startTiming('data-processing');

// Simulate data processing
const data = Array.from({ length: 10000 }, (_, i) => i * 2);
const processed = data.map(x => x * x).filter(x => x > 1000);

endTiming('data-processing');

// Performance Observer for continuous monitoring
const observer = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
        if (entry.entryType === 'measure') {
            console.log(`${entry.name}: ${entry.duration.toFixed(2)}ms`);
        }
    }
});

observer.observe({ entryTypes: ['measure'] });

import cProfile
import pstats
from functools import wraps
import tracemalloc
import time

# Function decorator for profiling
def profile_function(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        profiler = cProfile.Profile()
        profiler.enable()

        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()

        profiler.disable()

        execution_time = end_time - start_time
        print(f"{func.__name__} executed in {execution_time:.4f} seconds")

        # Print profiling stats
        stats = pstats.Stats(profiler)
        stats.sort_stats('cumulative').print_stats(10)

        return result
    return wrapper

# Memory profiling decorator
def profile_memory(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        tracemalloc.start()

        result = func(*args, **kwargs)

        current, peak = tracemalloc.get_traced_memory()
        print(f"Current memory usage: {current / 1024 / 1024:.2f} MB")
        print(f"Peak memory usage: {peak / 1024 / 1024:.2f} MB")

        tracemalloc.stop()
        return result
    return wrapper

# Usage example
@profile_function
@profile_memory
def process_data():
    data = []
    for i in range(100000):
        data.append({
            'id': i,
            'value': i * 2,
            'description': f'Item number {i}' * 10  # Create some memory usage
        })

    # Simulate processing
    processed = [item for item in data if item['id'] % 2 == 0]
    return processed

# Run profiled function
result = process_data();

# Line-by-line profiling with line_profiler
# Install: pip install line_profiler
# Usage: kernprof -l script.py
# Then: python -m line_profiler script.py.lprof

@profile  # This decorator is from line_profiler
def slow_function():
    total = 0
    for i in range(1000000):
        total += i ** 2
    return total

# Memory profiling with memory_profiler
# Install: pip install memory_profiler
# Usage: mprof run script.py
# Then: mprof plot

from memory_profiler import profile

@profile
def memory_intensive_function():
    big_list = []
    for i in range(100000):
        big_list.append('x' * 1000)  # 1KB per item
    return big_list

// New Relic Node.js agent setup
const newrelic = require('newrelic');

// Custom transaction naming
app.get('/api/users/:id', (req, res) => {
    newrelic.setTransactionName(`GET /api/users/:id`);

    // Add custom attributes
    newrelic.addCustomAttribute('userId', req.params.id);
    newrelic.addCustomAttribute('userAgent', req.get('User-Agent'));

    // Your route logic here
    res.json({ id: req.params.id, name: 'John Doe' });
});

// Custom metrics
const metricName = 'Custom/User/Registration/Time';
newrelic.recordMetric(metricName, registrationTimeInMs);

// Custom events
newrelic.recordCustomEvent('UserAction', {
    action: 'login',
    userId: user.id,
    timestamp: Date.now(),
    success: true
});

// Error tracking
app.use((error, req, res, next) => {
    // Record error in New Relic
    newrelic.noticeError(error, {
        userId: req.user?.id,
        url: req.url,
        method: req.method,
        userAgent: req.get('User-Agent')
    });

    res.status(500).json({ error: 'Internal server error' });
});

// DataDog APM setup
const tracer = require('dd-trace').init({
    service: 'my-application',
    env: process.env.NODE_ENV,
    version: '1.0.0'
});

// Custom spans
app.get('/api/complex-operation', async (req, res) => {
    const span = tracer.scope().active();

    span.setTag('operation', 'complex-calculation');
    span.setTag('user.id', req.user?.id);

    try {
        // Database operation
        const dbSpan = tracer.startSpan('database.query', {
            childOf: span
        });

        const result = await db.query('SELECT * FROM complex_data');
        dbSpan.finish();

        // Processing operation
        const processSpan = tracer.startSpan('data.processing', {
            childOf: span
        });

        const processed = result.map(item => ({
            ...item,
            processed: true
        }));

        processSpan.finish();

        res.json(processed);

    } catch (error) {
        span.setTag('error', true);
        span.setTag('error.message', error.message);
        throw error;
    } finally {
        span.finish();
    }
});