@takentrade/takentrade-libs 3.0.0 → 3.1.0

package/README.md

@@ -39,6 +39,7 @@ export class AppModule {}
 | **RPC**            | Request-response patterns for NATS             | [docs/rpc.md](docs/rpc.md)                     |
 | **Resilience**     | Circuit breakers for fault tolerance           | [docs/resilience.md](docs/resilience.md)       |
 | **Metrics**        | Prometheus metrics collection                  | [docs/metrics.md](docs/metrics.md)             |
+| **Monitoring**     | Error tracking, alerting, uptime monitoring    | [docs/monitoring.md](docs/monitoring.md)       |
 | **Common**         | Shared constants, enums, and utilities         | [docs/common.md](docs/common.md)               |
 | **Utils**          | DTOs, pipes, filters, and helpers              | [docs/utils.md](docs/utils.md)                 |
 

package/dist/auth/auth.interface.d.ts

@@ -0,0 +1,8 @@
+export interface TokenPayload {
+    sub: string;
+    iss: string;
+    aud: string;
+    email: string;
+    role: string;
+    id?: string;
+}

package/dist/auth/auth.interface.js

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

package/dist/auth/decorators/get-user.decorator.d.ts

@@ -0,0 +1,2 @@
+import { TokenPayload } from '../auth.interface';
+export declare const GetUser: (...dataOrPipes: (import("@nestjs/common").PipeTransform<any, any> | keyof TokenPayload | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>> | undefined)[]) => ParameterDecorator;

package/dist/auth/decorators/get-user.decorator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUser = void 0;
+const common_1 = require("@nestjs/common");
+exports.GetUser = (0, common_1.createParamDecorator)((data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user) {
+        throw new common_1.UnauthorizedException('Invalid credentials or account information');
+    }
+    if (!data) {
+        return user;
+    }
+    if (data === 'sub') {
+        const value = user.id || user.sub;
+        if (!value) {
+            throw new common_1.UnauthorizedException('User ID not found');
+        }
+        return value;
+    }
+    const value = user[data];
+    if (value === undefined) {
+        throw new common_1.UnauthorizedException(`User ${data} not found`);
+    }
+    return value;
+});

package/dist/auth/decorators/index.d.ts

@@ -1,2 +1,3 @@
 export * from './public.decorator';
 export * from './roles.decorator';
+export * from './get-user.decorator';

package/dist/auth/decorators/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./public.decorator"), exports);
 __exportStar(require("./roles.decorator"), exports);
+__exportStar(require("./get-user.decorator"), exports);

package/dist/auth/index.d.ts

@@ -1 +1,2 @@
 export * from './decorators';
+export * from './auth.interface';

package/dist/auth/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./decorators"), exports);
+__exportStar(require("./auth.interface"), exports);

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from './auth';
 export * from './notification';
 export * from './resilience';
 export * from './metrics';
+export * from './monitoring';

package/dist/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./auth"), exports);
 __exportStar(require("./notification"), exports);
 __exportStar(require("./resilience"), exports);
 __exportStar(require("./metrics"), exports);
+__exportStar(require("./monitoring"), exports);

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

@@ -1,92 +1,45 @@
 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";
@@ -96,11 +49,5 @@ export declare const CIRCUIT_BREAKER_METRICS: {
     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

@@ -1,9 +1,6 @@
 "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";
@@ -11,9 +8,6 @@ var MetricType;
     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',
@@ -23,13 +17,7 @@ exports.CIRCUIT_BREAKER_METRICS = {
     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/monitoring/alerting.service.d.ts

@@ -0,0 +1,82 @@
+import { Alert, AlertRule, AlertingConfig } from './monitoring.interface';
+/**
+ * Alerting Service
+ *
+ * Provides multi-channel alerting with rule engine and deduplication
+ */
+export declare class AlertingService {
+    private readonly logger;
+    private channels;
+    private rules;
+    private alertHistory;
+    private config;
+    constructor(config?: AlertingConfig);
+    /**
+     * Initialize alert channels
+     */
+    private initializeChannels;
+    /**
+     * Initialize alert rules
+     */
+    private initializeRules;
+    /**
+     * Register an alert rule
+     */
+    registerRule(rule: AlertRule): void;
+    /**
+     * Send an alert
+     */
+    sendAlert(alert: Alert): Promise<void>;
+    /**
+     * Evaluate alert rules
+     */
+    evaluateRules(metrics: any): Promise<void>;
+    /**
+     * Send alert to specific channel
+     */
+    private sendToChannel;
+    /**
+     * Send alert to Slack
+     */
+    private sendToSlack;
+    /**
+     * Send alert to email
+     */
+    private sendToEmail;
+    /**
+     * Send alert to webhook
+     */
+    private sendToWebhook;
+    /**
+     * Send alert to PagerDuty
+     */
+    private sendToPagerDuty;
+    /**
+     * Evaluate alert condition
+     */
+    private evaluateCondition;
+    /**
+     * Interpolate message template
+     */
+    private interpolateMessage;
+    /**
+     * Check if alert is throttled
+     */
+    private isThrottled;
+    /**
+     * Generate alert ID
+     */
+    private generateAlertId;
+    /**
+     * Get severity color for Slack
+     */
+    private getSeverityColor;
+    /**
+     * Get alert history
+     */
+    getAlertHistory(): Map<string, Date>;
+    /**
+     * Clear alert history
+     */
+    clearAlertHistory(): void;
+}

package/dist/monitoring/alerting.service.js

@@ -0,0 +1,290 @@
+"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 AlertingService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertingService = void 0;
+const common_1 = require("@nestjs/common");
+const monitoring_interface_1 = require("./monitoring.interface");
+/**
+ * Alerting Service
+ *
+ * Provides multi-channel alerting with rule engine and deduplication
+ */
+let AlertingService = AlertingService_1 = class AlertingService {
+    logger = new common_1.Logger(AlertingService_1.name);
+    channels = new Map();
+    rules = new Map();
+    alertHistory = new Map();
+    config;
+    constructor(config) {
+        this.config = config || { channels: [] };
+        this.initializeChannels();
+        this.initializeRules();
+    }
+    /**
+     * Initialize alert channels
+     */
+    initializeChannels() {
+        if (!this.config.channels) {
+            return;
+        }
+        for (const channel of this.config.channels) {
+            const name = channel.name || channel.type;
+            this.channels.set(name, {
+                ...channel,
+                enabled: channel.enabled ?? true,
+            });
+            this.logger.log(`Alert channel '${name}' registered`);
+        }
+    }
+    /**
+     * Initialize alert rules
+     */
+    initializeRules() {
+        if (!this.config.rules) {
+            return;
+        }
+        for (const rule of this.config.rules) {
+            this.registerRule(rule);
+        }
+    }
+    /**
+     * Register an alert rule
+     */
+    registerRule(rule) {
+        this.rules.set(rule.name, {
+            ...rule,
+            enabled: rule.enabled ?? true,
+            throttle: rule.throttle ?? 300000, // 5 minutes default
+        });
+        this.logger.log(`Alert rule '${rule.name}' registered`);
+    }
+    /**
+     * Send an alert
+     */
+    async sendAlert(alert) {
+        const alertId = alert.id || this.generateAlertId(alert);
+        // Check throttling
+        if (this.isThrottled(alertId)) {
+            this.logger.debug(`Alert '${alertId}' is throttled, skipping`);
+            return;
+        }
+        // Add timestamp
+        const fullAlert = {
+            ...alert,
+            id: alertId,
+            timestamp: alert.timestamp || new Date(),
+        };
+        // Send to all enabled channels
+        const promises = [];
+        for (const [name, channel] of this.channels.entries()) {
+            if (channel.enabled) {
+                promises.push(this.sendToChannel(fullAlert, channel));
+            }
+        }
+        await Promise.allSettled(promises);
+        // Update alert history
+        this.alertHistory.set(alertId, new Date());
+    }
+    /**
+     * Evaluate alert rules
+     */
+    async evaluateRules(metrics) {
+        for (const [name, rule] of this.rules.entries()) {
+            if (!rule.enabled) {
+                continue;
+            }
+            try {
+                const shouldAlert = this.evaluateCondition(rule.condition, metrics);
+                if (shouldAlert) {
+                    await this.sendAlert({
+                        title: rule.name,
+                        message: this.interpolateMessage(rule.message, metrics),
+                        severity: rule.severity,
+                        source: 'rule-engine',
+                        metadata: { rule: name, metrics },
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error evaluating rule '${name}':`, error);
+            }
+        }
+    }
+    /**
+     * Send alert to specific channel
+     */
+    async sendToChannel(alert, channel) {
+        try {
+            switch (channel.type) {
+                case 'slack':
+                    await this.sendToSlack(alert, channel);
+                    break;
+                case 'email':
+                    await this.sendToEmail(alert, channel);
+                    break;
+                case 'webhook':
+                    await this.sendToWebhook(alert, channel);
+                    break;
+                case 'pagerduty':
+                    await this.sendToPagerDuty(alert, channel);
+                    break;
+                default:
+                    this.logger.warn(`Unknown channel type: ${channel.type}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Failed to send alert to ${channel.type}:`, error);
+        }
+    }
+    /**
+     * Send alert to Slack
+     */
+    async sendToSlack(alert, channel) {
+        if (!channel.webhookUrl) {
+            throw new Error('Slack webhook URL not configured');
+        }
+        const color = this.getSeverityColor(alert.severity);
+        const payload = {
+            attachments: [
+                {
+                    color,
+                    title: alert.title,
+                    text: alert.message,
+                    fields: [
+                        {
+                            title: 'Severity',
+                            value: alert.severity.toUpperCase(),
+                            short: true,
+                        },
+                        {
+                            title: 'Source',
+                            value: alert.source || 'Unknown',
+                            short: true,
+                        },
+                        {
+                            title: 'Time',
+                            value: alert.timestamp?.toISOString() || new Date().toISOString(),
+                            short: false,
+                        },
+                    ],
+                },
+            ],
+        };
+        const response = await fetch(channel.webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Slack API error: ${response.statusText}`);
+        }
+        this.logger.debug(`Alert sent to Slack: ${alert.title}`);
+    }
+    /**
+     * Send alert to email
+     */
+    async sendToEmail(alert, channel) {
+        // This would integrate with your email service
+        // For now, just log
+        this.logger.log(`Email alert would be sent to: ${channel.recipients?.join(', ')}`);
+        this.logger.log(`Subject: ${alert.title}`);
+        this.logger.log(`Body: ${alert.message}`);
+    }
+    /**
+     * Send alert to webhook
+     */
+    async sendToWebhook(alert, channel) {
+        if (!channel.webhookUrl) {
+            throw new Error('Webhook URL not configured');
+        }
+        const response = await fetch(channel.webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(alert),
+        });
+        if (!response.ok) {
+            throw new Error(`Webhook error: ${response.statusText}`);
+        }
+        this.logger.debug(`Alert sent to webhook: ${alert.title}`);
+    }
+    /**
+     * Send alert to PagerDuty
+     */
+    async sendToPagerDuty(alert, channel) {
+        // PagerDuty integration would go here
+        this.logger.log(`PagerDuty alert: ${alert.title}`);
+    }
+    /**
+     * Evaluate alert condition
+     */
+    evaluateCondition(condition, metrics) {
+        if (typeof condition === 'function') {
+            return condition(metrics);
+        }
+        // Simple expression evaluation (extend as needed)
+        // For now, just return false for string conditions
+        return false;
+    }
+    /**
+     * Interpolate message template
+     */
+    interpolateMessage(template, data) {
+        return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+            return data[key] || match;
+        });
+    }
+    /**
+     * Check if alert is throttled
+     */
+    isThrottled(alertId) {
+        const lastSent = this.alertHistory.get(alertId);
+        if (!lastSent) {
+            return false;
+        }
+        const throttleDuration = 300000; // 5 minutes default
+        const elapsed = Date.now() - lastSent.getTime();
+        return elapsed < throttleDuration;
+    }
+    /**
+     * Generate alert ID
+     */
+    generateAlertId(alert) {
+        const parts = [alert.title, alert.severity, alert.source].filter(Boolean);
+        return parts.join(':').toLowerCase().replace(/\s+/g, '-');
+    }
+    /**
+     * Get severity color for Slack
+     */
+    getSeverityColor(severity) {
+        const colors = {
+            [monitoring_interface_1.AlertSeverity.INFO]: '#36a64f',
+            [monitoring_interface_1.AlertSeverity.WARNING]: '#ff9900',
+            [monitoring_interface_1.AlertSeverity.ERROR]: '#ff0000',
+            [monitoring_interface_1.AlertSeverity.CRITICAL]: '#8b0000',
+        };
+        return colors[severity] || '#808080';
+    }
+    /**
+     * Get alert history
+     */
+    getAlertHistory() {
+        return new Map(this.alertHistory);
+    }
+    /**
+     * Clear alert history
+     */
+    clearAlertHistory() {
+        this.alertHistory.clear();
+        this.logger.log('Alert history cleared');
+    }
+};
+exports.AlertingService = AlertingService;
+exports.AlertingService = AlertingService = AlertingService_1 = __decorate([
+    (0, common_1.Injectable)()
+], AlertingService);

package/dist/monitoring/index.d.ts

@@ -0,0 +1,5 @@
+export * from './monitoring.interface';
+export * from './sentry.service';
+export * from './alerting.service';
+export * from './uptime.service';
+export * from './monitoring.module';

package/dist/monitoring/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./monitoring.interface"), exports);
+__exportStar(require("./sentry.service"), exports);
+__exportStar(require("./alerting.service"), exports);
+__exportStar(require("./uptime.service"), exports);
+__exportStar(require("./monitoring.module"), exports);