@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/monitoring/process-registry.js

@@ -0,0 +1,222 @@
+/**
+ * Process Registry
+ *
+ * Central registry for tracking all spawned processes in the RevealUI system.
+ * Maintains process lifecycle information and provides query capabilities.
+ */
+import { DEFAULT_MONITORING_CONFIG } from './types.js';
+/**
+ * Global process registry instance
+ */
+class ProcessRegistry {
+    processes = new Map();
+    enabled = DEFAULT_MONITORING_CONFIG.enabled;
+    maxHistorySize = DEFAULT_MONITORING_CONFIG.maxHistorySize;
+    /**
+     * Register a new process
+     */
+    register(pid, command, args, source, metadata, ppid) {
+        if (!this.enabled)
+            return;
+        const process = {
+            pid,
+            command,
+            args,
+            source,
+            status: 'running',
+            startTime: Date.now(),
+            metadata,
+            ppid,
+        };
+        this.processes.set(pid, process);
+        this.trimHistory();
+    }
+    /**
+     * Update process status
+     */
+    updateStatus(pid, status, exitCode, signal) {
+        if (!this.enabled)
+            return;
+        const process = this.processes.get(pid);
+        if (!process)
+            return;
+        process.status = status;
+        process.endTime = Date.now();
+        if (exitCode !== undefined) {
+            process.exitCode = exitCode;
+        }
+        if (signal !== undefined) {
+            process.signal = signal;
+        }
+    }
+    /**
+     * Mark process as zombie
+     */
+    markZombie(pid) {
+        this.updateStatus(pid, 'zombie');
+    }
+    /**
+     * Get process by PID
+     */
+    get(pid) {
+        return this.processes.get(pid);
+    }
+    /**
+     * Get all processes
+     */
+    getAll() {
+        return Array.from(this.processes.values());
+    }
+    /**
+     * Get processes by status
+     */
+    getByStatus(status) {
+        return this.getAll().filter((p) => p.status === status);
+    }
+    /**
+     * Get processes by source
+     */
+    getBySource(source) {
+        return this.getAll().filter((p) => p.source === source);
+    }
+    /**
+     * Get running processes
+     */
+    getRunning() {
+        return this.getByStatus('running');
+    }
+    /**
+     * Get zombie processes
+     */
+    getZombies() {
+        return this.getByStatus('zombie');
+    }
+    /**
+     * Get failed processes
+     */
+    getFailed() {
+        return this.getByStatus('failed');
+    }
+    /**
+     * Get registry statistics
+     */
+    getStats() {
+        const all = this.getAll();
+        const bySource = {
+            exec: 0,
+            orchestration: 0,
+            mcp: 0,
+            'ai-runtime': 0,
+            'dev-server': 0,
+            database: 0,
+            unknown: 0,
+        };
+        for (const process of all) {
+            bySource[process.source]++;
+        }
+        return {
+            total: all.length,
+            running: this.getByStatus('running').length,
+            completed: this.getByStatus('completed').length,
+            failed: this.getByStatus('failed').length,
+            zombies: this.getByStatus('zombie').length,
+            killed: this.getByStatus('killed').length,
+            bySource,
+        };
+    }
+    /**
+     * Calculate spawn rate (processes per minute)
+     */
+    getSpawnRate() {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60_000;
+        const recentProcesses = this.getAll().filter((p) => p.startTime >= oneMinuteAgo);
+        return recentProcesses.length;
+    }
+    /**
+     * Clear completed/failed processes older than retention period
+     */
+    trimHistory() {
+        if (this.processes.size <= this.maxHistorySize)
+            return;
+        const processArray = Array.from(this.processes.entries());
+        // Sort by end time (oldest first), then start time
+        processArray.sort(([, a], [, b]) => {
+            const aTime = a.endTime || a.startTime;
+            const bTime = b.endTime || b.startTime;
+            return aTime - bTime;
+        });
+        // Keep only running processes and recent completed/failed
+        const toKeep = new Map();
+        let keptCount = 0;
+        // First pass: keep all running and zombie processes
+        for (const [pid, process] of processArray) {
+            if (process.status === 'running' || process.status === 'zombie') {
+                toKeep.set(pid, process);
+                keptCount++;
+            }
+        }
+        // Second pass: keep most recent completed/failed up to limit
+        for (const [pid, process] of processArray.reverse()) {
+            if (keptCount >= this.maxHistorySize)
+                break;
+            if (process.status !== 'running' && process.status !== 'zombie' && !toKeep.has(pid)) {
+                toKeep.set(pid, process);
+                keptCount++;
+            }
+        }
+        this.processes = toKeep;
+    }
+    /**
+     * Clear all processes
+     */
+    clear() {
+        this.processes.clear();
+    }
+    /**
+     * Enable or disable tracking
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Check if tracking is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+}
+/**
+ * Singleton instance
+ */
+export const processRegistry = new ProcessRegistry();
+/**
+ * Convenience functions
+ */
+export function registerProcess(pid, command, args, source, metadata, ppid) {
+    processRegistry.register(pid, command, args, source, metadata, ppid);
+}
+export function updateProcessStatus(pid, status, exitCode, signal) {
+    processRegistry.updateStatus(pid, status, exitCode, signal);
+}
+export function markProcessZombie(pid) {
+    processRegistry.markZombie(pid);
+}
+export function getProcess(pid) {
+    return processRegistry.get(pid);
+}
+export function getAllProcesses() {
+    return processRegistry.getAll();
+}
+export function getRunningProcesses() {
+    return processRegistry.getRunning();
+}
+export function getZombieProcesses() {
+    return processRegistry.getZombies();
+}
+export function getProcessStats() {
+    return processRegistry.getStats();
+}
+export function getSpawnRate() {
+    return processRegistry.getSpawnRate();
+}

package/dist/monitoring/query-monitor.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Database Query Performance Monitoring
+ *
+ * Tracks query execution time and logs slow queries
+ */
+interface QueryMetric {
+    name: string;
+    duration: number;
+    success: boolean;
+    error?: unknown;
+    timestamp: number;
+}
+interface SlowQueryLog {
+    query: string;
+    duration: number;
+    parameters?: unknown[];
+    timestamp: number;
+    stackTrace?: string;
+}
+/**
+ * Monitor a database query execution
+ */
+export declare function monitorQuery<T>(name: string, queryFn: () => Promise<T>): Promise<T>;
+/**
+ * Log slow query
+ */
+export declare function logSlowQuery(query: string, duration: number, parameters?: unknown[]): void;
+/**
+ * Get query statistics
+ */
+export declare function getQueryStats(): {
+    totalQueries: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    successRate: number;
+    slowQueries: number;
+    slowQueryRate?: undefined;
+} | {
+    totalQueries: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    successRate: number;
+    slowQueries: number;
+    slowQueryRate: number;
+};
+/**
+ * Get slow query logs
+ */
+export declare function getSlowQueries(): SlowQueryLog[];
+/**
+ * Get queries by name
+ */
+export declare function getQueriesByName(name: string): QueryMetric[];
+/**
+ * Get query percentiles
+ */
+export declare function getQueryPercentiles(): {
+    p50: number;
+    p95: number;
+    p99: number;
+};
+/**
+ * Clear all metrics
+ */
+export declare function clearQueryMetrics(): void;
+/**
+ * Get query report
+ */
+export declare function getQueryReport(): {
+    summary: {
+        percentiles: {
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        totalQueries: number;
+        avgDuration: number;
+        maxDuration: number;
+        minDuration: number;
+        successRate: number;
+        slowQueries: number;
+        slowQueryRate?: undefined;
+    } | {
+        percentiles: {
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        totalQueries: number;
+        avgDuration: number;
+        maxDuration: number;
+        minDuration: number;
+        successRate: number;
+        slowQueries: number;
+        slowQueryRate: number;
+    };
+    slowQueries: SlowQueryLog[];
+    topQueries: {
+        name: string;
+        count: number;
+        totalDuration: number;
+        avgDuration: number;
+    }[];
+};
+/**
+ * Create query wrapper with automatic monitoring
+ */
+export declare function createMonitoredQuery<T extends (...args: unknown[]) => Promise<unknown>>(name: string, queryFn: T): T;
+/**
+ * Measure query execution time
+ */
+export declare function measureQuery<T>(query: () => Promise<T>): Promise<{
+    result: T;
+    duration: number;
+}>;
+/**
+ * Export metrics for external monitoring
+ */
+export declare function exportMetrics(): {
+    queries: {
+        percentiles: {
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        totalQueries: number;
+        avgDuration: number;
+        maxDuration: number;
+        minDuration: number;
+        successRate: number;
+        slowQueries: number;
+        slowQueryRate?: undefined;
+    } | {
+        percentiles: {
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        totalQueries: number;
+        avgDuration: number;
+        maxDuration: number;
+        minDuration: number;
+        successRate: number;
+        slowQueries: number;
+        slowQueryRate: number;
+    };
+    slowQueries: number;
+    timestamp: number;
+};
+export {};
+//# sourceMappingURL=query-monitor.d.ts.map

package/dist/monitoring/query-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-monitor.d.ts","sourceRoot":"","sources":["../../src/monitoring/query-monitor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,OAAO,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAUD;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgCzF;AAcD;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI,CAqB1F;AAED;;GAEG;AACH,wBAAgB,aAAa;;;;;;;;;;;;;;;;EAyB5B;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,YAAY,EAAE,CAE/C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAE5D;AAED;;GAEG;AACH,wBAAgB,mBAAmB;;;;EAgBlC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC;AAED;;GAEG;AACH,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa7B;AA8BD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACrF,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,GACT,CAAC,CAIH;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACtB,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAM1C;AAED;;GAEG;AACH,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS5B"}

package/dist/monitoring/query-monitor.js

@@ -0,0 +1,209 @@
+/**
+ * Database Query Performance Monitoring
+ *
+ * Tracks query execution time and logs slow queries
+ */
+import { logger } from '../observability/logger.js';
+const queryMetrics = [];
+const slowQueryLogs = [];
+// Configuration
+const SLOW_QUERY_THRESHOLD = 100; // milliseconds
+const MAX_METRICS_STORED = 1000;
+const MAX_SLOW_QUERIES_STORED = 100;
+/**
+ * Monitor a database query execution
+ */
+export async function monitorQuery(name, queryFn) {
+    const start = Date.now();
+    try {
+        const result = await queryFn();
+        const duration = Date.now() - start;
+        recordQueryMetric({
+            name,
+            duration,
+            success: true,
+            timestamp: start,
+        });
+        if (duration > SLOW_QUERY_THRESHOLD) {
+            logger.warn('Slow query detected', { query: name, duration });
+        }
+        return result;
+    }
+    catch (error) {
+        const duration = Date.now() - start;
+        recordQueryMetric({
+            name,
+            duration,
+            success: false,
+            error,
+            timestamp: start,
+        });
+        throw error;
+    }
+}
+/**
+ * Record query metric
+ */
+function recordQueryMetric(metric) {
+    queryMetrics.push(metric);
+    // Limit stored metrics
+    if (queryMetrics.length > MAX_METRICS_STORED) {
+        queryMetrics.shift();
+    }
+}
+/**
+ * Log slow query
+ */
+export function logSlowQuery(query, duration, parameters) {
+    const log = {
+        query,
+        duration,
+        parameters,
+        timestamp: Date.now(),
+        stackTrace: new Error().stack,
+    };
+    slowQueryLogs.push(log);
+    // Limit stored logs
+    if (slowQueryLogs.length > MAX_SLOW_QUERIES_STORED) {
+        slowQueryLogs.shift();
+    }
+    logger.warn('Slow query logged', {
+        query,
+        duration,
+        parameters,
+    });
+}
+/**
+ * Get query statistics
+ */
+export function getQueryStats() {
+    if (queryMetrics.length === 0) {
+        return {
+            totalQueries: 0,
+            avgDuration: 0,
+            maxDuration: 0,
+            minDuration: 0,
+            successRate: 0,
+            slowQueries: 0,
+        };
+    }
+    const durations = queryMetrics.map((m) => m.duration);
+    const successCount = queryMetrics.filter((m) => m.success).length;
+    const slowQueriesCount = queryMetrics.filter((m) => m.duration > SLOW_QUERY_THRESHOLD).length;
+    return {
+        totalQueries: queryMetrics.length,
+        avgDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
+        maxDuration: Math.max(...durations),
+        minDuration: Math.min(...durations),
+        successRate: (successCount / queryMetrics.length) * 100,
+        slowQueries: slowQueriesCount,
+        slowQueryRate: (slowQueriesCount / queryMetrics.length) * 100,
+    };
+}
+/**
+ * Get slow query logs
+ */
+export function getSlowQueries() {
+    return [...slowQueryLogs].sort((a, b) => b.duration - a.duration);
+}
+/**
+ * Get queries by name
+ */
+export function getQueriesByName(name) {
+    return queryMetrics.filter((m) => m.name === name);
+}
+/**
+ * Get query percentiles
+ */
+export function getQueryPercentiles() {
+    if (queryMetrics.length === 0) {
+        return { p50: 0, p95: 0, p99: 0 };
+    }
+    const sortedDurations = queryMetrics.map((m) => m.duration).sort((a, b) => a - b);
+    const p50Index = Math.floor(sortedDurations.length * 0.5);
+    const p95Index = Math.floor(sortedDurations.length * 0.95);
+    const p99Index = Math.floor(sortedDurations.length * 0.99);
+    return {
+        p50: sortedDurations[p50Index] || 0,
+        p95: sortedDurations[p95Index] || 0,
+        p99: sortedDurations[p99Index] || 0,
+    };
+}
+/**
+ * Clear all metrics
+ */
+export function clearQueryMetrics() {
+    queryMetrics.length = 0;
+    slowQueryLogs.length = 0;
+}
+/**
+ * Get query report
+ */
+export function getQueryReport() {
+    const stats = getQueryStats();
+    const percentiles = getQueryPercentiles();
+    const slowQueries = getSlowQueries().slice(0, 10); // Top 10 slowest
+    return {
+        summary: {
+            ...stats,
+            percentiles,
+        },
+        slowQueries,
+        topQueries: getTopQueriesByDuration(),
+    };
+}
+/**
+ * Get top queries by total duration
+ */
+function getTopQueriesByDuration() {
+    const queryGroups = new Map();
+    for (const metric of queryMetrics) {
+        const existing = queryGroups.get(metric.name) || {
+            count: 0,
+            totalDuration: 0,
+        };
+        queryGroups.set(metric.name, {
+            count: existing.count + 1,
+            totalDuration: existing.totalDuration + metric.duration,
+        });
+    }
+    return Array.from(queryGroups.entries())
+        .map(([name, data]) => ({
+        name,
+        count: data.count,
+        totalDuration: data.totalDuration,
+        avgDuration: data.totalDuration / data.count,
+    }))
+        .sort((a, b) => b.totalDuration - a.totalDuration)
+        .slice(0, 10);
+}
+/**
+ * Create query wrapper with automatic monitoring
+ */
+export function createMonitoredQuery(name, queryFn) {
+    return (async (...args) => {
+        return monitorQuery(name, () => queryFn(...args));
+    });
+}
+/**
+ * Measure query execution time
+ */
+export async function measureQuery(query) {
+    const start = Date.now();
+    const result = await query();
+    const duration = Date.now() - start;
+    return { result, duration };
+}
+/**
+ * Export metrics for external monitoring
+ */
+export function exportMetrics() {
+    return {
+        queries: {
+            ...getQueryStats(),
+            percentiles: getQueryPercentiles(),
+        },
+        slowQueries: getSlowQueries().length,
+        timestamp: Date.now(),
+    };
+}