@takentrade/takentrade-libs 4.1.1 → 4.1.2

package/dist/monitoring/sentry.service.js

@@ -1,218 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-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 __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var SentryService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentryService = void 0;
-const common_1 = require("@nestjs/common");
-const Sentry = __importStar(require("@sentry/node"));
-require("@sentry/tracing");
-let SentryService = SentryService_1 = class SentryService {
-    logger = new common_1.Logger(SentryService_1.name);
-    initialized = false;
-    constructor(config) {
-        if (config?.dsn) {
-            this.initialize(config);
-        }
-    }
-    /**
-     * Initialize Sentry
-     */
-    initialize(config) {
-        try {
-            Sentry.init({
-                dsn: config.dsn,
-                environment: config.environment || process.env.NODE_ENV || 'development',
-                release: config.release,
-                sampleRate: config.sampleRate ?? 1.0,
-                tracesSampleRate: config.tracesSampleRate ?? 0.1,
-                debug: config.debug ?? false,
-                beforeSend: config.beforeSend,
-            });
-            this.initialized = true;
-            this.logger.log('Sentry initialized successfully');
-        }
-        catch (error) {
-            this.logger.error('Failed to initialize Sentry:', error);
-        }
-    }
-    /**
-     * Capture an exception
-     */
-    captureException(error, context) {
-        if (!this.initialized) {
-            this.logger.warn('Sentry not initialized, error not captured');
-            return undefined;
-        }
-        return Sentry.captureException(error, {
-            tags: context?.tags,
-            user: context?.user,
-            extra: context?.extra,
-            level: context?.level,
-        });
-    }
-    /**
-     * Capture a message
-     */
-    captureMessage(message, level = 'info', context) {
-        if (!this.initialized) {
-            this.logger.warn('Sentry not initialized, message not captured');
-            return undefined;
-        }
-        return Sentry.captureMessage(message, {
-            level,
-            tags: context?.tags,
-            user: context?.user,
-            extra: context?.extra,
-        });
-    }
-    /**
-     * Add a breadcrumb
-     */
-    addBreadcrumb(breadcrumb) {
-        if (!this.initialized) {
-            return;
-        }
-        Sentry.addBreadcrumb({
-            type: breadcrumb.type,
-            level: breadcrumb.level,
-            message: breadcrumb.message,
-            category: breadcrumb.category,
-            data: breadcrumb.data,
-            timestamp: breadcrumb.timestamp,
-        });
-    }
-    /**
-     * Set user context
-     */
-    setUser(user) {
-        if (!this.initialized) {
-            return;
-        }
-        Sentry.setUser(user);
-    }
-    /**
-     * Set a tag
-     */
-    setTag(key, value) {
-        if (!this.initialized) {
-            return;
-        }
-        Sentry.setTag(key, value);
-    }
-    /**
-     * Set multiple tags
-     */
-    setTags(tags) {
-        if (!this.initialized) {
-            return;
-        }
-        Sentry.setTags(tags);
-    }
-    /**
-     * Set context
-     */
-    setContext(name, context) {
-        if (!this.initialized) {
-            return;
-        }
-        Sentry.setContext(name, context);
-    }
-    /**
-     * Start a transaction for performance monitoring
-     * Note: Use Sentry.startTransaction directly in newer versions
-     */
-    startTransaction(name, op) {
-        if (!this.initialized) {
-            return null;
-        }
-        // In Sentry v7+, use withScope instead
-        return { name, op };
-    }
-    /**
-     * Configure scope (use withScope in newer versions)
-     */
-    configureScope(callback) {
-        if (!this.initialized) {
-            return;
-        }
-        // In Sentry v7+, use withScope
-        Sentry.withScope(callback);
-    }
-    /**
-     * Flush events
-     */
-    async flush(timeout = 2000) {
-        if (!this.initialized) {
-            return false;
-        }
-        return await Sentry.flush(timeout);
-    }
-    /**
-     * Close Sentry client
-     */
-    async close(timeout = 2000) {
-        if (!this.initialized) {
-            return false;
-        }
-        return await Sentry.close(timeout);
-    }
-    /**
-     * Check if Sentry is initialized
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    /**
-     * Cleanup on module destroy
-     */
-    async onModuleDestroy() {
-        if (this.initialized) {
-            this.logger.log('Flushing Sentry events...');
-            await this.flush();
-            await this.close();
-            this.logger.log('Sentry service shut down');
-        }
-    }
-};
-exports.SentryService = SentryService;
-exports.SentryService = SentryService = SentryService_1 = __decorate([
-    (0, common_1.Injectable)()
-], SentryService);

package/dist/monitoring/uptime.service.d.ts

@@ -1,59 +0,0 @@
-import { HealthCheck, HealthCheckResult, UptimeConfig, UptimeReport } from './monitoring.interface';
-/**
- * Uptime Monitoring Service
- *
- * Tracks service availability and generates SLA reports
- */
-export declare class UptimeService {
-    private readonly logger;
-    private healthChecks;
-    private healthResults;
-    private downtimeTracking;
-    private config;
-    private checkIntervals;
-    constructor(config?: UptimeConfig);
-    /**
-     * Register a health check
-     */
-    registerHealthCheck(check: HealthCheck): void;
-    /**
-     * Start periodic health check
-     */
-    private startHealthCheck;
-    /**
-     * Run a health check
-     */
-    runHealthCheck(name: string): Promise<HealthCheckResult>;
-    /**
-     * Get current health status
-     */
-    getHealthStatus(name?: string): Promise<HealthCheckResult[]>;
-    /**
-     * Get uptime percentage
-     */
-    getUptime(name: string, periodMs?: number): number;
-    /**
-     * Get SLA report
-     */
-    getSLAReport(name: string, period?: string): UptimeReport;
-    /**
-     * Parse period string to milliseconds
-     */
-    private parsePeriod;
-    /**
-     * Stop all health checks
-     */
-    stopAllHealthChecks(): void;
-    /**
-     * Stop specific health check
-     */
-    stopHealthCheck(name: string): void;
-    /**
-     * Get all registered health checks
-     */
-    getHealthChecks(): string[];
-    /**
-     * Cleanup on destroy
-     */
-    onModuleDestroy(): void;
-}

package/dist/monitoring/uptime.service.js

@@ -1,213 +0,0 @@
-"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-event-handler.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,70 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-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

@@ -1,51 +0,0 @@
-"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

@@ -1,37 +0,0 @@
-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;
-}