crewai-ts/flow/orchestration/FlowExecutionTracker.d.ts

TypeScript port of crewAI for agent-based workflows

/**
 * FlowExecutionTracker
 *
 * Provides optimized tracking and metrics for flow execution in the Flow Orchestration system.
 * Designed for high-performance in multi-flow environments with minimal memory footprint.
 */
import { EventEmitter } from 'events';
interface NodeExecutionData {
    nodeId: string;
    status: 'pending' | 'running' | 'completed' | 'failed';
    startTime?: number;
    endTime?: number;
    duration?: number;
    attempts: number;
    result?: any;
    error?: Error;
}
export type FlowStatus = 'pending' | 'ready' | 'running' | 'completed' | 'failed' | 'canceled';
export interface FlowMetrics {
    startTime: number | undefined;
    endTime?: number | undefined;
    duration?: number | undefined;
    status: FlowStatus;
    attempts: number;
    error?: Error | undefined;
    result?: any;
    nodeExecutions?: Map<string, NodeExecutionData> | undefined;
    metadata?: Record<string, any> | undefined;
    dependencies?: Set<string> | undefined;
    dependents?: Set<string> | undefined;
    resourceUsage?: {
        cpu: number | undefined;
        memory: number | undefined;
        io: number | undefined;
        network: number | undefined;
    };
    memory?: {
        bytesAllocated?: number | undefined;
        peakMemoryUsage?: number | undefined;
    };
    priority?: number | undefined;
}
export interface TrackerOptions {
    /** Enable in-depth memory tracking (adds overhead) */
    enableMemoryTracking?: boolean;
    /** Maximum number of flows to keep in history */
    maxHistorySize?: number;
    /** Interval (ms) to collect time series data, 0 to disable */
    timeSeriesInterval?: number;
    /** Maximum number of time series data points to keep */
    maxTimeSeriesPoints?: number;
    /** Automatically calculate bottlenecks */
    trackBottlenecks?: boolean;
    /** Track performance variance */
    trackVariance?: boolean;
    /** Sample rate for detailed tracking (1 = track everything, 0.5 = track 50%) */
    samplingRate?: number;
    /** Maximum errors to store per flow */
    maxErrorsPerFlow?: number;
}
/**
 * Tracks flow execution with optimized data structures and algorithms
 * for minimal overhead and maximum performance insight.
 */
export declare class FlowExecutionTracker extends EventEmitter {
    private flowData;
    private durations;
    private totalDuration;
    private statusCounts;
    private bottlenecks;
    private timeSeriesData;
    private startTime;
    private endTime?;
    constructor(options?: TrackerOptions);
    registerFlow(flowId: string): void;
    addDependency(flowId: string, dependencyId: string): void;
    startFlow(flowId: string): void;
    completeFlow(flowId: string, result: any): void;
    failFlow(flowId: string, error: Error): void;
    cancelFlow(flowId: string): void;
    resetFlow(flowId: string): void;
    private getFlowMetrics;
    getFlowExecutionTime(flowId: string): number;
    getFlowStatus(flowId: string): FlowStatus;
    getFlowError(flowId: string): Error | undefined;
    getFlowResult(flowId: string): any;
    getFlowCount(): number;
    getCompletedFlows(): number;
    getFailedFlows(): number;
    getRunningFlows(): number;
    getPendingFlows(): number;
    getCanceledFlows(): number;
    getReadyFlows(): number;
    getBottlenecks(): string[];
    getTimeSeriesData(): Array<{
        timestamp: number;
        metrics: Record<string, number>;
    }>;
    saveExecutionCheckpoint(): Promise<void>;
    loadExecutionCheckpoint(): Promise<void>;
    waitForAnyFlowToComplete(): Promise<string | undefined>;
    reset(): void;
    private collectTimeSeriesDataPoint;
    startTracking(): void;
    stopTracking(): void;
    private updateBottlenecks;
    private calculateMedian;
    private calculateP95;
    getMetrics(): FlowExecutionMetrics;
    updateDependencies(flowId: string, dependencies: string[]): void;
    updateFlowMetrics(flowId: string): void;
    getFlowResourceUsage(flowId: string): FlowResourceUsage | undefined;
}
export interface FlowExecutionMetrics {
    flowExecutionTimes: Map<string, number | undefined>;
    startTime: number;
    endTime: number | undefined;
    duration: number;
    averageFlowExecutionTime: number | undefined;
    medianFlowExecutionTime: number | undefined;
    maxFlowExecutionTime: number | undefined;
    minFlowExecutionTime: number | undefined;
    completedFlows: number;
    failedFlows: number;
    pendingFlows: number;
    runningFlows: number;
    readyFlows: number;
    canceledFlows: number;
    bottlenecks: string[];
    timeSeriesData: Array<{
        timestamp: number;
        metrics: Record<string, number>;
    }>;
}
export interface FlowResourceUsage {
    cpu: number;
    memory: number;
    io: number;
    network: number;
}
export {};
//# sourceMappingURL=FlowExecutionTracker.d.ts.map