@daniel.stefan/metalink 1.3.1

package/packages/core/dist/metrics/index.js

@@ -0,0 +1,792 @@
+/**
+ * Metrics Collection and Reporting
+ * Tracks server performance and API usage
+ */
+import fs from 'fs';
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+/**
+ * Metrics Collector
+ */
+export class MetricsCollector {
+    constructor() {
+        this.metrics = new Map();
+        this.serverMetrics = new Map();
+        this.toolMetrics = new Map(); // Key: "serverName-toolName"
+        this.errorRecords = []; // Keep last 1000 errors
+        this.toolCallCounts = new Map(); // Track total calls per tool
+        this.toolErrorCounts = new Map(); // Track error counts per tool
+        this.apiMetrics = {
+            requests: 0,
+            responses: 0,
+            errors: 0,
+            avgResponseTime: 0,
+            lastRequest: 0,
+        };
+    }
+    /**
+     * Increment counter metric
+     */
+    incrementCounter(name, unit = '') {
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, {
+                name,
+                type: 'counter',
+                unit,
+                value: 0,
+                history: [],
+            });
+        }
+        const metric = this.metrics.get(name);
+        metric.value++;
+        metric.history.push({
+            timestamp: Date.now(),
+            value: metric.value,
+        });
+        // Keep only last 1000 data points
+        if (metric.history.length > 1000) {
+            metric.history = metric.history.slice(-1000);
+        }
+    }
+    /**
+     * Set gauge metric
+     */
+    setGauge(name, value, unit = '') {
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, {
+                name,
+                type: 'gauge',
+                unit,
+                value,
+                history: [],
+            });
+        }
+        const metric = this.metrics.get(name);
+        metric.value = value;
+        metric.history.push({
+            timestamp: Date.now(),
+            value,
+        });
+        // Keep only last 1000 data points
+        if (metric.history.length > 1000) {
+            metric.history = metric.history.slice(-1000);
+        }
+    }
+    /**
+     * Record server startup
+     */
+    recordServerStart(serverName) {
+        this.serverMetrics.set(serverName, {
+            serverName,
+            startTime: Date.now(),
+            uptime: 0,
+            restarts: (this.serverMetrics.get(serverName)?.restarts || 0) + 1,
+            errors: 0,
+            tools: { total: 0, executed: 0, failed: 0 },
+        });
+    }
+    /**
+     * Record server error
+     */
+    recordServerError(serverName, error, errorType) {
+        const metrics = this.serverMetrics.get(serverName);
+        if (metrics) {
+            metrics.errors++;
+            metrics.lastError = error;
+        }
+        // If errorType provided, also record detailed error for analytics
+        if (errorType) {
+            this.recordToolError(error, undefined, serverName);
+        }
+    }
+    /**
+     * Record API request
+     */
+    recordApiRequest() {
+        this.apiMetrics.requests++;
+        this.apiMetrics.lastRequest = Date.now();
+    }
+    /**
+     * Record API response
+     */
+    recordApiResponse(responseTime) {
+        this.apiMetrics.responses++;
+        // Calculate running average
+        const totalTime = this.apiMetrics.avgResponseTime * (this.apiMetrics.responses - 1) + responseTime;
+        this.apiMetrics.avgResponseTime = totalTime / this.apiMetrics.responses;
+    }
+    /**
+     * Record API error
+     */
+    recordApiError() {
+        this.apiMetrics.errors++;
+    }
+    /**
+     * Record tool execution (success)
+     * @param serverName - Server name (e.g., "memory", "time")
+     * @param toolName - Tool name (e.g., "create_entities", "get_current_time")
+     * @param latency - Execution time in milliseconds
+     */
+    recordToolExecution(serverName, toolName, latency) {
+        const key = `${serverName}-${toolName}`;
+        if (!this.toolMetrics.has(key)) {
+            this.toolMetrics.set(key, {
+                toolName,
+                serverName,
+                calls: 0,
+                successes: 0,
+                failures: 0,
+                totalLatency: 0,
+                minLatency: Infinity,
+                maxLatency: 0,
+                avgLatency: 0,
+                latencyHistory: [],
+                lastCall: 0,
+            });
+        }
+        const metrics = this.toolMetrics.get(key);
+        metrics.calls++;
+        metrics.successes++;
+        metrics.totalLatency += latency;
+        metrics.minLatency = Math.min(metrics.minLatency, latency);
+        metrics.maxLatency = Math.max(metrics.maxLatency, latency);
+        metrics.avgLatency = metrics.totalLatency / metrics.successes;
+        metrics.lastCall = Date.now();
+        // Keep last 1000 latencies for percentile calculation
+        metrics.latencyHistory.push(latency);
+        if (metrics.latencyHistory.length > 1000) {
+            metrics.latencyHistory = metrics.latencyHistory.slice(-1000);
+        }
+    }
+    /**
+     * Record tool execution failure
+     * @param serverName - Server name
+     * @param toolName - Tool name
+     * @param error - Error message
+     */
+    recordToolFailure(serverName, toolName, error) {
+        const key = `${serverName}-${toolName}`;
+        if (!this.toolMetrics.has(key)) {
+            this.toolMetrics.set(key, {
+                toolName,
+                serverName,
+                calls: 0,
+                successes: 0,
+                failures: 0,
+                totalLatency: 0,
+                minLatency: Infinity,
+                maxLatency: 0,
+                avgLatency: 0,
+                latencyHistory: [],
+                lastCall: 0,
+            });
+        }
+        const metrics = this.toolMetrics.get(key);
+        metrics.calls++;
+        metrics.failures++;
+        metrics.lastCall = Date.now();
+        metrics.lastError = error;
+    }
+    /**
+     * Calculate percentile from sorted array
+     * @param sortedArray - Sorted array of numbers
+     * @param percentile - Percentile to calculate (0-100)
+     */
+    calculatePercentile(sortedArray, percentile) {
+        if (sortedArray.length === 0)
+            return 0;
+        const index = (percentile / 100) * (sortedArray.length - 1);
+        const lower = Math.floor(index);
+        const upper = Math.ceil(index);
+        const weight = index % 1;
+        if (lower === upper) {
+            return sortedArray[lower];
+        }
+        return sortedArray[lower] * (1 - weight) + sortedArray[upper] * weight;
+    }
+    /**
+     * Get all tool metrics with percentiles
+     */
+    getAllToolMetrics() {
+        return Array.from(this.toolMetrics.values()).map((metrics) => {
+            const sortedLatencies = [...metrics.latencyHistory].sort((a, b) => a - b);
+            return {
+                toolName: metrics.toolName,
+                serverName: metrics.serverName,
+                calls: metrics.calls,
+                successRate: metrics.calls > 0 ? (metrics.successes / metrics.calls) * 100 : 0,
+                failureRate: metrics.calls > 0 ? (metrics.failures / metrics.calls) * 100 : 0,
+                latency: {
+                    min: metrics.minLatency === Infinity ? 0 : metrics.minLatency,
+                    max: metrics.maxLatency,
+                    avg: metrics.avgLatency,
+                    p50: this.calculatePercentile(sortedLatencies, 50),
+                    p95: this.calculatePercentile(sortedLatencies, 95),
+                    p99: this.calculatePercentile(sortedLatencies, 99),
+                },
+                lastCall: metrics.lastCall,
+                lastError: metrics.lastError,
+            };
+        });
+    }
+    /**
+     * Get tool metrics for a specific tool
+     * @param serverName - Server name
+     * @param toolName - Tool name
+     */
+    getToolMetrics(serverName, toolName) {
+        const key = `${serverName}-${toolName}`;
+        const metrics = this.toolMetrics.get(key);
+        if (!metrics) {
+            return undefined;
+        }
+        const sortedLatencies = [...metrics.latencyHistory].sort((a, b) => a - b);
+        return {
+            toolName: metrics.toolName,
+            serverName: metrics.serverName,
+            calls: metrics.calls,
+            successRate: metrics.calls > 0 ? (metrics.successes / metrics.calls) * 100 : 0,
+            failureRate: metrics.calls > 0 ? (metrics.failures / metrics.calls) * 100 : 0,
+            latency: {
+                min: metrics.minLatency === Infinity ? 0 : metrics.minLatency,
+                max: metrics.maxLatency,
+                avg: metrics.avgLatency,
+                p50: this.calculatePercentile(sortedLatencies, 50),
+                p95: this.calculatePercentile(sortedLatencies, 95),
+                p99: this.calculatePercentile(sortedLatencies, 99),
+            },
+            lastCall: metrics.lastCall,
+            lastError: metrics.lastError,
+        };
+    }
+    /**
+     * Get top N slowest tools by P95 latency
+     * @param limit - Number of tools to return (default: 10)
+     */
+    getSlowestTools(limit = 10) {
+        const allMetrics = this.getAllToolMetrics();
+        return allMetrics
+            .sort((a, b) => b.latency.p95 - a.latency.p95)
+            .slice(0, limit);
+    }
+    /**
+     * Get tools with high error rates
+     * @param threshold - Error rate threshold percentage (default: 5%)
+     */
+    getHighErrorRateTools(threshold = 5) {
+        const allMetrics = this.getAllToolMetrics();
+        return allMetrics
+            .filter((m) => m.failureRate >= threshold && m.calls >= 5) // At least 5 calls to be meaningful
+            .sort((a, b) => b.failureRate - a.failureRate);
+    }
+    /**
+     * Classify error type from error message
+     * Public method to allow external error classification
+     */
+    classifyErrorType(error) {
+        const message = typeof error === 'string' ? error : error.message;
+        const lowerMessage = message.toLowerCase();
+        if (lowerMessage.includes('invalid') || lowerMessage.includes('validation') || lowerMessage.includes('required')) {
+            return 'validation';
+        }
+        if (lowerMessage.includes('timeout') || lowerMessage.includes('timed out')) {
+            return 'timeout';
+        }
+        if (lowerMessage.includes('econnrefused') || lowerMessage.includes('connection') || lowerMessage.includes('enotfound')) {
+            return 'connection';
+        }
+        if (lowerMessage.includes('rate limit')) {
+            return 'rate_limit';
+        }
+        if (lowerMessage.includes('permission') || lowerMessage.includes('unauthorized') || lowerMessage.includes('forbidden')) {
+            return 'permission';
+        }
+        if (lowerMessage.includes('not found') || lowerMessage.includes('does not exist')) {
+            return 'not_found';
+        }
+        if (lowerMessage.includes('internal') || lowerMessage.includes('crash')) {
+            return 'internal';
+        }
+        return 'unknown';
+    }
+    /**
+     * Record tool call (success or failure)
+     */
+    recordToolCall(toolName, serverName) {
+        const key = serverName ? `${serverName}-${toolName}` : toolName;
+        this.toolCallCounts.set(key, (this.toolCallCounts.get(key) || 0) + 1);
+    }
+    /**
+     * Record tool error with detailed tracking
+     */
+    recordToolError(error, toolName, serverName) {
+        const errorType = this.classifyErrorType(error);
+        const errorMessage = typeof error === 'string' ? error : error.message;
+        const stack = typeof error === 'string' ? undefined : error.stack;
+        const errorRecord = {
+            timestamp: Date.now(),
+            errorType,
+            message: errorMessage,
+            toolName,
+            serverName,
+            stack,
+        };
+        // Add to error records (keep last 1000)
+        this.errorRecords.push(errorRecord);
+        if (this.errorRecords.length > 1000) {
+            this.errorRecords = this.errorRecords.slice(-1000);
+        }
+        // Track error counts per tool
+        if (toolName) {
+            const key = serverName ? `${serverName}-${toolName}` : toolName;
+            this.toolErrorCounts.set(key, (this.toolErrorCounts.get(key) || 0) + 1);
+        }
+    }
+    /**
+     * Get error analytics for a specific tool
+     */
+    getToolErrorMetrics(toolName, serverName) {
+        const key = serverName ? `${serverName}-${toolName}` : toolName;
+        const totalCalls = this.toolCallCounts.get(key) || 0;
+        const totalErrors = this.toolErrorCounts.get(key) || 0;
+        if (totalCalls === 0) {
+            return null;
+        }
+        // Get errors for this tool
+        const toolErrors = this.errorRecords.filter((e) => e.toolName === toolName && (!serverName || e.serverName === serverName));
+        // Count errors by type
+        const errorsByType = {
+            validation: 0,
+            timeout: 0,
+            connection: 0,
+            internal: 0,
+            rate_limit: 0,
+            permission: 0,
+            not_found: 0,
+            unknown: 0,
+        };
+        for (const error of toolErrors) {
+            errorsByType[error.errorType]++;
+        }
+        // Calculate error patterns
+        const errorPatterns = Object.entries(errorsByType)
+            .filter(([_, count]) => count > 0)
+            .map(([type, count]) => ({
+            type: type,
+            count,
+            percentage: totalErrors > 0 ? (count / totalErrors) * 100 : 0,
+        }))
+            .sort((a, b) => b.count - a.count);
+        return {
+            toolName,
+            serverName: serverName || 'unknown',
+            totalCalls,
+            totalErrors,
+            errorRate: totalCalls > 0 ? (totalErrors / totalCalls) * 100 : 0,
+            errorsByType,
+            recentErrors: toolErrors.slice(-10), // Last 10 errors
+            lastError: toolErrors[toolErrors.length - 1],
+            errorPatterns,
+        };
+    }
+    /**
+     * Get aggregated error analytics across all tools
+     */
+    getErrorAnalytics() {
+        const totalCalls = Array.from(this.toolCallCounts.values()).reduce((sum, count) => sum + count, 0);
+        const totalErrors = this.errorRecords.length;
+        // Count errors by type
+        const errorsByType = {
+            validation: 0,
+            timeout: 0,
+            connection: 0,
+            internal: 0,
+            rate_limit: 0,
+            permission: 0,
+            not_found: 0,
+            unknown: 0,
+        };
+        const errorsByServer = {};
+        const errorsByTool = {};
+        for (const error of this.errorRecords) {
+            errorsByType[error.errorType]++;
+            if (error.serverName) {
+                errorsByServer[error.serverName] = (errorsByServer[error.serverName] || 0) + 1;
+            }
+            if (error.toolName) {
+                const key = error.serverName ? `${error.serverName}-${error.toolName}` : error.toolName;
+                errorsByTool[key] = (errorsByTool[key] || 0) + 1;
+            }
+        }
+        // Calculate top failing tools
+        const topFailingTools = [];
+        for (const [key, errorCount] of this.toolErrorCounts.entries()) {
+            const totalCalls = this.toolCallCounts.get(key) || 0;
+            if (totalCalls > 0) {
+                const [serverName, ...toolParts] = key.split('-');
+                const toolName = toolParts.join('-');
+                topFailingTools.push({
+                    toolName,
+                    serverName,
+                    errorCount,
+                    errorRate: (errorCount / totalCalls) * 100,
+                });
+            }
+        }
+        // Sort by error count descending
+        topFailingTools.sort((a, b) => b.errorCount - a.errorCount);
+        return {
+            totalErrors,
+            totalCalls,
+            errorRate: totalCalls > 0 ? (totalErrors / totalCalls) * 100 : 0,
+            errorsByType,
+            errorsByServer,
+            errorsByTool,
+            recentErrors: this.errorRecords.slice(-50), // Last 50 errors
+            topFailingTools: topFailingTools.slice(0, 10), // Top 10 failing tools
+        };
+    }
+    /**
+     * Get all metrics
+     */
+    getMetrics() {
+        return Array.from(this.metrics.values());
+    }
+    /**
+     * Get metric by name
+     */
+    getMetric(name) {
+        return this.metrics.get(name);
+    }
+    /**
+     * Get server metrics
+     */
+    getServerMetrics(serverName) {
+        const metrics = this.serverMetrics.get(serverName);
+        if (metrics) {
+            metrics.uptime = Date.now() - metrics.startTime;
+        }
+        return metrics;
+    }
+    /**
+     * Get API metrics
+     */
+    getApiMetrics() {
+        return { ...this.apiMetrics };
+    }
+    /**
+     * Get all server metrics
+     */
+    getAllServerMetrics() {
+        return Array.from(this.serverMetrics.values()).map((metrics) => ({
+            ...metrics,
+            uptime: Date.now() - metrics.startTime,
+        }));
+    }
+    /**
+     * Restore metrics from persisted data
+     * Used during daemon startup to restore metrics from disk
+     */
+    restoreMetrics(data) {
+        // Restore custom metrics
+        for (const metric of data.metrics) {
+            this.metrics.set(metric.name, {
+                ...metric,
+                history: metric.history.slice(-1000), // Keep last 1000 points
+            });
+        }
+        // Restore server metrics
+        for (const serverMetric of data.serverMetrics) {
+            this.serverMetrics.set(serverMetric.serverName, {
+                ...serverMetric,
+                // Preserve restarts count and errors, reset runtime values
+                startTime: Date.now(), // Reset start time to now
+                uptime: 0, // Will be recalculated
+            });
+        }
+        // Restore tool metrics (optional for backward compatibility)
+        if (data.toolMetrics && Array.isArray(data.toolMetrics)) {
+            for (const toolMetric of data.toolMetrics) {
+                const key = `${toolMetric.serverName}-${toolMetric.toolName}`;
+                this.toolMetrics.set(key, {
+                    ...toolMetric,
+                    latencyHistory: toolMetric.latencyHistory.slice(-1000), // Keep last 1000 points
+                });
+            }
+        }
+        // Restore API metrics
+        this.apiMetrics = {
+            ...data.apiMetrics,
+            lastRequest: Date.now(), // Update to current time
+        };
+        const toolCount = data.toolMetrics ? data.toolMetrics.length : 0;
+        console.log(`[MetricsCollector] Restored metrics: ${data.metrics.length} custom, ` +
+            `${data.serverMetrics.length} servers, ${toolCount} tools, API metrics loaded`);
+    }
+    /**
+     * Export metrics as Prometheus format
+     */
+    exportPrometheus() {
+        let output = '';
+        // Custom metrics
+        for (const metric of this.metrics.values()) {
+            output += `# TYPE ${metric.name} ${metric.type}\n`;
+            output += `# UNIT ${metric.name} ${metric.unit}\n`;
+            output += `${metric.name}{} ${metric.value}\n`;
+        }
+        // API metrics
+        output += `# TYPE api_requests counter\n`;
+        output += `api_requests{} ${this.apiMetrics.requests}\n`;
+        output += `api_responses{} ${this.apiMetrics.responses}\n`;
+        output += `api_errors{} ${this.apiMetrics.errors}\n`;
+        output += `api_response_time_ms{} ${this.apiMetrics.avgResponseTime.toFixed(2)}\n`;
+        // Server metrics
+        for (const metrics of this.serverMetrics.values()) {
+            output += `# TYPE server_uptime gauge\n`;
+            output += `server_uptime{server="${metrics.serverName}"} ${metrics.uptime}\n`;
+            output += `server_restarts{server="${metrics.serverName}"} ${metrics.restarts}\n`;
+            output += `server_errors{server="${metrics.serverName}"} ${metrics.errors}\n`;
+        }
+        // Tool metrics
+        const toolMetrics = this.getAllToolMetrics();
+        if (toolMetrics.length > 0) {
+            output += `# TYPE tool_calls counter\n`;
+            output += `# TYPE tool_success_rate gauge\n`;
+            output += `# TYPE tool_latency_ms gauge\n`;
+            for (const tool of toolMetrics) {
+                const labels = `{server="${tool.serverName}",tool="${tool.toolName}"}`;
+                output += `tool_calls${labels} ${tool.calls}\n`;
+                output += `tool_success_rate${labels} ${tool.successRate.toFixed(2)}\n`;
+                output += `tool_latency_ms${labels} ${tool.latency.avg.toFixed(2)}\n`;
+                output += `tool_latency_p50_ms${labels} ${tool.latency.p50.toFixed(2)}\n`;
+                output += `tool_latency_p95_ms${labels} ${tool.latency.p95.toFixed(2)}\n`;
+                output += `tool_latency_p99_ms${labels} ${tool.latency.p99.toFixed(2)}\n`;
+            }
+        }
+        // Error analytics by type
+        const errorAnalytics = this.getErrorAnalytics();
+        if (errorAnalytics.totalErrors > 0) {
+            output += `# TYPE error_total counter\n`;
+            output += `error_total{} ${errorAnalytics.totalErrors}\n`;
+            output += `# TYPE error_rate gauge\n`;
+            output += `error_rate{} ${errorAnalytics.errorRate.toFixed(2)}\n`;
+            // Errors by type
+            output += `# TYPE errors_by_type counter\n`;
+            for (const [errorType, count] of Object.entries(errorAnalytics.errorsByType)) {
+                if (count > 0) {
+                    output += `errors_by_type{type="${errorType}"} ${count}\n`;
+                }
+            }
+            // Errors by server
+            if (Object.keys(errorAnalytics.errorsByServer).length > 0) {
+                output += `# TYPE errors_by_server counter\n`;
+                for (const [serverName, count] of Object.entries(errorAnalytics.errorsByServer)) {
+                    output += `errors_by_server{server="${serverName}"} ${count}\n`;
+                }
+            }
+        }
+        return output;
+    }
+}
+// Global metrics instance
+export const globalMetrics = new MetricsCollector();
+/**
+ * MetricsPersistence - Disk persistence for metrics data
+ *
+ * Saves metrics to disk periodically to enable:
+ * - Metrics retention across daemon restarts
+ * - Historical analysis
+ * - Long-term trending
+ */
+export class MetricsPersistence {
+    constructor(baseDir) {
+        this.intervalHandle = null;
+        // Expand ~ to home directory if needed
+        this.persistenceDir = baseDir.replace(/^~/, process.env.HOME || '~');
+    }
+    /**
+     * Get the path to the metrics file
+     */
+    getMetricsPath() {
+        // Create directory if it doesn't exist
+        if (!fs.existsSync(this.persistenceDir)) {
+            fs.mkdirSync(this.persistenceDir, { recursive: true });
+        }
+        return path.join(this.persistenceDir, 'metrics.json');
+    }
+    /**
+     * Load metrics from disk
+     */
+    async load() {
+        try {
+            const content = await fsPromises.readFile(this.getMetricsPath(), 'utf8');
+            const data = JSON.parse(content);
+            console.log(`[MetricsPersistence] Loaded metrics from ${this.getMetricsPath()}`);
+            return data;
+        }
+        catch (error) {
+            const errCode = error.code;
+            if (errCode === 'ENOENT') {
+                // File doesn't exist yet - this is normal on first run
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Save metrics to disk
+     */
+    async save(data) {
+        try {
+            const content = JSON.stringify(data, null, 2);
+            await fsPromises.writeFile(this.getMetricsPath(), content, 'utf8');
+            console.log(`[MetricsPersistence] Saved metrics to ${this.getMetricsPath()} ` +
+                `(${data.metrics.length} metrics, ${data.serverMetrics.length} servers)`);
+        }
+        catch (error) {
+            console.error('[MetricsPersistence] Failed to save metrics:', error);
+            throw error;
+        }
+    }
+    /**
+     * Start periodic writes
+     * @param getData - Function to get current metrics data
+     * @param intervalMs - Write interval in milliseconds
+     */
+    startPeriodicWrites(getData, intervalMs) {
+        if (this.intervalHandle) {
+            clearInterval(this.intervalHandle);
+        }
+        this.intervalHandle = setInterval(async () => {
+            try {
+                const data = getData();
+                await this.save(data);
+            }
+            catch (error) {
+                console.error('[MetricsPersistence] Periodic write failed:', error);
+            }
+        }, intervalMs);
+    }
+    /**
+     * Stop periodic writes
+     */
+    stopPeriodicWrites() {
+        if (this.intervalHandle) {
+            clearInterval(this.intervalHandle);
+            this.intervalHandle = null;
+        }
+    }
+}
+/**
+ * MetricsAggregator - Time-series aggregation for metrics
+ *
+ * Provides aggregation functions for:
+ * - Hourly rollups
+ * - Daily rollups
+ * - Weekly rollups
+ * - Custom time windows
+ */
+export class MetricsAggregator {
+    /**
+     * Aggregate metrics by hour
+     * @param metrics - Array of metrics to aggregate
+     * @param hours - Number of hours to aggregate (default: 24)
+     */
+    aggregateHourly(metrics, hours = 24) {
+        const now = Date.now();
+        const hourMs = 60 * 60 * 1000;
+        const result = {};
+        for (const metric of metrics) {
+            const hourlyValues = new Array(hours).fill(0);
+            // Process history points
+            for (const point of metric.history) {
+                const hoursAgo = Math.floor((now - point.timestamp) / hourMs);
+                if (hoursAgo >= 0 && hoursAgo < hours) {
+                    const index = hours - 1 - hoursAgo; // Reverse so newest is last
+                    if (metric.type === 'counter') {
+                        hourlyValues[index] = Math.max(hourlyValues[index], point.value);
+                    }
+                    else if (metric.type === 'gauge') {
+                        hourlyValues[index] = point.value; // Latest value wins
+                    }
+                }
+            }
+            result[metric.name] = hourlyValues;
+        }
+        return result;
+    }
+    /**
+     * Aggregate metrics by day
+     * @param metrics - Array of metrics to aggregate
+     * @param days - Number of days to aggregate (default: 7)
+     */
+    aggregateDaily(metrics, days = 7) {
+        const now = Date.now();
+        const dayMs = 24 * 60 * 60 * 1000;
+        const result = {};
+        for (const metric of metrics) {
+            const dailyValues = new Array(days).fill(0);
+            // Process history points
+            for (const point of metric.history) {
+                const daysAgo = Math.floor((now - point.timestamp) / dayMs);
+                if (daysAgo >= 0 && daysAgo < days) {
+                    const index = days - 1 - daysAgo; // Reverse so newest is last
+                    if (metric.type === 'counter') {
+                        dailyValues[index] = Math.max(dailyValues[index], point.value);
+                    }
+                    else if (metric.type === 'gauge') {
+                        dailyValues[index] = point.value; // Latest value wins
+                    }
+                }
+            }
+            result[metric.name] = dailyValues;
+        }
+        return result;
+    }
+    /**
+     * Aggregate metrics by week
+     * @param metrics - Array of metrics to aggregate
+     * @param weeks - Number of weeks to aggregate (default: 4)
+     */
+    aggregateWeekly(metrics, weeks = 4) {
+        const now = Date.now();
+        const weekMs = 7 * 24 * 60 * 60 * 1000;
+        const result = {};
+        for (const metric of metrics) {
+            const weeklyValues = new Array(weeks).fill(0);
+            // Process history points
+            for (const point of metric.history) {
+                const weeksAgo = Math.floor((now - point.timestamp) / weekMs);
+                if (weeksAgo >= 0 && weeksAgo < weeks) {
+                    const index = weeks - 1 - weeksAgo; // Reverse so newest is last
+                    if (metric.type === 'counter') {
+                        weeklyValues[index] = Math.max(weeklyValues[index], point.value);
+                    }
+                    else if (metric.type === 'gauge') {
+                        weeklyValues[index] = point.value; // Latest value wins
+                    }
+                }
+            }
+            result[metric.name] = weeklyValues;
+        }
+        return result;
+    }
+    /**
+     * Calculate statistics for a metric over a time window
+     */
+    calculateStats(metric, windowMs) {
+        const now = Date.now();
+        const cutoff = now - windowMs;
+        const relevantPoints = metric.history.filter((p) => p.timestamp >= cutoff);
+        if (relevantPoints.length === 0) {
+            return { min: 0, max: 0, avg: 0, count: 0 };
+        }
+        const values = relevantPoints.map((p) => p.value);
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        const sum = values.reduce((a, b) => a + b, 0);
+        const avg = sum / values.length;
+        return { min, max, avg, count: relevantPoints.length };
+    }
+}
+//# sourceMappingURL=index.js.map