@re-shell/cli/dist/core/performance-monitor.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
export interface PerformanceMetric {
    id: string;
    timestamp: Date;
    category: string;
    name: string;
    value: number;
    unit: string;
    tags?: Record<string, string>;
    metadata?: Record<string, any>;
}
export interface PerformanceThreshold {
    metric: string;
    warning: number;
    critical: number;
    unit: string;
}
export interface PerformanceAlert {
    id: string;
    timestamp: Date;
    level: 'warning' | 'critical';
    metric: PerformanceMetric;
    threshold: PerformanceThreshold;
    message: string;
}
export interface SystemMetrics {
    timestamp: Date;
    cpu: {
        usage: number;
        loadAverage: number[];
        model: string;
        cores: number;
    };
    memory: {
        total: number;
        free: number;
        used: number;
        usage: number;
        heap: NodeJS.MemoryUsage;
    };
    process: {
        pid: number;
        uptime: number;
        cpu: number;
        memory: NodeJS.MemoryUsage;
    };
    disk: {
        available: number;
        used: number;
        total: number;
        usage: number;
    };
    network?: {
        connections: number;
        bytesReceived: number;
        bytesSent: number;
    };
}
export interface PerformanceDashboard {
    overview: {
        totalMetrics: number;
        activeAlerts: number;
        systemHealth: 'good' | 'warning' | 'critical';
        uptime: number;
    };
    realtime: {
        cpu: number;
        memory: number;
        operations: number;
        errors: number;
    };
    trends: {
        period: '1h' | '24h' | '7d' | '30d';
        metrics: Array<{
            name: string;
            current: number;
            average: number;
            trend: 'up' | 'down' | 'stable';
            change: number;
        }>;
    };
    alerts: PerformanceAlert[];
    top: {
        slowestOperations: Array<{
            name: string;
            duration: number;
            count: number;
        }>;
        memoryConsumers: Array<{
            name: string;
            usage: number;
        }>;
        errorRate: Array<{
            name: string;
            rate: number;
            count: number;
        }>;
    };
}
export interface PerformanceOptions {
    enabled: boolean;
    collectInterval: number;
    retentionPeriod: number;
    storageDir: string;
    dashboard: {
        enabled: boolean;
        port: number;
        updateInterval: number;
    };
    thresholds: PerformanceThreshold[];
    alerting: {
        enabled: boolean;
        cooldown: number;
    };
    metrics: {
        system: boolean;
        operations: boolean;
        memory: boolean;
        network: boolean;
    };
}
export declare class PerformanceMonitor extends EventEmitter {
    private options;
    private metrics;
    private alerts;
    private thresholds;
    private lastAlerts;
    private collectTimer?;
    private dashboardTimer?;
    private operationCounters;
    private startTime;
    constructor(options?: Partial<PerformanceOptions>);
    private setupThresholds;
    start(): void;
    stop(): void;
    private collectMetrics;
    private collectSystemMetrics;
    private getCpuUsage;
    private getProcessCpuUsage;
    private getDiskUsage;
    private getNetworkStats;
    private recordSystemMetrics;
    recordMetric(category: string, name: string, value: number, unit: string, tags?: Record<string, string>, metadata?: Record<string, any>): void;
    recordOperation(name: string, duration: number, success?: boolean, metadata?: Record<string, any>): void;
    private checkThresholds;
    private checkMetricThreshold;
    private triggerAlert;
    private cleanupMetrics;
    getDashboard(): PerformanceDashboard;
    private getLatestMetricValue;
    private calculateTrends;
    private startDashboard;
    private printConsoleDashboard;
    private getHealthEmoji;
    saveMetrics(filename?: string): Promise<void>;
    loadMetrics(filename: string): Promise<void>;
    getMetrics(filter?: {
        category?: string;
        name?: string;
        startTime?: Date;
        endTime?: Date;
    }): PerformanceMetric[];
    getAlerts(filter?: {
        level?: 'warning' | 'critical';
        startTime?: Date;
        endTime?: Date;
    }): PerformanceAlert[];
    setThreshold(metric: string, warning: number, critical: number, unit: string): void;
    removeThreshold(metric: string): void;
    getThresholds(): PerformanceThreshold[];
    isEnabled(): boolean;
    enable(): void;
    disable(): void;
}
export declare function createPerformanceMonitor(options?: Partial<PerformanceOptions>): PerformanceMonitor;
export declare function getGlobalPerformanceMonitor(): PerformanceMonitor;
export declare function setGlobalPerformanceMonitor(monitor: PerformanceMonitor): void;