observability-toolkit 1.8.2 → 1.8.5

package/dist/backends/local-jsonl-metrics.test.js

@@ -0,0 +1,876 @@
+import { describe, it, before, after, beforeEach } from 'node:test';
+import * as assert from 'node:assert';
+import * as path from 'path';
+import { LocalJsonlBackend } from './local-jsonl.js';
+import { getSharedTempDir, clearTempDir, removeSharedTempDir, writeJsonlFileAsync, getTestDate } from '../test-helpers/file-utils.js';
+import { createMockMetric, createMockMetrics, resetBuilderCounters, } from '../test-helpers/test-data-builders.js';
+describe('LocalJsonlBackend', () => {
+    let tempDir;
+    let backend;
+    before(() => {
+        tempDir = getSharedTempDir('LocalJsonlBackend-Metrics');
+    });
+    beforeEach(() => {
+        clearTempDir(tempDir);
+        backend = new LocalJsonlBackend(tempDir);
+    });
+    after(() => {
+        removeSharedTempDir('LocalJsonlBackend-Metrics');
+    });
+    describe('queryMetrics', () => {
+        it('should read and normalize metric data points from JSONL files', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({
+                    name: 'http.requests.total',
+                    value: 100,
+                    type: 'counter',
+                    unit: 'requests',
+                    resource: { serviceName: 'api-gateway' },
+                    attributes: { 'http.method': 'GET', 'http.status_code': 200 },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'http.requests.total');
+            assert.strictEqual(results[0].value, 100);
+            assert.strictEqual(results[0].unit, 'requests');
+            assert.strictEqual(results[0].attributes?.['service.name'], 'api-gateway');
+            assert.strictEqual(results[0].attributes?.['http.method'], 'GET');
+        });
+        it('should filter metrics by name substring', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'http.requests.total', value: 100, type: 'counter' }),
+                createMockMetric({ name: 'http.request.duration', value: 150, type: 'histogram' }),
+                createMockMetric({ name: 'memory.usage', value: 512, type: 'gauge' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ metricName: 'http' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(m => m.name.includes('http')));
+        });
+        it('should apply limit and offset to metric results', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = createMockMetrics(150, (i) => ({
+                timestamp: new Date(Date.now() + i * 1000).toISOString(),
+                name: `metric.${i}`,
+                value: i * 10,
+                type: 'gauge',
+            }));
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ limit: 50, offset: 30 });
+            assert.strictEqual(results.length, 50);
+            assert.strictEqual(results[0].name, 'metric.30');
+        });
+        it('should aggregate metrics with sum function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'requests', value: 100, type: 'counter' }),
+                createMockMetric({ name: 'requests', value: 150, type: 'counter' }),
+                createMockMetric({ name: 'requests', value: 200, type: 'counter' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'sum' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 450);
+        });
+        it('should aggregate metrics with avg function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'latency', value: 100, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 200, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 300, type: 'histogram' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'avg' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 200);
+        });
+        it('should aggregate metrics with min function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'response_time', value: 150, type: 'gauge' }),
+                createMockMetric({ name: 'response_time', value: 50, type: 'gauge' }),
+                createMockMetric({ name: 'response_time', value: 200, type: 'gauge' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'min' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 50);
+        });
+        it('should aggregate metrics with max function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'memory', value: 512, type: 'gauge' }),
+                createMockMetric({ name: 'memory', value: 256, type: 'gauge' }),
+                createMockMetric({ name: 'memory', value: 1024, type: 'gauge' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'max' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 1024);
+        });
+        it('should aggregate metrics with count function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'events', value: 10, type: 'counter' }),
+                createMockMetric({ name: 'events', value: 20, type: 'counter' }),
+                createMockMetric({ name: 'events', value: 30, type: 'counter' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'count' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 3);
+        });
+        it('should aggregate metrics with p50 (median) function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'latency', value: 10, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 20, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 30, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 40, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 50, type: 'histogram' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'p50' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 30); // median of [10, 20, 30, 40, 50]
+        });
+        it('should aggregate metrics with p95 function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            // Create 100 data points for a more realistic p95 calculation
+            const mockMetrics = createMockMetrics(100, (i) => ({
+                timestamp: `2026-01-28T10:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}Z`,
+                name: 'response_time',
+                value: i + 1, // values 1-100
+                type: 'histogram',
+            }));
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'p95' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 95); // 95th percentile of 1-100
+        });
+        it('should aggregate metrics with p99 function', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            // Create 100 data points for a more realistic p99 calculation
+            const mockMetrics = createMockMetrics(100, (i) => ({
+                timestamp: `2026-01-28T10:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}Z`,
+                name: 'response_time',
+                value: i + 1, // values 1-100
+                type: 'histogram',
+            }));
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'p99' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 99); // 99th percentile of 1-100
+        });
+        it('should handle p50 with even number of values', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'latency', value: 10, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 20, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 30, type: 'histogram' }),
+                createMockMetric({ name: 'latency', value: 40, type: 'histogram' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'p50' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 20); // ceil(0.5 * 4) - 1 = 1, sorted[1] = 20
+        });
+        it('should handle percentile with single value', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'latency', value: 42, type: 'histogram' }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'p95' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 42); // single value is the only percentile
+        });
+        it('should calculate percentiles with groupBy', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'latency', value: 10, type: 'histogram', attributes: { endpoint: '/api/users' } }),
+                createMockMetric({ name: 'latency', value: 20, type: 'histogram', attributes: { endpoint: '/api/users' } }),
+                createMockMetric({ name: 'latency', value: 30, type: 'histogram', attributes: { endpoint: '/api/users' } }),
+                createMockMetric({ name: 'latency', value: 100, type: 'histogram', attributes: { endpoint: '/api/orders' } }),
+                createMockMetric({ name: 'latency', value: 200, type: 'histogram', attributes: { endpoint: '/api/orders' } }),
+                createMockMetric({ name: 'latency', value: 300, type: 'histogram', attributes: { endpoint: '/api/orders' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'p50', groupBy: ['endpoint'] });
+            assert.strictEqual(results.length, 2);
+            const usersMetric = results.find(m => m.attributes?.endpoint === '/api/users');
+            const ordersMetric = results.find(m => m.attributes?.endpoint === '/api/orders');
+            assert.strictEqual(usersMetric?.value, 20); // median of [10, 20, 30]
+            assert.strictEqual(ordersMetric?.value, 200); // median of [100, 200, 300]
+        });
+        it('should aggregate metrics grouped by attributes', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({ name: 'http.requests', value: 100, type: 'counter', attributes: { method: 'GET' } }),
+                createMockMetric({ name: 'http.requests', value: 50, type: 'counter', attributes: { method: 'POST' } }),
+                createMockMetric({ name: 'http.requests', value: 200, type: 'counter', attributes: { method: 'GET' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'sum', groupBy: ['method'] });
+            assert.strictEqual(results.length, 2);
+            const getMetric = results.find(m => m.attributes?.method === 'GET');
+            const postMetric = results.find(m => m.attributes?.method === 'POST');
+            assert.strictEqual(getMetric?.value, 300);
+            assert.strictEqual(postMetric?.value, 50);
+        });
+        it('should return empty array when no metrics found', async () => {
+            // No files created
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 0);
+        });
+        it('should aggregate metrics by time bucket with 1m buckets', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                // First minute bucket: 10:00:00 - 10:00:59
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
+                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 20, type: 'counter' },
+                { timestamp: `${today}T10:00:45Z`, name: 'requests', value: 30, type: 'counter' },
+                // Second minute bucket: 10:01:00 - 10:01:59
+                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 100, type: 'counter' },
+                { timestamp: `${today}T10:01:30Z`, name: 'requests', value: 200, type: 'counter' },
+                // Third minute bucket: 10:02:00 - 10:02:59
+                { timestamp: `${today}T10:02:15Z`, name: 'requests', value: 50, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '1m' });
+            assert.strictEqual(results.length, 3);
+            // Results should be sorted by timestamp
+            assert.strictEqual(results[0].value, 60); // 10 + 20 + 30
+            assert.strictEqual(results[1].value, 300); // 100 + 200
+            assert.strictEqual(results[2].value, 50); // 50
+            // Timestamps should be floored to bucket boundaries
+            assert.strictEqual(results[0].timestamp, `${today}T10:00:00.000Z`);
+            assert.strictEqual(results[1].timestamp, `${today}T10:01:00.000Z`);
+            assert.strictEqual(results[2].timestamp, `${today}T10:02:00.000Z`);
+        });
+        it('should aggregate metrics by time bucket with 5m buckets', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                // First 5-minute bucket: 10:00:00 - 10:04:59
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
+                { timestamp: `${today}T10:02:00Z`, name: 'requests', value: 20, type: 'counter' },
+                { timestamp: `${today}T10:04:00Z`, name: 'requests', value: 30, type: 'counter' },
+                // Second 5-minute bucket: 10:05:00 - 10:09:59
+                { timestamp: `${today}T10:05:00Z`, name: 'requests', value: 100, type: 'counter' },
+                { timestamp: `${today}T10:08:00Z`, name: 'requests', value: 200, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '5m' });
+            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results[0].value, 60); // 10 + 20 + 30
+            assert.strictEqual(results[1].value, 300); // 100 + 200
+        });
+        it('should aggregate metrics by time bucket with 1h buckets', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                // First hour bucket: 10:00:00 - 10:59:59
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
+                { timestamp: `${today}T10:30:00Z`, name: 'requests', value: 20, type: 'counter' },
+                // Second hour bucket: 11:00:00 - 11:59:59
+                { timestamp: `${today}T11:00:00Z`, name: 'requests', value: 100, type: 'counter' },
+                { timestamp: `${today}T11:45:00Z`, name: 'requests', value: 200, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '1h' });
+            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results[0].value, 30); // 10 + 20
+            assert.strictEqual(results[1].value, 300); // 100 + 200
+        });
+        it('should aggregate metrics by time bucket with 1d buckets', async () => {
+            // Create metrics files for two days
+            await writeJsonlFileAsync(path.join(tempDir, 'metrics-2026-01-28.jsonl'), [
+                { timestamp: '2026-01-28T10:00:00Z', name: 'requests', value: 100, type: 'counter' },
+                { timestamp: '2026-01-28T20:00:00Z', name: 'requests', value: 200, type: 'counter' },
+            ]);
+            await writeJsonlFileAsync(path.join(tempDir, 'metrics-2026-01-29.jsonl'), [
+                { timestamp: '2026-01-29T08:00:00Z', name: 'requests', value: 300, type: 'counter' },
+                { timestamp: '2026-01-29T16:00:00Z', name: 'requests', value: 400, type: 'counter' },
+            ]);
+            const results = await backend.queryMetrics({
+                aggregation: 'sum',
+                timeBucket: '1d',
+                startDate: '2026-01-28',
+                endDate: '2026-01-29',
+            });
+            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results[0].value, 300); // 100 + 200
+            assert.strictEqual(results[1].value, 700); // 300 + 400
+        });
+        it('should combine time bucket with groupBy', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                // First minute, method=GET
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter', attributes: { method: 'GET' } },
+                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 20, type: 'counter', attributes: { method: 'GET' } },
+                // First minute, method=POST
+                { timestamp: `${today}T10:00:15Z`, name: 'requests', value: 5, type: 'counter', attributes: { method: 'POST' } },
+                // Second minute, method=GET
+                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 100, type: 'counter', attributes: { method: 'GET' } },
+                // Second minute, method=POST
+                { timestamp: `${today}T10:01:30Z`, name: 'requests', value: 50, type: 'counter', attributes: { method: 'POST' } },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({
+                aggregation: 'sum',
+                timeBucket: '1m',
+                groupBy: ['method'],
+            });
+            assert.strictEqual(results.length, 4);
+            // First bucket GET
+            const bucket1GET = results.find(m => m.timestamp === `${today}T10:00:00.000Z` && m.attributes?.method === 'GET');
+            assert.strictEqual(bucket1GET?.value, 30); // 10 + 20
+            // First bucket POST
+            const bucket1POST = results.find(m => m.timestamp === `${today}T10:00:00.000Z` && m.attributes?.method === 'POST');
+            assert.strictEqual(bucket1POST?.value, 5);
+            // Second bucket GET
+            const bucket2GET = results.find(m => m.timestamp === `${today}T10:01:00.000Z` && m.attributes?.method === 'GET');
+            assert.strictEqual(bucket2GET?.value, 100);
+            // Second bucket POST
+            const bucket2POST = results.find(m => m.timestamp === `${today}T10:01:00.000Z` && m.attributes?.method === 'POST');
+            assert.strictEqual(bucket2POST?.value, 50);
+        });
+        it('should use avg aggregation with time buckets', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                // First minute bucket
+                { timestamp: `${today}T10:00:00Z`, name: 'latency', value: 100, type: 'histogram' },
+                { timestamp: `${today}T10:00:30Z`, name: 'latency', value: 200, type: 'histogram' },
+                { timestamp: `${today}T10:00:45Z`, name: 'latency', value: 300, type: 'histogram' },
+                // Second minute bucket
+                { timestamp: `${today}T10:01:00Z`, name: 'latency', value: 500, type: 'histogram' },
+                { timestamp: `${today}T10:01:30Z`, name: 'latency', value: 700, type: 'histogram' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'avg', timeBucket: '1m' });
+            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results[0].value, 200); // (100 + 200 + 300) / 3
+            assert.strictEqual(results[1].value, 600); // (500 + 700) / 2
+        });
+        it('should ignore invalid time bucket format', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
+                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 20, type: 'counter' },
+                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 30, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            // Invalid format - should be ignored and aggregate all together
+            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: 'invalid' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 60); // All grouped together
+        });
+        it('should calculate rate of change per second', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 100, type: 'counter' },
+                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 200, type: 'counter' },
+                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 400, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'rate' });
+            assert.strictEqual(results.length, 1);
+            // Rate = (400 - 100) / 60 seconds = 5 per second
+            assert.strictEqual(results[0].value, 5);
+        });
+        it('should calculate rate with timeBucket', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                // First minute bucket: 10:00:00 - 10:00:59
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 0, type: 'counter' },
+                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 60, type: 'counter' },
+                // Second minute bucket: 10:01:00 - 10:01:59
+                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 100, type: 'counter' },
+                { timestamp: `${today}T10:01:30Z`, name: 'requests', value: 250, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'rate', timeBucket: '1m' });
+            assert.strictEqual(results.length, 2);
+            // First bucket: (60 - 0) / 30 seconds = 2 per second
+            assert.strictEqual(results[0].value, 2);
+            // Second bucket: (250 - 100) / 30 seconds = 5 per second
+            assert.strictEqual(results[1].value, 5);
+        });
+        it('should return rate of 0 for single data point', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 100, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'rate' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].value, 0);
+        });
+        it('should return rate of 0 when all timestamps are the same', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 100, type: 'counter' },
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 200, type: 'counter' },
+                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 300, type: 'counter' },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ aggregation: 'rate' });
+            assert.strictEqual(results.length, 1);
+            // Avoid division by zero - return 0 when duration is 0
+            assert.strictEqual(results[0].value, 0);
+        });
+        it('should read and normalize histogram metrics with bucket distribution', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'http.request.duration',
+                    value: 150, // typically the sum/count average or similar aggregate
+                    type: 'histogram',
+                    unit: 'ms',
+                    resource: { serviceName: 'api-gateway' },
+                    attributes: { 'http.method': 'GET' },
+                    histogram: {
+                        buckets: [
+                            { le: 50, count: 10 },
+                            { le: 100, count: 25 },
+                            { le: 250, count: 45 },
+                            { le: 500, count: 48 },
+                            { le: Infinity, count: 50 },
+                        ],
+                        sum: 7500,
+                        count: 50,
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'http.request.duration');
+            assert.strictEqual(results[0].value, 150);
+            assert.strictEqual(results[0].unit, 'ms');
+            assert.strictEqual(results[0].attributes?.['service.name'], 'api-gateway');
+            assert.strictEqual(results[0].attributes?.['http.method'], 'GET');
+            // Verify histogram data is present
+            assert.ok(results[0].histogram, 'Histogram data should be present');
+            assert.strictEqual(results[0].histogram?.sum, 7500);
+            assert.strictEqual(results[0].histogram?.count, 50);
+            assert.strictEqual(results[0].histogram?.buckets.length, 5);
+            // Verify bucket boundaries and cumulative counts
+            assert.strictEqual(results[0].histogram?.buckets[0].le, 50);
+            assert.strictEqual(results[0].histogram?.buckets[0].count, 10);
+            assert.strictEqual(results[0].histogram?.buckets[1].le, 100);
+            assert.strictEqual(results[0].histogram?.buckets[1].count, 25);
+            assert.strictEqual(results[0].histogram?.buckets[2].le, 250);
+            assert.strictEqual(results[0].histogram?.buckets[2].count, 45);
+        });
+        it('should handle histogram metrics without histogram data (non-histogram type)', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'http.requests.total',
+                    value: 100,
+                    type: 'counter',
+                    unit: 'requests',
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'http.requests.total');
+            assert.strictEqual(results[0].value, 100);
+            assert.strictEqual(results[0].histogram, undefined);
+        });
+        it('should handle mixed metric types including histograms', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'http.requests.total',
+                    value: 100,
+                    type: 'counter',
+                },
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'http.request.duration',
+                    value: 150,
+                    type: 'histogram',
+                    histogram: {
+                        buckets: [
+                            { le: 100, count: 20 },
+                            { le: 500, count: 80 },
+                            { le: Infinity, count: 100 },
+                        ],
+                        sum: 15000,
+                        count: 100,
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'memory.usage',
+                    value: 512,
+                    type: 'gauge',
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 3);
+            const counter = results.find(m => m.name === 'http.requests.total');
+            const histogram = results.find(m => m.name === 'http.request.duration');
+            const gauge = results.find(m => m.name === 'memory.usage');
+            assert.ok(counter, 'Counter metric should be present');
+            assert.strictEqual(counter?.histogram, undefined);
+            assert.ok(histogram, 'Histogram metric should be present');
+            assert.ok(histogram?.histogram, 'Histogram should have histogram data');
+            assert.strictEqual(histogram?.histogram?.count, 100);
+            assert.ok(gauge, 'Gauge metric should be present');
+            assert.strictEqual(gauge?.histogram, undefined);
+        });
+        it('should preserve histogram data when filtering by metric name', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'api.latency',
+                    value: 200,
+                    type: 'histogram',
+                    histogram: {
+                        buckets: [
+                            { le: 100, count: 5 },
+                            { le: 500, count: 15 },
+                            { le: 1000, count: 20 },
+                        ],
+                        sum: 4000,
+                        count: 20,
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'db.query.duration',
+                    value: 50,
+                    type: 'histogram',
+                    histogram: {
+                        buckets: [
+                            { le: 10, count: 30 },
+                            { le: 50, count: 80 },
+                            { le: 100, count: 100 },
+                        ],
+                        sum: 3500,
+                        count: 100,
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({ metricName: 'api.latency' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'api.latency');
+            assert.ok(results[0].histogram);
+            assert.strictEqual(results[0].histogram?.sum, 4000);
+            assert.strictEqual(results[0].histogram?.count, 20);
+            assert.strictEqual(results[0].histogram?.buckets.length, 3);
+        });
+        it('should ignore histogram field when metric type is not histogram', async () => {
+            const today = getTestDate();
+            // Edge case: a metric that has histogram field but type is not 'histogram'
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'malformed.metric',
+                    value: 100,
+                    type: 'gauge', // Not histogram type
+                    histogram: {
+                        // This should be ignored since type != 'histogram'
+                        buckets: [{ le: 100, count: 10 }],
+                        sum: 500,
+                        count: 10,
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'malformed.metric');
+            assert.strictEqual(results[0].value, 100);
+            // Histogram data should NOT be included since type is 'gauge', not 'histogram'
+            assert.strictEqual(results[0].histogram, undefined);
+        });
+        it('should normalize aggregationTemporality from numeric OTel values', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'http.requests.delta',
+                    value: 100,
+                    type: 'counter',
+                    aggregationTemporality: 1, // DELTA
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'http.requests.cumulative',
+                    value: 500,
+                    type: 'counter',
+                    aggregationTemporality: 2, // CUMULATIVE
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'http.requests.unspecified',
+                    value: 50,
+                    type: 'counter',
+                    aggregationTemporality: 0, // UNSPECIFIED
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 3);
+            const deltaMetric = results.find(m => m.name === 'http.requests.delta');
+            const cumulativeMetric = results.find(m => m.name === 'http.requests.cumulative');
+            const unspecifiedMetric = results.find(m => m.name === 'http.requests.unspecified');
+            assert.strictEqual(deltaMetric?.aggregationTemporality, 'DELTA');
+            assert.strictEqual(cumulativeMetric?.aggregationTemporality, 'CUMULATIVE');
+            assert.strictEqual(unspecifiedMetric?.aggregationTemporality, 'UNSPECIFIED');
+        });
+        it('should normalize aggregationTemporality from string values', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'requests.delta',
+                    value: 100,
+                    type: 'counter',
+                    aggregationTemporality: 'delta', // lowercase
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'requests.cumulative',
+                    value: 500,
+                    type: 'counter',
+                    aggregationTemporality: 'CUMULATIVE', // uppercase
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'requests.unspecified',
+                    value: 50,
+                    type: 'counter',
+                    aggregationTemporality: 'Unspecified', // mixed case
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 3);
+            const deltaMetric = results.find(m => m.name === 'requests.delta');
+            const cumulativeMetric = results.find(m => m.name === 'requests.cumulative');
+            const unspecifiedMetric = results.find(m => m.name === 'requests.unspecified');
+            assert.strictEqual(deltaMetric?.aggregationTemporality, 'DELTA');
+            assert.strictEqual(cumulativeMetric?.aggregationTemporality, 'CUMULATIVE');
+            assert.strictEqual(unspecifiedMetric?.aggregationTemporality, 'UNSPECIFIED');
+        });
+        it('should return undefined aggregationTemporality when not provided', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'gauge.metric',
+                    value: 42,
+                    type: 'gauge',
+                    // No aggregationTemporality field
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].aggregationTemporality, undefined);
+        });
+        it('should handle invalid aggregationTemporality string values', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'metric.invalid',
+                    value: 100,
+                    type: 'counter',
+                    aggregationTemporality: 'invalid_value',
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            // Invalid values should normalize to UNSPECIFIED
+            assert.strictEqual(results[0].aggregationTemporality, 'UNSPECIFIED');
+        });
+        it('should handle unknown numeric aggregationTemporality values', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'metric.unknown',
+                    value: 100,
+                    type: 'counter',
+                    aggregationTemporality: 99, // Unknown numeric value
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            // Unknown numeric values should normalize to UNSPECIFIED
+            assert.strictEqual(results[0].aggregationTemporality, 'UNSPECIFIED');
+        });
+        it('should read and normalize metrics with exemplars', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'http.request.duration',
+                    value: 150,
+                    type: 'histogram',
+                    unit: 'ms',
+                    histogram: {
+                        buckets: [
+                            { le: 100, count: 10 },
+                            { le: 500, count: 45 },
+                            { le: Infinity, count: 50 },
+                        ],
+                        sum: 7500,
+                        count: 50,
+                    },
+                    exemplars: [
+                        {
+                            timestamp: '2026-01-28T10:00:00.123Z',
+                            value: 450,
+                            traceId: 'abc123def456',
+                            spanId: 'span789',
+                            attributes: { 'http.status_code': 500 },
+                        },
+                        {
+                            timestamp: '2026-01-28T10:00:00.456Z',
+                            value: 95,
+                            traceId: 'xyz789abc123',
+                            spanId: 'span456',
+                        },
+                    ],
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'http.request.duration');
+            assert.ok(results[0].exemplars, 'Exemplars should be present');
+            assert.strictEqual(results[0].exemplars?.length, 2);
+            // Verify first exemplar (high latency with error)
+            const highLatencyExemplar = results[0].exemplars?.[0];
+            assert.strictEqual(highLatencyExemplar?.value, 450);
+            assert.strictEqual(highLatencyExemplar?.traceId, 'abc123def456');
+            assert.strictEqual(highLatencyExemplar?.spanId, 'span789');
+            assert.strictEqual(highLatencyExemplar?.attributes?.['http.status_code'], 500);
+            // Verify second exemplar
+            const normalExemplar = results[0].exemplars?.[1];
+            assert.strictEqual(normalExemplar?.value, 95);
+            assert.strictEqual(normalExemplar?.traceId, 'xyz789abc123');
+        });
+        it('should normalize exemplar timestamps from [seconds, nanoseconds] format', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'api.latency',
+                    value: 200,
+                    type: 'histogram',
+                    exemplars: [
+                        {
+                            timestamp: [1738062000, 123000000], // [seconds, nanoseconds]
+                            value: 350,
+                            traceId: 'trace123',
+                            spanId: 'span456',
+                        },
+                    ],
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.ok(results[0].exemplars);
+            assert.strictEqual(results[0].exemplars?.length, 1);
+            // Timestamp should be converted to ISO string
+            assert.ok(results[0].exemplars?.[0].timestamp.includes('T'));
+            assert.strictEqual(results[0].exemplars?.[0].value, 350);
+        });
+        it('should handle exemplars without optional fields', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'counter.metric',
+                    value: 100,
+                    type: 'counter',
+                    exemplars: [
+                        {
+                            value: 1, // Only required field
+                        },
+                    ],
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.ok(results[0].exemplars);
+            assert.strictEqual(results[0].exemplars?.length, 1);
+            assert.strictEqual(results[0].exemplars?.[0].value, 1);
+            // Timestamp should default to metric timestamp
+            assert.strictEqual(results[0].exemplars?.[0].timestamp, '2026-01-28T10:00:00Z');
+            assert.strictEqual(results[0].exemplars?.[0].traceId, undefined);
+            assert.strictEqual(results[0].exemplars?.[0].spanId, undefined);
+        });
+        it('should handle metrics without exemplars', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'simple.counter',
+                    value: 42,
+                    type: 'counter',
+                    // No exemplars field
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].exemplars, undefined);
+        });
+        it('should handle empty exemplars array', async () => {
+            const today = getTestDate();
+            const mockMetrics = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'empty.exemplars',
+                    value: 100,
+                    type: 'counter',
+                    exemplars: [], // Empty array
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const results = await backend.queryMetrics({});
+            assert.strictEqual(results.length, 1);
+            // Empty exemplars array should result in undefined
+            assert.strictEqual(results[0].exemplars, undefined);
+        });
+    });
+});
+//# sourceMappingURL=local-jsonl-metrics.test.js.map