@layr-labs/hourglass-performer/dist/utils/diagnostics.d.ts

TypeScript SDK for building Hourglass AVS performers

import { PerformerStatus } from '../types/performer';
import { MetricsCollector } from './metrics';
import { ILogger } from './logger';
/**
 * System information
 */
export interface SystemInfo {
    /** Node.js version */
    nodeVersion: string;
    /** Platform information */
    platform: string;
    /** Architecture */
    arch: string;
    /** CPU information */
    cpus: number;
    /** Total memory in bytes */
    totalMemory: number;
    /** Free memory in bytes */
    freeMemory: number;
    /** Uptime in seconds */
    uptime: number;
    /** Load average */
    loadAverage: number[];
}
/**
 * Performance snapshot
 */
export interface PerformanceSnapshot {
    /** Timestamp when snapshot was taken */
    timestamp: number;
    /** Memory usage */
    memory: NodeJS.MemoryUsage;
    /** CPU usage (if available) */
    cpu?: {
        user: number;
        system: number;
    };
    /** Event loop lag in milliseconds */
    eventLoopLag: number;
    /** Active handles and requests */
    handles: number;
    requests: number;
}
/**
 * Diagnostic information
 */
export interface DiagnosticInfo {
    /** System information */
    system: SystemInfo;
    /** Current performance snapshot */
    performance: PerformanceSnapshot;
    /** Performer status */
    status: PerformerStatus;
    /** Configuration */
    config: any;
    /** Environment variables (filtered) */
    environment: Record<string, string>;
    /** Recent errors */
    recentErrors: string[];
    /** Metrics summary */
    metricsSummary?: any;
}
/**
 * Debug mode configuration
 */
export interface DebugConfig {
    /** Enable debug mode */
    enabled: boolean;
    /** Enable performance monitoring */
    enablePerformanceMonitoring: boolean;
    /** Enable memory leak detection */
    enableMemoryLeakDetection: boolean;
    /** Enable request tracing */
    enableRequestTracing: boolean;
    /** Performance monitoring interval in milliseconds */
    performanceInterval: number;
    /** Memory threshold for warnings (in MB) */
    memoryThreshold: number;
}
/**
 * Memory leak detector
 */
export declare class MemoryLeakDetector {
    private snapshots;
    private config;
    private logger;
    private checkInterval?;
    constructor(logger: ILogger, config: DebugConfig);
    start(): void;
    stop(): void;
    private checkMemoryUsage;
    private calculateMemoryTrend;
    private createPerformanceSnapshot;
}
/**
 * Request tracer for debugging
 */
export declare class RequestTracer {
    private traces;
    private config;
    private logger;
    constructor(logger: ILogger, config: DebugConfig);
    startTrace(id: string, operation: string, metadata?: any): void;
    addStep(id: string, step: string, metadata?: any): void;
    endTrace(id: string, result?: any): void;
    getActiveTraces(): any[];
}
/**
 * Comprehensive diagnostics tool
 */
export declare class DiagnosticTool {
    private config;
    private logger;
    private memoryLeakDetector;
    private requestTracer;
    private metricsCollector?;
    private recentErrors;
    constructor(logger: ILogger, config?: Partial<DebugConfig>);
    /**
     * Start diagnostic monitoring
     */
    start(): void;
    /**
     * Stop diagnostic monitoring
     */
    stop(): void;
    /**
     * Set metrics collector
     */
    setMetricsCollector(collector: MetricsCollector): void;
    /**
     * Record error for diagnostics
     */
    recordError(error: string): void;
    /**
     * Get system information
     */
    getSystemInfo(): SystemInfo;
    /**
     * Get current performance snapshot
     */
    getPerformanceSnapshot(): PerformanceSnapshot;
    /**
     * Get comprehensive diagnostic information
     */
    getDiagnosticInfo(status: PerformerStatus, config: any): DiagnosticInfo;
    /**
     * Start request trace
     */
    startTrace(id: string, operation: string, metadata?: any): void;
    /**
     * Add step to trace
     */
    addTraceStep(id: string, step: string, metadata?: any): void;
    /**
     * End request trace
     */
    endTrace(id: string, result?: any): void;
    /**
     * Get active traces
     */
    getActiveTraces(): any[];
    /**
     * Perform health check on the system
     */
    performHealthCheck(): {
        healthy: boolean;
        issues: string[];
        recommendations: string[];
    };
    /**
     * Generate diagnostic report
     */
    generateReport(status: PerformerStatus, config: any): string;
    /**
     * Sanitize configuration for diagnostics
     */
    private sanitizeConfig;
    /**
     * Get filtered environment variables
     */
    private getFilteredEnvironment;
}
//# sourceMappingURL=diagnostics.d.ts.map