@takentrade/takentrade-libs 3.0.0 → 3.2.0

package/dist/monitoring/uptime.service.js

@@ -0,0 +1,213 @@
+"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 UptimeService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UptimeService = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Uptime Monitoring Service
+ *
+ * Tracks service availability and generates SLA reports
+ */
+let UptimeService = UptimeService_1 = class UptimeService {
+    logger = new common_1.Logger(UptimeService_1.name);
+    healthChecks = new Map();
+    healthResults = new Map();
+    downtimeTracking = new Map();
+    config;
+    checkIntervals = new Map();
+    constructor(config) {
+        this.config = config || { enabled: true, checkInterval: 60000 };
+    }
+    /**
+     * Register a health check
+     */
+    registerHealthCheck(check) {
+        this.healthChecks.set(check.name, check);
+        this.healthResults.set(check.name, []);
+        this.downtimeTracking.set(check.name, 0);
+        if (this.config.enabled) {
+            this.startHealthCheck(check);
+        }
+        this.logger.log(`Health check '${check.name}' registered`);
+    }
+    /**
+     * Start periodic health check
+     */
+    startHealthCheck(check) {
+        const interval = check.interval || this.config.checkInterval || 60000;
+        const timer = setInterval(async () => {
+            await this.runHealthCheck(check.name);
+        }, interval);
+        this.checkIntervals.set(check.name, timer);
+        // Run immediately
+        this.runHealthCheck(check.name);
+    }
+    /**
+     * Run a health check
+     */
+    async runHealthCheck(name) {
+        const check = this.healthChecks.get(name);
+        if (!check) {
+            throw new Error(`Health check '${name}' not found`);
+        }
+        const startTime = Date.now();
+        let result;
+        try {
+            const timeout = check.timeout || 5000;
+            await Promise.race([
+                check.check(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Health check timeout')), timeout)),
+            ]);
+            result = {
+                name,
+                status: 'healthy',
+                responseTime: Date.now() - startTime,
+                timestamp: new Date(),
+            };
+        }
+        catch (error) {
+            result = {
+                name,
+                status: 'unhealthy',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: new Date(),
+            };
+            // Track downtime
+            const currentDowntime = this.downtimeTracking.get(name) || 0;
+            this.downtimeTracking.set(name, currentDowntime + (check.interval || this.config.checkInterval || 60000));
+            this.logger.warn(`Health check '${name}' failed: ${result.error}`);
+        }
+        // Store result
+        const results = this.healthResults.get(name) || [];
+        results.push(result);
+        // Keep only last 1000 results
+        if (results.length > 1000) {
+            results.shift();
+        }
+        this.healthResults.set(name, results);
+        return result;
+    }
+    /**
+     * Get current health status
+     */
+    async getHealthStatus(name) {
+        if (name) {
+            const results = this.healthResults.get(name);
+            return results ? [results[results.length - 1]] : [];
+        }
+        // Get latest result for all checks
+        const allResults = [];
+        for (const [checkName, results] of this.healthResults.entries()) {
+            if (results.length > 0) {
+                allResults.push(results[results.length - 1]);
+            }
+        }
+        return allResults;
+    }
+    /**
+     * Get uptime percentage
+     */
+    getUptime(name, periodMs) {
+        const results = this.healthResults.get(name);
+        if (!results || results.length === 0) {
+            return 100;
+        }
+        const now = Date.now();
+        const period = periodMs || 24 * 60 * 60 * 1000; // 24 hours default
+        const startTime = now - period;
+        const relevantResults = results.filter((r) => r.timestamp.getTime() >= startTime);
+        if (relevantResults.length === 0) {
+            return 100;
+        }
+        const healthyCount = relevantResults.filter((r) => r.status === 'healthy').length;
+        return (healthyCount / relevantResults.length) * 100;
+    }
+    /**
+     * Get SLA report
+     */
+    getSLAReport(name, period = '30d') {
+        const periodMs = this.parsePeriod(period);
+        const now = new Date();
+        const startTime = new Date(now.getTime() - periodMs);
+        const results = this.healthResults.get(name) || [];
+        const relevantResults = results.filter((r) => r.timestamp.getTime() >= startTime.getTime());
+        const healthyCount = relevantResults.filter((r) => r.status === 'healthy').length;
+        const uptime = relevantResults.length > 0
+            ? (healthyCount / relevantResults.length) * 100
+            : 100;
+        const downtime = this.downtimeTracking.get(name) || 0;
+        const incidents = relevantResults.filter((r) => r.status === 'unhealthy').length;
+        return {
+            service: name,
+            uptime,
+            downtime,
+            incidents,
+            period,
+            startTime,
+            endTime: now,
+        };
+    }
+    /**
+     * Parse period string to milliseconds
+     */
+    parsePeriod(period) {
+        const match = period.match(/^(\d+)([hdwm])$/);
+        if (!match) {
+            throw new Error(`Invalid period format: ${period}`);
+        }
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        const multipliers = {
+            h: 60 * 60 * 1000,
+            d: 24 * 60 * 60 * 1000,
+            w: 7 * 24 * 60 * 60 * 1000,
+            m: 30 * 24 * 60 * 60 * 1000,
+        };
+        return value * multipliers[unit];
+    }
+    /**
+     * Stop all health checks
+     */
+    stopAllHealthChecks() {
+        for (const [name, timer] of this.checkIntervals.entries()) {
+            clearInterval(timer);
+            this.logger.log(`Health check '${name}' stopped`);
+        }
+        this.checkIntervals.clear();
+    }
+    /**
+     * Stop specific health check
+     */
+    stopHealthCheck(name) {
+        const timer = this.checkIntervals.get(name);
+        if (timer) {
+            clearInterval(timer);
+            this.checkIntervals.delete(name);
+            this.logger.log(`Health check '${name}' stopped`);
+        }
+    }
+    /**
+     * Get all registered health checks
+     */
+    getHealthChecks() {
+        return Array.from(this.healthChecks.keys());
+    }
+    /**
+     * Cleanup on destroy
+     */
+    onModuleDestroy() {
+        this.stopAllHealthChecks();
+        this.logger.log('Uptime service shut down');
+    }
+};
+exports.UptimeService = UptimeService;
+exports.UptimeService = UptimeService = UptimeService_1 = __decorate([
+    (0, common_1.Injectable)()
+], UptimeService);

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

@@ -1,88 +1,25 @@
 import CircuitBreaker from 'opossum';
-/**
- * Circuit breaker state enum
- */
 export declare enum CircuitState {
     CLOSED = "closed",
     OPEN = "open",
     HALF_OPEN = "halfOpen"
 }
-/**
- * Circuit breaker options based on Opossum configuration
- * @see https://nodeshift.dev/opossum/
- */
 export interface CircuitBreakerOptions {
-    /**
-     * The time in milliseconds that action should be allowed to execute before timing out.
-     * @default 10000 (10 seconds)
-     */
     timeout?: number;
-    /**
-     * The number of times the circuit can fail before opening.
-     * @default 50
-     */
     errorThresholdPercentage?: number;
-    /**
-     * The time in milliseconds to wait before setting the breaker to halfOpen state.
-     * @default 30000 (30 seconds)
-     */
     resetTimeout?: number;
-    /**
-     * The rolling statistical window in milliseconds.
-     * @default 10000 (10 seconds)
-     */
     rollingCountTimeout?: number;
-    /**
-     * The number of buckets the rolling statistical window is divided into.
-     * @default 10
-     */
     rollingCountBuckets?: number;
-    /**
-     * The name of the circuit breaker (for logging and metrics).
-     */
     name?: string;
-    /**
-     * The capacity of the internal event bus.
-     * @default 100
-     */
     capacity?: number;
-    /**
-     * Whether to enable snapshots for metrics.
-     * @default false
-     */
     enableSnapshots?: boolean;
-    /**
-     * Whether to allow warm up period (ignore errors initially).
-     * @default false
-     */
     allowWarmUp?: boolean;
-    /**
-     * The number of requests to allow during warm up.
-     * @default 0
-     */
     volumeThreshold?: number;
-    /**
-     * Custom error filter function to determine if an error should trip the circuit.
-     */
     errorFilter?: (error: any) => boolean;
-    /**
-     * Whether to cache the result of successful calls.
-     * @default false
-     */
     cache?: boolean;
-    /**
-     * Cache TTL in milliseconds.
-     * @default 0
-     */
     cacheTTL?: number;
-    /**
-     * Custom cache key generator function.
-     */
     cacheGetKey?: (...args: any[]) => string;
 }
-/**
- * Circuit breaker statistics
- */
 export interface CircuitBreakerStats {
     fires: number;
     failures: number;
@@ -98,9 +35,6 @@ export interface CircuitBreakerStats {
     latencyMean: number;
     latencyTimes: number[];
 }
-/**
- * Circuit breaker event types
- */
 export declare enum CircuitBreakerEvent {
     FIRE = "fire",
     SUCCESS = "success",
@@ -116,19 +50,10 @@ export declare enum CircuitBreakerEvent {
     CACHE_HIT = "cacheHit",
     CACHE_MISS = "cacheMiss"
 }
-/**
- * Circuit breaker instance wrapper
- */
 export interface CircuitBreakerInstance<T = any, R = any> {
     breaker: CircuitBreaker<T[], R>;
     name: string;
     options: CircuitBreakerOptions;
 }
-/**
- * Fallback function type
- */
 export type FallbackFunction<T = any> = (...args: any[]) => T | Promise<T>;
-/**
- * Health check function type
- */
 export type HealthCheckFunction = () => Promise<boolean>;

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

@@ -1,18 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CircuitBreakerEvent = exports.CircuitState = void 0;
-/**
- * Circuit breaker state enum
- */
 var CircuitState;
 (function (CircuitState) {
     CircuitState["CLOSED"] = "closed";
     CircuitState["OPEN"] = "open";
     CircuitState["HALF_OPEN"] = "halfOpen";
 })(CircuitState || (exports.CircuitState = CircuitState = {}));
-/**
- * Circuit breaker event types
- */
 var CircuitBreakerEvent;
 (function (CircuitBreakerEvent) {
     CircuitBreakerEvent["FIRE"] = "fire";