observability-toolkit 1.8.5 → 2.1.0

package/dist/lib/{file-utils.test.js → core/file-utils.test.js}

@@ -1,5 +1,10 @@
-import { describe, it, beforeEach, afterEach } from 'node:test';
+import { describe, it, beforeEach, afterEach } from 'vitest';
 import assert from 'node:assert';
+import { FLOAT_TOLERANCE } from '../../test-helpers/test-data-builders.js';
+import { DEFAULT_LIMIT_10, SAMPLE_SIZE_100, COUNT_FOUR, COUNT_FIFTEEN, COUNT_FIVE, COUNT_NINE, COUNT_SIX, COUNT_THREE, COUNT_TWO, VALUE_FORTY_TWO, } from '../../test-helpers/test-constants.js';
+import { MAX_RESULTS_IN_MEMORY, RETENTION_DAYS_DEFAULT, STREAMING_THRESHOLD, } from './constants.js';
+import { TIME_MS, } from './units.js';
+import { ESTIMATED_SIZE_MAX_BYTES, ESTIMATED_SIZE_MIN_BYTES, LARGE_ARRAY_SAMPLE_SIZE, LARGE_JSONL_LINE_COUNT, LARGE_RESERVOIR_DATASET_SIZE, LARGE_RESERVOIR_P50_EXPECTED, LARGE_RESERVOIR_P95_EXPECTED, LARGE_RESERVOIR_SUM_UPPER_TERM, MIXED_ARRAY_CIRCULAR_ITEMS, MIXED_ARRAY_NORMAL_ITEMS, MOSTLY_CIRCULAR_ITEMS, MOSTLY_CIRCULAR_NORMAL_ITEMS, PERCENTILE_P50_EXPECTED, PERCENTILE_P95_EXPECTED, PERCENTILE_P99_EXPECTED, PERCENTILE_TEST_SAMPLE_SIZE, RESULT_COUNT_EIGHT, RESULT_COUNT_TEN, NUMERIC_SEQUENCE_FIVE_TWO_EIGHT, NUMERIC_SEQUENCE_NEGATIVE_TEN_TO_TEN, NUMERIC_SEQUENCE_ONE_TO_FIVE, NUMERIC_SEQUENCE_ONE_TO_TEN, NUMERIC_SEQUENCE_ONE_TO_THREE, NUMERIC_SEQUENCE_TEN_TWENTY_THIRTY, RELATIVE_ERROR_TEN_PERCENT, STREAMING_COUNT_CUSTOM_HIGH, STREAMING_COUNT_CUSTOM_LOW, STREAMING_COUNT_CUSTOM_THRESHOLD, STREAMING_COUNT_DEFAULT_THRESHOLD, WINDOW_LIMIT_FIVE, WINDOW_LIMIT_TEN, WINDOW_LIMIT_THREE, WINDOW_OFFSET_TWO, } from './file-utils.test-constants.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -41,7 +46,7 @@ describe('file-utils', () => {
     });
     describe('loadJson', () => {
         it('should load and parse valid JSON file', () => {
-            const testData = { key: 'value', num: 42 };
+            const testData = { key: 'value', num: VALUE_FORTY_TWO };
             const filePath = path.join(testDir, 'test.json');
             fs.writeFileSync(filePath, JSON.stringify(testData));
             const result = loadJson(filePath);
@@ -78,7 +83,7 @@ describe('file-utils', () => {
         it('should parse complex nested JSON', () => {
             const testData = {
                 nested: { deep: { value: 'test' } },
-                array: [1, 2, 3],
+                array: [1, COUNT_TWO, COUNT_THREE],
             };
             const filePath = path.join(testDir, 'complex.json');
             fs.writeFileSync(filePath, JSON.stringify(testData));
@@ -152,7 +157,7 @@ describe('file-utils', () => {
             fs.writeFileSync(path.join(testDir, 'file3.txt'), 'text');
             fs.writeFileSync(path.join(testDir, 'file4.json'), '{}');
             const result = listFiles(testDir, /\.json$/);
-            assert.strictEqual(result.length, 3);
+            assert.strictEqual(result.length, COUNT_THREE);
             assert(result.every(f => f.endsWith('.json')));
         });
         it('should return full paths', () => {
@@ -168,9 +173,9 @@ describe('file-utils', () => {
             const file3 = path.join(testDir, 'file3.json');
             fs.writeFileSync(file1, '{}');
             // Small delay to ensure different mtimes
-            await new Promise(resolve => setTimeout(resolve, 50));
+            await new Promise(resolve => setTimeout(resolve, STREAMING_COUNT_CUSTOM_LOW));
             fs.writeFileSync(file2, '{}');
-            await new Promise(resolve => setTimeout(resolve, 50));
+            await new Promise(resolve => setTimeout(resolve, STREAMING_COUNT_CUSTOM_LOW));
             fs.writeFileSync(file3, '{}');
             const result = listFiles(testDir, /\.json$/);
             assert.strictEqual(result[0], file3); // newest first
@@ -187,7 +192,7 @@ describe('file-utils', () => {
             fs.writeFileSync(path.join(testDir, 'logs-2026-01-28.jsonl'), '{}');
             fs.writeFileSync(path.join(testDir, 'other.txt'), 'text');
             const result = listFiles(testDir, /^\w+-\d{4}-\d{2}-\d{2}\.jsonl$/);
-            assert.strictEqual(result.length, 3);
+            assert.strictEqual(result.length, COUNT_THREE);
         });
     });
     describe('parseDateFromFilename', () => {
@@ -265,7 +270,7 @@ describe('file-utils', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1,"name":"first"}\n{"id":2,"name":"second"}\n{"id":3,"name":"third"}');
             const result = readJsonlSync(filePath);
-            assert.strictEqual(result.length, 3);
+            assert.strictEqual(result.length, COUNT_THREE);
             assert.deepStrictEqual(result[0], { id: 1, name: 'first' });
             assert.deepStrictEqual(result[1], { id: 2, name: 'second' });
             assert.deepStrictEqual(result[2], { id: 3, name: 'third' });
@@ -274,34 +279,34 @@ describe('file-utils', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n\n{"id":2}\n   \n{"id":3}');
             const result = readJsonlSync(filePath);
-            assert.strictEqual(result.length, 3);
+            assert.strictEqual(result.length, COUNT_THREE);
         });
         it('should skip malformed JSON lines', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n{invalid json}\n{"id":2}');
             const result = readJsonlSync(filePath);
-            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result.length, COUNT_TWO);
             assert.deepStrictEqual(result[0], { id: 1 });
             assert.deepStrictEqual(result[1], { id: 2 });
         });
         it('should respect limit parameter', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}\n{"id":4}\n{"id":5}');
-            const result = readJsonlSync(filePath, 3);
-            assert.strictEqual(result.length, 3);
+            const result = readJsonlSync(filePath, COUNT_THREE);
+            assert.strictEqual(result.length, COUNT_THREE);
         });
         it('should stop reading at limit even with more lines', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}\n{"id":4}');
-            const result = readJsonlSync(filePath, 2);
-            assert.strictEqual(result.length, 2);
+            const result = readJsonlSync(filePath, COUNT_TWO);
+            assert.strictEqual(result.length, COUNT_TWO);
             assert.deepStrictEqual(result[1], { id: 2 });
         });
         it('should handle file with trailing whitespace', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n   ');
             const result = readJsonlSync(filePath);
-            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result.length, COUNT_TWO);
         });
         it('should handle single line file', () => {
             const filePath = path.join(testDir, 'test.jsonl');
@@ -315,7 +320,7 @@ describe('file-utils', () => {
             fs.writeFileSync(filePath, '{"nested":{"deep":{"value":1}}}\n{"array":[1,2,3]}');
             const result = readJsonlSync(filePath);
             assert.deepStrictEqual(result[0], { nested: { deep: { value: 1 } } });
-            assert.deepStrictEqual(result[1], { array: [1, 2, 3] });
+            assert.deepStrictEqual(result[1], { array: [1, COUNT_TWO, COUNT_THREE] });
         });
     });
     describe('isGzipFile', () => {
@@ -373,7 +378,7 @@ describe('file-utils', () => {
             for await (const item of streamJsonl(filePath)) {
                 results.push(item);
             }
-            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results.length, COUNT_THREE);
             assert.deepStrictEqual(results[0], { id: 1 });
             assert.deepStrictEqual(results[1], { id: 2 });
             assert.deepStrictEqual(results[2], { id: 3 });
@@ -385,7 +390,7 @@ describe('file-utils', () => {
             for await (const item of streamJsonl(filePath)) {
                 results.push(item);
             }
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
         });
         it('should skip malformed JSON lines', async () => {
             const filePath = path.join(testDir, 'test.jsonl');
@@ -394,19 +399,19 @@ describe('file-utils', () => {
             for await (const item of streamJsonl(filePath)) {
                 results.push(item);
             }
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
             assert.deepStrictEqual(results[0], { id: 1 });
             assert.deepStrictEqual(results[1], { id: 2 });
         });
         it('should handle large JSONL files efficiently', async () => {
             const filePath = path.join(testDir, 'large.jsonl');
-            const lines = Array.from({ length: 1000 }, (_, i) => JSON.stringify({ id: i })).join('\n');
+            const lines = Array.from({ length: LARGE_JSONL_LINE_COUNT }, (_, i) => JSON.stringify({ id: i })).join('\n');
             fs.writeFileSync(filePath, lines);
             let count = 0;
             for await (const _item of streamJsonl(filePath)) {
                 count++;
             }
-            assert.strictEqual(count, 1000);
+            assert.strictEqual(count, LARGE_JSONL_LINE_COUNT);
         });
         it('should stream gzipped JSONL file', async () => {
             const filePath = path.join(testDir, 'test.jsonl.gz');
@@ -416,7 +421,7 @@ describe('file-utils', () => {
             for await (const item of streamJsonl(filePath)) {
                 results.push(item);
             }
-            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results.length, COUNT_THREE);
             assert.deepStrictEqual(results[0], { id: 1 });
             assert.deepStrictEqual(results[1], { id: 2 });
             assert.deepStrictEqual(results[2], { id: 3 });
@@ -429,10 +434,40 @@ describe('file-utils', () => {
             for await (const item of streamJsonl(filePath)) {
                 results.push(item);
             }
-            assert.strictEqual(results.length, 2);
+            assert.strictEqual(results.length, COUNT_TWO);
             assert.deepStrictEqual(results[0], { id: 1 });
             assert.deepStrictEqual(results[1], { id: 2 });
         });
+        it('should track parse stats when statsTracker is provided', async () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            // 2 valid, 1 invalid, 2 empty
+            fs.writeFileSync(filePath, '{"id":1}\n\n{invalid}\n  \n{"id":2}');
+            const tracker = {
+                successes: 0,
+                failures: 0,
+                empties: 0,
+                recordSuccess(_path) { this.successes++; },
+                recordFailure(_path) { this.failures++; },
+                recordEmpty(_path) { this.empties++; },
+            };
+            const results = [];
+            for await (const item of streamJsonl(filePath, { statsTracker: tracker })) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, COUNT_TWO);
+            assert.strictEqual(tracker.successes, COUNT_TWO);
+            assert.strictEqual(tracker.failures, 1);
+            assert.strictEqual(tracker.empties, COUNT_TWO);
+        });
+        it('should work without statsTracker (backward compatible)', async () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}');
+            const results = [];
+            for await (const item of streamJsonl(filePath)) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, COUNT_TWO);
+        });
     });
     describe('filterByDateRange', () => {
         const items = [
@@ -443,31 +478,31 @@ describe('file-utils', () => {
         ];
         it('should return all items if no date range specified', () => {
             const result = filterByDateRange(items);
-            assert.strictEqual(result.length, 4);
+            assert.strictEqual(result.length, WINDOW_LIMIT_FIVE - 1);
         });
         it('should filter items after startDate', () => {
             const result = filterByDateRange(items, '2026-01-15');
-            assert.strictEqual(result.length, 3);
+            assert.strictEqual(result.length, COUNT_THREE);
             assert.deepStrictEqual(result[0], { id: 2, timestamp: '2026-01-15' });
         });
         it('should filter items before endDate', () => {
             const result = filterByDateRange(items, undefined, '2026-01-20');
-            assert.strictEqual(result.length, 3);
+            assert.strictEqual(result.length, COUNT_THREE);
             assert.deepStrictEqual(result[2], { id: 3, timestamp: '2026-01-20' });
         });
         it('should filter items between startDate and endDate', () => {
             const result = filterByDateRange(items, '2026-01-12', '2026-01-22');
-            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result.length, COUNT_TWO);
             assert.deepStrictEqual(result[0], { id: 2, timestamp: '2026-01-15' });
             assert.deepStrictEqual(result[1], { id: 3, timestamp: '2026-01-20' });
         });
         it('should include items with exact startDate', () => {
             const result = filterByDateRange(items, '2026-01-15');
-            assert(result.some(item => item.id === 2));
+            assert(result.some(item => item.id === COUNT_TWO));
         });
         it('should include items with exact endDate', () => {
             const result = filterByDateRange(items, undefined, '2026-01-15');
-            assert(result.some(item => item.id === 2));
+            assert(result.some(item => item.id === COUNT_TWO));
         });
         it('should include items without timestamp', () => {
             const itemsWithoutTs = [
@@ -476,8 +511,8 @@ describe('file-utils', () => {
                 { id: 3, timestamp: '2026-01-20' },
             ];
             const result = filterByDateRange(itemsWithoutTs, '2026-01-15');
-            assert.strictEqual(result.length, 2);
-            assert(result.some(item => item.id === 2));
+            assert.strictEqual(result.length, COUNT_TWO);
+            assert(result.some(item => item.id === COUNT_TWO));
         });
         it('should return empty array if no items in range', () => {
             const result = filterByDateRange(items, '2026-02-01', '2026-02-28');
@@ -496,7 +531,7 @@ describe('file-utils', () => {
             // Note: filterByDateRange uses lexicographic comparison
             // '2026-01-15T...' > '2026-01-15' due to 'T', so use end of day
             const result = filterByDateRange(itemsWithTime, '2026-01-15', '2026-01-15T23:59:59');
-            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result.length, COUNT_TWO);
         });
         it('should handle lexicographic string comparison correctly', () => {
             const itemsWithDates = [
@@ -505,7 +540,7 @@ describe('file-utils', () => {
                 { id: 3, timestamp: '2026-10-01' },
             ];
             const result = filterByDateRange(itemsWithDates, '2026-02-01', '2026-10-01');
-            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result.length, COUNT_TWO);
         });
         it('should handle generic type with optional timestamp', () => {
             const customItems = [
@@ -513,60 +548,60 @@ describe('file-utils', () => {
                 { name: 'item2' },
             ];
             const result = filterByDateRange(customItems, '2026-01-09', '2026-01-11');
-            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result.length, COUNT_TWO);
         });
     });
     describe('paginateResults', () => {
-        const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        const items = NUMERIC_SEQUENCE_ONE_TO_TEN;
         it('should return items from offset to offset + limit', () => {
-            const result = paginateResults(items, 2, 3);
-            assert.deepStrictEqual(result, [3, 4, 5]);
+            const result = paginateResults(items, WINDOW_OFFSET_TWO, WINDOW_LIMIT_THREE);
+            assert.deepStrictEqual(result, NUMERIC_SEQUENCE_ONE_TO_TEN.slice(WINDOW_LIMIT_THREE - 1, COUNT_SIX - 1));
         });
         it('should return from start when offset is 0', () => {
-            const result = paginateResults(items, 0, 5);
-            assert.deepStrictEqual(result, [1, 2, 3, 4, 5]);
+            const result = paginateResults(items, 0, WINDOW_LIMIT_FIVE);
+            assert.deepStrictEqual(result, NUMERIC_SEQUENCE_ONE_TO_FIVE);
         });
         it('should handle offset at end of array', () => {
-            const result = paginateResults(items, 8, 5);
-            assert.deepStrictEqual(result, [9, 10]);
+            const result = paginateResults(items, RESULT_COUNT_EIGHT, WINDOW_LIMIT_FIVE);
+            assert.deepStrictEqual(result, [COUNT_NINE, DEFAULT_LIMIT_10]);
         });
         it('should return empty array when offset exceeds length', () => {
-            const result = paginateResults(items, 15, 5);
+            const result = paginateResults(items, COUNT_FIFTEEN, WINDOW_LIMIT_FIVE);
             assert.deepStrictEqual(result, []);
         });
         it('should handle limit larger than remaining items', () => {
-            const result = paginateResults(items, 7, 10);
-            assert.deepStrictEqual(result, [8, 9, 10]);
+            const result = paginateResults(items, COUNT_SIX + 1, WINDOW_LIMIT_TEN);
+            assert.deepStrictEqual(result, [RESULT_COUNT_EIGHT, COUNT_NINE, DEFAULT_LIMIT_10]);
         });
         it('should handle empty array', () => {
-            const result = paginateResults([], 0, 10);
+            const result = paginateResults([], 0, WINDOW_LIMIT_TEN);
             assert.deepStrictEqual(result, []);
         });
         it('should work with object arrays', () => {
-            const objs = [{ id: 1 }, { id: 2 }, { id: 3 }];
-            const result = paginateResults(objs, 1, 2);
-            assert.deepStrictEqual(result, [{ id: 2 }, { id: 3 }]);
+            const objs = NUMERIC_SEQUENCE_ONE_TO_THREE.map((id) => ({ id }));
+            const result = paginateResults(objs, 1, WINDOW_OFFSET_TWO);
+            assert.deepStrictEqual(result, objs.slice(1));
         });
     });
     describe('hasReachedLimit', () => {
         it('should return true when results equal offset + limit', () => {
-            const result = hasReachedLimit(10, 5, 5);
+            const result = hasReachedLimit(RESULT_COUNT_TEN, WINDOW_LIMIT_FIVE, WINDOW_LIMIT_FIVE);
             assert.strictEqual(result, true);
         });
         it('should return true when results exceed offset + limit', () => {
-            const result = hasReachedLimit(15, 5, 5);
+            const result = hasReachedLimit(COUNT_FIFTEEN, WINDOW_LIMIT_FIVE, WINDOW_LIMIT_FIVE);
             assert.strictEqual(result, true);
         });
         it('should return false when results are less than offset + limit', () => {
-            const result = hasReachedLimit(8, 5, 5);
+            const result = hasReachedLimit(RESULT_COUNT_EIGHT, WINDOW_LIMIT_FIVE, WINDOW_LIMIT_FIVE);
             assert.strictEqual(result, false);
         });
         it('should return false with zero results', () => {
-            const result = hasReachedLimit(0, 0, 10);
+            const result = hasReachedLimit(0, 0, WINDOW_LIMIT_TEN);
             assert.strictEqual(result, false);
         });
         it('should handle zero offset', () => {
-            const result = hasReachedLimit(10, 0, 10);
+            const result = hasReachedLimit(RESULT_COUNT_TEN, 0, WINDOW_LIMIT_TEN);
             assert.strictEqual(result, true);
         });
     });
@@ -577,9 +612,9 @@ describe('file-utils', () => {
             const result = readJsonlSyncWithStats(filePath);
             assert.ok('data' in result);
             assert.ok('stats' in result);
-            assert.strictEqual(result.data.length, 3);
-            assert.strictEqual(result.stats.totalLines, 3);
-            assert.strictEqual(result.stats.parsedLines, 3);
+            assert.strictEqual(result.data.length, COUNT_THREE);
+            assert.strictEqual(result.stats.totalLines, COUNT_THREE);
+            assert.strictEqual(result.stats.parsedLines, COUNT_THREE);
             assert.strictEqual(result.stats.skippedLines, 0);
             assert.strictEqual(result.stats.emptyLines, 0);
         });
@@ -587,24 +622,24 @@ describe('file-utils', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n{invalid json}\n{"id":2}\n{also invalid}');
             const result = readJsonlSyncWithStats(filePath);
-            assert.strictEqual(result.data.length, 2);
-            assert.strictEqual(result.stats.parsedLines, 2);
-            assert.strictEqual(result.stats.skippedLines, 2);
+            assert.strictEqual(result.data.length, COUNT_TWO);
+            assert.strictEqual(result.stats.parsedLines, COUNT_TWO);
+            assert.strictEqual(result.stats.skippedLines, COUNT_TWO);
         });
         it('should count empty lines', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             // Note: trailing empty lines are removed by trim(), so only internal empty lines are counted
             fs.writeFileSync(filePath, '{"id":1}\n\n  \n{"id":2}');
             const result = readJsonlSyncWithStats(filePath);
-            assert.strictEqual(result.data.length, 2);
-            assert.strictEqual(result.stats.emptyLines, 2);
+            assert.strictEqual(result.data.length, COUNT_TWO);
+            assert.strictEqual(result.stats.emptyLines, COUNT_TWO);
         });
         it('should respect limit parameter', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}\n{"id":4}\n{"id":5}');
-            const result = readJsonlSyncWithStats(filePath, 3);
-            assert.strictEqual(result.data.length, 3);
-            assert.strictEqual(result.stats.parsedLines, 3);
+            const result = readJsonlSyncWithStats(filePath, COUNT_THREE);
+            assert.strictEqual(result.data.length, COUNT_THREE);
+            assert.strictEqual(result.stats.parsedLines, COUNT_THREE);
         });
         it('should return empty stats for non-existent file', () => {
             const result = readJsonlSyncWithStats(path.join(testDir, 'nonexistent.jsonl'));
@@ -616,11 +651,11 @@ describe('file-utils', () => {
             const filePath = path.join(testDir, 'test.jsonl');
             fs.writeFileSync(filePath, '{"id":1}\n\n{bad}\n{"id":2}\n  \n{invalid}\n{"id":3}');
             const result = readJsonlSyncWithStats(filePath);
-            assert.strictEqual(result.data.length, 3);
-            assert.strictEqual(result.stats.totalLines, 7);
-            assert.strictEqual(result.stats.parsedLines, 3);
-            assert.strictEqual(result.stats.skippedLines, 2);
-            assert.strictEqual(result.stats.emptyLines, 2);
+            assert.strictEqual(result.data.length, COUNT_THREE);
+            assert.strictEqual(result.stats.totalLines, COUNT_FIVE + COUNT_TWO);
+            assert.strictEqual(result.stats.parsedLines, COUNT_THREE);
+            assert.strictEqual(result.stats.skippedLines, COUNT_TWO);
+            assert.strictEqual(result.stats.emptyLines, COUNT_TWO);
         });
     });
     describe('cleanupOldFiles', () => {
@@ -636,8 +671,8 @@ describe('file-utils', () => {
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `logs-${oldDate}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `traces-${recentDate}.jsonl`), '{}');
-            const result = cleanupOldFiles(testDir, 7);
-            assert.strictEqual(result.deleted, 2);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
+            assert.strictEqual(result.deleted, COUNT_TWO);
             assert.deepStrictEqual(result.errors, []);
             // Verify old files are deleted
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.jsonl`)), false);
@@ -647,17 +682,17 @@ describe('file-utils', () => {
         });
         it('should not delete files within retention period', () => {
             const today = new Date();
-            const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+            const yesterday = new Date(today.getTime() - TIME_MS.DAY);
             const yesterdayStr = yesterday.toISOString().split('T')[0];
             fs.writeFileSync(path.join(testDir, `traces-${yesterdayStr}.jsonl`), '{}');
-            const result = cleanupOldFiles(testDir, 7);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
             assert.strictEqual(result.deleted, 0);
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${yesterdayStr}.jsonl`)), true);
         });
         it('should skip files without parseable dates', () => {
             fs.writeFileSync(path.join(testDir, 'some-random-file.jsonl'), '{}');
             fs.writeFileSync(path.join(testDir, 'no-date.jsonl'), '{}');
-            const result = cleanupOldFiles(testDir, 7);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
             assert.strictEqual(result.deleted, 0);
             assert.strictEqual(fs.existsSync(path.join(testDir, 'some-random-file.jsonl')), true);
             assert.strictEqual(fs.existsSync(path.join(testDir, 'no-date.jsonl')), true);
@@ -667,7 +702,7 @@ describe('file-utils', () => {
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.json`), '{}');
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.txt`), 'text');
-            const result = cleanupOldFiles(testDir, 7);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
             assert.strictEqual(result.deleted, 1);
             // Only .jsonl file should be deleted
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.jsonl`)), false);
@@ -677,20 +712,20 @@ describe('file-utils', () => {
         it('should respect custom retention period', () => {
             const today = new Date();
             // Create file from 5 days ago
-            const fiveDaysAgo = new Date(today.getTime() - 5 * 24 * 60 * 60 * 1000);
+            const fiveDaysAgo = new Date(today.getTime() - COUNT_FIVE * TIME_MS.DAY);
             const fiveDaysAgoStr = fiveDaysAgo.toISOString().split('T')[0];
             fs.writeFileSync(path.join(testDir, `traces-${fiveDaysAgoStr}.jsonl`), '{}');
             // With 7 day retention, file should be kept
-            let result = cleanupOldFiles(testDir, 7);
+            let result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
             assert.strictEqual(result.deleted, 0);
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${fiveDaysAgoStr}.jsonl`)), true);
             // With 3 day retention, file should be deleted
-            result = cleanupOldFiles(testDir, 3);
+            result = cleanupOldFiles(testDir, COUNT_THREE);
             assert.strictEqual(result.deleted, 1);
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${fiveDaysAgoStr}.jsonl`)), false);
         });
         it('should handle empty directory', () => {
-            const result = cleanupOldFiles(testDir, 7);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
             assert.strictEqual(result.deleted, 0);
             assert.deepStrictEqual(result.errors, []);
         });
@@ -698,7 +733,7 @@ describe('file-utils', () => {
             const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'outside-'));
             try {
                 fs.writeFileSync(path.join(outsideDir, 'traces-2020-01-01.jsonl'), '{}');
-                const result = cleanupOldFiles(outsideDir, 7, [testDir]);
+                const result = cleanupOldFiles(outsideDir, RETENTION_DAYS_DEFAULT, [testDir]);
                 assert.strictEqual(result.deleted, 0);
                 assert.strictEqual(result.errors.length, 1);
                 assert(result.errors[0].includes('not within allowed paths'));
@@ -713,7 +748,7 @@ describe('file-utils', () => {
             const subDir = path.join(testDir, 'subdir');
             fs.mkdirSync(subDir);
             fs.writeFileSync(path.join(subDir, 'traces-2020-01-01.jsonl'), '{}');
-            const result = cleanupOldFiles(subDir, 7, [testDir]);
+            const result = cleanupOldFiles(subDir, RETENTION_DAYS_DEFAULT, [testDir]);
             assert.strictEqual(result.deleted, 1);
             assert.deepStrictEqual(result.errors, []);
         });
@@ -722,17 +757,17 @@ describe('file-utils', () => {
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `logs-${oldDate}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `metrics-${oldDate}.jsonl`), '{}');
-            const result = cleanupOldFiles(testDir, 7);
-            assert.strictEqual(result.deleted, 3);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
+            assert.strictEqual(result.deleted, COUNT_THREE);
             assert.deepStrictEqual(result.errors, []);
         });
         it('should use default retention of 7 days', () => {
             const today = new Date();
             // Create file from 8 days ago
-            const eightDaysAgo = new Date(today.getTime() - 8 * 24 * 60 * 60 * 1000);
+            const eightDaysAgo = new Date(today.getTime() - RESULT_COUNT_EIGHT * TIME_MS.DAY);
             const eightDaysAgoStr = eightDaysAgo.toISOString().split('T')[0];
-            // Create file from 6 days ago
-            const sixDaysAgo = new Date(today.getTime() - 6 * 24 * 60 * 60 * 1000);
+            // Create file from COUNT_SIX days ago
+            const sixDaysAgo = new Date(today.getTime() - COUNT_SIX * TIME_MS.DAY);
             const sixDaysAgoStr = sixDaysAgo.toISOString().split('T')[0];
             fs.writeFileSync(path.join(testDir, `traces-${eightDaysAgoStr}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `traces-${sixDaysAgoStr}.jsonl`), '{}');
@@ -748,8 +783,8 @@ describe('file-utils', () => {
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl.gz`), gzipSync('{}'));
             fs.writeFileSync(path.join(testDir, `logs-${oldDate}.jsonl.gz`), gzipSync('{}'));
             fs.writeFileSync(path.join(testDir, `traces-${recentDate}.jsonl.gz`), gzipSync('{}'));
-            const result = cleanupOldFiles(testDir, 7);
-            assert.strictEqual(result.deleted, 2);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
+            assert.strictEqual(result.deleted, COUNT_TWO);
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.jsonl.gz`)), false);
             assert.strictEqual(fs.existsSync(path.join(testDir, `logs-${oldDate}.jsonl.gz`)), false);
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${recentDate}.jsonl.gz`)), true);
@@ -758,8 +793,8 @@ describe('file-utils', () => {
             const oldDate = '2020-01-01';
             fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
             fs.writeFileSync(path.join(testDir, `logs-${oldDate}.jsonl.gz`), gzipSync('{}'));
-            const result = cleanupOldFiles(testDir, 7);
-            assert.strictEqual(result.deleted, 2);
+            const result = cleanupOldFiles(testDir, RETENTION_DAYS_DEFAULT);
+            assert.strictEqual(result.deleted, COUNT_TWO);
             assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.jsonl`)), false);
             assert.strictEqual(fs.existsSync(path.join(testDir, `logs-${oldDate}.jsonl.gz`)), false);
         });
@@ -776,19 +811,19 @@ describe('file-utils', () => {
             writer.close();
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 3);
+            assert.strictEqual(lines.length, COUNT_THREE);
         });
         it('should flush remaining records on close', () => {
             const filePath = path.join(testDir, 'batch.jsonl');
-            const writer = new BatchWriter(filePath, { batchSize: 10 });
+            const writer = new BatchWriter(filePath, { batchSize: DEFAULT_LIMIT_10 });
             writer.write({ id: 1 });
             writer.write({ id: 2 });
             const stats = writer.close();
-            assert.strictEqual(stats.recordsWritten, 2);
+            assert.strictEqual(stats.recordsWritten, COUNT_TWO);
             assert.strictEqual(fs.existsSync(filePath), true);
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 2);
+            assert.strictEqual(lines.length, COUNT_TWO);
         });
         it('should append to file on multiple flushes', () => {
             const filePath = path.join(testDir, 'batch.jsonl');
@@ -801,14 +836,14 @@ describe('file-utils', () => {
             writer.close(); // Flush 3
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 5);
+            assert.strictEqual(lines.length, COUNT_FIVE);
             // Verify content
             assert.deepStrictEqual(JSON.parse(lines[0]), { id: 1 });
             assert.deepStrictEqual(JSON.parse(lines[4]), { id: 5 });
         });
         it('should write gzip compressed output', () => {
             const filePath = path.join(testDir, 'batch.jsonl.gz');
-            const writer = new BatchWriter(filePath, { batchSize: 10, gzip: true });
+            const writer = new BatchWriter(filePath, { batchSize: DEFAULT_LIMIT_10, gzip: true });
             writer.write({ id: 1 });
             writer.write({ id: 2 });
             writer.close();
@@ -816,7 +851,7 @@ describe('file-utils', () => {
             const compressed = fs.readFileSync(filePath);
             const decompressed = gunzipSync(compressed).toString('utf-8');
             const lines = decompressed.trim().split('\n');
-            assert.strictEqual(lines.length, 2);
+            assert.strictEqual(lines.length, COUNT_TWO);
         });
         it('should handle gzip append correctly', () => {
             const filePath = path.join(testDir, 'batch.jsonl.gz');
@@ -828,7 +863,7 @@ describe('file-utils', () => {
             const compressed = fs.readFileSync(filePath);
             const decompressed = gunzipSync(compressed).toString('utf-8');
             const lines = decompressed.trim().split('\n');
-            assert.strictEqual(lines.length, 3);
+            assert.strictEqual(lines.length, COUNT_THREE);
         });
         it('should create parent directories if mkdirp is true', () => {
             const filePath = path.join(testDir, 'nested', 'dir', 'batch.jsonl');
@@ -840,13 +875,14 @@ describe('file-utils', () => {
         it('should use default batch size of 100', () => {
             const filePath = path.join(testDir, 'batch.jsonl');
             const writer = new BatchWriter(filePath);
+            const preFlushCount = SAMPLE_SIZE_100 - 1;
             // Write 99 records - should not flush
-            for (let i = 0; i < 99; i++) {
+            for (let i = 0; i < preFlushCount; i++) {
                 writer.write({ id: i });
             }
             assert.strictEqual(fs.existsSync(filePath), false);
             // 100th record triggers flush
-            writer.write({ id: 99 });
+            writer.write({ id: preFlushCount });
             assert.strictEqual(fs.existsSync(filePath), true);
             writer.close();
         });
@@ -857,8 +893,8 @@ describe('file-utils', () => {
             writer.write({ id: 2 }); // Flush 1
             writer.write({ id: 3 });
             const stats = writer.close(); // Flush 2
-            assert.strictEqual(stats.recordsWritten, 3);
-            assert.strictEqual(stats.flushCount, 2);
+            assert.strictEqual(stats.recordsWritten, COUNT_THREE);
+            assert.strictEqual(stats.flushCount, COUNT_TWO);
             assert.ok(stats.bytesWritten > 0);
         });
         it('should report buffered count correctly', () => {
@@ -868,18 +904,18 @@ describe('file-utils', () => {
             writer.write({ id: 1 });
             assert.strictEqual(writer.bufferedCount, 1);
             writer.write({ id: 2 });
-            assert.strictEqual(writer.bufferedCount, 2);
+            assert.strictEqual(writer.bufferedCount, COUNT_TWO);
             writer.close();
             assert.strictEqual(writer.bufferedCount, 0);
         });
         it('should handle writeAll for multiple records', () => {
             const filePath = path.join(testDir, 'batch.jsonl');
-            const writer = new BatchWriter(filePath, { batchSize: 10 });
+            const writer = new BatchWriter(filePath, { batchSize: DEFAULT_LIMIT_10 });
             writer.writeAll([{ id: 1 }, { id: 2 }, { id: 3 }]);
             writer.close();
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 3);
+            assert.strictEqual(lines.length, COUNT_THREE);
         });
         it('should handle empty close gracefully', () => {
             const filePath = path.join(testDir, 'batch.jsonl');
@@ -893,70 +929,61 @@ describe('file-utils', () => {
     describe('StreamingAggregator', () => {
         it('should compute count correctly', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(1);
-            aggregator.add(2);
-            aggregator.add(3);
-            assert.strictEqual(aggregator.getResult('count'), 3);
-            assert.strictEqual(aggregator.getCount(), 3);
+            aggregator.addAll(NUMERIC_SEQUENCE_ONE_TO_THREE);
+            assert.strictEqual(aggregator.getResult('count'), COUNT_THREE);
+            assert.strictEqual(aggregator.getCount(), COUNT_THREE);
         });
         it('should compute sum correctly', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(10);
-            aggregator.add(20);
-            aggregator.add(30);
-            assert.strictEqual(aggregator.getResult('sum'), 60);
+            aggregator.addAll(NUMERIC_SEQUENCE_TEN_TWENTY_THIRTY);
+            assert.strictEqual(aggregator.getResult('sum'), NUMERIC_SEQUENCE_TEN_TWENTY_THIRTY.reduce((sum, value) => sum + value, 0));
         });
         it('should compute avg correctly', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(10);
-            aggregator.add(20);
-            aggregator.add(30);
-            assert.strictEqual(aggregator.getResult('avg'), 20);
+            aggregator.addAll(NUMERIC_SEQUENCE_TEN_TWENTY_THIRTY);
+            assert.strictEqual(aggregator.getResult('avg'), NUMERIC_SEQUENCE_TEN_TWENTY_THIRTY.reduce((sum, value) => sum + value, 0)
+                / COUNT_THREE);
         });
         it('should compute min correctly', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(5);
-            aggregator.add(2);
-            aggregator.add(8);
-            assert.strictEqual(aggregator.getResult('min'), 2);
+            aggregator.addAll(NUMERIC_SEQUENCE_FIVE_TWO_EIGHT);
+            assert.strictEqual(aggregator.getResult('min'), COUNT_TWO);
         });
         it('should compute max correctly', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(5);
-            aggregator.add(2);
-            aggregator.add(8);
-            assert.strictEqual(aggregator.getResult('max'), 8);
+            aggregator.addAll(NUMERIC_SEQUENCE_FIVE_TWO_EIGHT);
+            assert.strictEqual(aggregator.getResult('max'), RESULT_COUNT_EIGHT);
         });
         it('should compute p50 (median) correctly', () => {
             const aggregator = new StreamingAggregator();
             // Add values 1-100 for predictable p50
-            for (let i = 1; i <= 100; i++) {
+            for (let i = 1; i <= PERCENTILE_TEST_SAMPLE_SIZE; i++) {
                 aggregator.add(i);
             }
             const p50 = aggregator.getResult('p50');
             assert.ok(p50 !== undefined);
             // p50 should be close to 50.5 for 1-100
-            assert.ok(Math.abs(p50 - 50.5) < 1);
+            assert.ok(Math.abs(p50 - PERCENTILE_P50_EXPECTED) < 1);
         });
         it('should compute p95 correctly', () => {
             const aggregator = new StreamingAggregator();
-            for (let i = 1; i <= 100; i++) {
+            for (let i = 1; i <= PERCENTILE_TEST_SAMPLE_SIZE; i++) {
                 aggregator.add(i);
             }
             const p95 = aggregator.getResult('p95');
             assert.ok(p95 !== undefined);
             // p95 should be close to 95.05 for 1-100
-            assert.ok(Math.abs(p95 - 95.05) < 1);
+            assert.ok(Math.abs(p95 - PERCENTILE_P95_EXPECTED) < 1);
         });
         it('should compute p99 correctly', () => {
             const aggregator = new StreamingAggregator();
-            for (let i = 1; i <= 100; i++) {
+            for (let i = 1; i <= PERCENTILE_TEST_SAMPLE_SIZE; i++) {
                 aggregator.add(i);
             }
             const p99 = aggregator.getResult('p99');
             assert.ok(p99 !== undefined);
             // p99 should be close to 99.01 for 1-100
-            assert.ok(Math.abs(p99 - 99.01) < 1);
+            assert.ok(Math.abs(p99 - PERCENTILE_P99_EXPECTED) < 1);
         });
         it('should return undefined for aggregations on empty aggregator', () => {
             const aggregator = new StreamingAggregator();
@@ -969,47 +996,46 @@ describe('file-utils', () => {
         });
         it('should handle single value', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(42);
+            aggregator.add(VALUE_FORTY_TWO);
             assert.strictEqual(aggregator.getResult('count'), 1);
-            assert.strictEqual(aggregator.getResult('sum'), 42);
-            assert.strictEqual(aggregator.getResult('avg'), 42);
-            assert.strictEqual(aggregator.getResult('min'), 42);
-            assert.strictEqual(aggregator.getResult('max'), 42);
-            assert.strictEqual(aggregator.getResult('p50'), 42);
+            assert.strictEqual(aggregator.getResult('sum'), VALUE_FORTY_TWO);
+            assert.strictEqual(aggregator.getResult('avg'), VALUE_FORTY_TWO);
+            assert.strictEqual(aggregator.getResult('min'), VALUE_FORTY_TWO);
+            assert.strictEqual(aggregator.getResult('max'), VALUE_FORTY_TWO);
+            // DDSketch uses relative error; approximate match for percentiles
+            const p50Raw = aggregator.getResult('p50');
+            assert(p50Raw !== undefined, 'p50 result should be defined');
+            assert.ok(Math.abs(p50Raw - VALUE_FORTY_TWO) < VALUE_FORTY_TWO * 0.05, `p50 ${p50Raw} should approximate ${VALUE_FORTY_TWO}`);
         });
         it('should handle negative values', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(-10);
-            aggregator.add(-5);
-            aggregator.add(0);
-            aggregator.add(5);
-            aggregator.add(10);
+            aggregator.addAll(NUMERIC_SEQUENCE_NEGATIVE_TEN_TO_TEN);
             assert.strictEqual(aggregator.getResult('sum'), 0);
-            assert.strictEqual(aggregator.getResult('min'), -10);
-            assert.strictEqual(aggregator.getResult('max'), 10);
+            assert.strictEqual(aggregator.getResult('min'), -RESULT_COUNT_TEN);
+            assert.strictEqual(aggregator.getResult('max'), RESULT_COUNT_TEN);
             assert.strictEqual(aggregator.getResult('avg'), 0);
         });
         it('should skip non-finite values', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(10);
+            aggregator.add(RESULT_COUNT_TEN);
             aggregator.add(Infinity);
             aggregator.add(-Infinity);
             aggregator.add(NaN);
-            aggregator.add(20);
-            assert.strictEqual(aggregator.getResult('count'), 2);
-            assert.strictEqual(aggregator.getResult('sum'), 30);
-            assert.strictEqual(aggregator.getResult('avg'), 15);
+            aggregator.add(RESULT_COUNT_TEN * COUNT_TWO);
+            assert.strictEqual(aggregator.getResult('count'), COUNT_TWO);
+            assert.strictEqual(aggregator.getResult('sum'), RESULT_COUNT_TEN * COUNT_THREE);
+            assert.strictEqual(aggregator.getResult('avg'), COUNT_FIFTEEN);
         });
         it('should support addAll for multiple values', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.addAll([1, 2, 3, 4, 5]);
-            assert.strictEqual(aggregator.getResult('count'), 5);
-            assert.strictEqual(aggregator.getResult('sum'), 15);
-            assert.strictEqual(aggregator.getResult('avg'), 3);
+            aggregator.addAll(NUMERIC_SEQUENCE_ONE_TO_FIVE);
+            assert.strictEqual(aggregator.getResult('count'), COUNT_FIVE);
+            assert.strictEqual(aggregator.getResult('sum'), COUNT_FIFTEEN);
+            assert.strictEqual(aggregator.getResult('avg'), COUNT_THREE);
         });
         it('should reset correctly', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.addAll([1, 2, 3, 4, 5]);
+            aggregator.addAll(NUMERIC_SEQUENCE_ONE_TO_FIVE);
             aggregator.reset();
             assert.strictEqual(aggregator.getResult('count'), 0);
             assert.strictEqual(aggregator.getResult('sum'), undefined);
@@ -1017,83 +1043,83 @@ describe('file-utils', () => {
         });
         it('should return all stats via getStats()', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.addAll([1, 2, 3, 4, 5]);
+            aggregator.addAll(NUMERIC_SEQUENCE_ONE_TO_FIVE);
             const stats = aggregator.getStats();
-            assert.strictEqual(stats.count, 5);
-            assert.strictEqual(stats.sum, 15);
-            assert.strictEqual(stats.avg, 3);
+            assert.strictEqual(stats.count, COUNT_FIVE);
+            assert.strictEqual(stats.sum, COUNT_FIFTEEN);
+            assert.strictEqual(stats.avg, COUNT_THREE);
             assert.strictEqual(stats.min, 1);
-            assert.strictEqual(stats.max, 5);
+            assert.strictEqual(stats.max, COUNT_FIVE);
             assert.ok(stats.p50 !== undefined);
         });
         it('should handle large datasets with reservoir sampling', () => {
             const aggregator = new StreamingAggregator();
             // Add 50000 values - larger than reservoir size
-            for (let i = 1; i <= 50000; i++) {
+            for (let i = 1; i <= LARGE_RESERVOIR_DATASET_SIZE; i++) {
                 aggregator.add(i);
             }
-            assert.strictEqual(aggregator.getResult('count'), 50000);
-            assert.strictEqual(aggregator.getResult('sum'), (50000 * 50001) / 2);
+            assert.strictEqual(aggregator.getResult('count'), LARGE_RESERVOIR_DATASET_SIZE);
+            assert.strictEqual(aggregator.getResult('sum'), (LARGE_RESERVOIR_DATASET_SIZE * LARGE_RESERVOIR_SUM_UPPER_TERM) / COUNT_TWO);
             assert.strictEqual(aggregator.getResult('min'), 1);
-            assert.strictEqual(aggregator.getResult('max'), 50000);
+            assert.strictEqual(aggregator.getResult('max'), LARGE_RESERVOIR_DATASET_SIZE);
             // Percentiles should be approximately correct (within 10% error due to sampling)
             const p50 = aggregator.getResult('p50');
             assert.ok(p50 !== undefined);
-            assert.ok(Math.abs(p50 - 25000) / 25000 < 0.10);
+            assert.ok(Math.abs(p50 - LARGE_RESERVOIR_P50_EXPECTED) / LARGE_RESERVOIR_P50_EXPECTED < RELATIVE_ERROR_TEN_PERCENT);
             const p95 = aggregator.getResult('p95');
             assert.ok(p95 !== undefined);
-            assert.ok(Math.abs(p95 - 47500) / 47500 < 0.10);
+            assert.ok(Math.abs(p95 - LARGE_RESERVOIR_P95_EXPECTED) / LARGE_RESERVOIR_P95_EXPECTED < RELATIVE_ERROR_TEN_PERCENT);
         });
         it('should handle decimal values', () => {
             const aggregator = new StreamingAggregator();
-            aggregator.add(0.1);
-            aggregator.add(0.2);
-            aggregator.add(0.3);
+            aggregator.add(RELATIVE_ERROR_TEN_PERCENT);
+            aggregator.add(COUNT_TWO / DEFAULT_LIMIT_10);
+            aggregator.add(COUNT_THREE / DEFAULT_LIMIT_10);
             const sum = aggregator.getResult('sum');
             assert.ok(sum !== undefined);
-            assert.ok(Math.abs(sum - 0.6) < 0.0001);
+            assert.ok(Math.abs(sum - (COUNT_SIX / DEFAULT_LIMIT_10)) < FLOAT_TOLERANCE);
         });
     });
     describe('enforceMemoryLimit', () => {
         it('should return results unchanged when under limit', () => {
-            const items = [1, 2, 3, 4, 5];
-            const result = enforceMemoryLimit(items, 10);
+            const items = NUMERIC_SEQUENCE_ONE_TO_FIVE;
+            const result = enforceMemoryLimit(items, WINDOW_LIMIT_TEN);
             assert.deepStrictEqual(result.results, items);
             assert.strictEqual(result.truncated, false);
-            assert.strictEqual(result.originalCount, 5);
+            assert.strictEqual(result.originalCount, COUNT_FIVE);
         });
         it('should truncate results when over limit', () => {
-            const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-            const result = enforceMemoryLimit(items, 5);
-            assert.deepStrictEqual(result.results, [1, 2, 3, 4, 5]);
+            const items = NUMERIC_SEQUENCE_ONE_TO_TEN;
+            const result = enforceMemoryLimit(items, WINDOW_LIMIT_FIVE);
+            assert.deepStrictEqual(result.results, NUMERIC_SEQUENCE_ONE_TO_FIVE);
             assert.strictEqual(result.truncated, true);
-            assert.strictEqual(result.originalCount, 10);
+            assert.strictEqual(result.originalCount, RESULT_COUNT_TEN);
         });
         it('should return exactly at limit without truncation', () => {
-            const items = [1, 2, 3, 4, 5];
-            const result = enforceMemoryLimit(items, 5);
+            const items = NUMERIC_SEQUENCE_ONE_TO_FIVE;
+            const result = enforceMemoryLimit(items, WINDOW_LIMIT_FIVE);
             assert.deepStrictEqual(result.results, items);
             assert.strictEqual(result.truncated, false);
-            assert.strictEqual(result.originalCount, 5);
+            assert.strictEqual(result.originalCount, COUNT_FIVE);
         });
         it('should handle empty array', () => {
-            const result = enforceMemoryLimit([], 10);
+            const result = enforceMemoryLimit([], WINDOW_LIMIT_TEN);
             assert.deepStrictEqual(result.results, []);
             assert.strictEqual(result.truncated, false);
             assert.strictEqual(result.originalCount, 0);
         });
         it('should work with object arrays', () => {
-            const items = [{ id: 1 }, { id: 2 }, { id: 3 }];
-            const result = enforceMemoryLimit(items, 2);
-            assert.deepStrictEqual(result.results, [{ id: 1 }, { id: 2 }]);
+            const items = NUMERIC_SEQUENCE_ONE_TO_THREE.map((id) => ({ id }));
+            const result = enforceMemoryLimit(items, WINDOW_OFFSET_TWO);
+            assert.deepStrictEqual(result.results, items.slice(0, WINDOW_OFFSET_TWO));
             assert.strictEqual(result.truncated, true);
         });
         it('should use default limit when not specified', () => {
-            const items = Array.from({ length: 100 }, (_, i) => i);
+            const items = Array.from({ length: SAMPLE_SIZE_100 }, (_, i) => i);
             const result = enforceMemoryLimit(items);
             // Default is 10000, so 100 items should not be truncated
             assert.strictEqual(result.truncated, false);
-            assert.strictEqual(result.results.length, 100);
+            assert.strictEqual(result.results.length, SAMPLE_SIZE_100);
         });
         it('should log warning when truncating (verify via side effect)', () => {
             // Store original console.warn
@@ -1105,10 +1131,10 @@ describe('file-utils', () => {
                 warnMessage = msg;
             };
             try {
-                const items = [1, 2, 3, 4, 5];
-                enforceMemoryLimit(items, 3);
+                const items = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE];
+                enforceMemoryLimit(items, COUNT_THREE);
                 assert.strictEqual(warnCalled, true);
-                assert.ok(warnMessage.includes('[MEMORY]'));
+                assert.ok(warnMessage.includes('"memory"') || warnMessage.includes('memory'), 'Warning should reference memory component');
                 assert.ok(warnMessage.includes('5'));
                 assert.ok(warnMessage.includes('3'));
             }
@@ -1119,21 +1145,21 @@ describe('file-utils', () => {
     });
     describe('shouldUseStreamingAggregation', () => {
         it('should return false when count is below threshold', () => {
-            assert.strictEqual(shouldUseStreamingAggregation(100, 5000), false);
-            assert.strictEqual(shouldUseStreamingAggregation(4999, 5000), false);
-            assert.strictEqual(shouldUseStreamingAggregation(5000, 5000), false);
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_COUNT_CUSTOM_THRESHOLD, STREAMING_THRESHOLD), false);
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_THRESHOLD - 1, STREAMING_THRESHOLD), false);
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_THRESHOLD, STREAMING_THRESHOLD), false);
         });
         it('should return true when count exceeds threshold', () => {
-            assert.strictEqual(shouldUseStreamingAggregation(5001, 5000), true);
-            assert.strictEqual(shouldUseStreamingAggregation(10000, 5000), true);
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_THRESHOLD + 1, STREAMING_THRESHOLD), true);
+            assert.strictEqual(shouldUseStreamingAggregation(MAX_RESULTS_IN_MEMORY, STREAMING_THRESHOLD), true);
         });
         it('should use default threshold when not specified', () => {
-            // Default is 5000
-            assert.strictEqual(shouldUseStreamingAggregation(4000), false);
+            // Default is STREAMING_THRESHOLD
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_COUNT_DEFAULT_THRESHOLD), false);
         });
         it('should work with custom threshold', () => {
-            assert.strictEqual(shouldUseStreamingAggregation(500, 100), true);
-            assert.strictEqual(shouldUseStreamingAggregation(50, 100), false);
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_COUNT_CUSTOM_HIGH, STREAMING_COUNT_CUSTOM_THRESHOLD), true);
+            assert.strictEqual(shouldUseStreamingAggregation(STREAMING_COUNT_CUSTOM_LOW, STREAMING_COUNT_CUSTOM_THRESHOLD), false);
         });
     });
     describe('getMemoryLimits', () => {
@@ -1151,7 +1177,7 @@ describe('file-utils', () => {
         it('should return false for primitive values', () => {
             assert.strictEqual(hasCircularReference(null), false);
             assert.strictEqual(hasCircularReference(undefined), false);
-            assert.strictEqual(hasCircularReference(42), false);
+            assert.strictEqual(hasCircularReference(VALUE_FORTY_TWO), false);
             assert.strictEqual(hasCircularReference('string'), false);
             assert.strictEqual(hasCircularReference(true), false);
         });
@@ -1160,7 +1186,7 @@ describe('file-utils', () => {
             assert.strictEqual(hasCircularReference({ nested: { deep: { value: 1 } } }), false);
         });
         it('should return false for simple arrays', () => {
-            assert.strictEqual(hasCircularReference([1, 2, 3]), false);
+            assert.strictEqual(hasCircularReference([1, COUNT_TWO, COUNT_THREE]), false);
             assert.strictEqual(hasCircularReference([{ id: 1 }, { id: 2 }]), false);
         });
         it('should detect self-referencing object', () => {
@@ -1169,7 +1195,7 @@ describe('file-utils', () => {
             assert.strictEqual(hasCircularReference(obj), true);
         });
         it('should detect self-referencing array', () => {
-            const arr = [1, 2, 3];
+            const arr = [1, COUNT_TWO, COUNT_THREE];
             arr.push(arr);
             assert.strictEqual(hasCircularReference(arr), true);
         });
@@ -1209,7 +1235,7 @@ describe('file-utils', () => {
             const circularObj = { id: 1 };
             circularObj.self = circularObj;
             const items = [];
-            for (let i = 0; i < 200; i++) {
+            for (let i = 0; i < LARGE_ARRAY_SAMPLE_SIZE; i++) {
                 items.push(circularObj);
             }
             const result = estimateByteSize(items);
@@ -1221,11 +1247,11 @@ describe('file-utils', () => {
             circularObj.self = circularObj;
             const items = [];
             // Add 150 normal items (75% of 200)
-            for (let i = 0; i < 150; i++) {
+            for (let i = 0; i < MIXED_ARRAY_NORMAL_ITEMS; i++) {
                 items.push({ id: i, data: 'normal' });
             }
             // Add 50 circular items (25% of 200)
-            for (let i = 0; i < 50; i++) {
+            for (let i = 0; i < MIXED_ARRAY_CIRCULAR_ITEMS; i++) {
                 items.push(circularObj);
             }
             // Since less than 50% failed, should extrapolate from successful samples
@@ -1240,11 +1266,11 @@ describe('file-utils', () => {
             circularObj.self = circularObj;
             const items = [];
             // Add 40 normal items (20% of 200)
-            for (let i = 0; i < 40; i++) {
+            for (let i = 0; i < MOSTLY_CIRCULAR_NORMAL_ITEMS; i++) {
                 items.push({ id: i });
             }
             // Add 160 circular items (80% of 200)
-            for (let i = 0; i < 160; i++) {
+            for (let i = 0; i < MOSTLY_CIRCULAR_ITEMS; i++) {
                 items.push(circularObj);
             }
             const result = estimateByteSize(items);
@@ -1253,13 +1279,13 @@ describe('file-utils', () => {
         });
         it('should extrapolate size for large non-circular arrays', () => {
             // Create array larger than sample size
-            const items = Array.from({ length: 200 }, (_, i) => ({ id: i, name: `item-${i}` }));
+            const items = Array.from({ length: LARGE_ARRAY_SAMPLE_SIZE }, (_, i) => ({ id: i, name: `item-${i}` }));
             const result = estimateByteSize(items);
             // Result should be positive and reasonable
             assert.ok(result > 0);
             // Rough estimate: each item is ~25 bytes, so 200 items ~5000 bytes
-            assert.ok(result > 1000);
-            assert.ok(result < 100000);
+            assert.ok(result > ESTIMATED_SIZE_MIN_BYTES);
+            assert.ok(result < ESTIMATED_SIZE_MAX_BYTES);
         });
     });
     describe('enforceMemoryLimit with circular references', () => {
@@ -1271,7 +1297,7 @@ describe('file-utils', () => {
             // which exceeds the 50MB limit would not trigger, but the detection
             // prevents bypass (the conservative estimate ensures the check works)
             const items = [obj];
-            const result = enforceMemoryLimit(items, 10000);
+            const result = enforceMemoryLimit(items, MAX_RESULTS_IN_MEMORY);
             // Since a single item with circular ref returns 1MB estimate,
             // and 1MB < 50MB limit, it won't truncate
             // But the important thing is it doesn't crash and returns valid result
@@ -1284,19 +1310,19 @@ describe('file-utils', () => {
             obj1.ref = obj2;
             obj2.ref = obj1;
             const items = [obj1, obj2, { normal: 'object' }];
-            const result = enforceMemoryLimit(items, 10000);
+            const result = enforceMemoryLimit(items, MAX_RESULTS_IN_MEMORY);
             assert.ok(Array.isArray(result.results));
-            assert.strictEqual(result.originalCount, 3);
+            assert.strictEqual(result.originalCount, COUNT_THREE);
         });
         it('should not crash when JSON.stringify would throw', () => {
             // Create an object that would cause JSON.stringify to throw
             const obj = {};
             obj.circular = obj;
             const items = Array.from({ length: 50 }, () => obj);
-            const result = enforceMemoryLimit(items, 10000);
+            const result = enforceMemoryLimit(items, MAX_RESULTS_IN_MEMORY);
             // Should not throw and should return valid result
             assert.ok(Array.isArray(result.results));
-            assert.strictEqual(result.originalCount, 50);
+            assert.strictEqual(result.originalCount, STREAMING_COUNT_CUSTOM_LOW);
         });
     });
 });