observability-toolkit 1.8.5 → 2.1.0

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

@@ -3,6 +3,8 @@ 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 { BYTES, BITS, PERCENTILE, TIME_MS } from '../lib/core/units.js';
+import { COUNT_FOUR, SAMPLE_SIZE_100, COUNT_FIFTY, COUNT_FIVE, COUNT_SEVEN, COUNT_TEN, COUNT_SIXTY, COUNT_THREE, COUNT_THREE_HUNDRED, COUNT_TWENTY_FIVE, COUNT_THIRTY, COUNT_TWENTY, COUNT_TWO, COUNT_TWO_HUNDRED, EPOCH_SEC, NANO_HALF_SECOND, VALUE_FORTY_TWO, } from '../test-helpers/test-constants.js';
 import { createMockMetric, createMockMetrics, resetBuilderCounters, } from '../test-helpers/test-data-builders.js';
 describe('LocalJsonlBackend', () => {
     let tempDir;
@@ -35,7 +37,7 @@ describe('LocalJsonlBackend', () => {
             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].value, SAMPLE_SIZE_100);
             assert.strictEqual(results[0].unit, 'requests');
             assert.strictEqual(results[0].attributes?.['service.name'], 'api-gateway');
             assert.strictEqual(results[0].attributes?.['http.method'], 'GET');
@@ -46,25 +48,25 @@ describe('LocalJsonlBackend', () => {
             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' }),
+                createMockMetric({ name: 'memory.usage', value: BITS.B512, type: 'gauge' }),
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({ metricName: 'http' });
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
             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(),
+            const mockMetrics = createMockMetrics(SAMPLE_SIZE_100 + COUNT_FIFTY, (i) => ({
+                timestamp: new Date(Date.now() + i * TIME_MS.SECOND).toISOString(),
                 name: `metric.${i}`,
-                value: i * 10,
+                value: i * COUNT_TEN,
                 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.length, COUNT_FIFTY);
             assert.strictEqual(results[0].name, 'metric.30');
         });
         it('should aggregate metrics with sum function', async () => {
@@ -78,7 +80,8 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].value, [SAMPLE_SIZE_100, SAMPLE_SIZE_100 + COUNT_FIFTY, COUNT_TWO_HUNDRED]
+                .reduce((sum, value) => sum + value, 0));
         });
         it('should aggregate metrics with avg function', async () => {
             const today = getTestDate();
@@ -91,7 +94,7 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].value, COUNT_TWO_HUNDRED);
         });
         it('should aggregate metrics with min function', async () => {
             const today = getTestDate();
@@ -104,20 +107,20 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].value, COUNT_FIFTY);
         });
         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' }),
+                createMockMetric({ name: 'memory', value: BITS.B512, type: 'gauge' }),
+                createMockMetric({ name: 'memory', value: BITS.B256, type: 'gauge' }),
+                createMockMetric({ name: 'memory', value: BYTES.KB, 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);
+            assert.strictEqual(results[0].value, BYTES.KB);
         });
         it('should aggregate metrics with count function', async () => {
             const today = getTestDate();
@@ -130,7 +133,7 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].value, COUNT_THREE);
         });
         it('should aggregate metrics with p50 (median) function', async () => {
             const today = getTestDate();
@@ -145,14 +148,14 @@ describe('LocalJsonlBackend', () => {
             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]
+            assert.strictEqual(results[0].value, COUNT_THIRTY); // 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`,
+            const mockMetrics = createMockMetrics(SAMPLE_SIZE_100, (i) => ({
+                timestamp: `2026-01-28T10:${String(Math.floor(i / COUNT_SIXTY)).padStart(COUNT_TWO, '0')}:${String(i % COUNT_SIXTY).padStart(COUNT_TWO, '0')}Z`,
                 name: 'response_time',
                 value: i + 1, // values 1-100
                 type: 'histogram',
@@ -160,14 +163,14 @@ describe('LocalJsonlBackend', () => {
             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
+            assert.strictEqual(results[0].value, PERCENTILE.P95); // 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`,
+            const mockMetrics = createMockMetrics(SAMPLE_SIZE_100, (i) => ({
+                timestamp: `2026-01-28T10:${String(Math.floor(i / COUNT_SIXTY)).padStart(COUNT_TWO, '0')}:${String(i % COUNT_SIXTY).padStart(COUNT_TWO, '0')}Z`,
                 name: 'response_time',
                 value: i + 1, // values 1-100
                 type: 'histogram',
@@ -175,7 +178,7 @@ describe('LocalJsonlBackend', () => {
             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
+            assert.strictEqual(results[0].value, PERCENTILE.P99); // 99th percentile of 1-100
         });
         it('should handle p50 with even number of values', async () => {
             const today = getTestDate();
@@ -189,7 +192,7 @@ describe('LocalJsonlBackend', () => {
             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
+            assert.strictEqual(results[0].value, COUNT_TWENTY); // ceil(0.5 * 4) - 1 = 1, sorted[1] = 20
         });
         it('should handle percentile with single value', async () => {
             const today = getTestDate();
@@ -200,7 +203,7 @@ describe('LocalJsonlBackend', () => {
             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
+            assert.strictEqual(results[0].value, VALUE_FORTY_TWO); // single value is the only percentile
         });
         it('should calculate percentiles with groupBy', async () => {
             const today = getTestDate();
@@ -215,11 +218,11 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({ aggregation: 'p50', groupBy: ['endpoint'] });
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
             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]
+            assert.strictEqual(usersMetric?.value, COUNT_TWENTY); // median of [10, 20, 30]
+            assert.strictEqual(ordersMetric?.value, COUNT_TWO_HUNDRED); // median of [100, 200, 300]
         });
         it('should aggregate metrics grouped by attributes', async () => {
             const today = getTestDate();
@@ -231,11 +234,11 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({ aggregation: 'sum', groupBy: ['method'] });
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
             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);
+            assert.strictEqual(getMetric?.value, COUNT_THREE_HUNDRED);
+            assert.strictEqual(postMetric?.value, COUNT_FIFTY);
         });
         it('should return empty array when no metrics found', async () => {
             // No files created
@@ -257,11 +260,11 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '1m' });
-            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results.length, COUNT_THREE);
             // 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
+            assert.strictEqual(results[0].value, COUNT_SIXTY); // 10 + 20 + 30
+            assert.strictEqual(results[1].value, COUNT_THREE_HUNDRED); // 100 + 200
+            assert.strictEqual(results[2].value, COUNT_FIFTY); // 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`);
@@ -280,9 +283,9 @@ describe('LocalJsonlBackend', () => {
             ];
             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
+            assert.strictEqual(results.length, COUNT_TWO);
+            assert.strictEqual(results[0].value, COUNT_SIXTY); // 10 + 20 + 30
+            assert.strictEqual(results[1].value, COUNT_THREE_HUNDRED); // 100 + 200
         });
         it('should aggregate metrics by time bucket with 1h buckets', async () => {
             const today = getTestDate();
@@ -296,9 +299,9 @@ describe('LocalJsonlBackend', () => {
             ];
             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
+            assert.strictEqual(results.length, COUNT_TWO);
+            assert.strictEqual(results[0].value, COUNT_THIRTY); // 10 + 20
+            assert.strictEqual(results[1].value, COUNT_THREE_HUNDRED); // 100 + 200
         });
         it('should aggregate metrics by time bucket with 1d buckets', async () => {
             // Create metrics files for two days
@@ -316,9 +319,9 @@ describe('LocalJsonlBackend', () => {
                 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
+            assert.strictEqual(results.length, COUNT_TWO);
+            assert.strictEqual(results[0].value, COUNT_THREE_HUNDRED); // 100 + 200
+            assert.strictEqual(results[1].value, COUNT_SEVEN * SAMPLE_SIZE_100); // 300 + 400
         });
         it('should combine time bucket with groupBy', async () => {
             const today = getTestDate();
@@ -339,19 +342,19 @@ describe('LocalJsonlBackend', () => {
                 timeBucket: '1m',
                 groupBy: ['method'],
             });
-            assert.strictEqual(results.length, 4);
+            assert.strictEqual(results.length, COUNT_FOUR);
             // 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
+            assert.strictEqual(bucket1GET?.value, COUNT_THIRTY); // 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);
+            assert.strictEqual(bucket1POST?.value, COUNT_FIVE);
             // Second bucket GET
             const bucket2GET = results.find(m => m.timestamp === `${today}T10:01:00.000Z` && m.attributes?.method === 'GET');
-            assert.strictEqual(bucket2GET?.value, 100);
+            assert.strictEqual(bucket2GET?.value, SAMPLE_SIZE_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);
+            assert.strictEqual(bucket2POST?.value, COUNT_FIFTY);
         });
         it('should use avg aggregation with time buckets', async () => {
             const today = getTestDate();
@@ -366,9 +369,9 @@ describe('LocalJsonlBackend', () => {
             ];
             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
+            assert.strictEqual(results.length, COUNT_TWO);
+            assert.strictEqual(results[0].value, COUNT_TWO_HUNDRED); // (100 + 200 + 300) / 3
+            assert.strictEqual(results[1].value, COUNT_THREE_HUNDRED * COUNT_TWO); // (500 + 700) / 2
         });
         it('should ignore invalid time bucket format', async () => {
             const today = getTestDate();
@@ -381,7 +384,7 @@ describe('LocalJsonlBackend', () => {
             // 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
+            assert.strictEqual(results[0].value, COUNT_SIXTY); // All grouped together
         });
         it('should calculate rate of change per second', async () => {
             const today = getTestDate();
@@ -394,7 +397,7 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].value, COUNT_FIVE);
         });
         it('should calculate rate with timeBucket', async () => {
             const today = getTestDate();
@@ -408,11 +411,11 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({ aggregation: 'rate', timeBucket: '1m' });
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
             // First bucket: (60 - 0) / 30 seconds = 2 per second
-            assert.strictEqual(results[0].value, 2);
+            assert.strictEqual(results[0].value, COUNT_TWO);
             // Second bucket: (250 - 100) / 30 seconds = 5 per second
-            assert.strictEqual(results[1].value, 5);
+            assert.strictEqual(results[1].value, COUNT_FIVE);
         });
         it('should return rate of 0 for single data point', async () => {
             const today = getTestDate();
@@ -465,22 +468,22 @@ describe('LocalJsonlBackend', () => {
             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].value, SAMPLE_SIZE_100 + COUNT_FIFTY);
             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);
+            assert.strictEqual(results[0].histogram?.sum, (SAMPLE_SIZE_100 + COUNT_FIFTY) * COUNT_FIFTY);
+            assert.strictEqual(results[0].histogram?.count, COUNT_FIFTY);
+            assert.strictEqual(results[0].histogram?.buckets.length, COUNT_FIVE);
             // 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);
+            assert.strictEqual(results[0].histogram?.buckets[0].le, COUNT_FIFTY);
+            assert.strictEqual(results[0].histogram?.buckets[0].count, COUNT_TEN);
+            assert.strictEqual(results[0].histogram?.buckets[1].le, SAMPLE_SIZE_100);
+            assert.strictEqual(results[0].histogram?.buckets[1].count, COUNT_TWENTY_FIVE);
+            assert.strictEqual(results[0].histogram?.buckets[2].le, COUNT_TWENTY_FIVE * COUNT_TEN);
+            assert.strictEqual(results[0].histogram?.buckets[2].count, COUNT_FIFTY - COUNT_FIVE);
         });
         it('should handle histogram metrics without histogram data (non-histogram type)', async () => {
             const today = getTestDate();
@@ -497,7 +500,7 @@ describe('LocalJsonlBackend', () => {
             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].value, SAMPLE_SIZE_100);
             assert.strictEqual(results[0].histogram, undefined);
         });
         it('should handle mixed metric types including histograms', async () => {
@@ -533,7 +536,7 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results.length, COUNT_THREE);
             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');
@@ -541,7 +544,7 @@ describe('LocalJsonlBackend', () => {
             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.strictEqual(histogram?.histogram?.count, SAMPLE_SIZE_100);
             assert.ok(gauge, 'Gauge metric should be present');
             assert.strictEqual(gauge?.histogram, undefined);
         });
@@ -584,9 +587,9 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].histogram?.sum, TIME_MS.SECOND * COUNT_FOUR);
+            assert.strictEqual(results[0].histogram?.count, COUNT_TWENTY);
+            assert.strictEqual(results[0].histogram?.buckets.length, COUNT_THREE);
         });
         it('should ignore histogram field when metric type is not histogram', async () => {
             const today = getTestDate();
@@ -609,7 +612,7 @@ describe('LocalJsonlBackend', () => {
             const results = await backend.queryMetrics({});
             assert.strictEqual(results.length, 1);
             assert.strictEqual(results[0].name, 'malformed.metric');
-            assert.strictEqual(results[0].value, 100);
+            assert.strictEqual(results[0].value, SAMPLE_SIZE_100);
             // Histogram data should NOT be included since type is 'gauge', not 'histogram'
             assert.strictEqual(results[0].histogram, undefined);
         });
@@ -640,7 +643,7 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results.length, COUNT_THREE);
             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');
@@ -675,7 +678,7 @@ describe('LocalJsonlBackend', () => {
             ];
             await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
             const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results.length, COUNT_THREE);
             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');
@@ -773,16 +776,16 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].exemplars?.length, COUNT_TWO);
             // Verify first exemplar (high latency with error)
             const highLatencyExemplar = results[0].exemplars?.[0];
-            assert.strictEqual(highLatencyExemplar?.value, 450);
+            assert.strictEqual(highLatencyExemplar?.value, SAMPLE_SIZE_100 + COUNT_FIFTY + COUNT_THREE_HUNDRED);
             assert.strictEqual(highLatencyExemplar?.traceId, 'abc123def456');
             assert.strictEqual(highLatencyExemplar?.spanId, 'span789');
-            assert.strictEqual(highLatencyExemplar?.attributes?.['http.status_code'], 500);
+            assert.strictEqual(highLatencyExemplar?.attributes?.['http.status_code'], COUNT_FIVE * SAMPLE_SIZE_100);
             // Verify second exemplar
             const normalExemplar = results[0].exemplars?.[1];
-            assert.strictEqual(normalExemplar?.value, 95);
+            assert.strictEqual(normalExemplar?.value, PERCENTILE.P95);
             assert.strictEqual(normalExemplar?.traceId, 'xyz789abc123');
         });
         it('should normalize exemplar timestamps from [seconds, nanoseconds] format', async () => {
@@ -795,8 +798,8 @@ describe('LocalJsonlBackend', () => {
                     type: 'histogram',
                     exemplars: [
                         {
-                            timestamp: [1738062000, 123000000], // [seconds, nanoseconds]
-                            value: 350,
+                            timestamp: [EPOCH_SEC, NANO_HALF_SECOND], // [seconds, nanoseconds]
+                            value: COUNT_THREE_HUNDRED + COUNT_FIFTY,
                             traceId: 'trace123',
                             spanId: 'span456',
                         },
@@ -810,7 +813,7 @@ describe('LocalJsonlBackend', () => {
             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);
+            assert.strictEqual(results[0].exemplars?.[0].value, COUNT_THREE_HUNDRED + COUNT_FIFTY);
         });
         it('should handle exemplars without optional fields', async () => {
             const today = getTestDate();