@revealui/core 0.0.1-pre.4 → 0.2.0

package/dist/observability/alerts.js

@@ -0,0 +1,390 @@
+/**
+ * Alert System
+ *
+ * Configure and trigger alerts based on metrics and thresholds
+ */
+import { logger } from './logger.js';
+export class AlertingSystem {
+    rules = new Map();
+    channels = [];
+    activeAlerts = new Map();
+    lastFired = new Map();
+    /**
+     * Register alert rule
+     */
+    registerRule(rule) {
+        this.rules.set(rule.name, rule);
+    }
+    /**
+     * Unregister alert rule
+     */
+    unregisterRule(name) {
+        this.rules.delete(name);
+    }
+    /**
+     * Add alert channel
+     */
+    addChannel(channel) {
+        this.channels.push(channel);
+    }
+    /**
+     * Evaluate all rules
+     */
+    async evaluateRules() {
+        for (const [name, rule] of this.rules) {
+            if (rule.enabled === false)
+                continue;
+            try {
+                const shouldFire = await rule.condition();
+                if (shouldFire) {
+                    await this.fireAlert(name, rule);
+                }
+                else {
+                    await this.resolveAlert(name);
+                }
+            }
+            catch (error) {
+                logger.error('Failed to evaluate alert rule', error instanceof Error ? error : new Error(String(error)), { ruleName: name });
+            }
+        }
+    }
+    /**
+     * Fire an alert
+     */
+    async fireAlert(ruleName, rule) {
+        const now = Date.now();
+        const lastFired = this.lastFired.get(ruleName) || 0;
+        const cooldown = rule.cooldown || 0;
+        // Check cooldown
+        if (now - lastFired < cooldown) {
+            return;
+        }
+        // Create or update alert
+        let alert = this.activeAlerts.get(ruleName);
+        if (!alert) {
+            const message = typeof rule.message === 'function' ? rule.message({}) : rule.message;
+            alert = {
+                id: crypto.randomUUID(),
+                name: ruleName,
+                severity: rule.severity,
+                status: 'firing',
+                message,
+                timestamp: new Date().toISOString(),
+                labels: rule.labels,
+            };
+            this.activeAlerts.set(ruleName, alert);
+            this.lastFired.set(ruleName, now);
+            // Send to channels
+            await this.sendAlert(alert);
+        }
+    }
+    /**
+     * Resolve an alert
+     */
+    async resolveAlert(ruleName) {
+        const alert = this.activeAlerts.get(ruleName);
+        if (alert && alert.status === 'firing') {
+            alert.status = 'resolved';
+            alert.resolvedAt = new Date().toISOString();
+            // Send resolution to channels
+            await this.sendAlert(alert);
+            this.activeAlerts.delete(ruleName);
+        }
+    }
+    /**
+     * Send alert to channels
+     */
+    async sendAlert(alert) {
+        for (const channel of this.channels) {
+            // Check if channel handles this severity
+            if (channel.severities && !channel.severities.includes(alert.severity)) {
+                continue;
+            }
+            try {
+                await channel.send(alert);
+            }
+            catch (error) {
+                logger.error('Failed to send alert to channel', error instanceof Error ? error : new Error(String(error)), { channelName: channel.name });
+            }
+        }
+    }
+    /**
+     * Get active alerts
+     */
+    getActiveAlerts() {
+        return Array.from(this.activeAlerts.values());
+    }
+    /**
+     * Get alert by name
+     */
+    getAlert(name) {
+        return this.activeAlerts.get(name);
+    }
+    /**
+     * Start monitoring
+     */
+    startMonitoring(intervalMs = 60000) {
+        return setInterval(() => {
+            this.evaluateRules();
+        }, intervalMs);
+    }
+}
+/**
+ * Default alerting system
+ */
+export const alerting = new AlertingSystem();
+/**
+ * Console alert channel
+ */
+export const consoleChannel = {
+    name: 'console',
+    send: async (alert) => {
+        const emoji = alert.severity === 'critical'
+            ? '🔴'
+            : alert.severity === 'error'
+                ? '🟠'
+                : alert.severity === 'warning'
+                    ? '🟡'
+                    : '🔵';
+        const status = alert.status === 'firing' ? 'FIRING' : 'RESOLVED';
+        const logMessage = `${emoji} [${alert.severity.toUpperCase()}] ${status}: ${alert.name}`;
+        const logContext = {
+            message: alert.message,
+            details: alert.details,
+        };
+        if (alert.severity === 'critical' || alert.severity === 'error') {
+            logger.error(logMessage, undefined, logContext);
+        }
+        else if (alert.severity === 'warning') {
+            logger.warn(logMessage, logContext);
+        }
+        else {
+            logger.info(logMessage, logContext);
+        }
+        if (alert.details) {
+        }
+    },
+};
+/**
+ * Webhook alert channel
+ */
+export function createWebhookChannel(url, severities) {
+    return {
+        name: 'webhook',
+        severities,
+        send: async (alert) => {
+            await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(alert),
+            });
+        },
+    };
+}
+/**
+ * Email alert channel
+ */
+export function createEmailChannel(sendEmailFn, recipients, severities) {
+    return {
+        name: 'email',
+        severities,
+        send: async (alert) => {
+            const subject = `[${alert.severity.toUpperCase()}] ${alert.name}`;
+            const body = `
+Alert: ${alert.name}
+Severity: ${alert.severity}
+Status: ${alert.status}
+Time: ${alert.timestamp}
+
+${alert.message}
+
+${alert.details ? JSON.stringify(alert.details, null, 2) : ''}
+      `.trim();
+            for (const recipient of recipients) {
+                await sendEmailFn(recipient, subject, body);
+            }
+        },
+    };
+}
+/**
+ * Slack alert channel
+ */
+export function createSlackChannel(webhookUrl, severities) {
+    return {
+        name: 'slack',
+        severities,
+        send: async (alert) => {
+            const color = alert.severity === 'critical'
+                ? 'danger'
+                : alert.severity === 'error'
+                    ? 'warning'
+                    : alert.severity === 'warning'
+                        ? '#FFA500'
+                        : 'good';
+            const payload = {
+                attachments: [
+                    {
+                        color,
+                        title: `${alert.status === 'firing' ? '🔔' : '✅'} ${alert.name}`,
+                        text: alert.message,
+                        fields: [
+                            {
+                                title: 'Severity',
+                                value: alert.severity,
+                                short: true,
+                            },
+                            {
+                                title: 'Status',
+                                value: alert.status,
+                                short: true,
+                            },
+                            {
+                                title: 'Time',
+                                value: alert.timestamp,
+                                short: true,
+                            },
+                        ],
+                        footer: 'RevealUI Monitoring',
+                        ts: Math.floor(new Date(alert.timestamp).getTime() / 1000),
+                    },
+                ],
+            };
+            await fetch(webhookUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+        },
+    };
+}
+/**
+ * Common alert rules
+ */
+/**
+ * High error rate alert
+ */
+export function createErrorRateAlert(getErrorRate, threshold = 5) {
+    return {
+        name: 'high_error_rate',
+        severity: 'error',
+        condition: () => getErrorRate() > threshold,
+        message: `Error rate (${getErrorRate()}%) exceeds threshold (${threshold}%)`,
+        cooldown: 300000, // 5 minutes
+    };
+}
+/**
+ * High response time alert
+ */
+export function createResponseTimeAlert(getP95, threshold = 1000) {
+    return {
+        name: 'high_response_time',
+        severity: 'warning',
+        condition: () => getP95() > threshold,
+        message: `Response time p95 (${getP95()}ms) exceeds threshold (${threshold}ms)`,
+        cooldown: 300000, // 5 minutes
+    };
+}
+/**
+ * Low cache hit rate alert
+ */
+export function createCacheHitRateAlert(getCacheHitRate, threshold = 60) {
+    return {
+        name: 'low_cache_hit_rate',
+        severity: 'warning',
+        condition: () => getCacheHitRate() < threshold,
+        message: `Cache hit rate (${getCacheHitRate()}%) below threshold (${threshold}%)`,
+        cooldown: 600000, // 10 minutes
+    };
+}
+/**
+ * High memory usage alert
+ */
+export function createMemoryUsageAlert(getMemoryUsage, threshold = 90) {
+    return {
+        name: 'high_memory_usage',
+        severity: 'error',
+        condition: () => getMemoryUsage() > threshold,
+        message: `Memory usage (${getMemoryUsage()}%) exceeds threshold (${threshold}%)`,
+        cooldown: 300000, // 5 minutes
+    };
+}
+/**
+ * Database connection alert
+ */
+export function createDatabaseAlert(checkConnection) {
+    return {
+        name: 'database_connection',
+        severity: 'critical',
+        condition: async () => !(await checkConnection()),
+        message: 'Database connection lost',
+        cooldown: 60000, // 1 minute
+    };
+}
+/**
+ * Service health alert
+ */
+export function createServiceHealthAlert(serviceName, checkHealth) {
+    return {
+        name: `service_health_${serviceName}`,
+        severity: 'error',
+        condition: async () => !(await checkHealth()),
+        message: `Service ${serviceName} is unhealthy`,
+        cooldown: 180000, // 3 minutes
+    };
+}
+/**
+ * Disk space alert
+ */
+export function createDiskSpaceAlert(getDiskUsage, threshold = 90) {
+    return {
+        name: 'low_disk_space',
+        severity: 'warning',
+        condition: () => getDiskUsage() > threshold,
+        message: `Disk usage (${getDiskUsage()}%) exceeds threshold (${threshold}%)`,
+        cooldown: 3600000, // 1 hour
+    };
+}
+/**
+ * Queue size alert
+ */
+export function createQueueSizeAlert(queueName, getQueueSize, threshold = 1000) {
+    return {
+        name: `queue_size_${queueName}`,
+        severity: 'warning',
+        condition: () => getQueueSize() > threshold,
+        message: `Queue ${queueName} size (${getQueueSize()}) exceeds threshold (${threshold})`,
+        cooldown: 300000, // 5 minutes
+    };
+}
+/**
+ * Custom metric alert
+ */
+export function createMetricAlert(name, getMetric, threshold, operator = '>', severity = 'warning') {
+    const condition = () => {
+        const value = getMetric();
+        switch (operator) {
+            case '>':
+                return value > threshold;
+            case '<':
+                return value < threshold;
+            case '=':
+                return value === threshold;
+            default:
+                return false;
+        }
+    };
+    return {
+        name,
+        severity,
+        condition,
+        message: () => {
+            const value = getMetric();
+            return `Metric ${name} (${value}) ${operator} threshold (${threshold})`;
+        },
+        cooldown: 300000, // 5 minutes
+    };
+}

package/dist/observability/health-check.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Health Check System
+ *
+ * Provides health and readiness checks for the application
+ */
+export type HealthStatus = 'healthy' | 'degraded' | 'unhealthy';
+export interface HealthCheck {
+    name: string;
+    check: () => Promise<HealthCheckResult>;
+    critical?: boolean;
+    timeout?: number;
+}
+export interface HealthCheckResult {
+    status: HealthStatus;
+    message?: string;
+    details?: Record<string, unknown>;
+    duration?: number;
+    timestamp?: string;
+}
+export interface SystemHealth {
+    status: HealthStatus;
+    checks: Record<string, HealthCheckResult>;
+    timestamp: string;
+    uptime: number;
+    version?: string;
+}
+export declare class HealthCheckSystem {
+    private checks;
+    private startTime;
+    /**
+     * Register a health check
+     */
+    register(check: HealthCheck): void;
+    /**
+     * Unregister a health check
+     */
+    unregister(name: string): void;
+    /**
+     * Run all health checks
+     */
+    checkHealth(): Promise<SystemHealth>;
+    /**
+     * Run check with timeout
+     */
+    private runWithTimeout;
+    /**
+     * Get uptime in seconds
+     */
+    getUptime(): number;
+}
+/**
+ * Default health check system
+ */
+export declare const healthCheck: HealthCheckSystem;
+/**
+ * Database health check
+ */
+export declare function createDatabaseHealthCheck(queryFn: () => Promise<void>): HealthCheck;
+/**
+ * Redis health check
+ */
+export declare function createRedisHealthCheck(pingFn: () => Promise<string>): HealthCheck;
+/**
+ * Memory health check
+ */
+export declare function createMemoryHealthCheck(thresholdPercent?: number): HealthCheck;
+/**
+ * Disk health check
+ */
+export declare function createDiskHealthCheck(_thresholdPercent?: number): HealthCheck;
+/**
+ * API endpoint health check
+ */
+export declare function createAPIHealthCheck(url: string, expectedStatus?: number): HealthCheck;
+/**
+ * Custom health check
+ */
+export declare function createCustomHealthCheck(name: string, checkFn: () => Promise<HealthCheckResult>, critical?: boolean): HealthCheck;
+/**
+ * Create health check endpoint handler
+ */
+export declare function createHealthEndpoint(): () => Promise<Response>;
+/**
+ * Create readiness check endpoint handler
+ */
+export declare function createReadinessEndpoint(): () => Promise<Response>;
+/**
+ * Create liveness check endpoint handler
+ */
+export declare function createLivenessEndpoint(): () => Response;
+/**
+ * Monitor health and log status changes
+ */
+export declare function monitorHealth(intervalMs?: number, onStatusChange?: (status: HealthStatus) => void): Promise<NodeJS.Timeout>;
+//# sourceMappingURL=health-check.d.ts.map

package/dist/observability/health-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-check.d.ts","sourceRoot":"","sources":["../../src/observability/health-check.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACvC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,YAAY,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IACzC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,SAAS,CAAqB;IAEtC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAIlC;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI9B;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC;IAoD1C;;OAEG;YACW,cAAc;IAS5B;;OAEG;IACH,SAAS,IAAI,MAAM;CAGpB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,mBAA0B,CAAA;AAElD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,WAAW,CA4BnF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,WAAW,CAmCjF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,gBAAgB,GAAE,MAAW,GAAG,WAAW,CAwClF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,iBAAiB,GAAE,MAAW,GAAG,WAAW,CAcjF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,GAAE,MAAY,GAAG,WAAW,CAuC3F;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,EACzC,QAAQ,GAAE,OAAe,GACxB,WAAW,CAMb;AAED;;GAEG;AACH,wBAAgB,oBAAoB,UACjB,OAAO,CAAC,QAAQ,CAAC,CAanC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,UACpB,OAAO,CAAC,QAAQ,CAAC,CA2BnC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,UACzB,QAAQ,CAqBpB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,UAAU,GAAE,MAAc,EAC1B,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC9C,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAsBzB"}