@revealui/core 0.0.1-pre.4 → 0.2.0

package/dist/observability/metrics.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Metrics Collection System
+ *
+ * Collect and expose application metrics for monitoring
+ */
+export type MetricType = 'counter' | 'gauge' | 'histogram' | 'summary';
+export interface MetricLabels {
+    [key: string]: string | number;
+}
+export interface MetricValue {
+    value: number;
+    timestamp: number;
+    labels?: MetricLabels;
+}
+export interface Metric {
+    name: string;
+    type: MetricType;
+    help: string;
+    values: MetricValue[];
+    labels?: string[];
+}
+export interface HistogramBucket {
+    le: number;
+    count: number;
+}
+export interface HistogramMetric extends Metric {
+    type: 'histogram';
+    buckets: HistogramBucket[];
+    sum: number;
+    count: number;
+}
+export declare class MetricsCollector {
+    private metrics;
+    /**
+     * Register a counter metric
+     */
+    counter(name: string, help: string, labels?: string[]): Counter;
+    /**
+     * Register a gauge metric
+     */
+    gauge(name: string, help: string, labels?: string[]): Gauge;
+    /**
+     * Register a histogram metric
+     */
+    histogram(name: string, help: string, buckets?: number[], labels?: string[]): Histogram;
+    /**
+     * Get all metrics
+     */
+    getMetrics(): Metric[];
+    /**
+     * Get metric by name
+     */
+    getMetric(name: string): Metric | undefined;
+    /**
+     * Clear all metrics
+     */
+    clear(): void;
+    /**
+     * Export metrics in Prometheus format
+     */
+    exportPrometheus(): string;
+    /**
+     * Export metrics as JSON
+     */
+    exportJSON(): Record<string, unknown>;
+}
+/**
+ * Counter metric
+ */
+export declare class Counter {
+    private metric;
+    constructor(metric: Metric);
+    /**
+     * Increment counter
+     */
+    inc(value?: number, labels?: MetricLabels): void;
+    /**
+     * Get current value
+     */
+    get(labels?: MetricLabels): number;
+    /**
+     * Find value by labels
+     */
+    private findValue;
+    /**
+     * Check if labels match
+     */
+    private labelsMatch;
+}
+/**
+ * Gauge metric
+ */
+export declare class Gauge {
+    private metric;
+    constructor(metric: Metric);
+    /**
+     * Set gauge value
+     */
+    set(value: number, labels?: MetricLabels): void;
+    /**
+     * Increment gauge
+     */
+    inc(value?: number, labels?: MetricLabels): void;
+    /**
+     * Decrement gauge
+     */
+    dec(value?: number, labels?: MetricLabels): void;
+    /**
+     * Get current value
+     */
+    get(labels?: MetricLabels): number;
+    /**
+     * Find value by labels
+     */
+    private findValue;
+    /**
+     * Check if labels match
+     */
+    private labelsMatch;
+}
+/**
+ * Histogram metric
+ */
+export declare class Histogram {
+    private metric;
+    constructor(metric: HistogramMetric);
+    /**
+     * Observe a value
+     */
+    observe(value: number, labels?: MetricLabels): void;
+    /**
+     * Start a timer
+     */
+    startTimer(labels?: MetricLabels): () => void;
+    /**
+     * Get percentile
+     */
+    percentile(p: number): number;
+    /**
+     * Get average
+     */
+    average(): number;
+}
+/**
+ * Default metrics collector
+ */
+export declare const metrics: MetricsCollector;
+/**
+ * Application metrics
+ */
+export declare const appMetrics: {
+    httpRequestsTotal: Counter;
+    httpRequestDuration: Histogram;
+    dbQueriesTotal: Counter;
+    dbQueryDuration: Histogram;
+    cacheOperationsTotal: Counter;
+    cacheHitRate: Gauge;
+    activeConnections: Gauge;
+    errorsTotal: Counter;
+    queueSize: Gauge;
+    queueProcessingDuration: Histogram;
+    memoryUsage: Gauge;
+    apiCallsTotal: Counter;
+    apiCallDuration: Histogram;
+};
+/**
+ * Track HTTP request
+ */
+export declare function trackHTTPRequest(method: string, path: string, status: number, duration: number): void;
+/**
+ * Track database query
+ */
+export declare function trackDBQuery(operation: string, table: string, duration: number): void;
+/**
+ * Track cache operation
+ */
+export declare function trackCacheOperation(operation: 'hit' | 'miss' | 'set' | 'delete', result?: 'success' | 'error'): void;
+/**
+ * Track error
+ */
+export declare function trackError(type: string, severity?: 'low' | 'medium' | 'high' | 'critical'): void;
+/**
+ * Update active connections
+ */
+export declare function updateActiveConnections(type: string, delta: number): void;
+/**
+ * Update memory usage
+ */
+export declare function updateMemoryUsage(): void;
+/**
+ * Start memory monitoring
+ */
+export declare function startMemoryMonitoring(intervalMs?: number): NodeJS.Timeout;
+/**
+ * Create metrics middleware
+ */
+export declare function createMetricsMiddleware<TRequest = unknown, TResponse = unknown>(): (request: TRequest & {
+    method: string;
+    url: string;
+}, next: () => Promise<TResponse & {
+    status?: number;
+}>) => Promise<TResponse & {
+    status?: number;
+}>;
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/observability/metrics.ts"],"names":[],"mappings":"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"}

package/dist/observability/metrics.js

@@ -0,0 +1,429 @@
+/**
+ * Metrics Collection System
+ *
+ * Collect and expose application metrics for monitoring
+ */
+export class MetricsCollector {
+    metrics = new Map();
+    /**
+     * Register a counter metric
+     */
+    counter(name, help, labels) {
+        const metric = {
+            name,
+            type: 'counter',
+            help,
+            values: [],
+            labels,
+        };
+        this.metrics.set(name, metric);
+        return new Counter(metric);
+    }
+    /**
+     * Register a gauge metric
+     */
+    gauge(name, help, labels) {
+        const metric = {
+            name,
+            type: 'gauge',
+            help,
+            values: [],
+            labels,
+        };
+        this.metrics.set(name, metric);
+        return new Gauge(metric);
+    }
+    /**
+     * Register a histogram metric
+     */
+    histogram(name, help, buckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10], labels) {
+        const metric = {
+            name,
+            type: 'histogram',
+            help,
+            values: [],
+            labels,
+            buckets: buckets.map((le) => ({ le, count: 0 })),
+            sum: 0,
+            count: 0,
+        };
+        this.metrics.set(name, metric);
+        return new Histogram(metric);
+    }
+    /**
+     * Get all metrics
+     */
+    getMetrics() {
+        return Array.from(this.metrics.values());
+    }
+    /**
+     * Get metric by name
+     */
+    getMetric(name) {
+        return this.metrics.get(name);
+    }
+    /**
+     * Clear all metrics
+     */
+    clear() {
+        this.metrics.clear();
+    }
+    /**
+     * Export metrics in Prometheus format
+     */
+    exportPrometheus() {
+        const lines = [];
+        for (const metric of this.metrics.values()) {
+            // Add help text
+            lines.push(`# HELP ${metric.name} ${metric.help}`);
+            lines.push(`# TYPE ${metric.name} ${metric.type}`);
+            if (metric.type === 'histogram') {
+                const histMetric = metric;
+                // Export buckets
+                for (const bucket of histMetric.buckets) {
+                    lines.push(`${metric.name}_bucket{le="${bucket.le}"} ${bucket.count}`);
+                }
+                lines.push(`${metric.name}_bucket{le="+Inf"} ${histMetric.count}`);
+                lines.push(`${metric.name}_sum ${histMetric.sum}`);
+                lines.push(`${metric.name}_count ${histMetric.count}`);
+            }
+            else {
+                // Export regular metrics
+                for (const value of metric.values) {
+                    const labelStr = value.labels
+                        ? Object.entries(value.labels)
+                            .map(([k, v]) => `${k}="${v}"`)
+                            .join(',')
+                        : '';
+                    const metricLine = labelStr
+                        ? `${metric.name}{${labelStr}} ${value.value}`
+                        : `${metric.name} ${value.value}`;
+                    lines.push(metricLine);
+                }
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Export metrics as JSON
+     */
+    exportJSON() {
+        const result = {};
+        for (const metric of this.metrics.values()) {
+            if (metric.type === 'histogram') {
+                const histMetric = metric;
+                result[metric.name] = {
+                    type: metric.type,
+                    count: histMetric.count,
+                    sum: histMetric.sum,
+                    buckets: histMetric.buckets,
+                };
+            }
+            else {
+                result[metric.name] = {
+                    type: metric.type,
+                    values: metric.values,
+                };
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Counter metric
+ */
+export class Counter {
+    metric;
+    constructor(metric) {
+        this.metric = metric;
+    }
+    /**
+     * Increment counter
+     */
+    inc(value = 1, labels) {
+        const existing = this.findValue(labels);
+        if (existing) {
+            existing.value += value;
+            existing.timestamp = Date.now();
+        }
+        else {
+            this.metric.values.push({
+                value,
+                timestamp: Date.now(),
+                labels,
+            });
+        }
+    }
+    /**
+     * Get current value
+     */
+    get(labels) {
+        const value = this.findValue(labels);
+        return value ? value.value : 0;
+    }
+    /**
+     * Find value by labels
+     */
+    findValue(labels) {
+        return this.metric.values.find((v) => this.labelsMatch(v.labels, labels));
+    }
+    /**
+     * Check if labels match
+     */
+    labelsMatch(a, b) {
+        if (!(a || b))
+            return true;
+        if (!(a && b))
+            return false;
+        const aKeys = Object.keys(a).sort();
+        const bKeys = Object.keys(b).sort();
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key, i) => key === bKeys[i] && a[key] === b[key]);
+    }
+}
+/**
+ * Gauge metric
+ */
+export class Gauge {
+    metric;
+    constructor(metric) {
+        this.metric = metric;
+    }
+    /**
+     * Set gauge value
+     */
+    set(value, labels) {
+        const existing = this.findValue(labels);
+        if (existing) {
+            existing.value = value;
+            existing.timestamp = Date.now();
+        }
+        else {
+            this.metric.values.push({
+                value,
+                timestamp: Date.now(),
+                labels,
+            });
+        }
+    }
+    /**
+     * Increment gauge
+     */
+    inc(value = 1, labels) {
+        const existing = this.findValue(labels);
+        if (existing) {
+            existing.value += value;
+            existing.timestamp = Date.now();
+        }
+        else {
+            this.metric.values.push({
+                value,
+                timestamp: Date.now(),
+                labels,
+            });
+        }
+    }
+    /**
+     * Decrement gauge
+     */
+    dec(value = 1, labels) {
+        this.inc(-value, labels);
+    }
+    /**
+     * Get current value
+     */
+    get(labels) {
+        const value = this.findValue(labels);
+        return value ? value.value : 0;
+    }
+    /**
+     * Find value by labels
+     */
+    findValue(labels) {
+        return this.metric.values.find((v) => this.labelsMatch(v.labels, labels));
+    }
+    /**
+     * Check if labels match
+     */
+    labelsMatch(a, b) {
+        if (!(a || b))
+            return true;
+        if (!(a && b))
+            return false;
+        const aKeys = Object.keys(a).sort();
+        const bKeys = Object.keys(b).sort();
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key, i) => key === bKeys[i] && a[key] === b[key]);
+    }
+}
+/**
+ * Histogram metric
+ */
+export class Histogram {
+    metric;
+    constructor(metric) {
+        this.metric = metric;
+    }
+    /**
+     * Observe a value
+     */
+    observe(value, labels) {
+        // Update buckets
+        for (const bucket of this.metric.buckets) {
+            if (value <= bucket.le) {
+                bucket.count++;
+            }
+        }
+        // Update sum and count
+        this.metric.sum += value;
+        this.metric.count++;
+        // Store value
+        this.metric.values.push({
+            value,
+            timestamp: Date.now(),
+            labels,
+        });
+    }
+    /**
+     * Start a timer
+     */
+    startTimer(labels) {
+        const start = Date.now();
+        return () => {
+            const duration = (Date.now() - start) / 1000;
+            this.observe(duration, labels);
+        };
+    }
+    /**
+     * Get percentile
+     */
+    percentile(p) {
+        if (this.metric.values.length === 0)
+            return 0;
+        const sorted = [...this.metric.values].sort((a, b) => a.value - b.value);
+        const index = Math.ceil((p / 100) * sorted.length) - 1;
+        return sorted[index]?.value || 0;
+    }
+    /**
+     * Get average
+     */
+    average() {
+        if (this.metric.count === 0)
+            return 0;
+        return this.metric.sum / this.metric.count;
+    }
+}
+/**
+ * Default metrics collector
+ */
+export const metrics = new MetricsCollector();
+/**
+ * Application metrics
+ */
+export const appMetrics = {
+    // HTTP requests
+    httpRequestsTotal: metrics.counter('http_requests_total', 'Total number of HTTP requests', [
+        'method',
+        'path',
+        'status',
+    ]),
+    httpRequestDuration: metrics.histogram('http_request_duration_seconds', 'HTTP request duration in seconds', [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5], ['method', 'path']),
+    // Database queries
+    dbQueriesTotal: metrics.counter('db_queries_total', 'Total number of database queries', [
+        'operation',
+        'table',
+    ]),
+    dbQueryDuration: metrics.histogram('db_query_duration_seconds', 'Database query duration in seconds', [0.001, 0.01, 0.05, 0.1, 0.5, 1, 5], ['operation', 'table']),
+    // Cache operations
+    cacheOperationsTotal: metrics.counter('cache_operations_total', 'Total number of cache operations', ['operation', 'result']),
+    cacheHitRate: metrics.gauge('cache_hit_rate', 'Cache hit rate percentage'),
+    // Active connections
+    activeConnections: metrics.gauge('active_connections', 'Number of active connections', ['type']),
+    // Errors
+    errorsTotal: metrics.counter('errors_total', 'Total number of errors', ['type', 'severity']),
+    // Queue metrics
+    queueSize: metrics.gauge('queue_size', 'Current queue size', ['queue']),
+    queueProcessingDuration: metrics.histogram('queue_processing_duration_seconds', 'Queue item processing duration', [0.1, 0.5, 1, 5, 10, 30], ['queue']),
+    // Memory usage
+    memoryUsage: metrics.gauge('memory_usage_bytes', 'Memory usage in bytes', ['type']),
+    // API calls (external)
+    apiCallsTotal: metrics.counter('api_calls_total', 'Total number of external API calls', [
+        'service',
+        'status',
+    ]),
+    apiCallDuration: metrics.histogram('api_call_duration_seconds', 'External API call duration', [0.1, 0.5, 1, 2, 5, 10], ['service']),
+};
+/**
+ * Track HTTP request
+ */
+export function trackHTTPRequest(method, path, status, duration) {
+    appMetrics.httpRequestsTotal.inc(1, { method, path, status: String(status) });
+    appMetrics.httpRequestDuration.observe(duration / 1000, { method, path });
+}
+/**
+ * Track database query
+ */
+export function trackDBQuery(operation, table, duration) {
+    appMetrics.dbQueriesTotal.inc(1, { operation, table });
+    appMetrics.dbQueryDuration.observe(duration / 1000, { operation, table });
+}
+/**
+ * Track cache operation
+ */
+export function trackCacheOperation(operation, result = 'success') {
+    appMetrics.cacheOperationsTotal.inc(1, { operation, result });
+}
+/**
+ * Track error
+ */
+export function trackError(type, severity = 'medium') {
+    appMetrics.errorsTotal.inc(1, { type, severity });
+}
+/**
+ * Update active connections
+ */
+export function updateActiveConnections(type, delta) {
+    appMetrics.activeConnections.inc(delta, { type });
+}
+/**
+ * Update memory usage
+ */
+export function updateMemoryUsage() {
+    if (typeof process !== 'undefined' && process.memoryUsage) {
+        const mem = process.memoryUsage();
+        appMetrics.memoryUsage.set(mem.heapUsed, { type: 'heap' });
+        appMetrics.memoryUsage.set(mem.external, { type: 'external' });
+        appMetrics.memoryUsage.set(mem.rss, { type: 'rss' });
+    }
+}
+/**
+ * Start memory monitoring
+ */
+export function startMemoryMonitoring(intervalMs = 60000) {
+    return setInterval(updateMemoryUsage, intervalMs);
+}
+/**
+ * Create metrics middleware
+ */
+export function createMetricsMiddleware() {
+    return async (request, next) => {
+        const startTime = Date.now();
+        const method = request.method;
+        const path = new URL(request.url).pathname;
+        try {
+            const response = await next();
+            const duration = Date.now() - startTime;
+            trackHTTPRequest(method, path, response.status ?? 200, duration);
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            trackHTTPRequest(method, path, 500, duration);
+            trackError('http_error', 'high');
+            throw error;
+        }
+    };
+}