116 lines
No EOL
3.6 KiB
TypeScript
116 lines
No EOL
3.6 KiB
TypeScript
import { getDatabaseConfig } from '@stock-bot/config';
|
|
import { getLogger } from '@stock-bot/logger';
|
|
import { createMongoDBClient, createPostgreSQLClient } from '@stock-bot/connection-factory';
|
|
import type { DynamicPoolConfig } from '@stock-bot/mongodb-client';
|
|
|
|
const logger = getLogger('dynamic-pool-example');
|
|
|
|
/**
|
|
* Example of setting up dynamic pool sizing for high-load scenarios
|
|
*/
|
|
export async function setupDynamicPools() {
|
|
const dbConfig = getDatabaseConfig();
|
|
|
|
// Dynamic pool configuration for batch processing
|
|
const dynamicConfig: DynamicPoolConfig = {
|
|
enabled: true,
|
|
minSize: 5,
|
|
maxSize: 100,
|
|
scaleUpThreshold: 70, // Scale up when 70% of connections are in use
|
|
scaleDownThreshold: 30, // Scale down when only 30% are in use
|
|
scaleUpIncrement: 10, // Add 10 connections at a time
|
|
scaleDownIncrement: 5, // Remove 5 connections at a time
|
|
evaluationInterval: 10000 // Check every 10 seconds
|
|
};
|
|
|
|
// Create MongoDB client with dynamic pooling
|
|
const mongoClient = createMongoDBClient({
|
|
uri: dbConfig.mongodb.uri,
|
|
database: dbConfig.mongodb.database,
|
|
poolSettings: {
|
|
minPoolSize: dynamicConfig.minSize,
|
|
maxPoolSize: dynamicConfig.maxSize,
|
|
}
|
|
}, {
|
|
onConnect: () => logger.info('MongoDB connected with dynamic pooling'),
|
|
onError: (error) => logger.error('MongoDB pool error', { error }),
|
|
});
|
|
|
|
await mongoClient.connect();
|
|
mongoClient.setDynamicPoolConfig(dynamicConfig);
|
|
|
|
// Create PostgreSQL client with dynamic pooling
|
|
const pgClient = createPostgreSQLClient({
|
|
host: dbConfig.postgresql.host,
|
|
port: dbConfig.postgresql.port,
|
|
database: dbConfig.postgresql.database,
|
|
username: dbConfig.postgresql.user,
|
|
password: dbConfig.postgresql.password,
|
|
poolSettings: {
|
|
min: dynamicConfig.minSize,
|
|
max: dynamicConfig.maxSize,
|
|
}
|
|
}, undefined, {
|
|
onConnect: () => logger.info('PostgreSQL connected with dynamic pooling'),
|
|
onError: (error) => logger.error('PostgreSQL pool error', { error }),
|
|
});
|
|
|
|
await pgClient.connect();
|
|
pgClient.setDynamicPoolConfig(dynamicConfig);
|
|
|
|
// Monitor pool metrics
|
|
setInterval(() => {
|
|
const mongoMetrics = mongoClient.getPoolMetrics();
|
|
const pgMetrics = pgClient.getPoolMetrics();
|
|
|
|
logger.info('Pool metrics', {
|
|
mongodb: {
|
|
total: mongoMetrics.totalConnections,
|
|
active: mongoMetrics.activeConnections,
|
|
idle: mongoMetrics.idleConnections,
|
|
waiting: mongoMetrics.waitingRequests,
|
|
},
|
|
postgresql: {
|
|
total: pgMetrics.totalConnections,
|
|
active: pgMetrics.activeConnections,
|
|
idle: pgMetrics.idleConnections,
|
|
waiting: pgMetrics.waitingRequests,
|
|
}
|
|
});
|
|
}, 30000); // Log metrics every 30 seconds
|
|
|
|
return { mongoClient, pgClient };
|
|
}
|
|
|
|
/**
|
|
* Example of adaptive pool sizing based on time of day
|
|
*/
|
|
export function getTimeBasedPoolConfig(): DynamicPoolConfig {
|
|
const hour = new Date().getHours();
|
|
|
|
// High load hours (9 AM - 5 PM)
|
|
if (hour >= 9 && hour <= 17) {
|
|
return {
|
|
enabled: true,
|
|
minSize: 10,
|
|
maxSize: 150,
|
|
scaleUpThreshold: 60,
|
|
scaleDownThreshold: 20,
|
|
scaleUpIncrement: 20,
|
|
scaleDownIncrement: 10,
|
|
evaluationInterval: 5000 // More frequent checks during peak
|
|
};
|
|
}
|
|
|
|
// Low load hours (night time)
|
|
return {
|
|
enabled: true,
|
|
minSize: 2,
|
|
maxSize: 50,
|
|
scaleUpThreshold: 80,
|
|
scaleDownThreshold: 40,
|
|
scaleUpIncrement: 5,
|
|
scaleDownIncrement: 2,
|
|
evaluationInterval: 30000 // Less frequent checks at night
|
|
};
|
|
} |