observability-toolkit 1.8.5 → 2.0.0

package/dist/lib/instrumentation.test.js

@@ -0,0 +1,821 @@
+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