blax/dist/watch/watchdogMonitor.d.ts

Blax - HMS-Powered Multi-Agent Platform with Government Agency Analysis, Deep Research, and Enterprise-Ready Deployment. No local LLM keys required.

import { EventEmitter } from 'events';
import { MessageBus } from '../core/messageBus.js';
export interface WatchEvent {
    eventId: string;
    timestamp: Date;
    source: string;
    eventType: string;
    channel: string;
    data: Record<string, unknown>;
    severity: 'debug' | 'info' | 'warning' | 'error' | 'critical';
    tags: string[];
    correlationId?: string;
    sessionId?: string;
}
export interface WatchdogConfig {
    redisUrl?: string;
    monitoredPatterns: string[];
    persistEvents: boolean;
    logDirectory: string;
    compressionEnabled: boolean;
    maxFileSize: number;
    logRetentionHours: number;
    maxMemoryEvents: number;
    flushInterval: number;
    alertThresholds: {
        errorRate: number;
        eventRate: number;
        memoryUsage: number;
    };
    excludePatterns: string[];
    minimumSeverity: WatchEvent['severity'];
}
export interface ChannelStats {
    eventCount: number;
    lastEventTime: Date;
    errorCount: number;
    averageEventSize: number;
    eventTypes: Record<string, number>;
}
export interface Alert {
    alertId: string;
    type: 'rate_limit' | 'error_threshold' | 'memory_usage' | 'system_health';
    severity: 'warning' | 'error' | 'critical';
    title: string;
    message: string;
    timestamp: Date;
    acknowledged: boolean;
    resolvedAt?: Date;
    metadata: Record<string, unknown>;
}
/**
 * Watchdog Monitor for event fan-out and persistence
 * Provides real-time monitoring and alerting for HMS Dev system
 */
export declare class WatchdogMonitor extends EventEmitter {
    private config;
    private messageBus;
    private running;
    private eventBuffer;
    private channelStats;
    private logStreams;
    private currentLogFile?;
    private flushTimer?;
    private alerts;
    private eventRateCounter;
    private errorRateCounter;
    private lastRateReset;
    private totalEventsProcessed;
    private totalErrorsDetected;
    private startTime;
    constructor(config: Partial<WatchdogConfig>, messageBus: MessageBus);
    /**
     * Start monitoring
     */
    start(): Promise<void>;
    /**
     * Stop monitoring
     */
    stop(): Promise<void>;
    /**
     * Handle incoming events
     */
    private handleEvent;
    /**
     * Create watch event from message
     */
    private createWatchEvent;
    /**
     * Add event to buffer
     */
    private addToBuffer;
    /**
     * Fan out event to monitor channels
     */
    private fanOutEvent;
    /**
     * Flush events to persistent storage
     */
    private flushEvents;
    /**
     * Get or create log stream
     */
    private getLogStream;
    /**
     * Generate log file name based on current date
     */
    private generateLogFileName;
    /**
     * Check alert conditions
     */
    private checkAlertConditions;
    /**
     * Create alert
     */
    private createAlert;
    /**
     * Update channel statistics
     */
    private updateChannelStats;
    /**
     * Get monitoring statistics
     */
    getStats(): {
        running: boolean;
        uptime: number;
        totalEventsProcessed: number;
        totalErrorsDetected: number;
        bufferedEvents: number;
        channelCount: number;
        activeAlerts: number;
        memoryUsage: NodeJS.MemoryUsage;
    };
    /**
     * Get channel statistics
     */
    getChannelStats(): Map<string, ChannelStats>;
    /**
     * Get recent events
     */
    getRecentEvents(limit?: number, filter?: {
        severity?: WatchEvent['severity'][];
        eventType?: string[];
        source?: string[];
    }): WatchEvent[];
    /**
     * Get active alerts
     */
    getActiveAlerts(): Alert[];
    /**
     * Acknowledge alert
     */
    acknowledgeAlert(alertId: string): boolean;
    private setupEventHandlers;
    private startPeriodicTasks;
    private ensureLogDirectory;
    private cleanupOldLogs;
    private shouldExcludeEvent;
    private meetsSeverityThreshold;
    private matchesPattern;
    private extractChannelFromMessage;
    private determineSeverity;
    private extractTags;
    private extractCorrelationId;
    private extractSessionId;
    private getSeverityPriority;
    /**
     * Health check
     */
    healthCheck(): Promise<{
        status: 'healthy' | 'unhealthy';
        details: Record<string, unknown>;
    }>;
}
//# sourceMappingURL=watchdogMonitor.d.ts.map