@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/observability/health-check.js

@@ -0,0 +1,345 @@
+/**
+ * Health Check System
+ *
+ * Provides health and readiness checks for the application
+ */
+import { logger } from './logger.js';
+export class HealthCheckSystem {
+    checks = new Map();
+    startTime = Date.now();
+    /**
+     * Register a health check
+     */
+    register(check) {
+        this.checks.set(check.name, check);
+    }
+    /**
+     * Unregister a health check
+     */
+    unregister(name) {
+        this.checks.delete(name);
+    }
+    /**
+     * Run all health checks
+     */
+    async checkHealth() {
+        const results = {};
+        let overallStatus = 'healthy';
+        for (const [name, check] of this.checks) {
+            const startTime = Date.now();
+            try {
+                const timeout = check.timeout || 5000;
+                const result = await this.runWithTimeout(check.check(), timeout);
+                results[name] = {
+                    ...result,
+                    duration: Date.now() - startTime,
+                    timestamp: new Date().toISOString(),
+                };
+                // Update overall status
+                if (check.critical && result.status === 'unhealthy') {
+                    overallStatus = 'unhealthy';
+                }
+                else if (result.status === 'degraded' && overallStatus === 'healthy') {
+                    overallStatus = 'degraded';
+                }
+                else if (result.status === 'unhealthy' && overallStatus !== 'unhealthy') {
+                    overallStatus = 'degraded';
+                }
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                results[name] = {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'Check failed',
+                    duration,
+                    timestamp: new Date().toISOString(),
+                };
+                if (check.critical) {
+                    overallStatus = 'unhealthy';
+                }
+                else if (overallStatus === 'healthy') {
+                    overallStatus = 'degraded';
+                }
+            }
+        }
+        return {
+            status: overallStatus,
+            checks: results,
+            timestamp: new Date().toISOString(),
+            uptime: Date.now() - this.startTime,
+            version: process.env.APP_VERSION,
+        };
+    }
+    /**
+     * Run check with timeout
+     */
+    async runWithTimeout(promise, timeoutMs) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Check timeout')), timeoutMs)),
+        ]);
+    }
+    /**
+     * Get uptime in seconds
+     */
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime) / 1000);
+    }
+}
+/**
+ * Default health check system
+ */
+export const healthCheck = new HealthCheckSystem();
+/**
+ * Database health check
+ */
+export function createDatabaseHealthCheck(queryFn) {
+    return {
+        name: 'database',
+        critical: true,
+        timeout: 5000,
+        check: async () => {
+            const startTime = Date.now();
+            try {
+                await queryFn();
+                const duration = Date.now() - startTime;
+                return {
+                    status: duration > 1000 ? 'degraded' : 'healthy',
+                    message: duration > 1000 ? 'Database responding slowly' : 'Database healthy',
+                    details: {
+                        responseTime: duration,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'Database connection failed',
+                };
+            }
+        },
+    };
+}
+/**
+ * Redis health check
+ */
+export function createRedisHealthCheck(pingFn) {
+    return {
+        name: 'redis',
+        critical: false,
+        timeout: 3000,
+        check: async () => {
+            const startTime = Date.now();
+            try {
+                const response = await pingFn();
+                if (response !== 'PONG') {
+                    return {
+                        status: 'unhealthy',
+                        message: 'Redis ping failed',
+                    };
+                }
+                const duration = Date.now() - startTime;
+                return {
+                    status: duration > 500 ? 'degraded' : 'healthy',
+                    message: duration > 500 ? 'Redis responding slowly' : 'Redis healthy',
+                    details: {
+                        responseTime: duration,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'Redis connection failed',
+                };
+            }
+        },
+    };
+}
+/**
+ * Memory health check
+ */
+export function createMemoryHealthCheck(thresholdPercent = 90) {
+    return {
+        name: 'memory',
+        critical: false,
+        timeout: 1000,
+        check: async () => {
+            if (typeof process === 'undefined') {
+                return {
+                    status: 'healthy',
+                    message: 'Memory check not available',
+                };
+            }
+            const usage = process.memoryUsage();
+            const usedPercent = (usage.heapUsed / usage.heapTotal) * 100;
+            let status = 'healthy';
+            let message = 'Memory usage normal';
+            if (usedPercent > thresholdPercent) {
+                status = 'unhealthy';
+                message = 'Memory usage critical';
+            }
+            else if (usedPercent > thresholdPercent * 0.8) {
+                status = 'degraded';
+                message = 'Memory usage high';
+            }
+            return {
+                status,
+                message,
+                details: {
+                    heapUsed: usage.heapUsed,
+                    heapTotal: usage.heapTotal,
+                    usedPercent: usedPercent.toFixed(2),
+                    external: usage.external,
+                    rss: usage.rss,
+                },
+            };
+        },
+    };
+}
+/**
+ * Disk health check
+ */
+export function createDiskHealthCheck(_thresholdPercent = 90) {
+    return {
+        name: 'disk',
+        critical: false,
+        timeout: 2000,
+        check: async () => {
+            // This would require a native module or fs stats
+            // Placeholder implementation
+            return {
+                status: 'healthy',
+                message: 'Disk check not implemented',
+            };
+        },
+    };
+}
+/**
+ * API endpoint health check
+ */
+export function createAPIHealthCheck(url, expectedStatus = 200) {
+    return {
+        name: `api:${url}`,
+        critical: false,
+        timeout: 10000,
+        check: async () => {
+            const startTime = Date.now();
+            try {
+                const response = await fetch(url);
+                const duration = Date.now() - startTime;
+                if (response.status !== expectedStatus) {
+                    return {
+                        status: 'unhealthy',
+                        message: `API returned ${response.status}, expected ${expectedStatus}`,
+                        details: {
+                            status: response.status,
+                            responseTime: duration,
+                        },
+                    };
+                }
+                return {
+                    status: duration > 2000 ? 'degraded' : 'healthy',
+                    message: duration > 2000 ? 'API responding slowly' : 'API healthy',
+                    details: {
+                        status: response.status,
+                        responseTime: duration,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'API unreachable',
+                };
+            }
+        },
+    };
+}
+/**
+ * Custom health check
+ */
+export function createCustomHealthCheck(name, checkFn, critical = false) {
+    return {
+        name,
+        critical,
+        check: checkFn,
+    };
+}
+/**
+ * Create health check endpoint handler
+ */
+export function createHealthEndpoint() {
+    return async () => {
+        const health = await healthCheck.checkHealth();
+        const status = health.status === 'healthy' ? 200 : health.status === 'degraded' ? 200 : 503;
+        return new Response(JSON.stringify(health, null, 2), {
+            status,
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-cache, no-store, must-revalidate',
+            },
+        });
+    };
+}
+/**
+ * Create readiness check endpoint handler
+ */
+export function createReadinessEndpoint() {
+    return async () => {
+        const health = await healthCheck.checkHealth();
+        // Only return 200 if all critical checks are healthy
+        const ready = health.status !== 'unhealthy';
+        const status = ready ? 200 : 503;
+        return new Response(JSON.stringify({
+            ready,
+            status: health.status,
+            timestamp: health.timestamp,
+        }, null, 2), {
+            status,
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-cache, no-store, must-revalidate',
+            },
+        });
+    };
+}
+/**
+ * Create liveness check endpoint handler
+ */
+export function createLivenessEndpoint() {
+    return () => {
+        // Liveness is simple - if we can respond, we're alive
+        return new Response(JSON.stringify({
+            alive: true,
+            timestamp: new Date().toISOString(),
+            uptime: healthCheck.getUptime(),
+        }, null, 2), {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-cache, no-store, must-revalidate',
+            },
+        });
+    };
+}
+/**
+ * Monitor health and log status changes
+ */
+export async function monitorHealth(intervalMs = 30000, onStatusChange) {
+    let lastStatus = null;
+    const monitor = async () => {
+        const health = await healthCheck.checkHealth();
+        if (health.status !== lastStatus) {
+            logger.info('Health status changed', { from: lastStatus, to: health.status });
+            if (onStatusChange) {
+                onStatusChange(health.status);
+            }
+            lastStatus = health.status;
+        }
+    };
+    // Run immediately
+    await monitor();
+    // Then run on interval
+    return setInterval(monitor, intervalMs);
+}

package/dist/observability/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Observability Module
+ *
+ * Centralized exports for observability functionality including logging,
+ * metrics, tracing, alerts, and health checks.
+ */
+export * from './alerts.js';
+export * from './health-check.js';
+export * from './logger.js';
+export * from './metrics.js';
+export * from './tracing.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/observability/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observability/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

package/dist/observability/index.js

@@ -0,0 +1,11 @@
+/**
+ * Observability Module
+ *
+ * Centralized exports for observability functionality including logging,
+ * metrics, tracing, alerts, and health checks.
+ */
+export * from './alerts.js';
+export * from './health-check.js';
+export * from './logger.js';
+export * from './metrics.js';
+export * from './tracing.js';

package/dist/observability/logger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Structured Logging Infrastructure
+ *
+ * Re-exports from @revealui/utils to maintain backward compatibility.
+ * The actual implementation has been moved to @revealui/utils to break circular dependencies.
+ */
+export type { LogContext, LogEntry, LoggerConfig, LogLevel, } from '@revealui/utils/logger';
+export { createLogger, Logger, logAudit, logError, logger, logQuery, } from '@revealui/utils/logger';
+/**
+ * Request logger middleware
+ */
+export declare function createRequestLogger<TRequest = unknown, TResponse = unknown>(options?: {
+    includeBody?: boolean;
+    includeHeaders?: boolean;
+}): (request: TRequest & {
+    method: string;
+    url: string;
+    headers?: {
+        get?: (key: string) => string | null;
+        entries?: () => Iterable<[string, string]>;
+    };
+}, next: () => Promise<TResponse>) => Promise<TResponse>;
+/**
+ * Performance logger
+ */
+export declare function logPerformance(operation: string, duration: number, context?: Record<string, unknown>): void;
+/**
+ * API call logger
+ */
+export declare function logAPICall(method: string, url: string, status: number, duration: number, context?: Record<string, unknown>): void;
+/**
+ * Cache operation logger
+ */
+export declare function logCache(operation: 'hit' | 'miss' | 'set' | 'delete', key: string, context?: Record<string, unknown>): void;
+/**
+ * User action logger
+ */
+export declare function logUserAction(action: string, userId?: string, context?: Record<string, unknown>): void;
+/**
+ * System event logger
+ */
+export declare function logSystemEvent(event: string, context?: Record<string, unknown>): void;
+/**
+ * Sanitize sensitive data from logs
+ */
+export declare function sanitizeLogData(data: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/observability/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/observability/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,YAAY,EACV,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,GACT,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EACL,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,QAAQ,GACT,MAAM,wBAAwB,CAAA;AAK/B;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,GAAG,OAAO,EAAE,SAAS,GAAG,OAAO,EACzE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,IAG/D,SAAS,QAAQ,GAAG;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;KAAE,CAAA;CAC/F,EACD,MAAM,MAAM,OAAO,CAAC,SAAS,CAAC,KAC7B,OAAO,CAAC,SAAS,CAAC,CA6CtB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CASN;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CAgBN;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,EAC5C,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CAMN;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CAMN;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAKrF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2BtF"}

package/dist/observability/logger.js

@@ -0,0 +1,140 @@
+/**
+ * Structured Logging Infrastructure
+ *
+ * Re-exports from @revealui/utils to maintain backward compatibility.
+ * The actual implementation has been moved to @revealui/utils to break circular dependencies.
+ */
+// Import logger for internal use
+import { logger as utilsLogger } from '@revealui/utils/logger';
+export { createLogger, Logger, logAudit, logError, logger, logQuery, } from '@revealui/utils/logger';
+// Additional helper functions that were in core but not in utils
+// These can stay here as they're core-specific
+/**
+ * Request logger middleware
+ */
+export function createRequestLogger(options = {}) {
+    return async (request, next) => {
+        // Import logger at runtime to avoid circular deps
+        const { logger } = await import('@revealui/utils/logger');
+        const requestId = crypto.randomUUID();
+        const startTime = Date.now();
+        const requestLogger = logger.child({
+            requestId,
+            method: request.method,
+            url: request.url,
+            userAgent: request.headers?.get?.('user-agent'),
+        });
+        requestLogger.info('Request started');
+        if (options.includeHeaders) {
+            requestLogger.debug('Request headers', {
+                headers: Object.fromEntries(request.headers?.entries?.() || []),
+            });
+        }
+        try {
+            const response = await next();
+            const duration = Date.now() - startTime;
+            const responseWithStatus = response;
+            requestLogger.info('Request completed', {
+                status: responseWithStatus.status ?? 200,
+                duration,
+            });
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            requestLogger.error('Request failed', error instanceof Error ? error : new Error(String(error)), { duration });
+            throw error;
+        }
+    };
+}
+/**
+ * Performance logger
+ */
+export function logPerformance(operation, duration, context) {
+    const level = duration > 1000 ? 'warn' : 'info';
+    utilsLogger[level](`Performance: ${operation}`, {
+        ...context,
+        operation,
+        duration,
+        slow: duration > 1000,
+    });
+}
+/**
+ * API call logger
+ */
+export function logAPICall(method, url, status, duration, context) {
+    const apiContext = {
+        ...context,
+        method,
+        url,
+        status,
+        duration,
+    };
+    if (status >= 400) {
+        utilsLogger.error('API call', undefined, apiContext);
+    }
+    else if (status >= 300) {
+        utilsLogger.warn('API call', apiContext);
+    }
+    else {
+        utilsLogger.info('API call', apiContext);
+    }
+}
+/**
+ * Cache operation logger
+ */
+export function logCache(operation, key, context) {
+    utilsLogger.debug(`Cache ${operation}`, {
+        ...context,
+        operation,
+        key,
+    });
+}
+/**
+ * User action logger
+ */
+export function logUserAction(action, userId, context) {
+    utilsLogger.info('User action', {
+        ...context,
+        action,
+        userId,
+    });
+}
+/**
+ * System event logger
+ */
+export function logSystemEvent(event, context) {
+    utilsLogger.info('System event', {
+        ...context,
+        event,
+    });
+}
+/**
+ * Sanitize sensitive data from logs
+ */
+export function sanitizeLogData(data) {
+    const sensitiveKeys = [
+        'password',
+        'token',
+        'secret',
+        'apiKey',
+        'accessToken',
+        'refreshToken',
+        'creditCard',
+        'ssn',
+    ];
+    const sanitized = {};
+    for (const [key, value] of Object.entries(data)) {
+        const lowerKey = key.toLowerCase();
+        if (sensitiveKeys.some((sensitive) => lowerKey.includes(sensitive))) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            sanitized[key] = sanitizeLogData(value);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}