@takentrade/takentrade-libs 3.0.0 → 3.2.0

package/dist/monitoring/monitoring.interface.d.ts

@@ -0,0 +1,102 @@
+export interface MonitoringModuleOptions {
+    sentry?: SentryConfig;
+    alerting?: AlertingConfig;
+    uptime?: UptimeConfig;
+}
+export interface SentryConfig {
+    dsn: string;
+    environment?: string;
+    release?: string;
+    sampleRate?: number;
+    tracesSampleRate?: number;
+    debug?: boolean;
+    beforeSend?: (event: any) => any;
+    integrations?: string[];
+}
+export interface AlertingConfig {
+    channels: AlertChannel[];
+    rules?: AlertRule[];
+    defaultSeverity?: AlertSeverity;
+}
+export interface AlertChannel {
+    type: 'slack' | 'email' | 'webhook' | 'pagerduty';
+    name?: string;
+    webhookUrl?: string;
+    recipients?: string[];
+    enabled?: boolean;
+}
+export interface AlertRule {
+    name: string;
+    condition: string | ((metrics: any) => boolean);
+    severity: AlertSeverity;
+    message: string;
+    channels: string[];
+    throttle?: number;
+    enabled?: boolean;
+}
+export declare enum AlertSeverity {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error",
+    CRITICAL = "critical"
+}
+export interface Alert {
+    id?: string;
+    title: string;
+    message: string;
+    severity: AlertSeverity;
+    source?: string;
+    metadata?: Record<string, any>;
+    timestamp?: Date;
+}
+export interface UptimeConfig {
+    enabled: boolean;
+    checkInterval?: number;
+    slaThreshold?: number;
+    alertOnDowntime?: boolean;
+}
+export interface HealthCheck {
+    name: string;
+    check: () => Promise<void>;
+    interval?: number;
+    timeout?: number;
+    critical?: boolean;
+}
+export interface HealthCheckResult {
+    name: string;
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    responseTime: number;
+    error?: string;
+    timestamp: Date;
+}
+export interface UptimeReport {
+    service: string;
+    uptime: number;
+    downtime: number;
+    incidents: number;
+    period: string;
+    startTime: Date;
+    endTime: Date;
+}
+export interface SentryBreadcrumb {
+    type?: string;
+    level?: 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug';
+    message?: string;
+    category?: string;
+    data?: Record<string, any>;
+    timestamp?: number;
+}
+export interface SentryUser {
+    id?: string;
+    email?: string;
+    username?: string;
+    ip_address?: string;
+    [key: string]: any;
+}
+export interface ErrorContext {
+    tags?: Record<string, string>;
+    user?: SentryUser;
+    extra?: Record<string, any>;
+    breadcrumbs?: SentryBreadcrumb[];
+    level?: 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug';
+}

package/dist/monitoring/monitoring.interface.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertSeverity = void 0;
+var AlertSeverity;
+(function (AlertSeverity) {
+    AlertSeverity["INFO"] = "info";
+    AlertSeverity["WARNING"] = "warning";
+    AlertSeverity["ERROR"] = "error";
+    AlertSeverity["CRITICAL"] = "critical";
+})(AlertSeverity || (exports.AlertSeverity = AlertSeverity = {}));

package/dist/monitoring/monitoring.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { MonitoringModuleOptions } from './monitoring.interface';
+export declare class MonitoringModule {
+    /**
+     * Register the monitoring module with options
+     */
+    static register(options?: MonitoringModuleOptions): DynamicModule;
+}

package/dist/monitoring/monitoring.module.js

@@ -0,0 +1,44 @@
+"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 MonitoringModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitoringModule = void 0;
+const common_1 = require("@nestjs/common");
+const sentry_service_1 = require("./sentry.service");
+const alerting_service_1 = require("./alerting.service");
+const uptime_service_1 = require("./uptime.service");
+let MonitoringModule = MonitoringModule_1 = class MonitoringModule {
+    /**
+     * Register the monitoring module with options
+     */
+    static register(options = {}) {
+        return {
+            module: MonitoringModule_1,
+            providers: [
+                {
+                    provide: sentry_service_1.SentryService,
+                    useValue: new sentry_service_1.SentryService(options.sentry),
+                },
+                {
+                    provide: alerting_service_1.AlertingService,
+                    useValue: new alerting_service_1.AlertingService(options.alerting),
+                },
+                {
+                    provide: uptime_service_1.UptimeService,
+                    useValue: new uptime_service_1.UptimeService(options.uptime),
+                },
+            ],
+            exports: [sentry_service_1.SentryService, alerting_service_1.AlertingService, uptime_service_1.UptimeService],
+        };
+    }
+};
+exports.MonitoringModule = MonitoringModule;
+exports.MonitoringModule = MonitoringModule = MonitoringModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], MonitoringModule);

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

@@ -0,0 +1,65 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import '@sentry/tracing';
+import { SentryConfig, SentryBreadcrumb, SentryUser, ErrorContext } from './monitoring.interface';
+export declare class SentryService implements OnModuleDestroy {
+    private readonly logger;
+    private initialized;
+    constructor(config?: SentryConfig);
+    /**
+     * Initialize Sentry
+     */
+    private initialize;
+    /**
+     * Capture an exception
+     */
+    captureException(error: Error, context?: ErrorContext): string | undefined;
+    /**
+     * Capture a message
+     */
+    captureMessage(message: string, level?: 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug', context?: ErrorContext): string | undefined;
+    /**
+     * Add a breadcrumb
+     */
+    addBreadcrumb(breadcrumb: SentryBreadcrumb): void;
+    /**
+     * Set user context
+     */
+    setUser(user: SentryUser | null): void;
+    /**
+     * Set a tag
+     */
+    setTag(key: string, value: string): void;
+    /**
+     * Set multiple tags
+     */
+    setTags(tags: Record<string, string>): void;
+    /**
+     * Set context
+     */
+    setContext(name: string, context: Record<string, any>): void;
+    /**
+     * Start a transaction for performance monitoring
+     * Note: Use Sentry.startTransaction directly in newer versions
+     */
+    startTransaction(name: string, op: string): any;
+    /**
+     * Configure scope (use withScope in newer versions)
+     */
+    configureScope(callback: (scope: any) => void): void;
+    /**
+     * Flush events
+     */
+    flush(timeout?: number): Promise<boolean>;
+    /**
+     * Close Sentry client
+     */
+    close(timeout?: number): Promise<boolean>;
+    /**
+     * Check if Sentry is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy(): Promise<void>;
+}

package/dist/monitoring/sentry.service.js

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

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