@layr-labs/hourglass-performer/dist/server/healthManager.d.ts

TypeScript SDK for building Hourglass AVS performers

import { PerformerStatus } from '../types/performer';
import { ILogger } from '../utils/logger';
/**
 * Health check configuration
 */
export interface HealthCheckConfig {
    /** Interval for automatic health checks in milliseconds */
    checkInterval?: number;
    /** Maximum number of consecutive failures before marking unhealthy */
    maxFailures?: number;
    /** Timeout for health check operations in milliseconds */
    timeout?: number;
    /** Enable automatic recovery attempts */
    autoRecover?: boolean;
}
/**
 * Health check result
 */
export interface HealthCheckResult {
    /** Overall health status */
    status: PerformerStatus;
    /** Health check timestamp */
    timestamp: number;
    /** Detailed health information */
    details: {
        uptime: number;
        memoryUsage: NodeJS.MemoryUsage;
        taskCount: number;
        lastTaskTime?: number;
        errors: string[];
    };
    /** Custom health indicators */
    custom?: Record<string, any>;
}
/**
 * Health check provider interface
 */
export interface HealthCheckProvider {
    /** Provider name */
    name: string;
    /** Check health and return status */
    check(): Promise<{
        healthy: boolean;
        details?: any;
        error?: string;
    }>;
}
/**
 * Built-in health check providers
 */
export declare class MemoryHealthProvider implements HealthCheckProvider {
    private maxMemoryMB;
    name: string;
    constructor(maxMemoryMB?: number);
    check(): Promise<{
        healthy: boolean;
        details?: any;
        error?: string;
    }>;
}
export declare class UptimeHealthProvider implements HealthCheckProvider {
    private startTime;
    name: string;
    constructor(startTime?: number);
    check(): Promise<{
        healthy: boolean;
        details?: any;
    }>;
}
/**
 * Health manager for tracking performer health and status
 */
export declare class HealthManager {
    private logger;
    private currentStatus;
    private config;
    private providers;
    private failures;
    private lastHealthCheck?;
    private healthCheckInterval?;
    private startTime;
    private taskCount;
    private lastTaskTime?;
    private errors;
    private customMetrics;
    constructor(logger: ILogger, config?: HealthCheckConfig);
    /**
     * Start the health manager
     */
    start(): void;
    /**
     * Stop the health manager
     */
    stop(): void;
    /**
     * Add a custom health check provider
     */
    addProvider(provider: HealthCheckProvider): void;
    /**
     * Remove a health check provider
     */
    removeProvider(name: string): void;
    /**
     * Get current status
     */
    getStatus(): PerformerStatus;
    /**
     * Set status manually
     */
    setStatus(status: PerformerStatus): void;
    /**
     * Record a task execution
     */
    recordTask(): void;
    /**
     * Record an error
     */
    recordError(error: string): void;
    /**
     * Set custom metric
     */
    setCustomMetric(key: string, value: any): void;
    /**
     * Get custom metric
     */
    getCustomMetric(key: string): any;
    /**
     * Perform comprehensive health check
     */
    performHealthCheck(): Promise<HealthCheckResult>;
    /**
     * Get last health check result
     */
    getLastHealthCheck(): HealthCheckResult | undefined;
    /**
     * Get health summary for monitoring
     */
    getHealthSummary(): {
        status: PerformerStatus;
        uptime: number;
        taskCount: number;
        errorCount: number;
        memoryUsageMB: number;
    };
}
//# sourceMappingURL=healthManager.d.ts.map