1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// ANTI-PATTERN: Leaked resource on exception path
function processFile(path: string): ProcessResult {
    const file = fs.openSync(path, 'r');
    
    // If parse() throws, file handle is never closed!
    const content = readContent(file);
    const result = parse(content); // May throw
    
    fs.closeSync(file);
    return result;
}
 
// Static analyzer warning:
// "Resource 'file' acquired at line 2 may not be released 
//  if exception occurs at line 6"
 
// CORRECT: Ensure cleanup on all paths
function processFileSafe(path: string): ProcessResult {
    const file = fs.openSync(path, 'r');
    try {
        const content = readContent(file);
        return parse(content);
    } finally {
        fs.closeSync(file); // Always executes
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// Comprehensive resource tracking for leak detection
interface ResourceEntry {
    id: string;
    type: string;
    acquiredAt: Date;
    stackTrace: string;
    metadata?: Record<string, unknown>;
}
 
class ResourceLeakDetector {
    private static instance: ResourceLeakDetector;
    private resources = new Map<string, ResourceEntry>();
    private enabled = process.env.NODE_ENV !== 'production';
    
    static getInstance(): ResourceLeakDetector {
        if (!this.instance) {
            this.instance = new ResourceLeakDetector();
        }
        return this.instance;
    }
    
    trackAcquisition(
        id: string, 
        type: string,
        metadata?: Record<string, unknown>
    ): void {
        if (!this.enabled) return;
        
        this.resources.set(id, {
            id,
            type,
            acquiredAt: new Date(),
            stackTrace: new Error().stack || '',
            metadata,
        });
    }
    
    trackRelease(id: string): void {
        if (!this.enabled) return;
        this.resources.delete(id);
    }
    
    getActiveResources(): ResourceEntry[] {
        return Array.from(this.resources.values());
    }
    
    getResourcesByType(type: string): ResourceEntry[] {
        return this.getActiveResources().filter(r => r.type === type);
    }
    
    getLeakReport(): LeakReport {
        const resources = this.getActiveResources();
        const byType = new Map<string, ResourceEntry[]>();
        
        for (const resource of resources) {
            const existing = byType.get(resource.type) || [];
            existing.push(resource);
            byType.set(resource.type, existing);
        }
        
        return {
            totalLeaks: resources.length,
            byType: Object.fromEntries(byType),
            oldestLeak: resources.sort(
                (a, b) => a.acquiredAt.getTime() - b.acquiredAt.getTime()
            )[0],
        };
    }
    
    assertNoLeaks(options: { ignoreTypes?: string[] } = {}): void {
        const resources = this.getActiveResources().filter(
            r => !options.ignoreTypes?.includes(r.type)
        );
        
        if (resources.length > 0) {
            const report = resources.map(r => 
                `[${r.type}] ${r.id} acquired at ${r.acquiredAt.toISOString()}\n` +
                `Stack: ${r.stackTrace.split('\n').slice(0, 5).join('\n')}`
            ).join('\n\n');
            
            throw new Error(
                `Resource leaks detected (\${resources.length}):\n\n${report}`
            );
        }
    }
    
    clear(): void {
        this.resources.clear();
    }
}
 
// Usage: Wrap resource operations
class TrackedConnection implements IConnection {
    private readonly id: string;
    
    constructor(private readonly inner: IConnection) {
        this.id = crypto.randomUUID();
        ResourceLeakDetector.getInstance().trackAcquisition(
            this.id,
            'DatabaseConnection',
            { connectionTime: new Date() }
        );
    }
    
    async execute(query: string): Promise<Result> {
        return this.inner.execute(query);
    }
    
    dispose(): void {
        this.inner.dispose();
        ResourceLeakDetector.getInstance().trackRelease(this.id);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

// Connection pool with leak detection
interface LeakDetectionConfig {
    enabled: boolean;
    leakThresholdMs: number;      // Time after which unreturned connection is suspicious
    checkIntervalMs: number;       // How often to scan for leaks
    onLeakDetected: (leak: LeakInfo) => void;
}
 
interface LeakInfo {
    connectionId: string;
    acquiredAt: Date;
    elapsedMs: number;
    stackTrace: string;
}
 
class LeakDetectingConnectionPool {
    private borrowedConnections = new Map<string, {
        connection: Connection;
        acquiredAt: Date;
        stackTrace: string;
    }>();
    
    private leakCheckInterval?: NodeJS.Timeout;
    
    constructor(
        private readonly config: LeakDetectionConfig,
        private readonly innerPool: ConnectionPool
    ) {
        if (config.enabled) {
            this.startLeakDetection();
        }
    }
    
    async borrow(): Promise<Connection> {
        const connection = await this.innerPool.borrow();
        const wrappedId = crypto.randomUUID();
        
        this.borrowedConnections.set(wrappedId, {
            connection,
            acquiredAt: new Date(),
            stackTrace: new Error().stack || '',
        });
        
        // Return a proxy that tracks return
        return this.wrapConnection(connection, wrappedId);
    }
    
    private wrapConnection(conn: Connection, id: string): Connection {
        const self = this;
        return new Proxy(conn, {
            get(target, prop) {
                if (prop === 'close' || prop === 'release') {
                    return () => {
                        self.borrowedConnections.delete(id);
                        return (target as any)[prop]();
                    };
                }
                return (target as any)[prop];
            }
        });
    }
    
    private startLeakDetection(): void {
        this.leakCheckInterval = setInterval(() => {
            this.checkForLeaks();
        }, this.config.checkIntervalMs);
    }
    
    private checkForLeaks(): void {
        const now = Date.now();
        
        for (const [id, info] of this.borrowedConnections) {
            const elapsedMs = now - info.acquiredAt.getTime();
            
            if (elapsedMs > this.config.leakThresholdMs) {
                this.config.onLeakDetected({
                    connectionId: id,
                    acquiredAt: info.acquiredAt,
                    elapsedMs,
                    stackTrace: info.stackTrace,
                });
            }
        }
    }
    
    getStats(): PoolStats {
        return {
            borrowed: this.borrowedConnections.size,
            available: this.innerPool.available,
            leakCandidates: Array.from(this.borrowedConnections.entries())
                .filter(([_, info]) => 
                    Date.now() - info.acquiredAt.getTime() > this.config.leakThresholdMs
                ).length,
        };
    }
    
    shutdown(): void {
        if (this.leakCheckInterval) {
            clearInterval(this.leakCheckInterval);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// ANTI-PATTERN 1: Event listener accumulation
class LeakyComponent {
    private handler = () => this.handleEvent();
    
    mount() {
        // Listener registered but never removed
        eventBus.on('data', this.handler);
    }
    
    // Forgot to implement unmount() with:
    // eventBus.off('data', this.handler);
}
 
// Creates leak: each component instance stays in memory
// because eventBus holds reference via handler
 
// FIX: Always pair registration with cleanup
class SafeComponent {
    private handler = () => this.handleEvent();
    
    mount() {
        eventBus.on('data', this.handler);
    }
    
    unmount() {
        eventBus.off('data', this.handler); // Remove reference
    }
}
 
// ANTI-PATTERN 2: Unbounded cache
class LeakyCache {
    private cache = new Map<string, LargeObject>();
    
    get(key: string): LargeObject {
        let obj = this.cache.get(key);
        if (!obj) {
            obj = this.createLargeObject(key);
            this.cache.set(key, obj); // Never evicted!
        }
        return obj;
    }
}
 
// FIX: Use LRU cache with size limit
import LRU from 'lru-cache';
 
class SafeCache {
    private cache = new LRU<string, LargeObject>({ 
        max: 1000,  // Maximum entries
        maxSize: 100 * 1024 * 1024,  // Maximum 100MB
        sizeCalculation: (obj) => obj.sizeBytes,
    });
    
    get(key: string): LargeObject {
        let obj = this.cache.get(key);
        if (!obj) {
            obj = this.createLargeObject(key);
            this.cache.set(key, obj);
        }
        return obj;
    }
}
 
// ANTI-PATTERN 3: Closure capturing too much
class LeakyProcessor {
    processItems(items: LargeItem[]) {
        items.forEach(item => {
            // This closure captures 'items' array, keeping all of it alive
            someAsyncQueue.push(() => {
                console.log(`Processing ${item.id} of ${items.length}`);
            });
        });
    }
}
 
// FIX: Capture only what you need
class SafeProcessor {
    processItems(items: LargeItem[]) {
        const itemCount = items.length;  // Extract primitive
        items.forEach(item => {
            const itemId = item.id;  // Extract only needed data
            someAsyncQueue.push(() => {
                console.log(`Processing ${itemId} of ${itemCount}`);
            });
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

// Node.js heap snapshot capture for leak analysis
import v8 from 'v8';
import fs from 'fs';
 
class HeapAnalyzer {
    private snapshotCount = 0;
    
    captureSnapshot(label?: string): string {
        // Trigger GC first for accurate snapshot
        if (global.gc) {
            global.gc();
        }
        
        const filename = `heap-${Date.now()}-${++this.snapshotCount}.heapsnapshot`;
        const snapshotPath = `./diagnostics/${filename}`;
        
        // Capture and write snapshot
        const stream = fs.createWriteStream(snapshotPath);
        v8.writeHeapSnapshot(snapshotPath);
        
        console.log(`Heap snapshot saved: ${snapshotPath}`);
        if (label) console.log(`  Label: ${label}`);
        console.log(`  Heap used: ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`);
        
        return snapshotPath;
    }
}
 
// Test pattern: snapshot before and after to detect leaks
describe('memory leak detection', () => {
    const analyzer = new HeapAnalyzer();
    
    it('should not leak memory during operations', async () => {
        // Force GC and capture baseline
        if (global.gc) global.gc();
        const baselineHeap = process.memoryUsage().heapUsed;
        analyzer.captureSnapshot('baseline');
        
        // Perform operations that might leak
        for (let i = 0; i < 1000; i++) {
            await performPotentiallyLeakyOperation();
        }
        
        // Force GC and measure
        if (global.gc) global.gc();
        await new Promise(r => setTimeout(r, 100)); // Let finalizers run
        
        const afterHeap = process.memoryUsage().heapUsed;
        analyzer.captureSnapshot('after-operations');
        
        // Calculate leak
        const growthBytes = afterHeap - baselineHeap;
        const growthMB = growthBytes / 1024 / 1024;
        
        // Assert acceptable growth (some overhead is normal)
        expect(growthMB).toBeLessThan(10); // 10MB threshold
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

// Linux/macOS: Monitor open file descriptors
import { execSync } from 'child_process';
 
class FileDescriptorMonitor {
    getOpenDescriptorCount(): number {
        const pid = process.pid;
        
        try {
            // Linux
            const result = execSync(`ls -la /proc/${pid}/fd 2>/dev/null | wc -l`);
            return parseInt(result.toString().trim()) - 3; // Subtract . and .. and header
        } catch {
            try {
                // macOS
                const result = execSync(`lsof -p ${pid} 2>/dev/null | wc -l`);
                return parseInt(result.toString().trim()) - 1;
            } catch {
                return -1; // Unable to determine
            }
        }
    }
    
    getOpenDescriptorDetails(): string[] {
        const pid = process.pid;
        try {
            const result = execSync(`lsof -p ${pid} 2>/dev/null`);
            return result.toString().split('\n');
        } catch {
            return ['Unable to get descriptor details'];
        }
    }
    
    getLimit(): { soft: number; hard: number } {
        try {
            const soft = execSync('ulimit -Sn').toString().trim();
            const hard = execSync('ulimit -Hn').toString().trim();
            return {
                soft: parseInt(soft),
                hard: parseInt(hard),
            };
        } catch {
            return { soft: -1, hard: -1 };
        }
    }
}
 
// Test pattern: verify no descriptor leaks
describe('file descriptor leak detection', () => {
    const monitor = new FileDescriptorMonitor();
    
    beforeEach(() => {
        // Capture baseline
        this.baselineDescriptors = monitor.getOpenDescriptorCount();
    });
    
    afterEach(() => {
        // Allow async cleanup
        return new Promise<void>((resolve) => setTimeout(async () => {
            const current = monitor.getOpenDescriptorCount();
            const leaked = current - this.baselineDescriptors;
            
            if (leaked > 0) {
                console.error(`Leaked ${leaked} file descriptors`);
                console.error('Open descriptors:', monitor.getOpenDescriptorDetails());
                throw new Error(`File descriptor leak: ${leaked} descriptors`);
            }
            resolve();
        }, 100));
    });
    
    it('should not leak file descriptors', async () => {
        // Operations that open files
        for (let i = 0; i < 100; i++) {
            await processFile(`./data/file-${i}.txt`);
        }
        // afterEach will verify no leak
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// Connection pool metrics for leak detection
interface PoolMetrics {
    total: number;          // Total connections in pool
    idle: number;           // Available connections
    active: number;         // Currently borrowed
    waiting: number;        // Requests waiting for connection
    maxSeen: number;        // Highest active count observed
    leakCandidates: number; // Connections held longer than threshold
}
 
class ConnectionPoolMonitor {
    private maxActiveEverSeen = 0;
    private readonly leakThresholdSeconds: number;
    
    constructor(
        private readonly pool: ConnectionPool,
        options: { leakThresholdSeconds?: number } = {}
    ) {
        this.leakThresholdSeconds = options.leakThresholdSeconds ?? 300; // 5 min default
    }
    
    getMetrics(): PoolMetrics {
        const stats = this.pool.getStats();
        
        this.maxActiveEverSeen = Math.max(this.maxActiveEverSeen, stats.active);
        
        return {
            total: stats.total,
            idle: stats.idle,
            active: stats.active,
            waiting: stats.waiting,
            maxSeen: this.maxActiveEverSeen,
            leakCandidates: this.countLeakCandidates(),
        };
    }
    
    private countLeakCandidates(): number {
        const now = Date.now();
        return this.pool.getBorrowedConnections()
            .filter(conn => {
                const heldSeconds = (now - conn.borrowedAt.getTime()) / 1000;
                return heldSeconds > this.leakThresholdSeconds;
            }).length;
    }
    
    checkHealth(): HealthCheckResult {
        const metrics = this.getMetrics();
        const issues: string[] = [];
        
        // Check for potential exhaustion
        if (metrics.idle === 0 && metrics.waiting > 0) {
            issues.push(`Pool exhausted: ${metrics.waiting} requests waiting`);
        }
        
        // Check for leak candidates
        if (metrics.leakCandidates > 0) {
            issues.push(`Potential leaks: ${metrics.leakCandidates} connections held > ${this.leakThresholdSeconds}s`);
        }
        
        // Check for growth pattern (may indicate slow leak)
        if (metrics.active > metrics.maxSeen * 0.9 && metrics.active > 5) {
            issues.push(`High watermark: ${metrics.active}/${this.maxActiveEverSeen} active`);
        }
        
        return {
            healthy: issues.length === 0,
            metrics,
            issues,
        };
    }
}
 
// Periodic health check and alerting
const monitor = new ConnectionPoolMonitor(pool, { leakThresholdSeconds: 300 });
 
setInterval(() => {
    const health = monitor.checkHealth();
    
    if (!health.healthy) {
        alerting.warn('Connection pool health issues', {
            issues: health.issues,
            metrics: health.metrics,
        });
    }
    
    // Export metrics for monitoring dashboard
    metrics.gauge('connection_pool.active', health.metrics.active);
    metrics.gauge('connection_pool.idle', health.metrics.idle);
    metrics.gauge('connection_pool.leak_candidates', health.metrics.leakCandidates);
}, 10000); // Every 10 seconds

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// vitest.config.ts or jest setup
import { beforeEach, afterEach, afterAll } from 'vitest';
 
// Global leak detection state
const leakDetector = {
    baselineDescriptors: 0,
    baselineMemory: 0,
    resourceRegistry: new ResourceRegistry(),
};
 
// Configure global test hooks
beforeEach(() => {
    // Capture baselines before each test
    if (global.gc) global.gc();
    
    leakDetector.baselineDescriptors = getOpenDescriptorCount();
    leakDetector.baselineMemory = process.memoryUsage().heapUsed;
    leakDetector.resourceRegistry.clear();
});
 
afterEach(async (context) => {
    // Allow async cleanup to complete
    await new Promise(resolve => setTimeout(resolve, 50));
    if (global.gc) global.gc();
    
    // Check for file descriptor leaks
    const currentDescriptors = getOpenDescriptorCount();
    const descriptorLeak = currentDescriptors - leakDetector.baselineDescriptors;
    
    if (descriptorLeak > 0) {
        throw new Error(
            `Test "${context.task.name}" leaked ${descriptorLeak} file descriptor(s)`
        );
    }
    
    // Check for tracked resource leaks
    const resourceLeaks = leakDetector.resourceRegistry.getLeaks();
    if (resourceLeaks.length > 0) {
        const details = resourceLeaks.map(r => 
            `  - [${r.type}] ${r.id}: ${r.stackTrace.split('\n')[1]}`
        ).join('\n');
        
        throw new Error(
            `Test "${context.task.name}" leaked ${resourceLeaks.length} resource(s):\n${details}`
        );
    }
    
    // Check for suspicious memory growth (potential leak)
    const currentMemory = process.memoryUsage().heapUsed;
    const memoryGrowth = currentMemory - leakDetector.baselineMemory;
    const memoryGrowthMB = memoryGrowth / 1024 / 1024;
    
    // Only warn on large leaks (individual tests may legitimately use memory)
    if (memoryGrowthMB > 50) {
        console.warn(
            `Warning: Test "${context.task.name}" grew heap by ${memoryGrowthMB.toFixed(2)}MB`
        );
    }
});
 
afterAll(() => {
    // Final leak check across entire suite
    if (global.gc) global.gc();
    
    const finalMemory = process.memoryUsage();
    console.log(`Final heap usage: ${Math.round(finalMemory.heapUsed / 1024 / 1024)}MB`);
    
    const finalResourceLeaks = leakDetector.resourceRegistry.getLeaks();
    if (finalResourceLeaks.length > 0) {
        console.error('Resources leaked across test suite:', finalResourceLeaks);
    }
});
 
// Export registry for tests to use
export function getResourceRegistry(): ResourceRegistry {
    return leakDetector.resourceRegistry;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// Soak test pattern for detecting slow leaks
describe('soak tests for leak detection', () => {
    it('should not leak memory over 10,000 iterations', async () => {
        // Warm up to stabilize JIT and initial allocations
        for (let i = 0; i < 100; i++) {
            await performOperation();
        }
        
        // Capture baseline after warmup
        if (global.gc) global.gc();
        await sleep(100);
        const baselineMemory = process.memoryUsage().heapUsed;
        
        // Main soak run
        const iterations = 10_000;
        const measurePoints: number[] = [];
        
        for (let i = 0; i < iterations; i++) {
            await performOperation();
            
            // Periodic measurement
            if (i % 1000 === 0) {
                if (global.gc) global.gc();
                measurePoints.push(process.memoryUsage().heapUsed);
            }
        }
        
        // Final measurement
        if (global.gc) global.gc();
        await sleep(100);
        const finalMemory = process.memoryUsage().heapUsed;
        
        // Analyze trend
        const growth = finalMemory - baselineMemory;
        const growthPerIteration = growth / iterations;
        
        // Assert no significant per-iteration growth
        // Allow small overhead (1KB per 1000 iterations)
        expect(growthPerIteration).toBeLessThan(1); // < 1 byte per iteration
        
        // Check for monotonic growth pattern (leak signature)
        const isMonotonicallyGrowing = measurePoints.every((val, i) => 
            i === 0 || val >= measurePoints[i - 1]
        );
        
        if (isMonotonicallyGrowing && growth > 1024 * 1024) {
            throw new Error(
                `Memory monotonically increased by ${(growth / 1024 / 1024).toFixed(2)}MB over ${iterations} iterations - likely leak`
            );
        }
    }, 60000); // 60 second timeout for soak test
    
    it('should not leak file handles over repeated file operations', async () => {
        const baselineDescriptors = getOpenDescriptorCount();
        const iterations = 5000;
        
        for (let i = 0; i < iterations; i++) {
            await processFileAndClose(`./test-data/file-${i % 100}.txt`);
        }
        
        // Allow cleanup
        await sleep(200);
        
        const finalDescriptors = getOpenDescriptorCount();
        const growth = finalDescriptors - baselineDescriptors;
        
        // Should have essentially no growth
        expect(growth).toBeLessThan(5);
    }, 30000);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// Production leak detection monitoring
import { Gauge, register } from 'prom-client';
 
// Metrics for leak detection
const memoryMetrics = {
    heapUsed: new Gauge({
        name: 'nodejs_heap_used_bytes',
        help: 'Current heap memory used in bytes',
    }),
    heapTotal: new Gauge({
        name: 'nodejs_heap_total_bytes',
        help: 'Total heap memory allocated in bytes',
    }),
    external: new Gauge({
        name: 'nodejs_external_memory_bytes',
        help: 'Memory used by C++ objects bound to JS',
    }),
    rss: new Gauge({
        name: 'nodejs_rss_bytes',
        help: 'Resident Set Size - total process memory',
    }),
};
 
const resourceMetrics = {
    openDescriptors: new Gauge({
        name: 'process_open_fds',
        help: 'Number of open file descriptors',
    }),
    activeConnections: new Gauge({
        name: 'db_connections_active',
        help: 'Number of database connections in use',
    }),
    eventListenerCount: new Gauge({
        name: 'event_listeners_total',
        help: 'Total registered event listeners',
        labelNames: ['emitter'],
    }),
};
 
// Periodic metric collection
setInterval(() => {
    const mem = process.memoryUsage();
    
    memoryMetrics.heapUsed.set(mem.heapUsed);
    memoryMetrics.heapTotal.set(mem.heapTotal);
    memoryMetrics.external.set(mem.external);
    memoryMetrics.rss.set(mem.rss);
    
    resourceMetrics.openDescriptors.set(getOpenDescriptorCount());
    resourceMetrics.activeConnections.set(connectionPool.activeCount);
}, 15000); // Every 15 seconds
 
// Alerting rules (example for Prometheus)
/*
# Alert on memory leak pattern
- alert: MemoryLeakSuspected
  expr: |
    increase(nodejs_heap_used_bytes[1h]) > 100000000
    AND
    min_over_time(nodejs_heap_used_bytes[1h]) > 0.7 * max_over_time(nodejs_heap_used_bytes[1h])
  for: 30m
  labels:
    severity: warning
  annotations:
    summary: "Possible memory leak in {{ $labels.instance }}"
    description: "Heap has grown >100MB in last hour without significant GC reclamation"
 
# Alert on file descriptor exhaustion risk
- alert: FileDescriptorsHigh
  expr: process_open_fds / process_max_fds > 0.8
  for: 10m
  labels:
    severity: critical
  annotations:
    summary: "File descriptors approaching limit"
*/