Connection Pooling

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
114
115
116
117
118

/**
 * Pool Size Calculator
 * 
 * Uses queueing theory to calculate recommended pool sizes
 * for different scenarios and confidence levels.
 */
 
interface WorkloadCharacteristics {
    // Request rates
    averageRequestsPerSecond: number;
    peakRequestsPerSecond: number;     // e.g., 2x average
    
    // Connection hold times (in milliseconds)
    averageHoldTimeMs: number;
    p99HoldTimeMs: number;
    maxHoldTimeMs: number;
    
    // Concurrency
    applicationInstances: number;
}
 
interface DatabaseConstraints {
    maxConnections: number;              // Database max_connections setting
    connectionMemoryMb: number;          // Memory per connection
    availableMemoryMb: number;           // Total database memory
    reservedForAdminConnections: number; // Keep some connections for admin
}
 
interface PoolSizeRecommendation {
    minConnections: number;
    maxConnections: number;
    rationale: string[];
}
 
function calculatePoolSize(
    workload: WorkloadCharacteristics,
    constraints: DatabaseConstraints
): PoolSizeRecommendation {
    const rationale: string[] = [];
    
    // 1. Little's Law baseline (per instance)
    const perInstanceRps = workload.averageRequestsPerSecond / workload.applicationInstances;
    const avgHoldSec = workload.averageHoldTimeMs / 1000;
    const littlesLawMin = Math.ceil(perInstanceRps * avgHoldSec);
    rationale.push(
        `Little's Law baseline: ${perInstanceRps} req/s × ${avgHoldSec}s = ${littlesLawMin} connections`
    );
    
    // 2. P99 scenario (handles 99% of situations)
    const peakPerInstance = workload.peakRequestsPerSecond / workload.applicationInstances;
    const p99HoldSec = workload.p99HoldTimeMs / 1000;
    const p99Connections = Math.ceil(peakPerInstance * p99HoldSec);
    rationale.push(
        `P99 scenario: ${peakPerInstance} peak req/s × ${p99HoldSec}s P99 = ${p99Connections} connections`
    );
    
    // 3. Database constraint (connections available per instance)
    const availableForApp = constraints.maxConnections - constraints.reservedForAdminConnections;
    const maxPerInstance = Math.floor(availableForApp / workload.applicationInstances);
    rationale.push(
        `Database limit: (${constraints.maxConnections} - ${constraints.reservedForAdminConnections}) / ${workload.applicationInstances} = ${maxPerInstance} max`
    );
    
    // 4. Memory constraint
    const memoryLimitedConnections = Math.floor(
        constraints.availableMemoryMb / constraints.connectionMemoryMb
    );
    const memoryMaxPerInstance = Math.floor(memoryLimitedConnections / workload.applicationInstances);
    rationale.push(
        `Memory limit: ${constraints.availableMemoryMb}MB / ${constraints.connectionMemoryMb}MB per conn = ${memoryLimitedConnections} total`
    );
    
    // 5. Calculate recommendation
    // Min: Baseline + 50% buffer, but at least 5
    const calculatedMin = Math.max(5, Math.ceil(littlesLawMin * 1.5));
    
    // Max: P99 + 20% buffer, but constrained by database/memory limits
    const calculatedMax = Math.ceil(p99Connections * 1.2);
    const constrainedMax = Math.min(calculatedMax, maxPerInstance, memoryMaxPerInstance);
    
    // Ensure max >= min
    const finalMax = Math.max(constrainedMax, calculatedMin);
    
    rationale.push(
        `Recommendation: min=${calculatedMin} (baseline+50%), max=${finalMax} (P99+20%, constrained)`
    );
    
    return {
        minConnections: calculatedMin,
        maxConnections: finalMax,
        rationale
    };
}
 
// Example calculation
const workload: WorkloadCharacteristics = {
    averageRequestsPerSecond: 500,
    peakRequestsPerSecond: 1000,
    averageHoldTimeMs: 50,
    p99HoldTimeMs: 200,
    maxHoldTimeMs: 1000,
    applicationInstances: 10
};
 
const constraints: DatabaseConstraints = {
    maxConnections: 500,
    connectionMemoryMb: 10,  // PostgreSQL default
    availableMemoryMb: 4096,
    reservedForAdminConnections: 20
};
 
const recommendation = calculatePoolSize(workload, constraints);
// Result:
// {
//   minConnections: 8,   // ceil(50 req/s × 0.05s × 1.5)
//   maxConnections: 24,  // min(24 calculated, 48 db limit, 40 memory limit)
//   rationale: [...]
// }

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

/**
 * Connection Budget Calculator
 * 
 * Plans pool sizes considering all consumers of database connections.
 */
 
interface ConnectionConsumer {
    name: string;
    instances: number;
    maxConnectionsPerInstance: number;
    priority: 'critical' | 'high' | 'normal' | 'low';
}
 
interface ConnectionBudget {
    databaseMaxConnections: number;
    reservedForAdmin: number;
    reservedForReplication: number;
    reservedForProxies: number;
    consumers: ConnectionConsumer[];
}
 
interface BudgetAllocation {
    consumer: string;
    requestedTotal: number;
    allocated: number;
    perInstance: number;
    satisfied: boolean;
}
 
function allocateConnectionBudget(budget: ConnectionBudget): BudgetAllocation[] {
    // Calculate available connections
    const available = budget.databaseMaxConnections
        - budget.reservedForAdmin
        - budget.reservedForReplication
        - budget.reservedForProxies;
    
    console.log(`Total available for applications: ${available}`);
    
    // Calculate total requested
    const totalRequested = budget.consumers.reduce(
        (sum, c) => sum + (c.instances * c.maxConnectionsPerInstance), 0
    );
    
    if (totalRequested <= available) {
        // Everyone gets what they want
        return budget.consumers.map(c => ({
            consumer: c.name,
            requestedTotal: c.instances * c.maxConnectionsPerInstance,
            allocated: c.instances * c.maxConnectionsPerInstance,
            perInstance: c.maxConnectionsPerInstance,
            satisfied: true
        }));
    }
    
    // Need to allocate proportionally with priority weighting
    const priorityWeights = {
        critical: 4,
        high: 2,
        normal: 1,
        low: 0.5
    };
    
    // Calculate weighted shares
    const weightedRequests = budget.consumers.map(c => ({
        ...c,
        requested: c.instances * c.maxConnectionsPerInstance,
        weight: priorityWeights[c.priority]
    }));
    
    const totalWeight = weightedRequests.reduce(
        (sum, r) => sum + (r.requested * r.weight), 0
    );
    
    // Allocate based on weighted proportion
    return weightedRequests.map(c => {
        const weightedShare = (c.requested * c.weight) / totalWeight;
        const allocated = Math.floor(available * weightedShare);
        const perInstance = Math.floor(allocated / c.instances);
        
        return {
            consumer: c.name,
            requestedTotal: c.requested,
            allocated: perInstance * c.instances,  // Round to instance boundaries
            perInstance,
            satisfied: perInstance >= c.maxConnectionsPerInstance
        };
    });
}
 
// Example: Multi-service architecture
const budget: ConnectionBudget = {
    databaseMaxConnections: 500,
    reservedForAdmin: 20,
    reservedForReplication: 10,
    reservedForProxies: 20,
    consumers: [
        { name: 'api-gateway', instances: 20, maxConnectionsPerInstance: 30, priority: 'critical' },
        { name: 'order-service', instances: 10, maxConnectionsPerInstance: 20, priority: 'high' },
        { name: 'analytics', instances: 5, maxConnectionsPerInstance: 15, priority: 'normal' },
        { name: 'batch-jobs', instances: 3, maxConnectionsPerInstance: 10, priority: 'low' }
    ]
};
 
const allocations = allocateConnectionBudget(budget);
// Shows how to distribute limited connection capacity across services

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/**
 * Dynamic Pool Sizing Algorithm
 * 
 * Adjusts pool size based on observed utilization patterns.
 * Uses moving averages to smooth out temporary spikes.
 */
 
interface DynamicSizingConfig {
    minimumPoolSize: number;        // Never go below this
    maximumPoolSize: number;        // Never exceed this
    targetUtilization: number;      // Aim for this % of pool in use (0.6-0.8)
    scaleUpThreshold: number;       // Scale up when utilization exceeds (0.8-0.9)
    scaleDownThreshold: number;     // Scale down when utilization below (0.3-0.5)
    evaluationWindowMs: number;     // How long to observe before deciding
    scaleUpIncrement: number;       // Connections to add when scaling up
    scaleDownIncrement: number;     // Connections to remove when scaling down
    cooldownPeriodMs: number;       // Minimum time between resize operations
}
 
class DynamicallySizedPool {
    private config: DynamicSizingConfig;
    private currentMaxSize: number;
    private utilizationHistory: number[] = [];
    private lastResizeTime: number = 0;
    
    constructor(config: DynamicSizingConfig) {
        this.config = config;
        this.currentMaxSize = config.minimumPoolSize;
    }
    
    /**
     * Record current utilization
     * Called periodically (e.g., every second)
     */
    recordUtilization(): void {
        const utilization = this.inUse.size / this.currentMaxSize;
        
        this.utilizationHistory.push(utilization);
        
        // Keep only recent history
        const maxSamples = this.config.evaluationWindowMs / 1000;
        if (this.utilizationHistory.length > maxSamples) {
            this.utilizationHistory.shift();
        }
    }
    
    /**
     * Evaluate and potentially resize
     * Called periodically after utilization recording
     */
    evaluateResize(): void {
        // Respect cooldown period
        if (Date.now() - this.lastResizeTime < this.config.cooldownPeriodMs) {
            return;
        }
        
        // Need enough history for decision
        const minSamples = this.config.evaluationWindowMs / 2000;
        if (this.utilizationHistory.length < minSamples) {
            return;
        }
        
        // Calculate average utilization
        const avgUtilization = this.utilizationHistory.reduce((a, b) => a + b, 0) 
            / this.utilizationHistory.length;
        
        // Calculate P95 utilization (for spike detection)
        const sorted = [...this.utilizationHistory].sort((a, b) => a - b);
        const p95Index = Math.floor(sorted.length * 0.95);
        const p95Utilization = sorted[p95Index];
        
        // Decision logic
        if (p95Utilization > this.config.scaleUpThreshold) {
            // High utilization sustained - scale up
            this.scaleUp();
        } else if (avgUtilization < this.config.scaleDownThreshold) {
            // Low utilization sustained - scale down
            this.scaleDown();
        }
    }
    
    private scaleUp(): void {
        const newMax = Math.min(
            this.currentMaxSize + this.config.scaleUpIncrement,
            this.config.maximumPoolSize
        );
        
        if (newMax > this.currentMaxSize) {
            console.log(
                `Scaling pool up: ${this.currentMaxSize} → ${newMax} ` +
                `(utilization: ${this.getAvgUtilization().toFixed(2)})`
            );
            
            this.currentMaxSize = newMax;
            this.lastResizeTime = Date.now();
            this.utilizationHistory = [];  // Reset history after resize
        }
    }
    
    private scaleDown(): void {
        // Don't scale below current usage
        const currentlyInUse = this.inUse.size;
        const safeMin = Math.max(
            this.config.minimumPoolSize,
            currentlyInUse + 2  // Buffer above current use
        );
        
        const newMax = Math.max(
            this.currentMaxSize - this.config.scaleDownIncrement,
            safeMin
        );
        
        if (newMax < this.currentMaxSize) {
            console.log(
                `Scaling pool down: ${this.currentMaxSize} → ${newMax} ` +
                `(utilization: ${this.getAvgUtilization().toFixed(2)})`
            );
            
            // Close excess idle connections
            this.trimIdleConnections(newMax);
            
            this.currentMaxSize = newMax;
            this.lastResizeTime = Date.now();
            this.utilizationHistory = [];
        }
    }
    
    private trimIdleConnections(targetSize: number): void {
        while (this.available.length + this.inUse.size > targetSize 
               && this.available.length > 0) {
            const conn = this.available.pop();
            if (conn) {
                conn.close().catch(console.error);
            }
        }
    }
}
 
// Recommended configuration
const dynamicConfig: DynamicSizingConfig = {
    minimumPoolSize: 10,
    maximumPoolSize: 50,
    targetUtilization: 0.7,         // Aim for 70% usage
    scaleUpThreshold: 0.85,         // Scale up if consistently >85%
    scaleDownThreshold: 0.4,        // Scale down if consistently <40%
    evaluationWindowMs: 60000,      // Evaluate over 1 minute
    scaleUpIncrement: 5,            // Add 5 connections at a time
    scaleDownIncrement: 2,          // Remove 2 at a time (more conservative)
    cooldownPeriodMs: 120000        // 2 minutes between resize operations
};

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
114
115

/**
 * Optimal Pool Size Estimator
 * 
 * Based on database server hardware characteristics,
 * estimates the maximum effective connections.
 */
 
interface DatabaseServerSpec {
    cpuCores: number;
    storageType: 'hdd' | 'ssd' | 'nvme';
    storageDevices: number;  // Number of drives/devices
    availableMemoryGb: number;
    memoryPerConnectionMb: number;
}
 
interface ClusterSpec {
    databaseServers: DatabaseServerSpec[];
    applicationInstances: number;
    includesProxy: boolean;  // PgBouncer, ProxySQL, etc.
    proxyMaxConnections?: number;
}
 
function estimateOptimalConnections(server: DatabaseServerSpec): {
    formulaBased: number;
    memoryConstrained: number;
    recommended: number;
} {
    // Formula-based estimate
    let effectiveSpindles: number;
    switch (server.storageType) {
        case 'hdd':
            effectiveSpindles = server.storageDevices;
            break;
        case 'ssd':
            effectiveSpindles = server.storageDevices * 4;  // SSDs support more parallel ops
            break;
        case 'nvme':
            effectiveSpindles = server.storageDevices * 8;  // NVMe even more parallel
            break;
    }
    
    const formulaBased = (server.cpuCores * 2) + effectiveSpindles;
    
    // Memory-constrained estimate
    const totalMemoryMb = server.availableMemoryGb * 1024;
    const memoryForConnections = totalMemoryMb * 0.25;  // Reserve 25% for connections
    const memoryConstrained = Math.floor(memoryForConnections / server.memoryPerConnectionMb);
    
    // Recommended is the lower of formula and memory limits
    const recommended = Math.min(formulaBased, memoryConstrained);
    
    return { formulaBased, memoryConstrained, recommended };
}
 
function calculateClusterPoolSizes(cluster: ClusterSpec): {
    totalDatabaseConnections: number;
    perInstancePoolSize: number;
    reasoning: string[];
} {
    const reasoning: string[] = [];
    
    // Calculate optimal connections per database server
    let totalOptimal = 0;
    for (const server of cluster.databaseServers) {
        const estimate = estimateOptimalConnections(server);
        totalOptimal += estimate.recommended;
        reasoning.push(
            `Server (${server.cpuCores} cores, ${server.storageType}): ` +
            `${estimate.recommended} connections optimal`
        );
    }
    
    reasoning.push(`Total cluster optimal connections: ${totalOptimal}`);
    
    // Reserve for admin/monitoring
    const reservedConnections = Math.ceil(totalOptimal * 0.1);
    const availableForApps = totalOptimal - reservedConnections;
    reasoning.push(`After reserving 10% for admin: ${availableForApps} available`);
    
    // Divide among application instances
    let perInstance = Math.floor(availableForApps / cluster.applicationInstances);
    
    // If using proxy, different calculation
    if (cluster.includesProxy && cluster.proxyMaxConnections) {
        // Proxy multiplexes - apps can have more connections than database
        perInstance = Math.floor(cluster.proxyMaxConnections / cluster.applicationInstances);
        reasoning.push(
            `With proxy multiplexing: ${perInstance} connections per application instance`
        );
    } else {
        reasoning.push(
            `Per application instance: ${perInstance} connections`
        );
    }
    
    return {
        totalDatabaseConnections: totalOptimal,
        perInstancePoolSize: perInstance,
        reasoning
    };
}
 
// Example: Typical production cluster
const cluster: ClusterSpec = {
    databaseServers: [
        { cpuCores: 16, storageType: 'nvme', storageDevices: 2, 
          availableMemoryGb: 64, memoryPerConnectionMb: 10 },
    ],
    applicationInstances: 10,
    includesProxy: false
};
 
const sizing = calculateClusterPoolSizes(cluster);
// Result might suggest: 48 connections per instance (480 total)
// Much less than naive "set to 200" approach!

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

# PgBouncer Configuration (pgbouncer.ini)
 
[databases]
# Define backend database connections
mydb = host=db-primary.internal port=5432 dbname=production
 
[pgbouncer]
# Listen for incoming connections
listen_addr = 0.0.0.0
listen_port = 6432
 
# Authentication
auth_type = md5
auth_file = /etc/pgbouncer/userlist.txt
 
# Pool mode determines when connections are returned to pool:
# - session: Connection is held for entire session (like no pooling)
# - transaction: Connection returned after each transaction (most common)
# - statement: Connection returned after each statement (most aggressive)
pool_mode = transaction
 
# Pool size limits
default_pool_size = 100          # Connections per user/database pair
max_client_conn = 1000           # Total client connections allowed
min_pool_size = 10               # Minimum connections to maintain
 
# Connection lifetime
server_lifetime = 3600           # Close connections older than 1 hour
server_idle_timeout = 600        # Close idle connections after 10 min
 
# Timeouts
server_connect_timeout = 15      # Timeout connecting to PostgreSQL
server_login_retry = 3           # Retries on connect failure
 
# Query handling in transaction mode
# IMPORTANT: Set these for transaction pooling
server_reset_query = DISCARD ALL # Reset connection state between uses
 
# Logging
log_connections = 1
log_disconnections = 1
log_pooler_errors = 1
 
# Statistics
stats_period = 60                # Log stats every minute

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

/**
 * Pool Metrics Collection
 * 
 * Comprehensive metrics for pool health monitoring.
 * Compatible with Prometheus, StatsD, or any metrics system.
 */
 
interface PoolMetrics {
    // Current state
    activeConnections: number;
    idleConnections: number;
    maxConnections: number;
    waitingRequests: number;
    
    // Rates (per minute)
    acquisitionsPerMinute: number;
    releasesPerMinute: number;
    creationsPerMinute: number;
    destructionsPerMinute: number;
    timeoutsPerMinute: number;
    
    // Latencies (milliseconds)
    avgWaitTimeMs: number;
    p99WaitTimeMs: number;
    maxWaitTimeMs: number;
    
    // Health indicators
    utilizationPercent: number;
    connectionAgeMaxSeconds: number;
}
 
class InstrumentedPool {
    private metrics: PoolMetrics;
    private waitTimeHistogram: number[] = [];
    private acquisitionCounter = 0;
    private creationCounter = 0;
    private lastMetricsClear = Date.now();
    
    /**
     * Record wait time when connection is acquired
     */
    async acquire(): Promise<Connection> {
        const waitStart = Date.now();
        this.metrics.waitingRequests++;
        
        try {
            const connection = await this.doAcquire();
            
            const waitTime = Date.now() - waitStart;
            this.recordWaitTime(waitTime);
            
            this.acquisitionCounter++;
            
            return connection;
        } finally {
            this.metrics.waitingRequests--;
        }
    }
    
    /**
     * Get current metrics snapshot
     */
    getMetrics(): PoolMetrics {
        const elapsed = (Date.now() - this.lastMetricsClear) / 60000; // Minutes
        
        return {
            activeConnections: this.inUse.size,
            idleConnections: this.available.length,
            maxConnections: this.config.maxConnections,
            waitingRequests: this.metrics.waitingRequests,
            
            acquisitionsPerMinute: this.acquisitionCounter / elapsed,
            releasesPerMinute: this.releaseCounter / elapsed,
            creationsPerMinute: this.creationCounter / elapsed,
            destructionsPerMinute: this.destructionCounter / elapsed,
            timeoutsPerMinute: this.timeoutCounter / elapsed,
            
            avgWaitTimeMs: this.calculateAverage(this.waitTimeHistogram),
            p99WaitTimeMs: this.calculatePercentile(this.waitTimeHistogram, 99),
            maxWaitTimeMs: Math.max(...this.waitTimeHistogram),
            
            utilizationPercent: (this.inUse.size / this.config.maxConnections) * 100,
            connectionAgeMaxSeconds: this.getOldestConnectionAge(),
        };
    }
    
    /**
     * Export metrics in Prometheus format
     */
    getPrometheusMetrics(): string {
        const m = this.getMetrics();
        const prefix = 'db_pool';
        
        return `
# HELP ${prefix}_connections_active Currently active connections
# TYPE ${prefix}_connections_active gauge
${prefix}_connections_active ${m.activeConnections}
 
# HELP ${prefix}_connections_idle Currently idle connections
# TYPE ${prefix}_connections_idle gauge
${prefix}_connections_idle ${m.idleConnections}
 
# HELP ${prefix}_connections_max Maximum pool size
# TYPE ${prefix}_connections_max gauge
${prefix}_connections_max ${m.maxConnections}
 
# HELP ${prefix}_waiting_requests Requests waiting for connection
# TYPE ${prefix}_waiting_requests gauge
${prefix}_waiting_requests ${m.waitingRequests}
 
# HELP ${prefix}_utilization_percent Pool utilization percentage
# TYPE ${prefix}_utilization_percent gauge
${prefix}_utilization_percent ${m.utilizationPercent}
 
# HELP ${prefix}_wait_time_milliseconds Connection wait time distribution
# TYPE ${prefix}_wait_time_milliseconds histogram
${prefix}_wait_time_milliseconds{quantile="0.5"} ${this.calculatePercentile(this.waitTimeHistogram, 50)}
${prefix}_wait_time_milliseconds{quantile="0.99"} ${m.p99WaitTimeMs}
 
# HELP ${prefix}_acquisitions_total Total connection acquisitions
# TYPE ${prefix}_acquisitions_total counter
${prefix}_acquisitions_total ${this.acquisitionCounter}
 
# HELP ${prefix}_timeouts_total Total acquisition timeouts
# TYPE ${prefix}_timeouts_total counter
${prefix}_timeouts_total ${this.timeoutCounter}
        `.trim();
    }
}
 
// Alert thresholds
const alertThresholds = {
    // Utilization > 90% for 5 minutes
    highUtilization: {
        condition: (m: PoolMetrics) => m.utilizationPercent > 90,
        message: 'Pool utilization critically high',
        severity: 'warning'
    },
    
    // Any timeouts
    connectionTimeouts: {
        condition: (m: PoolMetrics) => m.timeoutsPerMinute > 0,
        message: 'Connection timeouts occurring',
        severity: 'critical'
    },
    
    // Wait time > 100ms P99
    highWaitTime: {
        condition: (m: PoolMetrics) => m.p99WaitTimeMs > 100,
        message: 'High connection wait times',
        severity: 'warning'
    },
    
    // High creation rate (indicates connection churn)
    highChurn: {
        condition: (m: PoolMetrics) => m.creationsPerMinute > 10,
        message: 'High connection creation rate - possible instability',
        severity: 'warning'
    }
};