@jetit/publisher 4.1.1 → 5.1.1

package/src/lib/monitoring/adapters/prom.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrometheusAdapter = void 0;
+class PrometheusAdapter {
+    /**
+     *
+     * @param streams [Publisher]
+     * @param promClient [Prom Client] This needs to be an instance of prom-client
+     */
+    constructor(streams, promClient) {
+        this.streams = streams;
+        this.promClient = promClient;
+        this.registry = new this.promClient.Registry({ collectDefaultMetrics: { timeout: 60000 } });
+        this.initializeMetrics();
+    }
+    initializeMetrics() {
+        this.queueDepth = new this.promClient.Gauge({
+            name: 'queue_depth',
+            help: 'Total number of messages in all queues',
+            registers: [this.registry],
+        });
+        this.dlqSize = new this.promClient.Gauge({
+            name: 'dlq_size',
+            help: 'Number of messages in the Dead Letter Queue',
+            registers: [this.registry],
+        });
+        this.duplicateEventCount = new this.promClient.Counter({
+            name: 'duplicate_event_count',
+            help: 'Number of duplicate events detected',
+            registers: [this.registry],
+        });
+        this.dlqRate = new this.promClient.Gauge({
+            name: 'dlq_rate',
+            help: 'Rate of messages being added to the Dead Letter Queue',
+            registers: [this.registry],
+        });
+        this.operationCount = new this.promClient.Counter({
+            name: 'operation_count',
+            help: 'Total number of operations performed',
+            registers: [this.registry],
+        });
+        this.totalTime = new this.promClient.Gauge({
+            name: 'total_time',
+            help: 'Total processing time in milliseconds',
+            registers: [this.registry],
+        });
+        this.redisOperationTime = new this.promClient.Gauge({
+            name: 'redis_operation_time',
+            help: 'Time spent on Redis operations in milliseconds',
+            registers: [this.registry],
+        });
+        this.processingTime = new this.promClient.Gauge({
+            name: 'processing_time',
+            help: 'Time spent on processing events in milliseconds',
+            registers: [this.registry],
+        });
+        this.eventCount = new this.promClient.Counter({
+            name: 'event_count',
+            help: 'Total number of events processed',
+            registers: [this.registry],
+        });
+        this.publishErrorCount = new this.promClient.Counter({
+            name: 'publish_error_count',
+            help: 'Number of errors encountered during publish operations',
+            registers: [this.registry],
+        });
+        this.subscribeErrorCount = new this.promClient.Counter({
+            name: 'subscribe_error_count',
+            help: 'Number of errors encountered during subscribe operations',
+            registers: [this.registry],
+        });
+        this.individualQueueDepth = new this.promClient.Gauge({
+            name: 'individual_queue_depth',
+            help: 'Number of messages in each individual queue',
+            labelNames: ['queue_name'],
+            registers: [this.registry],
+        });
+        this.messageRatePublish = new this.promClient.Gauge({
+            name: 'message_rate_publish',
+            help: 'Number of messages published per event type',
+            labelNames: ['event_type'],
+            registers: [this.registry],
+        });
+        this.messageRateSubscribe = new this.promClient.Gauge({
+            name: 'message_rate_subscribe',
+            help: 'Number of messages subscribed per event type',
+            labelNames: ['event_type'],
+            registers: [this.registry],
+        });
+        this.processingTimeHistogram = new this.promClient.Histogram({
+            name: 'processing_time_histogram',
+            help: 'Distribution of event processing times',
+            buckets: [0, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+            registers: [this.registry],
+        });
+        this.redisCommandLatency = new this.promClient.Gauge({
+            name: 'redis_command_latency',
+            help: 'Latency of Redis commands',
+            labelNames: ['command'],
+            registers: [this.registry],
+        });
+        this.consumerLag = new this.promClient.Gauge({
+            name: 'consumer_lag',
+            help: 'Lag of consumers in milliseconds',
+            labelNames: ['consumer_group'],
+            registers: [this.registry],
+        });
+        this.registry.registerMetric(this.queueDepth);
+        this.registry.registerMetric(this.dlqSize);
+        this.registry.registerMetric(this.dlqRate);
+        this.registry.registerMetric(this.operationCount);
+        this.registry.registerMetric(this.totalTime);
+        this.registry.registerMetric(this.redisOperationTime);
+        this.registry.registerMetric(this.processingTime);
+        this.registry.registerMetric(this.eventCount);
+        this.registry.registerMetric(this.publishErrorCount);
+        this.registry.registerMetric(this.subscribeErrorCount);
+        this.registry.registerMetric(this.individualQueueDepth);
+        this.registry.registerMetric(this.duplicateEventCount);
+        this.registry.registerMetric(this.messageRatePublish);
+        this.registry.registerMetric(this.messageRateSubscribe);
+        this.registry.registerMetric(this.processingTimeHistogram);
+        this.registry.registerMetric(this.redisCommandLatency);
+        this.registry.registerMetric(this.consumerLag);
+    }
+    async updateMetrics() {
+        const metrics = await this.streams.getLatestMetrics();
+        if (metrics) {
+            this.updatePrometheusMetrics(metrics);
+        }
+    }
+    updatePrometheusMetrics(metrics) {
+        this.queueDepth.set(metrics.queueDepth);
+        this.dlqSize.set(metrics.dlqSize);
+        this.dlqRate.set(metrics.dlqRate);
+        this.operationCount.inc(metrics.operationCount);
+        this.totalTime.set(metrics.totalTime);
+        this.redisOperationTime.set(metrics.redisOperationTime);
+        this.processingTime.set(metrics.processingTime);
+        this.eventCount.inc(metrics.eventCount);
+        this.publishErrorCount.inc(metrics.publishErrorCount);
+        this.subscribeErrorCount.inc(metrics.subscribeErrorCount);
+        this.duplicateEventCount.inc(metrics.duplicateEventsCount);
+        if (metrics.individualQueueDepts) {
+            Object.entries(metrics.individualQueueDepts).forEach(([queueName, depth]) => {
+                this.individualQueueDepth.set({ queue_name: queueName }, depth);
+            });
+        }
+        Object.entries(metrics.messageRatePublish).forEach(([eventType, rate]) => {
+            this.messageRatePublish.set({ event_type: eventType }, rate);
+        });
+        Object.entries(metrics.messageRateSubscribe).forEach(([eventType, rate]) => {
+            this.messageRateSubscribe.set({ event_type: eventType }, rate);
+        });
+        Object.entries(metrics.processingTimeDistribution).forEach(([bucket, count]) => {
+            const [lower, upper] = bucket.split('-').map(Number);
+            for (let i = 0; i < count; i++) {
+                this.processingTimeHistogram.observe(upper || lower);
+            }
+        });
+        Object.entries(metrics.redisCommandLatencies).forEach(([command, latency]) => {
+            this.redisCommandLatency.set({ command }, latency);
+        });
+        Object.entries(metrics.consumerLag).forEach(([consumerGroup, lag]) => {
+            this.consumerLag.set({ consumer_group: consumerGroup }, lag);
+        });
+    }
+    /**
+     * @param app This needs to be an instance of express or fastify something that supports the express api
+     */
+    setupEndpoint(app, endPoint = '/metrics') {
+        app.get(endPoint, async (_, res) => {
+            await this.updateMetrics();
+            res.set('Content-Type', this.registry.contentType);
+            res.send(await this.registry.metrics());
+        });
+    }
+}
+exports.PrometheusAdapter = PrometheusAdapter;

package/src/lib/monitoring/collector.d.ts

@@ -0,0 +1,22 @@
+import { DeadLetterQueue } from '../redis/dlq';
+import { IAggregatedMetrics, IMetricsCollectorConfig, IPerformanceMetrics } from './types';
+export declare class MetricsCollector {
+    private redisClient;
+    private collectionInterval;
+    private retentionPeriod;
+    private dlq;
+    private metrics;
+    private metricsKey;
+    constructor(config: IMetricsCollectorConfig, dlq: DeadLetterQueue);
+    addMetrics(metrics: IPerformanceMetrics): void;
+    private aggregateAndStoreMetrics;
+    private aggregateMessageRates;
+    private aggregateHistogram;
+    private aggregateRedisCommandLatencies;
+    private aggregateConsumerLag;
+    private calculateAverages;
+    private getQueueDepth;
+    private storeMetrics;
+    getMetrics(startTime: number, endTime: number): Promise<IAggregatedMetrics[]>;
+    getLatestMetrics(): Promise<IAggregatedMetrics | null>;
+}

package/src/lib/monitoring/collector.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+class MetricsCollector {
+    constructor(config, dlq) {
+        this.metrics = [];
+        this.metricsKey = 'publisher:metrics';
+        this.redisClient = config.redisClient;
+        this.collectionInterval = config.collectionInterval;
+        this.retentionPeriod = config.retentionPeriod;
+        this.dlq = dlq;
+        setInterval(() => this.aggregateAndStoreMetrics(), this.collectionInterval);
+    }
+    addMetrics(metrics) {
+        this.metrics.push(metrics);
+    }
+    async aggregateAndStoreMetrics() {
+        if (this.metrics.length === 0)
+            return;
+        const queueDepths = await this.getQueueDepth();
+        const aggregated = {
+            timestamp: Date.now(),
+            totalTime: 0,
+            redisOperationTime: 0,
+            processingTime: 0,
+            eventCount: 0,
+            subscribeErrorCount: 0,
+            publishErrorCount: 0,
+            queueDepth: queueDepths.total,
+            individualQueueDepts: queueDepths.individual,
+            dlqSize: 0,
+            dlqRate: 0,
+            operationCount: this.metrics.length,
+            duplicateEventsCount: 0,
+            messageRatePublish: {},
+            messageRateSubscribe: {},
+            processingTimeDistribution: {},
+            redisCommandLatencies: {},
+            consumerLag: {},
+        };
+        for (const metric of this.metrics) {
+            aggregated.totalTime += metric.totalTime;
+            aggregated.redisOperationTime += metric.redisOperationTime;
+            aggregated.processingTime += metric.processingTime;
+            aggregated.eventCount += metric.eventCount;
+            aggregated.publishErrorCount += metric.publishErrorCount;
+            aggregated.subscribeErrorCount += metric.subscribeErrorCount;
+            aggregated.duplicateEventsCount += metric.duplicateEventsCount;
+            this.aggregateMessageRates(aggregated.messageRatePublish, metric.messageRatePublish);
+            this.aggregateMessageRates(aggregated.messageRateSubscribe, metric.messageRateSubscribe);
+            this.aggregateHistogram(aggregated.processingTimeDistribution, metric.processingTimeDistribution);
+            this.aggregateRedisCommandLatencies(aggregated.redisCommandLatencies, metric.redisCommandLatencies);
+            this.aggregateConsumerLag(aggregated.consumerLag, metric.consumerLag);
+        }
+        // Calculate averages for time-based metrics
+        aggregated.totalTime /= aggregated.operationCount;
+        aggregated.redisOperationTime /= aggregated.operationCount;
+        aggregated.processingTime /= aggregated.operationCount;
+        const dlqStats = await this.dlq.getDLQStats();
+        aggregated.dlqSize = dlqStats.size;
+        aggregated.dlqRate = dlqStats.additionRate;
+        this.calculateAverages(aggregated.redisCommandLatencies);
+        this.calculateAverages(aggregated.consumerLag);
+        await this.storeMetrics(aggregated);
+        this.metrics = [];
+    }
+    aggregateMessageRates(target, source) {
+        for (const [eventType, count] of Object.entries(source)) {
+            if (!target[eventType])
+                target[eventType] = 0;
+            target[eventType] += count;
+        }
+    }
+    aggregateHistogram(target, source) {
+        for (const [bucket, count] of Object.entries(source)) {
+            if (!target[bucket])
+                target[bucket] = 0;
+            target[bucket] += count;
+        }
+    }
+    aggregateRedisCommandLatencies(target, source) {
+        for (const [command, { total, count }] of Object.entries(source)) {
+            if (!target[command]) {
+                target[command] = { total: 0, count: 0 };
+            }
+            target[command].total += total;
+            target[command].count += count;
+        }
+    }
+    aggregateConsumerLag(target, source) {
+        for (const [consumerGroup, { total, count }] of Object.entries(source)) {
+            if (!target[consumerGroup]) {
+                target[consumerGroup] = { total: 0, count: 0 };
+            }
+            target[consumerGroup].total += total;
+            target[consumerGroup].count += count;
+        }
+    }
+    calculateAverages(data) {
+        for (const key in data) {
+            if (data[key].count > 0) {
+                data[key].total = data[key].total / data[key].count;
+            }
+            else {
+                data[key].total = 0;
+            }
+        }
+    }
+    async getQueueDepth() {
+        let totalDepth = 0;
+        const individualDepths = {};
+        let cursor = '0';
+        do {
+            const [nextCursor, keys] = await this.redisClient.scan(cursor, 'MATCH', `ack:*:cg-*`, 'COUNT', 100);
+            cursor = nextCursor;
+            if (keys.length > 0) {
+                const pipeline = this.redisClient.pipeline();
+                keys.forEach((key) => {
+                    pipeline.xlen(key.slice(4));
+                    pipeline.zcard(key);
+                });
+                const results = await pipeline.exec();
+                if (!results) {
+                    continue;
+                }
+                for (let i = 0; i < results.length; i += 2) {
+                    const key = keys[i / 2];
+                    const [streamLengthErr, streamLength] = results[i];
+                    const [ackCountErr, ackCount] = results[i + 1];
+                    if (streamLengthErr) {
+                        console.error(`Error getting length for key: ${streamLengthErr}`);
+                        continue;
+                    }
+                    if (ackCountErr) {
+                        console.error(`Error getting ack count for key: ${ackCountErr}`);
+                        continue;
+                    }
+                    const queueDepth = Math.max(0, streamLength - ackCount);
+                    totalDepth += queueDepth;
+                    individualDepths[key] = queueDepth;
+                }
+            }
+        } while (cursor !== '0');
+        return { total: totalDepth, individual: individualDepths };
+    }
+    async storeMetrics(metrics) {
+        const score = metrics.timestamp;
+        const member = JSON.stringify(metrics);
+        await this.redisClient.zadd(this.metricsKey, score, member);
+        // Remove old metrics based on retention period
+        const cutoffTime = Date.now() - this.retentionPeriod;
+        await this.redisClient.zremrangebyscore(this.metricsKey, 0, cutoffTime);
+    }
+    async getMetrics(startTime, endTime) {
+        const metricsData = await this.redisClient.zrangebyscore(this.metricsKey, startTime, endTime);
+        return metricsData.map((data) => JSON.parse(data));
+    }
+    async getLatestMetrics() {
+        const latestMetrics = await this.redisClient.zrevrange(this.metricsKey, 0, 0);
+        return latestMetrics.length > 0 ? JSON.parse(latestMetrics[0]) : null;
+    }
+}
+exports.MetricsCollector = MetricsCollector;

package/src/lib/monitoring/tracker.d.ts

@@ -0,0 +1,20 @@
+import { IPerformanceMetrics } from './types';
+export declare class MetricsTracker {
+    private startTime;
+    private metrics;
+    constructor();
+    startRedisOperation(): void;
+    endRedisOperation(): void;
+    startProcessing(): void;
+    endProcessing(): void;
+    incrementEventCount(): void;
+    incrementDuplicateEvent(): void;
+    incrementErrorCount(type: 'publish' | 'subscribe'): void;
+    getMetrics(): IPerformanceMetrics;
+    incrementMessageRate(type: 'publish' | 'subscribe', eventType: string): void;
+    addProcessingTime(time: number): void;
+    private getBucket;
+    addRedisCommandLatency(command: string, time: number): void;
+    setConsumerLag(consumerGroup: string, lag: number): void;
+    reset(): void;
+}

package/src/lib/monitoring/tracker.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsTracker = void 0;
+const node_process_1 = require("node:process");
+class MetricsTracker {
+    constructor() {
+        this.metrics = {
+            totalTime: 0,
+            redisOperationTime: 0,
+            processingTime: 0,
+            eventCount: 0,
+            publishErrorCount: 0,
+            subscribeErrorCount: 0,
+            duplicateEventsCount: 0,
+            messageRatePublish: {},
+            messageRateSubscribe: {},
+            processingTimeDistribution: {},
+            redisCommandLatencies: {},
+            consumerLag: {},
+        };
+        this.startTime = (0, node_process_1.hrtime)();
+    }
+    startRedisOperation() {
+        this.startTime = (0, node_process_1.hrtime)();
+    }
+    endRedisOperation() {
+        const [seconds, nanoseconds] = (0, node_process_1.hrtime)(this.startTime);
+        this.metrics.redisOperationTime += seconds * 1000 + nanoseconds / 1e6;
+    }
+    startProcessing() {
+        this.startTime = (0, node_process_1.hrtime)();
+    }
+    endProcessing() {
+        const [seconds, nanoseconds] = (0, node_process_1.hrtime)(this.startTime);
+        this.metrics.processingTime += seconds * 1000 + nanoseconds / 1e6;
+    }
+    incrementEventCount() {
+        this.metrics.eventCount++;
+    }
+    incrementDuplicateEvent() {
+        this.metrics.duplicateEventsCount++;
+    }
+    incrementErrorCount(type) {
+        this.metrics[`${type}ErrorCount`]++;
+    }
+    getMetrics() {
+        const [totalSeconds, totalNanoseconds] = (0, node_process_1.hrtime)(this.startTime);
+        this.metrics.totalTime = totalSeconds * 1000 + totalNanoseconds / 1e6;
+        return { ...this.metrics };
+    }
+    incrementMessageRate(type, eventType) {
+        const key = `messageRate${type.charAt(0).toUpperCase() + type.slice(1)}`;
+        if (!this.metrics[key][eventType]) {
+            this.metrics[key][eventType] = 0;
+        }
+        this.metrics[key][eventType]++;
+    }
+    addProcessingTime(time) {
+        const bucket = this.getBucket(time);
+        if (!this.metrics.processingTimeDistribution[bucket]) {
+            this.metrics.processingTimeDistribution[bucket] = 0;
+        }
+        this.metrics.processingTimeDistribution[bucket]++;
+    }
+    getBucket(time) {
+        const buckets = [0, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
+        for (let i = 0; i < buckets.length; i++) {
+            if (time <= buckets[i]) {
+                return i === 0 ? `0-${buckets[i]}` : `${buckets[i - 1] + 1}-${buckets[i]}`;
+            }
+        }
+        return `>${buckets[buckets.length - 1]}`;
+    }
+    addRedisCommandLatency(command, time) {
+        if (!this.metrics.redisCommandLatencies[command]) {
+            this.metrics.redisCommandLatencies[command] = { total: 0, count: 0 };
+        }
+        this.metrics.redisCommandLatencies[command].total += time;
+        this.metrics.redisCommandLatencies[command].count++;
+    }
+    setConsumerLag(consumerGroup, lag) {
+        if (!this.metrics.consumerLag[consumerGroup]) {
+            this.metrics.consumerLag[consumerGroup] = { total: 0, count: 0 };
+        }
+        this.metrics.consumerLag[consumerGroup].total += lag;
+        this.metrics.consumerLag[consumerGroup].count++;
+    }
+    reset() {
+        this.startTime = (0, node_process_1.hrtime)();
+        this.metrics = {
+            totalTime: 0,
+            redisOperationTime: 0,
+            processingTime: 0,
+            eventCount: 0,
+            publishErrorCount: 0,
+            subscribeErrorCount: 0,
+            duplicateEventsCount: 0,
+            messageRatePublish: {},
+            messageRateSubscribe: {},
+            processingTimeDistribution: {},
+            redisCommandLatencies: {},
+            consumerLag: {},
+        };
+    }
+}
+exports.MetricsTracker = MetricsTracker;

package/src/lib/monitoring/types.d.ts

@@ -0,0 +1,58 @@
+import { RedisType } from '../redis/registry';
+export interface IAggregatedMetrics extends IPerformanceMetrics {
+    timestamp: number;
+    queueDepth: number;
+    dlqSize: number;
+    dlqRate: number;
+    operationCount: number;
+    totalTime: number;
+    redisOperationTime: number;
+    processingTime: number;
+    eventCount: number;
+    publishErrorCount: number;
+    subscribeErrorCount: number;
+    individualQueueDepts: IQueueDepths['individual'];
+    duplicateEventsCount: number;
+}
+export interface IMetricsCollectorConfig {
+    redisClient: RedisType;
+    collectionInterval: number;
+    retentionPeriod: number;
+}
+export type TQueryableMetrics = Omit<IAggregatedMetrics, 'timestamp' | 'individualQueueDepts' | 'messageRatePublish' | 'messageRateSubscribe' | 'processingTimeDistribution' | 'redisCommandLatencies' | 'consumerLag'>;
+export interface IQueueDepths {
+    total: number;
+    individual: {
+        [key: string]: number;
+    };
+}
+export interface IPerformanceMetrics {
+    totalTime: number;
+    redisOperationTime: number;
+    processingTime: number;
+    eventCount: number;
+    publishErrorCount: number;
+    subscribeErrorCount: number;
+    duplicateEventsCount: number;
+    messageRatePublish: {
+        [eventType: string]: number;
+    };
+    messageRateSubscribe: {
+        [eventType: string]: number;
+    };
+    processingTimeDistribution: {
+        [bucket: string]: number;
+    };
+    redisCommandLatencies: {
+        [command: string]: {
+            total: number;
+            count: number;
+        };
+    };
+    consumerLag: {
+        [consumerGroup: string]: {
+            total: number;
+            count: number;
+        };
+    };
+}

package/src/lib/monitoring/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/performance/circuit_breaker.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { RedisType } from '../redis/registry';
+import { EventData, IStreamsConfig } from '../redis/types';
+export declare enum CircuitState {
+    CLOSED = 0,
+    OPEN = 1,
+    HALF_OPEN = 2
+}
+export declare class CircuitBreaker extends EventEmitter {
+    private readonly config;
+    private state;
+    private failureCount;
+    private successCount;
+    private lastStateChange;
+    private readonly redisClient;
+    constructor(config: IStreamsConfig['circuitBreaker'], redisClient: RedisType);
+    recordSuccess(): Promise<void>;
+    recordFailure(): Promise<void>;
+    isAllowed(): Promise<boolean>;
+    private openCircuit;
+    private closeCircuit;
+    private halfOpenCircuit;
+    getState(): CircuitState;
+    storeEvent(event: EventData<unknown, string>): Promise<void>;
+    getStoredEvents(): Promise<EventData<unknown, string>[]>;
+    clearStoredEvents(): Promise<void>;
+    private startStateCheck;
+}

package/src/lib/performance/circuit_breaker.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = exports.CircuitState = void 0;
+const events_1 = require("events");
+var CircuitState;
+(function (CircuitState) {
+    CircuitState[CircuitState["CLOSED"] = 0] = "CLOSED";
+    CircuitState[CircuitState["OPEN"] = 1] = "OPEN";
+    CircuitState[CircuitState["HALF_OPEN"] = 2] = "HALF_OPEN";
+})(CircuitState || (exports.CircuitState = CircuitState = {}));
+class CircuitBreaker extends events_1.EventEmitter {
+    constructor(config, redisClient) {
+        super();
+        this.config = config;
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastStateChange = Date.now();
+        this.redisClient = redisClient;
+        this.startStateCheck();
+    }
+    async recordSuccess() {
+        this.successCount++;
+        if (this.state === CircuitState.HALF_OPEN) {
+            if (this.successCount >= this.config.halfOpenStateMaxAttempts) {
+                await this.closeCircuit();
+            }
+        }
+    }
+    async recordFailure() {
+        this.failureCount++;
+        if (this.state === CircuitState.CLOSED) {
+            const totalAttempts = this.failureCount + this.successCount;
+            const failureRate = (this.failureCount / totalAttempts) * 100;
+            if (this.failureCount >= this.config.errorThreshold || failureRate >= this.config.errorThresholdPercentage) {
+                await this.openCircuit();
+            }
+        }
+        else if (this.state === CircuitState.HALF_OPEN) {
+            await this.openCircuit();
+        }
+    }
+    async isAllowed() {
+        const now = Date.now();
+        if (this.state === CircuitState.OPEN) {
+            if (now - this.lastStateChange >= this.config.openStateDuration) {
+                await this.halfOpenCircuit();
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+    openCircuit() {
+        if (this.state !== CircuitState.OPEN) {
+            this.state = CircuitState.OPEN;
+            this.lastStateChange = Date.now();
+            this.emit('stateChange', CircuitState.OPEN);
+        }
+    }
+    closeCircuit() {
+        if (this.state !== CircuitState.CLOSED) {
+            this.state = CircuitState.CLOSED;
+            this.lastStateChange = Date.now();
+            this.failureCount = 0;
+            this.successCount = 0;
+            this.emit('stateChange', CircuitState.CLOSED);
+        }
+    }
+    halfOpenCircuit() {
+        if (this.state !== CircuitState.HALF_OPEN) {
+            this.state = CircuitState.HALF_OPEN;
+            this.lastStateChange = Date.now();
+            this.failureCount = 0;
+            this.successCount = 0;
+            this.emit('stateChange', CircuitState.HALF_OPEN);
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    async storeEvent(event) {
+        const key = `circuit_breaker:stored_events`;
+        await this.redisClient.lpush(key, JSON.stringify(event));
+        await this.redisClient.ltrim(key, 0, this.config.maxStoredEvents - 1);
+    }
+    async getStoredEvents() {
+        const key = `circuit_breaker:stored_events`;
+        const events = await this.redisClient.lrange(key, 0, -1);
+        return events.map((event) => JSON.parse(event));
+    }
+    async clearStoredEvents() {
+        const key = `circuit_breaker:stored_events`;
+        await this.redisClient.del(key);
+    }
+    startStateCheck() {
+        setInterval(() => {
+            this.isAllowed();
+        }, 2000);
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;