observability-toolkit 2.0.0 → 2.1.1

package/dist/lib/edge-cases.test.js

@@ -1,634 +0,0 @@
-/**
- * Edge case tests for security and robustness (T2)
- *
- * Covers:
- * - Malformed JSONL with null bytes
- * - Extremely large attribute values
- * - Time range edge cases spanning year boundaries
- * - Integer overflow in timestamp calculations
- */
-import { describe, it, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import * as fs from 'fs';
-import * as path from 'path';
-import { readJsonlSync, readJsonlSyncWithStats, streamJsonl, filterByDateRange, } from './file-utils.js';
-import { LocalJsonlBackend } from '../backends/local-jsonl.js';
-import { createTempDir, removeTempDir, getSharedTempDir, clearTempDir, removeSharedTempDir, writeJsonlFileAsync, getTestDate } from '../test-helpers/file-utils.js';
-describe('edge-cases: malformed JSONL with null bytes', () => {
-    let testDir;
-    before(() => {
-        testDir = getSharedTempDir('EdgeCasesNullBytes');
-    });
-    beforeEach(() => {
-        clearTempDir(testDir);
-    });
-    after(() => {
-        removeSharedTempDir('EdgeCasesNullBytes');
-    });
-    describe('readJsonlSync', () => {
-        it('should skip lines containing null bytes in JSON string values', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            // Line with null byte in value - null byte in JSON string may cause parse issues
-            // depending on how Node handles it. The actual behavior is implementation-specific.
-            fs.writeFileSync(filePath, '{"id":1}\n{"id":2,"val":"test\0null"}\n{"id":3}');
-            const result = readJsonlSync(filePath);
-            // At minimum, we should get lines 1 and 3
-            assert.ok(result.length >= 2);
-            assert.deepStrictEqual(result[0], { id: 1 });
-        });
-        it('should skip lines with null byte breaking JSON structure', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            // Null byte as separate character breaking JSON
-            fs.writeFileSync(filePath, '{"id":1}\n\0\n{"id":2}');
-            const result = readJsonlSync(filePath);
-            assert.strictEqual(result.length, 2);
-        });
-        it('should handle line that is just null bytes', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1}\n\0\0\0\n{"id":2}');
-            const result = readJsonlSync(filePath);
-            assert.strictEqual(result.length, 2);
-        });
-        it('should handle null byte at start of line', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1}\n\0{"id":2}\n{"id":3}');
-            const result = readJsonlSync(filePath);
-            // First line valid, second line starts with null so JSON.parse may fail or succeed
-            // Third line valid
-            assert.ok(result.length >= 2);
-            assert.deepStrictEqual(result[0], { id: 1 });
-        });
-        it('should handle null byte at end of line', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\0\n{"id":3}');
-            const result = readJsonlSync(filePath);
-            // Second line ends with null, JSON.parse may fail
-            assert.ok(result.length >= 2);
-        });
-        it('should handle file that is entirely null bytes', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, Buffer.from([0, 0, 0, 0, 0]));
-            const result = readJsonlSync(filePath);
-            assert.deepStrictEqual(result, []);
-        });
-        it('should handle mixed null bytes and valid JSON', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            const content = Buffer.concat([
-                Buffer.from('{"id":1}\n'),
-                Buffer.from([0, 0, 0]),
-                Buffer.from('\n{"id":2}\n'),
-                Buffer.from([0]),
-                Buffer.from('{"broken\n'),
-                Buffer.from('{"id":3}'),
-            ]);
-            fs.writeFileSync(filePath, content);
-            const result = readJsonlSync(filePath);
-            // Should get at least the valid JSON objects
-            assert.ok(result.length >= 2);
-        });
-    });
-    describe('readJsonlSyncWithStats', () => {
-        it('should track skipped lines with null bytes', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1}\n\0invalid\n{"id":2}');
-            const { data, stats } = readJsonlSyncWithStats(filePath);
-            assert.strictEqual(data.length, 2);
-            assert.strictEqual(stats.skippedLines, 1);
-            assert.strictEqual(stats.totalLines, 3);
-        });
-        it('should count null-byte-only lines as skipped', () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1}\n\0\0\0\n{"id":2}');
-            const { data, stats } = readJsonlSyncWithStats(filePath);
-            assert.strictEqual(data.length, 2);
-            // Null-byte line is either skipped or counted as empty
-            assert.ok(stats.skippedLines >= 0 || stats.emptyLines >= 0);
-        });
-    });
-    describe('streamJsonl', () => {
-        it('should skip lines with null bytes when streaming', async () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1}\n\0broken\n{"id":2}');
-            const results = [];
-            for await (const item of streamJsonl(filePath)) {
-                results.push(item);
-            }
-            assert.strictEqual(results.length, 2);
-            assert.deepStrictEqual(results[0], { id: 1 });
-            assert.deepStrictEqual(results[1], { id: 2 });
-        });
-        it('should handle streaming file with embedded null bytes in values', async () => {
-            const filePath = path.join(testDir, 'test.jsonl');
-            fs.writeFileSync(filePath, '{"id":1,"data":"before\0after"}\n{"id":2}');
-            const results = [];
-            for await (const item of streamJsonl(filePath)) {
-                results.push(item);
-            }
-            // Null bytes in JSON strings may or may not parse depending on readline handling
-            // The important thing is it doesn't crash and we get at least valid JSON
-            assert.ok(results.length >= 1);
-            // Verify we at least got the second (clean) object
-            const hasId2 = results.some((r) => r.id === 2);
-            assert.ok(hasId2 || results.length >= 1);
-        });
-    });
-    describe('LocalJsonlBackend with null bytes', () => {
-        it('should skip malformed trace spans with null bytes', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            // Write file with mix of valid and null-byte-corrupted spans
-            const content = [
-                JSON.stringify({ traceId: 't1', spanId: 's1', name: 'valid1', startTime: [1700000000, 0] }),
-                '\0corrupted',
-                JSON.stringify({ traceId: 't2', spanId: 's2', name: 'valid2', startTime: [1700000000, 0] }),
-            ].join('\n');
-            fs.writeFileSync(path.join(testDir, `traces-${today}.jsonl`), content);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 2);
-        });
-        it('should skip malformed log records with null bytes', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            const content = [
-                JSON.stringify({ timestamp: '2026-01-01T00:00:00Z', body: 'valid log 1' }),
-                '\0\0\0',
-                JSON.stringify({ timestamp: '2026-01-01T00:00:01Z', body: 'valid log 2' }),
-            ].join('\n');
-            fs.writeFileSync(path.join(testDir, `logs-${today}.jsonl`), content);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 2);
-        });
-    });
-});
-describe('edge-cases: extremely large attribute values', () => {
-    let testDir;
-    before(() => {
-        testDir = getSharedTempDir('EdgeCasesLargeAttrs');
-    });
-    beforeEach(() => {
-        clearTempDir(testDir);
-    });
-    after(() => {
-        removeSharedTempDir('EdgeCasesLargeAttrs');
-    });
-    describe('attribute size limits', () => {
-        it('should handle span with very large attribute value', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            // Create a span with a 100KB attribute value
-            const largeValue = 'x'.repeat(100 * 1024);
-            const span = {
-                traceId: 't1',
-                spanId: 's1',
-                name: 'large-attr-span',
-                startTime: [1700000000, 0],
-                attributes: { 'large.attr': largeValue },
-            };
-            await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), [span]);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['large.attr'], largeValue);
-        });
-        it('should handle span with many attributes', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            // Create a span with 1000 attributes
-            const manyAttrs = {};
-            for (let i = 0; i < 1000; i++) {
-                manyAttrs[`attr.${i}`] = `value-${i}`;
-            }
-            const span = {
-                traceId: 't1',
-                spanId: 's1',
-                name: 'many-attrs-span',
-                startTime: [1700000000, 0],
-                attributes: manyAttrs,
-            };
-            await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), [span]);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            // Attributes should include all 1000 custom attributes
-            // (resource attributes like service.name only added if resource is provided)
-            assert.ok(Object.keys(results[0].attributes || {}).length >= 1000);
-        });
-        it('should handle deeply nested attribute objects', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            // Create deeply nested object (50 levels)
-            let nested = { value: 'deep' };
-            for (let i = 0; i < 50; i++) {
-                nested = { level: i, child: nested };
-            }
-            const span = {
-                traceId: 't1',
-                spanId: 's1',
-                name: 'nested-span',
-                startTime: [1700000000, 0],
-                attributes: { nested },
-            };
-            await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), [span]);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.ok(results[0].attributes?.nested);
-        });
-        it('should handle log with very large body', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            const largeBody = 'Log message: ' + 'x'.repeat(50 * 1024);
-            const log = {
-                timestamp: '2026-01-01T00:00:00Z',
-                body: largeBody,
-            };
-            await writeJsonlFileAsync(path.join(testDir, `logs-${today}.jsonl`), [log]);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, largeBody);
-        });
-        it('should handle metric with large number of exemplars', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            // Create metric with 100 exemplars
-            const exemplars = Array.from({ length: 100 }, (_, i) => ({
-                traceId: `trace-${i}`,
-                spanId: `span-${i}`,
-                value: i * 1.5,
-                timestamp: `2026-01-01T00:00:${String(i % 60).padStart(2, '0')}Z`,
-            }));
-            const metric = {
-                timestamp: '2026-01-01T00:00:00Z',
-                name: 'test.metric',
-                value: 100,
-                type: 'histogram',
-                exemplars,
-            };
-            await writeJsonlFileAsync(path.join(testDir, `metrics-${today}.jsonl`), [metric]);
-            const results = await backend.queryMetrics({});
-            assert.ok(results.length >= 1);
-        });
-        it('should handle attribute key with special characters', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            const span = {
-                traceId: 't1',
-                spanId: 's1',
-                name: 'special-key-span',
-                startTime: [1700000000, 0],
-                attributes: {
-                    'key.with.dots': 'value1',
-                    'key-with-dashes': 'value2',
-                    'key_with_underscores': 'value3',
-                    'key:with:colons': 'value4',
-                    'key/with/slashes': 'value5',
-                },
-            };
-            await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), [span]);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['key.with.dots'], 'value1');
-            assert.strictEqual(results[0].attributes?.['key-with-dashes'], 'value2');
-        });
-        it('should handle unicode attribute values', async () => {
-            const today = getTestDate();
-            const backend = new LocalJsonlBackend(testDir);
-            const span = {
-                traceId: 't1',
-                spanId: 's1',
-                name: 'unicode-span',
-                startTime: [1700000000, 0],
-                attributes: {
-                    'unicode.emoji': '🔥🎉🚀',
-                    'unicode.chinese': '中文测试',
-                    'unicode.arabic': 'اختبار',
-                    'unicode.mixed': 'Test 测试 🎉',
-                },
-            };
-            await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), [span]);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['unicode.emoji'], '🔥🎉🚀');
-            assert.strictEqual(results[0].attributes?.['unicode.chinese'], '中文测试');
-        });
-    });
-});
-describe('edge-cases: time range spanning year boundaries', () => {
-    describe('filterByDateRange with year boundaries', () => {
-        const yearBoundaryItems = [
-            { id: 1, timestamp: '2025-12-30' },
-            { id: 2, timestamp: '2025-12-31' },
-            { id: 3, timestamp: '2026-01-01' },
-            { id: 4, timestamp: '2026-01-02' },
-        ];
-        it('should filter items spanning year boundary', () => {
-            const result = filterByDateRange(yearBoundaryItems, '2025-12-31', '2026-01-01');
-            assert.strictEqual(result.length, 2);
-            assert.deepStrictEqual(result[0], { id: 2, timestamp: '2025-12-31' });
-            assert.deepStrictEqual(result[1], { id: 3, timestamp: '2026-01-01' });
-        });
-        it('should filter items starting before year boundary', () => {
-            const result = filterByDateRange(yearBoundaryItems, '2025-12-29', '2025-12-31');
-            assert.strictEqual(result.length, 2);
-            assert.deepStrictEqual(result[0], { id: 1, timestamp: '2025-12-30' });
-            assert.deepStrictEqual(result[1], { id: 2, timestamp: '2025-12-31' });
-        });
-        it('should filter items ending after year boundary', () => {
-            const result = filterByDateRange(yearBoundaryItems, '2026-01-01', '2026-01-03');
-            assert.strictEqual(result.length, 2);
-            assert.deepStrictEqual(result[0], { id: 3, timestamp: '2026-01-01' });
-            assert.deepStrictEqual(result[1], { id: 4, timestamp: '2026-01-02' });
-        });
-        it('should handle multi-year span', () => {
-            const multiYearItems = [
-                { id: 1, timestamp: '2024-06-15' },
-                { id: 2, timestamp: '2025-06-15' },
-                { id: 3, timestamp: '2026-06-15' },
-                { id: 4, timestamp: '2027-06-15' },
-            ];
-            const result = filterByDateRange(multiYearItems, '2025-01-01', '2026-12-31');
-            assert.strictEqual(result.length, 2);
-            assert.strictEqual(result[0].id, 2);
-            assert.strictEqual(result[1].id, 3);
-        });
-        it('should handle leap year boundary (Feb 28/29)', () => {
-            const leapYearItems = [
-                { id: 1, timestamp: '2024-02-28' },
-                { id: 2, timestamp: '2024-02-29' }, // Leap year
-                { id: 3, timestamp: '2024-03-01' },
-            ];
-            const result = filterByDateRange(leapYearItems, '2024-02-28', '2024-03-01');
-            assert.strictEqual(result.length, 3);
-        });
-        it('should handle non-leap year boundary', () => {
-            const nonLeapYearItems = [
-                { id: 1, timestamp: '2025-02-28' },
-                { id: 2, timestamp: '2025-03-01' }, // No Feb 29 in 2025
-            ];
-            const result = filterByDateRange(nonLeapYearItems, '2025-02-28', '2025-03-01');
-            assert.strictEqual(result.length, 2);
-        });
-        it('should handle decade boundary', () => {
-            const decadeItems = [
-                { id: 1, timestamp: '2029-12-31' },
-                { id: 2, timestamp: '2030-01-01' },
-            ];
-            const result = filterByDateRange(decadeItems, '2029-12-30', '2030-01-02');
-            assert.strictEqual(result.length, 2);
-        });
-        it('should handle century boundary (if applicable)', () => {
-            const centuryItems = [
-                { id: 1, timestamp: '2099-12-31' },
-                { id: 2, timestamp: '2100-01-01' },
-            ];
-            const result = filterByDateRange(centuryItems, '2099-12-31', '2100-01-01');
-            assert.strictEqual(result.length, 2);
-        });
-    });
-    describe('LocalJsonlBackend with year boundary date ranges', () => {
-        let testDir;
-        let backend;
-        before(() => {
-            testDir = getSharedTempDir('EdgeCasesYearBoundary');
-        });
-        beforeEach(() => {
-            clearTempDir(testDir);
-            backend = new LocalJsonlBackend(testDir);
-        });
-        after(() => {
-            removeSharedTempDir('EdgeCasesYearBoundary');
-        });
-        it('should query traces spanning year boundary files', async () => {
-            // Create files for end of 2025 and start of 2026
-            const spans2025 = [
-                { traceId: 't1', spanId: 's1', name: 'span-2025', startTime: [1735603200, 0] }, // 2025-12-31
-            ];
-            const spans2026 = [
-                { traceId: 't2', spanId: 's2', name: 'span-2026', startTime: [1735689600, 0] }, // 2026-01-01
-            ];
-            await writeJsonlFileAsync(path.join(testDir, 'traces-2025-12-31.jsonl'), spans2025);
-            await writeJsonlFileAsync(path.join(testDir, 'traces-2026-01-01.jsonl'), spans2026);
-            const results = await backend.queryTraces({
-                startDate: '2025-12-31',
-                endDate: '2026-01-01',
-            });
-            assert.strictEqual(results.length, 2);
-        });
-        it('should query logs spanning year boundary', async () => {
-            const logs2025 = [
-                { timestamp: '2025-12-31T23:59:59Z', body: 'Last log of 2025' },
-            ];
-            const logs2026 = [
-                { timestamp: '2026-01-01T00:00:00Z', body: 'First log of 2026' },
-            ];
-            await writeJsonlFileAsync(path.join(testDir, 'logs-2025-12-31.jsonl'), logs2025);
-            await writeJsonlFileAsync(path.join(testDir, 'logs-2026-01-01.jsonl'), logs2026);
-            const results = await backend.queryLogs({
-                startDate: '2025-12-31',
-                endDate: '2026-01-01',
-            });
-            assert.strictEqual(results.length, 2);
-        });
-    });
-});
-describe('edge-cases: integer overflow in timestamp calculations', () => {
-    describe('timestamp boundary values', () => {
-        it('should handle timestamp at Unix epoch', () => {
-            const items = [
-                { id: 1, timestamp: '1970-01-01T00:00:00Z' },
-                { id: 2, timestamp: '1970-01-01T00:00:01Z' },
-            ];
-            const result = filterByDateRange(items, '1970-01-01', '1970-01-02');
-            assert.strictEqual(result.length, 2);
-        });
-        it('should handle very large year (2100)', () => {
-            const items = [
-                { id: 1, timestamp: '2100-06-15' }, // Use date without time to avoid lexicographic issues
-            ];
-            const result = filterByDateRange(items, '2100-01-01', '2100-12-31');
-            assert.strictEqual(result.length, 1);
-        });
-        it('should handle nanosecond precision timestamps', async () => {
-            const testDir = createTempDir('edge-case-nanosecond-');
-            try {
-                const backend = new LocalJsonlBackend(testDir);
-                const today = getTestDate();
-                // Test max nanosecond value (999999999)
-                const spans = [
-                    {
-                        traceId: 't1',
-                        spanId: 's1',
-                        name: 'max-nanos',
-                        startTime: [1700000000, 999999999],
-                        endTime: [1700000001, 0],
-                    },
-                    {
-                        traceId: 't2',
-                        spanId: 's2',
-                        name: 'zero-nanos',
-                        startTime: [1700000000, 0],
-                        endTime: [1700000000, 500000000],
-                    },
-                ];
-                await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), spans);
-                const results = await backend.queryTraces({});
-                assert.strictEqual(results.length, 2);
-                // Verify duration calculations don't overflow
-                assert.ok(results[0].durationMs !== undefined);
-                assert.ok(results[1].durationMs !== undefined);
-            }
-            finally {
-                removeTempDir(testDir);
-            }
-        });
-        it('should handle duration with max seconds value', async () => {
-            const testDir = createTempDir('edge-case-max-duration-');
-            try {
-                const backend = new LocalJsonlBackend(testDir);
-                const today = getTestDate();
-                // Duration of ~24 hours in nanoseconds format
-                const spans = [
-                    {
-                        traceId: 't1',
-                        spanId: 's1',
-                        name: 'long-duration',
-                        startTime: [1700000000, 0],
-                        duration: [86400, 0], // 24 hours
-                    },
-                ];
-                await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), spans);
-                const results = await backend.queryTraces({});
-                assert.strictEqual(results.length, 1);
-                assert.strictEqual(results[0].durationMs, 86400000); // 24 hours in ms
-            }
-            finally {
-                removeTempDir(testDir);
-            }
-        });
-        it('should handle negative duration gracefully', async () => {
-            const testDir = createTempDir('edge-case-negative-duration-');
-            try {
-                const backend = new LocalJsonlBackend(testDir);
-                const today = getTestDate();
-                // Negative duration (invalid but should not crash)
-                const spans = [
-                    {
-                        traceId: 't1',
-                        spanId: 's1',
-                        name: 'negative-duration',
-                        startTime: [1700000000, 0],
-                        endTime: [1699999999, 0], // End before start
-                    },
-                ];
-                await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), spans);
-                const results = await backend.queryTraces({});
-                // Should still return the span (validation is caller's responsibility)
-                assert.strictEqual(results.length, 1);
-            }
-            finally {
-                removeTempDir(testDir);
-            }
-        });
-        it('should handle duration filtering with extreme values', async () => {
-            const testDir = createTempDir('edge-case-extreme-duration-');
-            try {
-                const backend = new LocalJsonlBackend(testDir);
-                const today = getTestDate();
-                const spans = [
-                    {
-                        traceId: 't1',
-                        spanId: 's1',
-                        name: 'microsecond',
-                        startTime: [1700000000, 0],
-                        duration: [0, 1000], // 1 microsecond
-                    },
-                    {
-                        traceId: 't2',
-                        spanId: 's2',
-                        name: 'hour',
-                        startTime: [1700000000, 0],
-                        duration: [3600, 0], // 1 hour
-                    },
-                ];
-                await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), spans);
-                // Filter for durations > 1ms and < 1 hour
-                const results = await backend.queryTraces({
-                    minDurationMs: 1,
-                    maxDurationMs: 3600000,
-                });
-                // Only the 1-hour span should match (microsecond < 1ms)
-                assert.strictEqual(results.length, 1);
-                assert.strictEqual(results[0].name, 'hour');
-            }
-            finally {
-                removeTempDir(testDir);
-            }
-        });
-        it('should handle Number.MAX_SAFE_INTEGER in calculations', () => {
-            // This tests that timestamp math doesn't lose precision
-            const maxSafe = Number.MAX_SAFE_INTEGER;
-            const timestampMs = maxSafe - 1000;
-            // Creating a date from this should not lose precision for reasonable dates
-            const date = new Date(1700000000000); // Reasonable timestamp
-            assert.ok(date.getTime() === 1700000000000);
-        });
-        it('should handle zero duration correctly', async () => {
-            const testDir = createTempDir('edge-case-zero-duration-');
-            try {
-                const backend = new LocalJsonlBackend(testDir);
-                const today = getTestDate();
-                const spans = [
-                    {
-                        traceId: 't1',
-                        spanId: 's1',
-                        name: 'zero-duration',
-                        startTime: [1700000000, 0],
-                        duration: [0, 0],
-                    },
-                    {
-                        traceId: 't2',
-                        spanId: 's2',
-                        name: 'nonzero-duration',
-                        startTime: [1700000000, 0],
-                        duration: [1, 0],
-                    },
-                ];
-                await writeJsonlFileAsync(path.join(testDir, `traces-${today}.jsonl`), spans);
-                const results = await backend.queryTraces({ minDurationMs: 0 });
-                // Both should match (0 >= 0)
-                assert.strictEqual(results.length, 2);
-            }
-            finally {
-                removeTempDir(testDir);
-            }
-        });
-        it('should handle timestamp comparison near millisecond boundaries', () => {
-            // Test that string comparison works correctly for timestamps
-            const items = [
-                { id: 1, timestamp: '2026-01-15T10:00:00.000Z' },
-                { id: 2, timestamp: '2026-01-15T10:00:00.001Z' },
-                { id: 3, timestamp: '2026-01-15T10:00:00.999Z' },
-            ];
-            const result = filterByDateRange(items, '2026-01-15T10:00:00.000Z', '2026-01-15T10:00:00.500Z');
-            assert.strictEqual(result.length, 2);
-            assert.strictEqual(result[0].id, 1);
-            assert.strictEqual(result[1].id, 2);
-        });
-    });
-    describe('hours calculation edge cases', () => {
-        it('should not overflow when calculating milliseconds for large hour values', () => {
-            // Test the pattern used in SigNoz: hours * 60 * 60 * 1000
-            const hoursValues = [1, 24, 168, 720, 8760]; // 1h, 1d, 1w, 1m, 1y
-            for (const hours of hoursValues) {
-                const ms = hours * 60 * 60 * 1000;
-                assert.ok(Number.isSafeInteger(ms), `${hours} hours should produce safe integer: ${ms}`);
-                assert.ok(ms > 0, `${hours} hours should produce positive value: ${ms}`);
-            }
-        });
-        it('should handle max reasonable hours without overflow', () => {
-            // 10 years in hours
-            const maxReasonableHours = 10 * 365 * 24;
-            const ms = maxReasonableHours * 60 * 60 * 1000;
-            assert.ok(Number.isSafeInteger(ms));
-            assert.ok(ms < Number.MAX_SAFE_INTEGER);
-        });
-    });
-});
-//# sourceMappingURL=edge-cases.test.js.map