@averox/cryptosphare/dist/crypto/Monitoring.js

Real-time SDK for end-to-end encrypted messaging, key monitoring, and secure A/V streaming

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SecurityMonitor = void 0;
const events_1 = require("events");
const logger_1 = require("../config/logger");
class SecurityMonitor extends events_1.EventEmitter {
    constructor(telemetryLevel = 'Basic') {
        super();
        this.keyEvents = new Map();
        this.encryptionStats = new Map();
        this.telemetryLevel = telemetryLevel;
        this.logger = new logger_1.Logger({
            minLevel: logger_1.LogLevel.INFO,
            timestamps: true,
            showLevel: true,
        });
    }
    trackKeyEvent(keyId, event) {
        if (this.telemetryLevel !== 'Basic') {
            this.keyEvents.set(keyId, event);
            this.logger.info(`Key Event: ${keyId} - ${event.type}`, event);
            this.updateUI('keyEvents', Array.from(this.keyEvents.values()));
        }
    }
    trackEncryptionStats(operationId, stats) {
        if (this.telemetryLevel === 'Advanced' || this.telemetryLevel === 'Comprehensive') {
            this.encryptionStats.set(operationId, stats);
            this.logger.info(`Encryption Stats: ${operationId}`, stats);
            this.updateUI('encryptionStats', Array.from(this.encryptionStats.values()));
        }
        else if (this.telemetryLevel === 'Standard') {
            const basicStats = {
                ...stats,
                metadata: { success: stats.success },
            };
            this.encryptionStats.set(operationId, basicStats);
            this.updateUI('encryptionStats', Array.from(this.encryptionStats.values()));
        }
    }
    updateUI(component, data) {
        if (this.telemetryLevel === 'Comprehensive') {
            this.emit('monitoringUpdate', {
                component,
                data,
                timestamp: new Date(),
                level: this.telemetryLevel,
            });
        }
        else {
            const basicData = data.map((item) => ({
                timestamp: item.timestamp,
                type: item.type,
                status: 'status' in item ? item.status : undefined,
            }));
            this.emit('monitoringUpdate', {
                component,
                data: basicData,
                timestamp: new Date(),
                level: this.telemetryLevel,
            });
        }
    }
    getKeyMetrics() {
        const metrics = {
            totalKeys: this.keyEvents.size,
            activeKeys: Array.from(this.keyEvents.values()).filter((e) => e.status === 'active').length,
            compromisedKeys: Array.from(this.keyEvents.values()).filter((e) => e.status === 'compromised')
                .length,
            lastUpdated: new Date(),
        };
        if (this.telemetryLevel === 'Comprehensive') {
            return {
                ...metrics,
                keyTypes: new Set(Array.from(this.keyEvents.values()).map((e) => e.type)).size,
                averageKeyAge: this.calculateAverageKeyAge(),
            };
        }
        return metrics;
    }
    getEncryptionMetrics() {
        const metrics = {
            totalOperations: this.encryptionStats.size,
            successRate: this.calculateSuccessRate(),
            averageLatency: this.calculateAverageLatency(),
            lastUpdated: new Date(),
        };
        if (this.telemetryLevel === 'Advanced' || this.telemetryLevel === 'Comprehensive') {
            return {
                ...metrics,
                operationsByType: this.calculateOperationsByType(),
                peakLatency: this.calculatePeakLatency(),
            };
        }
        return metrics;
    }
    calculateSuccessRate() {
        const stats = Array.from(this.encryptionStats.values());
        if (stats.length === 0)
            return 0;
        return stats.filter((s) => s.success).length / stats.length;
    }
    calculateAverageLatency() {
        const stats = Array.from(this.encryptionStats.values());
        if (stats.length === 0)
            return 0;
        return stats.reduce((sum, s) => sum + s.latency, 0) / stats.length;
    }
    calculateAverageKeyAge() {
        const events = Array.from(this.keyEvents.values());
        if (events.length === 0)
            return 0;
        const now = new Date().getTime();
        return events.reduce((sum, e) => sum + (now - e.timestamp.getTime()), 0) / events.length;
    }
    calculateOperationsByType() {
        const stats = Array.from(this.encryptionStats.values());
        return stats.reduce((acc, stat) => {
            acc[stat.type] = (acc[stat.type] || 0) + 1;
            return acc;
        }, {});
    }
    calculatePeakLatency() {
        const stats = Array.from(this.encryptionStats.values());
        if (stats.length === 0)
            return 0;
        return Math.max(...stats.map((s) => s.latency));
    }
}
exports.SecurityMonitor = SecurityMonitor;