observability-toolkit 2.0.0 → 2.1.1

package/dist/lib/instrumentation.test.js

@@ -1,821 +0,0 @@
-import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
-import * as assert from 'node:assert';
-import { initializeInstrumentation, shutdownInstrumentation, resetInstrumentationForTesting, getTracer, isInstrumentationEnabled, withSpan, withSpanSync, waitForInitialization, getInitializationStatus, InstrumentationManager, getDefaultManager, } from './instrumentation.js';
-describe('Instrumentation', () => {
-    // Store original env vars
-    let originalOtelEnabled;
-    let originalOtelEndpoint;
-    let originalOtelServiceName;
-    before(() => {
-        originalOtelEnabled = process.env.OTEL_ENABLED;
-        originalOtelEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-        originalOtelServiceName = process.env.OTEL_SERVICE_NAME;
-    });
-    afterEach(async () => {
-        // Reset env vars after each test
-        if (originalOtelEnabled !== undefined) {
-            process.env.OTEL_ENABLED = originalOtelEnabled;
-        }
-        else {
-            delete process.env.OTEL_ENABLED;
-        }
-        if (originalOtelEndpoint !== undefined) {
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT = originalOtelEndpoint;
-        }
-        else {
-            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-        }
-        if (originalOtelServiceName !== undefined) {
-            process.env.OTEL_SERVICE_NAME = originalOtelServiceName;
-        }
-        else {
-            delete process.env.OTEL_SERVICE_NAME;
-        }
-        // Always reset instrumentation state
-        await shutdownInstrumentation();
-        resetInstrumentationForTesting();
-    });
-    after(() => {
-        // Restore original env vars
-        if (originalOtelEnabled !== undefined) {
-            process.env.OTEL_ENABLED = originalOtelEnabled;
-        }
-        else {
-            delete process.env.OTEL_ENABLED;
-        }
-        if (originalOtelEndpoint !== undefined) {
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT = originalOtelEndpoint;
-        }
-        else {
-            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-        }
-        if (originalOtelServiceName !== undefined) {
-            process.env.OTEL_SERVICE_NAME = originalOtelServiceName;
-        }
-        else {
-            delete process.env.OTEL_SERVICE_NAME;
-        }
-    });
-    describe('isInstrumentationEnabled', () => {
-        it('should return false when OTEL_ENABLED is not set', () => {
-            delete process.env.OTEL_ENABLED;
-            assert.strictEqual(isInstrumentationEnabled(), false);
-        });
-        it('should return false when OTEL_ENABLED is "false"', () => {
-            process.env.OTEL_ENABLED = 'false';
-            assert.strictEqual(isInstrumentationEnabled(), false);
-        });
-        it('should return true when OTEL_ENABLED is "true"', () => {
-            process.env.OTEL_ENABLED = 'true';
-            assert.strictEqual(isInstrumentationEnabled(), true);
-        });
-        it('should respect config.enabled over environment', () => {
-            process.env.OTEL_ENABLED = 'true';
-            assert.strictEqual(isInstrumentationEnabled({ enabled: false }), false);
-            process.env.OTEL_ENABLED = 'false';
-            assert.strictEqual(isInstrumentationEnabled({ enabled: true }), true);
-        });
-    });
-    describe('initializeInstrumentation - disabled', () => {
-        it('should skip initialization when disabled (default)', async () => {
-            delete process.env.OTEL_ENABLED;
-            await initializeInstrumentation();
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should skip initialization when OTEL_ENABLED is false', async () => {
-            process.env.OTEL_ENABLED = 'false';
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:4318';
-            await initializeInstrumentation();
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should skip initialization when enabled but no endpoint', async () => {
-            process.env.OTEL_ENABLED = 'true';
-            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-            await initializeInstrumentation();
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should skip when config overrides to disabled', async () => {
-            process.env.OTEL_ENABLED = 'true';
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:4318';
-            await initializeInstrumentation({ enabled: false });
-            assert.strictEqual(getTracer(), null);
-        });
-    });
-    describe('initializeInstrumentation - enabled', () => {
-        it('should initialize when enabled via environment', async () => {
-            process.env.OTEL_ENABLED = 'true';
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:4318';
-            await initializeInstrumentation();
-            // Tracer should be set (not null)
-            assert.notStrictEqual(getTracer(), null);
-        });
-        it('should initialize when enabled via config', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.notStrictEqual(getTracer(), null);
-        });
-        it('should use custom service name from config', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-                serviceName: 'custom-service',
-            });
-            assert.notStrictEqual(getTracer(), null);
-        });
-        it('should use OTEL_SERVICE_NAME environment variable', async () => {
-            process.env.OTEL_ENABLED = 'true';
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:4318';
-            process.env.OTEL_SERVICE_NAME = 'env-service';
-            await initializeInstrumentation();
-            assert.notStrictEqual(getTracer(), null);
-        });
-        it('should be idempotent (multiple calls are no-ops)', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const tracer1 = getTracer();
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const tracer2 = getTracer();
-            // Should be the same tracer (not re-initialized)
-            assert.strictEqual(tracer1, tracer2);
-        });
-    });
-    describe('getTracer', () => {
-        it('should return null when not initialized', () => {
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should return null when disabled', async () => {
-            await initializeInstrumentation({ enabled: false });
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should return tracer when enabled', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const tracer = getTracer();
-            assert.notStrictEqual(tracer, null);
-            assert.ok(typeof tracer?.startSpan === 'function');
-        });
-    });
-    describe('shutdownInstrumentation', () => {
-        it('should be safe to call when not initialized', async () => {
-            await assert.doesNotReject(async () => {
-                await shutdownInstrumentation();
-            });
-        });
-        it('should be safe to call multiple times', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            await assert.doesNotReject(async () => {
-                await shutdownInstrumentation();
-                await shutdownInstrumentation();
-                await shutdownInstrumentation();
-            });
-        });
-        it('should clear tracer on shutdown', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.notStrictEqual(getTracer(), null);
-            await shutdownInstrumentation();
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should allow re-initialization after shutdown', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            await shutdownInstrumentation();
-            resetInstrumentationForTesting();
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.notStrictEqual(getTracer(), null);
-        });
-    });
-    describe('resetInstrumentationForTesting', () => {
-        it('should reset all internal state', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.notStrictEqual(getTracer(), null);
-            resetInstrumentationForTesting();
-            assert.strictEqual(getTracer(), null);
-        });
-        it('should allow fresh initialization after reset', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            resetInstrumentationForTesting();
-            // Should be able to initialize again (unlike shutdown which sets initialized=false)
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.notStrictEqual(getTracer(), null);
-        });
-    });
-    describe('withSpan - disabled', () => {
-        it('should execute function directly when disabled', async () => {
-            const result = await withSpan('test.span', { attr: 'value' }, async (span) => {
-                assert.strictEqual(span, null);
-                return 'result';
-            });
-            assert.strictEqual(result, 'result');
-        });
-        it('should propagate errors when disabled', async () => {
-            const error = new Error('test error');
-            await assert.rejects(async () => {
-                await withSpan('test.span', {}, async () => {
-                    throw error;
-                });
-            }, (err) => {
-                assert.strictEqual(err, error);
-                return true;
-            });
-        });
-        it('should handle undefined attributes when disabled', async () => {
-            const result = await withSpan('test.span', { defined: 'value', undef: undefined }, async () => 'ok');
-            assert.strictEqual(result, 'ok');
-        });
-    });
-    describe('withSpan - enabled', () => {
-        beforeEach(async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-        });
-        it('should provide span to callback', async () => {
-            let receivedSpan = undefined;
-            await withSpan('test.span', {}, async (span) => {
-                receivedSpan = span;
-                return 'result';
-            });
-            assert.notStrictEqual(receivedSpan, null);
-            assert.ok(receivedSpan !== undefined);
-        });
-        it('should return function result', async () => {
-            const result = await withSpan('test.span', {}, async () => {
-                return { data: 'test' };
-            });
-            assert.deepStrictEqual(result, { data: 'test' });
-        });
-        it('should propagate errors and record exception', async () => {
-            const error = new Error('test error');
-            await assert.rejects(async () => {
-                await withSpan('test.span', {}, async () => {
-                    throw error;
-                });
-            }, (err) => {
-                assert.strictEqual(err, error);
-                return true;
-            });
-        });
-        it('should allow setting attributes on span', async () => {
-            await withSpan('test.span', { 'initial.attr': 'value' }, async (span) => {
-                if (span) {
-                    span.setAttribute('dynamic.attr', 42);
-                }
-                return 'ok';
-            });
-            // No assertion needed - just verify it doesn't throw
-        });
-        it('should filter undefined attributes', async () => {
-            await assert.doesNotReject(async () => {
-                await withSpan('test.span', {
-                    defined: 'value',
-                    undef: undefined,
-                    num: 42,
-                    bool: true,
-                }, async () => 'ok');
-            });
-        });
-        it('should support different span kinds', async () => {
-            await assert.doesNotReject(async () => {
-                await withSpan('test.internal', {}, async () => 'ok', 'INTERNAL');
-                await withSpan('test.server', {}, async () => 'ok', 'SERVER');
-                await withSpan('test.client', {}, async () => 'ok', 'CLIENT');
-                await withSpan('test.producer', {}, async () => 'ok', 'PRODUCER');
-                await withSpan('test.consumer', {}, async () => 'ok', 'CONSUMER');
-            });
-        });
-    });
-    describe('withSpanSync - disabled', () => {
-        it('should execute function directly when disabled', () => {
-            const result = withSpanSync('test.span', { attr: 'value' }, (span) => {
-                assert.strictEqual(span, null);
-                return 'result';
-            });
-            assert.strictEqual(result, 'result');
-        });
-        it('should propagate errors when disabled', () => {
-            const error = new Error('test error');
-            assert.throws(() => {
-                withSpanSync('test.span', {}, () => {
-                    throw error;
-                });
-            }, (err) => {
-                assert.strictEqual(err, error);
-                return true;
-            });
-        });
-    });
-    describe('withSpanSync - enabled', () => {
-        beforeEach(async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-        });
-        it('should provide span to callback', () => {
-            let receivedSpan = undefined;
-            withSpanSync('test.span', {}, (span) => {
-                receivedSpan = span;
-                return 'result';
-            });
-            assert.notStrictEqual(receivedSpan, null);
-        });
-        it('should return function result', () => {
-            const result = withSpanSync('test.span', {}, () => {
-                return { data: 'test' };
-            });
-            assert.deepStrictEqual(result, { data: 'test' });
-        });
-        it('should propagate errors', () => {
-            const error = new Error('test error');
-            assert.throws(() => {
-                withSpanSync('test.span', {}, () => {
-                    throw error;
-                });
-            }, (err) => {
-                assert.strictEqual(err, error);
-                return true;
-            });
-        });
-        it('should filter undefined attributes', () => {
-            assert.doesNotThrow(() => {
-                withSpanSync('test.span', {
-                    defined: 'value',
-                    undef: undefined,
-                }, () => 'ok');
-            });
-        });
-    });
-    describe('graceful degradation', () => {
-        it('should not throw when SDK fails to load', async () => {
-            // This tests graceful degradation by ensuring errors during init don't crash
-            await assert.doesNotReject(async () => {
-                // Valid config but SDK might fail for various reasons
-                await initializeInstrumentation({
-                    enabled: true,
-                    endpoint: 'http://localhost:4318',
-                });
-            });
-        });
-        it('should continue to work after failed initialization', async () => {
-            // Even if init fails somehow, withSpan should still work
-            resetInstrumentationForTesting();
-            const result = await withSpan('test.span', {}, async () => 'ok');
-            assert.strictEqual(result, 'ok');
-        });
-        // M5 fix: Verify re-initialization is possible after proper shutdown
-        it('should allow re-initialization after shutdown and reset', async () => {
-            // First init
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const tracer1 = getTracer();
-            assert.notStrictEqual(tracer1, null);
-            // Shutdown and reset
-            await shutdownInstrumentation();
-            resetInstrumentationForTesting();
-            // Second init should work
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const tracer2 = getTracer();
-            assert.notStrictEqual(tracer2, null);
-        });
-    });
-    // M4 fix: Add concurrent span tests to verify spans don't interfere
-    describe('concurrent spans', () => {
-        beforeEach(async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-        });
-        it('should handle multiple async spans in parallel', async () => {
-            const results = await Promise.all([
-                withSpan('concurrent.span.1', { id: 1 }, async () => {
-                    await new Promise(resolve => setTimeout(resolve, 10));
-                    return 'result1';
-                }),
-                withSpan('concurrent.span.2', { id: 2 }, async () => {
-                    await new Promise(resolve => setTimeout(resolve, 5));
-                    return 'result2';
-                }),
-                withSpan('concurrent.span.3', { id: 3 }, async () => {
-                    return 'result3';
-                }),
-            ]);
-            assert.deepStrictEqual(results, ['result1', 'result2', 'result3']);
-        });
-        it('should handle nested spans correctly', async () => {
-            const result = await withSpan('outer.span', {}, async (outerSpan) => {
-                assert.notStrictEqual(outerSpan, null);
-                const innerResult = await withSpan('inner.span', {}, async (innerSpan) => {
-                    assert.notStrictEqual(innerSpan, null);
-                    return 'inner';
-                });
-                return `outer-${innerResult}`;
-            });
-            assert.strictEqual(result, 'outer-inner');
-        });
-        it('should isolate errors in concurrent spans', async () => {
-            const results = await Promise.allSettled([
-                withSpan('success.span', {}, async () => 'success'),
-                withSpan('error.span', {}, async () => {
-                    throw new Error('intentional error');
-                }),
-                withSpan('success.span.2', {}, async () => 'success2'),
-            ]);
-            assert.strictEqual(results[0].status, 'fulfilled');
-            assert.strictEqual(results[0].value, 'success');
-            assert.strictEqual(results[1].status, 'rejected');
-            assert.strictEqual(results[1].reason.message, 'intentional error');
-            assert.strictEqual(results[2].status, 'fulfilled');
-            assert.strictEqual(results[2].value, 'success2');
-        });
-        it('should handle concurrent sync spans', () => {
-            // Sync spans don't actually run in parallel, but test they work sequentially
-            const result1 = withSpanSync('sync.span.1', {}, () => 'result1');
-            const result2 = withSpanSync('sync.span.2', {}, () => 'result2');
-            assert.strictEqual(result1, 'result1');
-            assert.strictEqual(result2, 'result2');
-        });
-        it('should handle deeply nested spans', async () => {
-            const result = await withSpan('level1', {}, async () => {
-                return withSpan('level2', {}, async () => {
-                    return withSpan('level3', {}, async () => {
-                        return withSpanSync('level4.sync', {}, () => {
-                            return 'deepest';
-                        });
-                    });
-                });
-            });
-            assert.strictEqual(result, 'deepest');
-        });
-        it('should handle parallel spans with nested child spans', async () => {
-            const results = await Promise.all([
-                withSpan('parent.1', {}, async () => {
-                    const child = await withSpan('child.1', {}, async () => 'child1-result');
-                    return `parent1-${child}`;
-                }),
-                withSpan('parent.2', {}, async () => {
-                    const child = await withSpan('child.2', {}, async () => 'child2-result');
-                    return `parent2-${child}`;
-                }),
-            ]);
-            assert.deepStrictEqual(results, ['parent1-child1-result', 'parent2-child2-result']);
-        });
-    });
-    // TQ2 fix: Error injection tests for various failure modes
-    describe('error injection', () => {
-        beforeEach(async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-        });
-        it('should handle TypeError correctly', async () => {
-            const typeError = new TypeError('null is not an object');
-            await assert.rejects(async () => {
-                await withSpan('error.type', {}, async () => {
-                    throw typeError;
-                });
-            }, (err) => {
-                assert.strictEqual(err, typeError);
-                assert.strictEqual(err.constructor.name, 'TypeError');
-                return true;
-            });
-        });
-        it('should handle RangeError correctly', async () => {
-            const rangeError = new RangeError('value out of range');
-            await assert.rejects(async () => {
-                await withSpan('error.range', {}, async () => {
-                    throw rangeError;
-                });
-            }, (err) => {
-                assert.strictEqual(err, rangeError);
-                assert.strictEqual(err.constructor.name, 'RangeError');
-                return true;
-            });
-        });
-        it('should handle custom error classes', async () => {
-            class CustomAppError extends Error {
-                code;
-                constructor(message, code) {
-                    super(message);
-                    this.code = code;
-                    this.name = 'CustomAppError';
-                }
-            }
-            const customError = new CustomAppError('app failure', 'E001');
-            await assert.rejects(async () => {
-                await withSpan('error.custom', {}, async () => {
-                    throw customError;
-                });
-            }, (err) => {
-                assert.strictEqual(err, customError);
-                assert.strictEqual(err.code, 'E001');
-                return true;
-            });
-        });
-        it('should handle non-Error throws (string)', async () => {
-            await assert.rejects(async () => {
-                await withSpan('error.string', {}, async () => {
-                    throw 'string error';
-                });
-            }, (err) => {
-                assert.strictEqual(err, 'string error');
-                return true;
-            });
-        });
-        it('should handle non-Error throws (object)', async () => {
-            const errorObj = { code: 'FAIL', message: 'object error' };
-            await assert.rejects(async () => {
-                await withSpan('error.object', {}, async () => {
-                    throw errorObj;
-                });
-            }, (err) => {
-                assert.deepStrictEqual(err, errorObj);
-                return true;
-            });
-        });
-        it('should handle sync TypeError correctly', () => {
-            const typeError = new TypeError('undefined is not a function');
-            assert.throws(() => {
-                withSpanSync('error.sync.type', {}, () => {
-                    throw typeError;
-                });
-            }, (err) => {
-                assert.strictEqual(err, typeError);
-                return true;
-            });
-        });
-        it('should handle sync non-Error throws', () => {
-            assert.throws(() => {
-                withSpanSync('error.sync.number', {}, () => {
-                    throw 42;
-                });
-            }, (err) => {
-                assert.strictEqual(err, 42);
-                return true;
-            });
-        });
-        it('should handle error in deeply nested spans', async () => {
-            const deepError = new Error('deep failure');
-            await assert.rejects(async () => {
-                await withSpan('level1', {}, async () => {
-                    return withSpan('level2', {}, async () => {
-                        return withSpan('level3', {}, async () => {
-                            throw deepError;
-                        });
-                    });
-                });
-            }, (err) => {
-                assert.strictEqual(err, deepError);
-                return true;
-            });
-        });
-        it('should isolate errors in sibling spans', async () => {
-            const results = await Promise.allSettled([
-                withSpan('sibling.1', {}, async () => {
-                    throw new Error('sibling 1 error');
-                }),
-                withSpan('sibling.2', {}, async () => 'sibling 2 ok'),
-            ]);
-            assert.strictEqual(results[0].status, 'rejected');
-            assert.strictEqual(results[1].status, 'fulfilled');
-            assert.strictEqual(results[1].value, 'sibling 2 ok');
-        });
-    });
-    // P2 fix: Test deferred attribute allocation
-    describe('deferred attributes', () => {
-        it('should not call attribute function when disabled', async () => {
-            resetInstrumentationForTesting();
-            let attrFnCalled = false;
-            const result = await withSpan('test.deferred', () => {
-                attrFnCalled = true;
-                return { attr: 'value' };
-            }, async () => 'result');
-            assert.strictEqual(result, 'result');
-            assert.strictEqual(attrFnCalled, false, 'Attribute function should not be called when disabled');
-        });
-        it('should call attribute function when enabled', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            let attrFnCalled = false;
-            const result = await withSpan('test.deferred.enabled', () => {
-                attrFnCalled = true;
-                return { attr: 'value' };
-            }, async () => 'result');
-            assert.strictEqual(result, 'result');
-            assert.strictEqual(attrFnCalled, true, 'Attribute function should be called when enabled');
-        });
-        it('should support deferred attributes in withSpanSync when disabled', () => {
-            resetInstrumentationForTesting();
-            let attrFnCalled = false;
-            const result = withSpanSync('test.sync.deferred', () => {
-                attrFnCalled = true;
-                return { attr: 'value' };
-            }, () => 'sync-result');
-            assert.strictEqual(result, 'sync-result');
-            assert.strictEqual(attrFnCalled, false, 'Attribute function should not be called when disabled');
-        });
-        it('should support deferred attributes in withSpanSync when enabled', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            let attrFnCalled = false;
-            const result = withSpanSync('test.sync.deferred.enabled', () => {
-                attrFnCalled = true;
-                return { attr: 'value' };
-            }, () => 'sync-result');
-            assert.strictEqual(result, 'sync-result');
-            assert.strictEqual(attrFnCalled, true, 'Attribute function should be called when enabled');
-        });
-    });
-    // M1-B4 fix: Tests for initialization status tracking
-    describe('initialization status (M1-B4)', () => {
-        it('should return pending status before initialization', () => {
-            const status = getInitializationStatus();
-            assert.strictEqual(status.status, 'pending');
-            assert.strictEqual(status.error, undefined);
-            assert.strictEqual(status.retryCount, undefined);
-        });
-        it('should return pending from waitForInitialization before init called', async () => {
-            const result = await waitForInitialization();
-            assert.strictEqual(result.status, 'pending');
-        });
-        it('should return disabled status when OTEL_ENABLED is not set', async () => {
-            delete process.env.OTEL_ENABLED;
-            await initializeInstrumentation();
-            const syncStatus = getInitializationStatus();
-            assert.strictEqual(syncStatus.status, 'disabled');
-            const asyncStatus = await waitForInitialization();
-            assert.strictEqual(asyncStatus.status, 'disabled');
-        });
-        it('should return disabled status when no endpoint configured', async () => {
-            process.env.OTEL_ENABLED = 'true';
-            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-            await initializeInstrumentation();
-            const status = getInitializationStatus();
-            assert.strictEqual(status.status, 'disabled');
-        });
-        it('should return ready status when successfully initialized', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const syncStatus = getInitializationStatus();
-            assert.strictEqual(syncStatus.status, 'ready');
-            const asyncStatus = await waitForInitialization();
-            assert.strictEqual(asyncStatus.status, 'ready');
-        });
-        it('should reset status on shutdown', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.strictEqual(getInitializationStatus().status, 'ready');
-            await shutdownInstrumentation();
-            assert.strictEqual(getInitializationStatus().status, 'pending');
-        });
-        it('should reset status on resetInstrumentationForTesting', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            assert.strictEqual(getInitializationStatus().status, 'ready');
-            resetInstrumentationForTesting();
-            assert.strictEqual(getInitializationStatus().status, 'pending');
-        });
-        it('waitForInitialization should return same result on multiple calls', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const result1 = await waitForInitialization();
-            const result2 = await waitForInitialization();
-            assert.strictEqual(result1.status, 'ready');
-            assert.strictEqual(result2.status, 'ready');
-        });
-        it('should include retryCount when initialization succeeds', async () => {
-            await initializeInstrumentation({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            const result = await waitForInitialization();
-            assert.strictEqual(result.status, 'ready');
-            // retryCount should be 0 on first successful init (may be undefined or 0)
-            assert.ok(result.retryCount === undefined || result.retryCount === 0);
-        });
-    });
-    // A1 fix: Test InstrumentationManager for isolated instances
-    describe('InstrumentationManager (A1 fix)', () => {
-        it('should export InstrumentationManager class', () => {
-            assert.ok(InstrumentationManager);
-            assert.strictEqual(typeof InstrumentationManager, 'function');
-        });
-        it('should export getDefaultManager function', () => {
-            assert.ok(getDefaultManager);
-            assert.strictEqual(typeof getDefaultManager, 'function');
-        });
-        it('should create isolated instances', () => {
-            const manager1 = new InstrumentationManager();
-            const manager2 = new InstrumentationManager();
-            assert.notStrictEqual(manager1, manager2);
-        });
-        it('should allow independent initialization of isolated instances', async () => {
-            const manager1 = new InstrumentationManager();
-            const manager2 = new InstrumentationManager();
-            // Initialize manager1 with enabled
-            await manager1.initialize({
-                enabled: true,
-                endpoint: 'http://localhost:4318',
-            });
-            // manager2 should still be uninitialized
-            assert.notStrictEqual(manager1.getTracer(), null);
-            assert.strictEqual(manager2.getTracer(), null);
-            // Clean up
-            await manager1.shutdown();
-        });
-        it('should allow isolated instances to be reset independently', async () => {
-            const manager1 = new InstrumentationManager();
-            const manager2 = new InstrumentationManager();
-            await manager1.initialize({ enabled: true, endpoint: 'http://localhost:4318' });
-            await manager2.initialize({ enabled: true, endpoint: 'http://localhost:4318' });
-            assert.notStrictEqual(manager1.getTracer(), null);
-            assert.notStrictEqual(manager2.getTracer(), null);
-            // Reset only manager1
-            manager1.reset();
-            assert.strictEqual(manager1.getTracer(), null);
-            assert.notStrictEqual(manager2.getTracer(), null);
-            // Clean up
-            await manager2.shutdown();
-        });
-        it('should have isEnabled method on instance', () => {
-            const manager = new InstrumentationManager();
-            assert.strictEqual(manager.isEnabled({ enabled: false }), false);
-            assert.strictEqual(manager.isEnabled({ enabled: true }), true);
-        });
-        it('should have withSpan method on instance', async () => {
-            const manager = new InstrumentationManager();
-            const result = await manager.withSpan('test', {}, async () => 'ok');
-            assert.strictEqual(result, 'ok');
-        });
-        it('should have withSpanSync method on instance', () => {
-            const manager = new InstrumentationManager();
-            const result = manager.withSpanSync('test', {}, () => 'ok');
-            assert.strictEqual(result, 'ok');
-        });
-        it('getDefaultManager should return the singleton', () => {
-            const defaultManager = getDefaultManager();
-            assert.ok(defaultManager instanceof InstrumentationManager);
-            // Module-level functions should delegate to the same instance
-            assert.strictEqual(defaultManager.getTracer(), getTracer());
-        });
-        it('should not interfere with module-level functions', async () => {
-            // Create an isolated manager
-            const isolated = new InstrumentationManager();
-            await isolated.initialize({ enabled: true, endpoint: 'http://localhost:4318' });
-            // Module-level tracer should still be null (controlled by resetInstrumentationForTesting in afterEach)
-            assert.strictEqual(getTracer(), null);
-            assert.notStrictEqual(isolated.getTracer(), null);
-            // Clean up
-            await isolated.shutdown();
-        });
-    });
-});
-//# sourceMappingURL=instrumentation.test.js.map