hikma-engine/dist/api/utils/timing.d.ts

Code Knowledge Graph Indexer - A sophisticated TypeScript-based indexer that transforms Git repositories into multi-dimensional knowledge stores for AI agents

/**
 * @file Response timing and metadata injection utilities.
 *       Provides comprehensive timing and performance monitoring for API responses.
 */
import { Request, Response, NextFunction } from 'express';
/**
 * Performance timing interface.
 */
export interface PerformanceTiming {
    startTime: number;
    endTime?: number;
    duration?: number;
    markers: Record<string, number>;
    measures: Record<string, number>;
}
/**
 * Request timing context.
 */
export interface TimingContext {
    request: PerformanceTiming;
    database?: PerformanceTiming;
    cache?: PerformanceTiming;
    search?: PerformanceTiming;
    processing?: PerformanceTiming;
}
/**
 * Timing measurement utility class.
 */
export declare class TimingUtil {
    private timings;
    /**
     * Starts a new timing measurement.
     */
    start(name: string): void;
    /**
     * Ends a timing measurement.
     */
    end(name: string): number;
    /**
     * Adds a marker to a timing measurement.
     */
    mark(timingName: string, markerName: string): void;
    /**
     * Measures time between two markers.
     */
    measure(timingName: string, measureName: string, startMarker: string, endMarker: string): void;
    /**
     * Gets timing information.
     */
    getTiming(name: string): PerformanceTiming | undefined;
    /**
     * Gets all timings.
     */
    getAllTimings(): Record<string, PerformanceTiming>;
    /**
     * Clears all timings.
     */
    clear(): void;
    /**
     * Gets duration for a completed timing.
     */
    getDuration(name: string): number | undefined;
}
/**
 * Request timing manager that attaches to request context.
 */
export declare class RequestTimingManager {
    private timingUtil;
    private requestId;
    constructor(requestId: string);
    /**
     * Starts request timing.
     */
    startRequest(): void;
    /**
     * Ends request timing.
     */
    endRequest(): number;
    /**
     * Times a database operation.
     */
    timeDatabase<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Times a cache operation.
     */
    timeCache<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Times a search operation.
     */
    timeSearch<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Times a processing operation.
     */
    timeProcessing<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Adds a custom marker.
     */
    mark(marker: string): void;
    /**
     * Gets performance summary.
     */
    getPerformanceSummary(): Record<string, number>;
    /**
     * Gets detailed timing information.
     */
    getDetailedTiming(): TimingContext;
}
/**
 * Extended Request interface with timing manager.
 */
declare global {
    namespace Express {
        interface Request {
            timing?: RequestTimingManager;
        }
    }
}
/**
 * Middleware to initialize request timing.
 */
export declare function initializeTimingMiddleware(req: Request, res: Response, next: NextFunction): void;
/**
 * Middleware to log performance metrics.
 */
export declare function performanceLoggingMiddleware(req: Request, res: Response, next: NextFunction): void;
/**
 * Utility function to create timing decorator for async functions.
 */
export declare function withTiming<T extends any[], R>(name: string, fn: (...args: T) => Promise<R>): (...args: T) => Promise<R>;
/**
 * Server-side performance metrics collector.
 */
export declare class PerformanceMetrics {
    private static metrics;
    /**
     * Records a metric value.
     */
    static record(metric: string, value: number): void;
    /**
     * Gets metric statistics.
     */
    static getStats(metric: string): {
        count: number;
        min: number;
        max: number;
        avg: number;
        p50: number;
        p95: number;
        p99: number;
    } | null;
    /**
     * Gets all metrics.
     */
    static getAllStats(): Record<string, any>;
    /**
     * Clears all metrics.
     */
    static clear(): void;
}
/**
 * Middleware to collect performance metrics.
 */
export declare function metricsCollectionMiddleware(req: Request, res: Response, next: NextFunction): void;
/**
 * Response header injection utilities.
 */
export declare const responseHeaders: {
    /**
     * Adds performance headers to response.
     */
    addPerformanceHeaders(res: Response, timing: RequestTimingManager): void;
    /**
     * Adds cache headers to response.
     */
    addCacheHeaders(res: Response, hit: boolean, ttl?: number): void;
    /**
     * Adds security headers to response.
     */
    addSecurityHeaders(res: Response): void;
};
//# sourceMappingURL=timing.d.ts.map