@takentrade/takentrade-libs 2.0.8 → 3.0.0

package/dist/metrics/metrics.interface.d.ts

@@ -0,0 +1,106 @@
+import { Counter, Gauge, Histogram, Summary, CounterConfiguration, GaugeConfiguration, HistogramConfiguration, SummaryConfiguration } from 'prom-client';
+/**
+ * Metric types supported by the metrics service
+ */
+export declare enum MetricType {
+    COUNTER = "counter",
+    GAUGE = "gauge",
+    HISTOGRAM = "histogram",
+    SUMMARY = "summary"
+}
+/**
+ * Configuration options for the metrics module
+ */
+export interface MetricsModuleOptions {
+    /**
+     * Enable default metrics collection (CPU, memory, etc.)
+     * @default true
+     */
+    defaultMetrics?: boolean;
+    /**
+     * Prefix for all metric names
+     * @default ''
+     */
+    prefix?: string;
+    /**
+     * Default labels to add to all metrics
+     * @default {}
+     */
+    defaultLabels?: Record<string, string>;
+    /**
+     * Interval for collecting default metrics (in milliseconds)
+     * @default 10000
+     */
+    defaultMetricsInterval?: number;
+    /**
+     * Enable circuit breaker metrics integration
+     * @default true
+     */
+    circuitBreakerMetrics?: boolean;
+}
+/**
+ * Counter metric configuration
+ */
+export interface CounterConfig extends Omit<CounterConfiguration<string>, 'registers'> {
+    name: string;
+    help: string;
+    labelNames?: string[];
+}
+/**
+ * Gauge metric configuration
+ */
+export interface GaugeConfig extends Omit<GaugeConfiguration<string>, 'registers'> {
+    name: string;
+    help: string;
+    labelNames?: string[];
+}
+/**
+ * Histogram metric configuration
+ */
+export interface HistogramConfig extends Omit<HistogramConfiguration<string>, 'registers'> {
+    name: string;
+    help: string;
+    labelNames?: string[];
+    buckets?: number[];
+}
+/**
+ * Summary metric configuration
+ */
+export interface SummaryConfig extends Omit<SummaryConfiguration<string>, 'registers'> {
+    name: string;
+    help: string;
+    labelNames?: string[];
+    percentiles?: number[];
+}
+/**
+ * Metric instance types
+ */
+export type MetricInstance = Counter<string> | Gauge<string> | Histogram<string> | Summary<string>;
+/**
+ * Metric registry entry
+ */
+export interface MetricEntry {
+    type: MetricType;
+    metric: MetricInstance;
+    config: CounterConfig | GaugeConfig | HistogramConfig | SummaryConfig;
+}
+/**
+ * Circuit breaker metric names
+ */
+export declare const CIRCUIT_BREAKER_METRICS: {
+    readonly STATE: "circuit_breaker_state";
+    readonly CALLS_TOTAL: "circuit_breaker_calls_total";
+    readonly LATENCY_SECONDS: "circuit_breaker_latency_seconds";
+    readonly FAILURES_TOTAL: "circuit_breaker_failures_total";
+    readonly SUCCESSES_TOTAL: "circuit_breaker_successes_total";
+    readonly REJECTS_TOTAL: "circuit_breaker_rejects_total";
+    readonly TIMEOUTS_TOTAL: "circuit_breaker_timeouts_total";
+};
+/**
+ * Default histogram buckets for latency metrics (in seconds)
+ */
+export declare const DEFAULT_LATENCY_BUCKETS: number[];
+/**
+ * Default summary percentiles
+ */
+export declare const DEFAULT_PERCENTILES: number[];

package/dist/metrics/metrics.interface.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PERCENTILES = exports.DEFAULT_LATENCY_BUCKETS = exports.CIRCUIT_BREAKER_METRICS = exports.MetricType = void 0;
+/**
+ * Metric types supported by the metrics service
+ */
+var MetricType;
+(function (MetricType) {
+    MetricType["COUNTER"] = "counter";
+    MetricType["GAUGE"] = "gauge";
+    MetricType["HISTOGRAM"] = "histogram";
+    MetricType["SUMMARY"] = "summary";
+})(MetricType || (exports.MetricType = MetricType = {}));
+/**
+ * Circuit breaker metric names
+ */
+exports.CIRCUIT_BREAKER_METRICS = {
+    STATE: 'circuit_breaker_state',
+    CALLS_TOTAL: 'circuit_breaker_calls_total',
+    LATENCY_SECONDS: 'circuit_breaker_latency_seconds',
+    FAILURES_TOTAL: 'circuit_breaker_failures_total',
+    SUCCESSES_TOTAL: 'circuit_breaker_successes_total',
+    REJECTS_TOTAL: 'circuit_breaker_rejects_total',
+    TIMEOUTS_TOTAL: 'circuit_breaker_timeouts_total',
+};
+/**
+ * Default histogram buckets for latency metrics (in seconds)
+ */
+exports.DEFAULT_LATENCY_BUCKETS = [
+    0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10,
+];
+/**
+ * Default summary percentiles
+ */
+exports.DEFAULT_PERCENTILES = [0.5, 0.9, 0.95, 0.99];

package/dist/metrics/metrics.module.d.ts

@@ -0,0 +1,11 @@
+import { DynamicModule } from '@nestjs/common';
+import { MetricsModuleOptions } from './metrics.interface';
+export declare class MetricsModule {
+    /**
+     * Register the metrics module with options
+     *
+     * @param options - Module configuration options
+     * @returns Dynamic module
+     */
+    static register(options?: MetricsModuleOptions): DynamicModule;
+}

package/dist/metrics/metrics.module.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MetricsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsModule = void 0;
+const common_1 = require("@nestjs/common");
+const metrics_service_1 = require("./metrics.service");
+const metrics_controller_1 = require("./metrics.controller");
+let MetricsModule = MetricsModule_1 = class MetricsModule {
+    /**
+     * Register the metrics module with options
+     *
+     * @param options - Module configuration options
+     * @returns Dynamic module
+     */
+    static register(options = {}) {
+        return {
+            module: MetricsModule_1,
+            providers: [
+                {
+                    provide: metrics_service_1.MetricsService,
+                    useValue: new metrics_service_1.MetricsService(options),
+                },
+            ],
+            controllers: [metrics_controller_1.MetricsController],
+            exports: [metrics_service_1.MetricsService],
+        };
+    }
+};
+exports.MetricsModule = MetricsModule;
+exports.MetricsModule = MetricsModule = MetricsModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], MetricsModule);

package/dist/metrics/metrics.service.d.ts

@@ -0,0 +1,50 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { Registry } from 'prom-client';
+import { CounterConfig, GaugeConfig, HistogramConfig, SummaryConfig, MetricsModuleOptions } from './metrics.interface';
+/**
+ * Prometheus Metrics Service
+ *
+ * Provides comprehensive metrics collection and exposure for monitoring
+ * and observability using Prometheus.
+ *
+ * @example
+ * ```typescript
+ * // Register a counter
+ * this.metricsService.registerCounter({
+ *   name: 'api_requests_total',
+ *   help: 'Total API requests',
+ *   labelNames: ['method', 'endpoint'],
+ * });
+ *
+ * // Increment counter
+ * this.metricsService.incrementCounter('api_requests_total', { method: 'GET', endpoint: '/users' });
+ * ```
+ */
+export declare class MetricsService implements OnModuleDestroy {
+    private readonly logger;
+    private readonly registry;
+    private readonly metricsRegistry;
+    private readonly metricsUpdater;
+    private defaultMetricsInterval?;
+    private options;
+    constructor(options?: MetricsModuleOptions);
+    registerCounter(config: CounterConfig): import("prom-client").Counter<string>;
+    registerGauge(config: GaugeConfig): import("prom-client").Gauge<string>;
+    registerHistogram(config: HistogramConfig): import("prom-client").Histogram<string>;
+    registerSummary(config: SummaryConfig): import("prom-client").Summary<string>;
+    incrementCounter(name: string, labels?: Record<string, string | number>, value?: number): void;
+    setGauge(name: string, value: number, labels?: Record<string, string | number>): void;
+    incrementGauge(name: string, labels?: Record<string, string | number>, value?: number): void;
+    decrementGauge(name: string, labels?: Record<string, string | number>, value?: number): void;
+    observeHistogram(name: string, value: number, labels?: Record<string, string | number>): void;
+    observeSummary(name: string, value: number, labels?: Record<string, string | number>): void;
+    getMetric(name: string): import("./metrics.interface").MetricEntry | undefined;
+    getMetrics(): Promise<string>;
+    getContentType(): string;
+    getRegistry(): Registry;
+    getMetricNames(): string[];
+    hasMetric(name: string): boolean;
+    resetMetrics(): void;
+    clearMetrics(): void;
+    onModuleDestroy(): Promise<void>;
+}

package/dist/metrics/metrics.service.js

@@ -0,0 +1,165 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MetricsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsService = void 0;
+const common_1 = require("@nestjs/common");
+const prom_client_1 = require("prom-client");
+const metrics_registry_1 = require("./metrics-registry");
+const metrics_updater_1 = require("./metrics-updater");
+/**
+ * Prometheus Metrics Service
+ *
+ * Provides comprehensive metrics collection and exposure for monitoring
+ * and observability using Prometheus.
+ *
+ * @example
+ * ```typescript
+ * // Register a counter
+ * this.metricsService.registerCounter({
+ *   name: 'api_requests_total',
+ *   help: 'Total API requests',
+ *   labelNames: ['method', 'endpoint'],
+ * });
+ *
+ * // Increment counter
+ * this.metricsService.incrementCounter('api_requests_total', { method: 'GET', endpoint: '/users' });
+ * ```
+ */
+let MetricsService = MetricsService_1 = class MetricsService {
+    logger = new common_1.Logger(MetricsService_1.name);
+    registry;
+    metricsRegistry;
+    metricsUpdater;
+    defaultMetricsInterval;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            defaultMetrics: true,
+            prefix: '',
+            defaultLabels: {},
+            defaultMetricsInterval: 10000,
+            circuitBreakerMetrics: true,
+            ...options,
+        };
+        this.registry = new prom_client_1.Registry();
+        this.metricsRegistry = new metrics_registry_1.MetricsRegistry(this.registry, this.options.prefix);
+        this.metricsUpdater = new metrics_updater_1.MetricsUpdater();
+        // Set default labels
+        if (this.options.defaultLabels) {
+            this.registry.setDefaultLabels(this.options.defaultLabels);
+        }
+        // Collect default metrics
+        if (this.options.defaultMetrics) {
+            this.defaultMetricsInterval = (0, prom_client_1.collectDefaultMetrics)({
+                register: this.registry,
+                prefix: this.options.prefix,
+            });
+            this.logger.log('Default metrics collection enabled');
+        }
+        this.logger.log('Metrics service initialized');
+    }
+    // ==================== Registration Methods ====================
+    registerCounter(config) {
+        return this.metricsRegistry.registerCounter(config);
+    }
+    registerGauge(config) {
+        return this.metricsRegistry.registerGauge(config);
+    }
+    registerHistogram(config) {
+        return this.metricsRegistry.registerHistogram(config);
+    }
+    registerSummary(config) {
+        return this.metricsRegistry.registerSummary(config);
+    }
+    // ==================== Update Methods ====================
+    incrementCounter(name, labels, value = 1) {
+        const entry = this.metricsRegistry.getMetric(name);
+        if (!entry) {
+            throw new Error(`Counter '${name}' not found`);
+        }
+        this.metricsUpdater.incrementCounter(entry, labels, value);
+    }
+    setGauge(name, value, labels) {
+        const entry = this.metricsRegistry.getMetric(name);
+        if (!entry) {
+            throw new Error(`Gauge '${name}' not found`);
+        }
+        this.metricsUpdater.setGauge(entry, value, labels);
+    }
+    incrementGauge(name, labels, value = 1) {
+        const entry = this.metricsRegistry.getMetric(name);
+        if (!entry) {
+            throw new Error(`Gauge '${name}' not found`);
+        }
+        this.metricsUpdater.incrementGauge(entry, labels, value);
+    }
+    decrementGauge(name, labels, value = 1) {
+        const entry = this.metricsRegistry.getMetric(name);
+        if (!entry) {
+            throw new Error(`Gauge '${name}' not found`);
+        }
+        this.metricsUpdater.decrementGauge(entry, labels, value);
+    }
+    observeHistogram(name, value, labels) {
+        const entry = this.metricsRegistry.getMetric(name);
+        if (!entry) {
+            throw new Error(`Histogram '${name}' not found`);
+        }
+        this.metricsUpdater.observeHistogram(entry, value, labels);
+    }
+    observeSummary(name, value, labels) {
+        const entry = this.metricsRegistry.getMetric(name);
+        if (!entry) {
+            throw new Error(`Summary '${name}' not found`);
+        }
+        this.metricsUpdater.observeSummary(entry, value, labels);
+    }
+    // ==================== Query Methods ====================
+    getMetric(name) {
+        return this.metricsRegistry.getMetric(name);
+    }
+    async getMetrics() {
+        return this.registry.metrics();
+    }
+    getContentType() {
+        return this.registry.contentType;
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    getMetricNames() {
+        return this.metricsRegistry.getMetricNames();
+    }
+    hasMetric(name) {
+        return this.metricsRegistry.hasMetric(name);
+    }
+    // ==================== Management Methods ====================
+    resetMetrics() {
+        this.registry.resetMetrics();
+        this.logger.log('All metrics reset');
+    }
+    clearMetrics() {
+        this.registry.clear();
+        this.metricsRegistry.clear();
+        this.logger.log('All metrics cleared');
+    }
+    // ==================== Lifecycle ====================
+    async onModuleDestroy() {
+        this.logger.log('Shutting down metrics service...');
+        if (this.defaultMetricsInterval) {
+            clearInterval(this.defaultMetricsInterval);
+        }
+        this.clearMetrics();
+        this.logger.log('Metrics service shut down');
+    }
+};
+exports.MetricsService = MetricsService;
+exports.MetricsService = MetricsService = MetricsService_1 = __decorate([
+    (0, common_1.Injectable)()
+], MetricsService);

package/dist/resilience/circuit-breaker-event-handler.d.ts

@@ -0,0 +1,16 @@
+import CircuitBreaker from 'opossum';
+/**
+ * Circuit Breaker Event Handler
+ *
+ * Handles all circuit breaker events and provides logging
+ */
+export declare class CircuitBreakerEventHandler {
+    private readonly logger;
+    /**
+     * Set up event listeners for a circuit breaker
+     *
+     * @param breaker - Circuit breaker instance
+     * @param name - Circuit breaker name
+     */
+    setupEventListeners(breaker: CircuitBreaker, name: string): void;
+}

package/dist/resilience/circuit-breaker-event-handler.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerEventHandler = void 0;
+const common_1 = require("@nestjs/common");
+const circuit_breaker_interface_1 = require("./circuit-breaker.interface");
+/**
+ * Circuit Breaker Event Handler
+ *
+ * Handles all circuit breaker events and provides logging
+ */
+class CircuitBreakerEventHandler {
+    logger = new common_1.Logger(CircuitBreakerEventHandler.name);
+    /**
+     * Set up event listeners for a circuit breaker
+     *
+     * @param breaker - Circuit breaker instance
+     * @param name - Circuit breaker name
+     */
+    setupEventListeners(breaker, name) {
+        // Success event
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.SUCCESS, (result, latency) => {
+            this.logger.debug(`[${name}] Success - Latency: ${latency}ms`);
+        });
+        // Failure event
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.FAILURE, (error) => {
+            this.logger.warn(`[${name}] Failure - Error: ${error.message}`);
+        });
+        // Timeout event
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.TIMEOUT, () => {
+            this.logger.warn(`[${name}] Timeout - Request exceeded timeout threshold`);
+        });
+        // Reject event (circuit is open)
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.REJECT, () => {
+            this.logger.warn(`[${name}] Reject - Circuit is open, request rejected`);
+        });
+        // Circuit opened
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.OPEN, () => {
+            this.logger.error(`[${name}] Circuit OPENED - Too many failures detected`);
+        });
+        // Circuit closed
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.CLOSE, () => {
+            this.logger.log(`[${name}] Circuit CLOSED - Service recovered`);
+        });
+        // Circuit half-open
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.HALF_OPEN, () => {
+            this.logger.log(`[${name}] Circuit HALF-OPEN - Testing service recovery`);
+        });
+        // Fallback executed
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.FALLBACK, (result) => {
+            this.logger.debug(`[${name}] Fallback executed`);
+        });
+        // Semaphore locked (too many concurrent requests)
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.SEMAPHORE_LOCKED, () => {
+            this.logger.warn(`[${name}] Semaphore locked - Too many concurrent requests`);
+        });
+        // Health check failed
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.HEALTH_CHECK_FAILED, () => {
+            this.logger.warn(`[${name}] Health check failed`);
+        });
+        // Cache hit
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.CACHE_HIT, () => {
+            this.logger.debug(`[${name}] Cache hit`);
+        });
+        // Cache miss
+        breaker.on(circuit_breaker_interface_1.CircuitBreakerEvent.CACHE_MISS, () => {
+            this.logger.debug(`[${name}] Cache miss`);
+        });
+    }
+}
+exports.CircuitBreakerEventHandler = CircuitBreakerEventHandler;

package/dist/resilience/circuit-breaker-factory.d.ts

@@ -0,0 +1,19 @@
+import { CircuitBreakerOptions, CircuitBreakerInstance } from './circuit-breaker.interface';
+/**
+ * Circuit Breaker Factory
+ *
+ * Responsible for creating and configuring circuit breaker instances
+ */
+export declare class CircuitBreakerFactory {
+    private readonly logger;
+    private readonly eventHandler;
+    /**
+     * Create a new circuit breaker instance
+     *
+     * @param name - Unique identifier for the circuit breaker
+     * @param action - The async function to be protected
+     * @param options - Circuit breaker configuration options
+     * @returns Circuit breaker instance
+     */
+    create<T = any, R = any>(name: string, action: (...args: T[]) => Promise<R>, options?: CircuitBreakerOptions): CircuitBreakerInstance<T, R>;
+}

package/dist/resilience/circuit-breaker-factory.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerFactory = void 0;
+const common_1 = require("@nestjs/common");
+const opossum_1 = __importDefault(require("opossum"));
+const circuit_breaker_event_handler_1 = require("./circuit-breaker-event-handler");
+/**
+ * Circuit Breaker Factory
+ *
+ * Responsible for creating and configuring circuit breaker instances
+ */
+class CircuitBreakerFactory {
+    logger = new common_1.Logger(CircuitBreakerFactory.name);
+    eventHandler = new circuit_breaker_event_handler_1.CircuitBreakerEventHandler();
+    /**
+     * Create a new circuit breaker instance
+     *
+     * @param name - Unique identifier for the circuit breaker
+     * @param action - The async function to be protected
+     * @param options - Circuit breaker configuration options
+     * @returns Circuit breaker instance
+     */
+    create(name, action, options = {}) {
+        const defaultOptions = {
+            timeout: 10000, // 10 seconds
+            errorThresholdPercentage: 50, // 50% error rate
+            resetTimeout: 30000, // 30 seconds
+            rollingCountTimeout: 10000, // 10 seconds
+            rollingCountBuckets: 10,
+            capacity: 100,
+            enableSnapshots: true,
+            volumeThreshold: 5, // Minimum number of requests before circuit can open
+            name,
+            ...options,
+        };
+        const breaker = new opossum_1.default(action, defaultOptions);
+        // Set up event listeners for monitoring and logging
+        this.eventHandler.setupEventListeners(breaker, name);
+        const instance = {
+            breaker,
+            name,
+            options: defaultOptions,
+        };
+        this.logger.log(`Circuit breaker '${name}' created successfully`);
+        return instance;
+    }
+}
+exports.CircuitBreakerFactory = CircuitBreakerFactory;

package/dist/resilience/circuit-breaker-stats.service.d.ts

@@ -0,0 +1,37 @@
+import CircuitBreaker from 'opossum';
+import { CircuitBreakerStats, CircuitState, CircuitBreakerInstance } from './circuit-breaker.interface';
+/**
+ * Circuit Breaker Statistics Service
+ *
+ * Handles statistics and state management for circuit breakers
+ */
+export declare class CircuitBreakerStatsService {
+    /**
+     * Get statistics for a circuit breaker
+     *
+     * @param instance - Circuit breaker instance
+     * @returns Circuit breaker statistics
+     */
+    getStats(instance: CircuitBreakerInstance): CircuitBreakerStats;
+    /**
+     * Get all circuit breaker statistics
+     *
+     * @param breakers - Map of circuit breaker instances
+     * @returns Map of circuit breaker names to their statistics
+     */
+    getAllStats(breakers: Map<string, CircuitBreakerInstance>): Map<string, CircuitBreakerStats>;
+    /**
+     * Get the current state of a circuit breaker
+     *
+     * @param breaker - Circuit breaker instance
+     * @returns Current circuit state
+     */
+    getState(breaker: CircuitBreaker): CircuitState;
+    /**
+     * Check if a circuit breaker is open
+     *
+     * @param breaker - Circuit breaker instance
+     * @returns True if circuit is open
+     */
+    isOpen(breaker: CircuitBreaker): boolean;
+}

package/dist/resilience/circuit-breaker-stats.service.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerStatsService = void 0;
+const circuit_breaker_interface_1 = require("./circuit-breaker.interface");
+/**
+ * Circuit Breaker Statistics Service
+ *
+ * Handles statistics and state management for circuit breakers
+ */
+class CircuitBreakerStatsService {
+    /**
+     * Get statistics for a circuit breaker
+     *
+     * @param instance - Circuit breaker instance
+     * @returns Circuit breaker statistics
+     */
+    getStats(instance) {
+        const stats = instance.breaker.stats;
+        return {
+            fires: stats.fires,
+            failures: stats.failures,
+            successes: stats.successes,
+            rejects: stats.rejects,
+            timeouts: stats.timeouts,
+            cacheHits: stats.cacheHits,
+            cacheMisses: stats.cacheMisses,
+            semaphoreRejections: stats.semaphoreRejections,
+            percentiles: stats.percentiles,
+            latencyMean: stats.latencyMean,
+            latencyTimes: stats.latencyTimes,
+        };
+    }
+    /**
+     * Get all circuit breaker statistics
+     *
+     * @param breakers - Map of circuit breaker instances
+     * @returns Map of circuit breaker names to their statistics
+     */
+    getAllStats(breakers) {
+        const allStats = new Map();
+        for (const [name, instance] of breakers.entries()) {
+            allStats.set(name, this.getStats(instance));
+        }
+        return allStats;
+    }
+    /**
+     * Get the current state of a circuit breaker
+     *
+     * @param breaker - Circuit breaker instance
+     * @returns Current circuit state
+     */
+    getState(breaker) {
+        if (breaker.opened)
+            return circuit_breaker_interface_1.CircuitState.OPEN;
+        if (breaker.halfOpen)
+            return circuit_breaker_interface_1.CircuitState.HALF_OPEN;
+        return circuit_breaker_interface_1.CircuitState.CLOSED;
+    }
+    /**
+     * Check if a circuit breaker is open
+     *
+     * @param breaker - Circuit breaker instance
+     * @returns True if circuit is open
+     */
+    isOpen(breaker) {
+        return breaker.opened;
+    }
+}
+exports.CircuitBreakerStatsService = CircuitBreakerStatsService;