autotel 4.1.0 → 4.2.0

package/src/init.integrations.test.ts

@@ -1,399 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { NodeSDK } from '@opentelemetry/sdk-node';
-import type { DeepMockProxy } from 'vitest-mock-extended';
-import { mockDeep } from 'vitest-mock-extended';
-import {
-  _setAutoInstrumentationsLoader,
-  _resetAutoInstrumentationsLoader,
-  type AutoInstrumentationsLoader,
-} from './init';
-
-type SdkRecord = {
-  options: Record<string, unknown>;
-  instance: DeepMockProxy<NodeSDK>;
-};
-
-const mockedModules = [
-  '@opentelemetry/sdk-node',
-  '@opentelemetry/exporter-trace-otlp-http',
-  '@opentelemetry/exporter-metrics-otlp-http',
-  '@opentelemetry/sdk-metrics',
-];
-
-// Mock instrumentation classes with exact names from OpenTelemetry.
-// NodeSDK.start() calls lifecycle hooks on each instrumentation instance.
-class MockInstrumentationBase {
-  constructor(public config?: Record<string, unknown>) {}
-
-  setConfig(_config: Record<string, unknown>) {}
-  setTracerProvider(_provider: unknown) {}
-  setMeterProvider(_provider: unknown) {}
-  setLoggerProvider(_provider: unknown) {}
-  enable() {}
-  disable() {}
-}
-
-class MongoDBInstrumentation extends MockInstrumentationBase {}
-
-class MongooseInstrumentation extends MockInstrumentationBase {}
-
-class HttpInstrumentation extends MockInstrumentationBase {}
-
-async function loadInitWithMocks() {
-  const sdkInstances: SdkRecord[] = [];
-  const traceExporterOptions: Record<string, unknown>[] = [];
-  const metricExporterOptions: Record<string, unknown>[] = [];
-  const autoInstrumentationsConfig: Record<string, { enabled?: boolean }>[] =
-    [];
-  const logMessages: {
-    level: string;
-    message: string;
-  }[] = [];
-
-  class MockNodeSDK {
-    constructor(options: Record<string, unknown>) {
-      const instance = mockDeep<NodeSDK>();
-      instance.start.mockImplementation(() => {});
-      instance.shutdown.mockResolvedValue();
-      sdkInstances.push({ options, instance });
-      return instance;
-    }
-  }
-
-  class MockOTLPTraceExporter {
-    options: Record<string, unknown>;
-
-    constructor(options: Record<string, unknown>) {
-      this.options = options;
-      traceExporterOptions.push(options);
-    }
-  }
-
-  class MockOTLPMetricExporter {
-    options: Record<string, unknown>;
-
-    constructor(options: Record<string, unknown>) {
-      this.options = options;
-      metricExporterOptions.push(options);
-    }
-  }
-
-  class MockPeriodicExportingMetricReader {
-    constructor(public options: Record<string, unknown>) {}
-  }
-
-  // Mock getNodeAutoInstrumentations function
-  const mockGetNodeAutoInstrumentations = vi.fn(
-    (config?: Record<string, { enabled?: boolean }>) => {
-      if (config) {
-        autoInstrumentationsConfig.push(config);
-      }
-
-      // Simulate returning auto-instrumentations based on config
-      const instrumentations: unknown[] = [];
-
-      // If MongoDB is not explicitly disabled, add it
-      if (
-        !config ||
-        !config['@opentelemetry/instrumentation-mongodb'] ||
-        config['@opentelemetry/instrumentation-mongodb'].enabled !== false
-      ) {
-        instrumentations.push(new MongoDBInstrumentation());
-      }
-
-      // If Mongoose is not explicitly disabled, add it
-      if (
-        !config ||
-        !config['@opentelemetry/instrumentation-mongoose'] ||
-        config['@opentelemetry/instrumentation-mongoose'].enabled !== false
-      ) {
-        instrumentations.push(new MongooseInstrumentation());
-      }
-
-      // If HTTP is not explicitly disabled, add it
-      if (
-        !config ||
-        !config['@opentelemetry/instrumentation-http'] ||
-        config['@opentelemetry/instrumentation-http'].enabled !== false
-      ) {
-        instrumentations.push(new HttpInstrumentation());
-      }
-
-      return instrumentations;
-    },
-  );
-
-  // Mock logger to capture log messages (Pino-compatible signature: extra, message)
-  const mockLogger = {
-    info: vi.fn((extra: Record<string, unknown>, msg?: string) => {
-      logMessages.push({ level: 'info', message: msg || '' });
-    }),
-    warn: vi.fn((extra: Record<string, unknown>, msg?: string) => {
-      logMessages.push({ level: 'warn', message: msg || '' });
-    }),
-    error: vi.fn((extra: Record<string, unknown>, msg?: string) => {
-      logMessages.push({ level: 'error', message: msg || '' });
-    }),
-    debug: vi.fn((extra: Record<string, unknown>, msg?: string) => {
-      logMessages.push({ level: 'debug', message: msg || '' });
-    }),
-  };
-
-  vi.doMock('@opentelemetry/sdk-node', () => ({
-    NodeSDK: MockNodeSDK,
-  }));
-
-  vi.doMock('@opentelemetry/exporter-trace-otlp-http', () => ({
-    OTLPTraceExporter: MockOTLPTraceExporter,
-  }));
-
-  vi.doMock('@opentelemetry/exporter-metrics-otlp-http', () => ({
-    OTLPMetricExporter: MockOTLPMetricExporter,
-  }));
-
-  vi.doMock('@opentelemetry/sdk-metrics', () => ({
-    PeriodicExportingMetricReader: MockPeriodicExportingMetricReader,
-  }));
-
-  const initModule = await import('./init');
-
-  // Inject the mock loader via the exported setter
-  initModule._setAutoInstrumentationsLoader(
-    () => mockGetNodeAutoInstrumentations as AutoInstrumentationsLoader,
-  );
-
-  return {
-    init: initModule.init,
-    getConfig: initModule.getConfig,
-    sdkInstances,
-    traceExporterOptions,
-    metricExporterOptions,
-    autoInstrumentationsConfig,
-    logMessages,
-    mockLogger,
-    mockGetNodeAutoInstrumentations,
-    initModule,
-  };
-}
-
-describe('init() integrations vs instrumentations', () => {
-  beforeEach(() => {
-    vi.resetModules();
-    _resetAutoInstrumentationsLoader();
-  });
-
-  afterEach(async () => {
-    for (const mod of mockedModules) {
-      vi.doUnmock(mod);
-    }
-    vi.clearAllMocks();
-    _resetAutoInstrumentationsLoader();
-    delete process.env.AUTOTEL_METRICS;
-    // Reset global OTel state that can leak between forked test files
-    const { trace, context, propagation } = await import('@opentelemetry/api');
-    trace.disable();
-    context.disable();
-    propagation.disable();
-  });
-
-  it('excludes manual instrumentations from auto-instrumentations when autoInstrumentations: true', async () => {
-    const {
-      init,
-      sdkInstances,
-      autoInstrumentationsConfig,
-      mockLogger,
-      logMessages,
-    } = await loadInitWithMocks();
-
-    const manualMongoDBInstrumentation = new MongoDBInstrumentation({
-      requireParentSpan: false,
-    });
-    const manualMongooseInstrumentation = new MongooseInstrumentation({
-      requireParentSpan: false,
-    });
-
-    init({
-      service: 'test-app',
-      autoInstrumentations: true,
-      instrumentations: [
-        manualMongoDBInstrumentation,
-        manualMongooseInstrumentation,
-      ],
-      logger: mockLogger,
-    });
-
-    // Check that auto-instrumentations were called with exclusion config
-    expect(autoInstrumentationsConfig).toHaveLength(1);
-    const config = autoInstrumentationsConfig[0];
-    expect(config['@opentelemetry/instrumentation-mongodb']).toEqual({
-      enabled: false,
-    });
-    expect(config['@opentelemetry/instrumentation-mongoose']).toEqual({
-      enabled: false,
-    });
-
-    // Check that manual instrumentations are in the final list
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
-    const instrumentations = options.instrumentations as unknown[];
-    expect(instrumentations).toContain(manualMongoDBInstrumentation);
-    expect(instrumentations).toContain(manualMongooseInstrumentation);
-
-    // Check that warning was logged about detected manual instrumentations
-    const manualInstrumentationWarnings = logMessages.filter(
-      (log) => log.level === 'info' && log.message.includes('Detected manual'),
-    );
-    expect(manualInstrumentationWarnings).toHaveLength(1);
-    expect(manualInstrumentationWarnings[0].message).toContain(
-      'Detected manual instrumentations',
-    );
-    expect(manualInstrumentationWarnings[0].message).toContain(
-      'MongoDBInstrumentation',
-    );
-    expect(manualInstrumentationWarnings[0].message).toContain(
-      'MongooseInstrumentation',
-    );
-  });
-
-  it('excludes manual instrumentations from specific autoInstrumentations list', async () => {
-    const {
-      init,
-      sdkInstances,
-      autoInstrumentationsConfig,
-      mockLogger,
-      logMessages,
-    } = await loadInitWithMocks();
-
-    const manualMongoDBInstrumentation = new MongoDBInstrumentation({
-      requireParentSpan: false,
-    });
-
-    init({
-      service: 'test-app',
-      autoInstrumentations: ['http', 'mongodb'],
-      instrumentations: [manualMongoDBInstrumentation],
-      logger: mockLogger,
-    });
-
-    // Check that auto-instrumentations were called with MongoDB disabled
-    expect(autoInstrumentationsConfig).toHaveLength(1);
-    const config = autoInstrumentationsConfig[0];
-    expect(config['@opentelemetry/instrumentation-mongodb']).toEqual({
-      enabled: false,
-    });
-    expect(config['@opentelemetry/instrumentation-http']).toEqual({
-      enabled: true,
-    });
-
-    // Check that manual MongoDB instrumentation is in the final list
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
-    const instrumentations = options.instrumentations as unknown[];
-    expect(instrumentations).toContain(manualMongoDBInstrumentation);
-
-    // Check that warning was logged about detected manual instrumentations
-    const manualInstrumentationWarnings = logMessages.filter(
-      (log) => log.level === 'info' && log.message.includes('Detected manual'),
-    );
-    expect(manualInstrumentationWarnings).toHaveLength(1);
-    expect(manualInstrumentationWarnings[0].message).toContain(
-      'MongoDBInstrumentation',
-    );
-  });
-
-  it('does not log warning when no manual instrumentations provided', async () => {
-    const { init, mockLogger, logMessages } = await loadInitWithMocks();
-
-    init({
-      service: 'test-app',
-      autoInstrumentations: true,
-      logger: mockLogger,
-    });
-
-    // Check that no warning was logged
-    const infoMessages = logMessages.filter(
-      (log) => log.level === 'info' && log.message.includes('Detected manual'),
-    );
-    expect(infoMessages).toHaveLength(0);
-  });
-
-  it('does not log warning when autoInstrumentations is false', async () => {
-    const { init, mockLogger, logMessages } = await loadInitWithMocks();
-
-    const manualMongoDBInstrumentation = new MongoDBInstrumentation({
-      requireParentSpan: false,
-    });
-
-    init({
-      service: 'test-app',
-      autoInstrumentations: false,
-      instrumentations: [manualMongoDBInstrumentation],
-      logger: mockLogger,
-    });
-
-    // Check that no warning was logged
-    const infoMessages = logMessages.filter(
-      (log) => log.level === 'info' && log.message.includes('Detected manual'),
-    );
-    expect(infoMessages).toHaveLength(0);
-  });
-
-  it('handles object-style autoInstrumentations config with manual instrumentations', async () => {
-    const { init, sdkInstances, autoInstrumentationsConfig, mockLogger } =
-      await loadInitWithMocks();
-
-    const manualMongoDBInstrumentation = new MongoDBInstrumentation({
-      requireParentSpan: false,
-    });
-
-    init({
-      service: 'test-app',
-      autoInstrumentations: {
-        http: { enabled: true },
-        mongodb: { enabled: true },
-      },
-      instrumentations: [manualMongoDBInstrumentation],
-      logger: mockLogger,
-    });
-
-    // Check that auto-instrumentations were called with MongoDB disabled
-    expect(autoInstrumentationsConfig).toHaveLength(1);
-    const config = autoInstrumentationsConfig[0];
-    expect(config['@opentelemetry/instrumentation-mongodb']).toEqual({
-      enabled: false,
-    });
-
-    // Check that manual MongoDB instrumentation is in the final list
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
-    const instrumentations = options.instrumentations as unknown[];
-    expect(instrumentations).toContain(manualMongoDBInstrumentation);
-  });
-
-  it('works correctly when no conflicts exist', async () => {
-    const { init, sdkInstances, mockLogger, logMessages } =
-      await loadInitWithMocks();
-
-    const manualHttpInstrumentation = new HttpInstrumentation({
-      requireParentSpan: false,
-    });
-
-    init({
-      service: 'test-app',
-      autoInstrumentations: ['mongodb', 'mongoose'],
-      instrumentations: [manualHttpInstrumentation],
-      logger: mockLogger,
-    });
-
-    // Check that manual instrumentation is in the final list
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
-    const instrumentations = options.instrumentations as unknown[];
-    expect(instrumentations).toContain(manualHttpInstrumentation);
-
-    // Check that warning was logged (because manual HTTP provided with auto-integrations)
-    const manualInstrumentationWarnings = logMessages.filter(
-      (log) => log.level === 'info' && log.message.includes('Detected manual'),
-    );
-    expect(manualInstrumentationWarnings).toHaveLength(1);
-    expect(manualInstrumentationWarnings[0].message).toContain(
-      'HttpInstrumentation',
-    );
-  });
-});

package/src/init.openllmetry.test.ts

@@ -1,194 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-type InitModule = typeof import('./init');
-
-async function loadInitModule(): Promise<InitModule> {
-  vi.resetModules();
-  return import('./init');
-}
-
-function createSdkFactory() {
-  const calls: Array<Record<string, unknown>> = [];
-  const getTracerProvider = vi.fn(() => ({ id: 'mock-tracer-provider' }));
-  const start = vi.fn();
-  const shutdown = vi.fn(async () => {});
-
-  return {
-    calls,
-    getTracerProvider,
-    start,
-    shutdown,
-    sdkFactory: (options: Record<string, unknown>) => {
-      calls.push(options);
-      return {
-        start,
-        shutdown,
-        getTracerProvider,
-      } as never;
-    },
-  };
-}
-
-describe('init() OpenLLMetry integration', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-    delete process.env.AUTOTEL_METRICS;
-    delete process.env.NODE_ENV;
-    delete process.env.TRACELOOP_API_KEY;
-  });
-
-  it('should not initialize OpenLLMetry when disabled', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
-
-    mod._setOptionalRequireForTesting(() => ({
-      initialize: (options?: Record<string, unknown>) =>
-        traceloopInitializeCalls.push(options ?? {}),
-    }));
-
-    mod.init({ service: 'test-app', sdkFactory: sdk.sdkFactory });
-
-    expect(traceloopInitializeCalls).toHaveLength(0);
-    mod._resetOptionalRequireForTesting();
-  });
-
-  it('should initialize OpenLLMetry when enabled', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
-
-    mod._setOptionalRequireForTesting(() => ({
-      initialize: (options?: Record<string, unknown>) =>
-        traceloopInitializeCalls.push(options ?? {}),
-    }));
-
-    mod.init({
-      service: 'test-app',
-      openllmetry: { enabled: true },
-      sdkFactory: sdk.sdkFactory,
-    });
-
-    expect(traceloopInitializeCalls).toHaveLength(1);
-    expect(traceloopInitializeCalls[0]).toBeDefined();
-    mod._resetOptionalRequireForTesting();
-  });
-
-  it('should pass OpenLLMetry options to initialize', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
-
-    mod._setOptionalRequireForTesting(() => ({
-      initialize: (options?: Record<string, unknown>) =>
-        traceloopInitializeCalls.push(options ?? {}),
-    }));
-
-    mod.init({
-      service: 'test-app',
-      openllmetry: {
-        enabled: true,
-        options: {
-          disableBatch: true,
-          apiKey: 'test-key',
-        },
-      },
-      sdkFactory: sdk.sdkFactory,
-    });
-
-    expect(traceloopInitializeCalls).toHaveLength(1);
-    expect(traceloopInitializeCalls[0]).toMatchObject({
-      disableBatch: true,
-      apiKey: 'test-key',
-    });
-    mod._resetOptionalRequireForTesting();
-  });
-
-  it('should reuse autotel tracer provider when OpenLLMetry is enabled', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
-
-    mod._setOptionalRequireForTesting(() => ({
-      initialize: (options?: Record<string, unknown>) =>
-        traceloopInitializeCalls.push(options ?? {}),
-    }));
-
-    mod.init({
-      service: 'test-app',
-      openllmetry: { enabled: true },
-      sdkFactory: sdk.sdkFactory,
-    });
-
-    expect(traceloopInitializeCalls).toHaveLength(1);
-    const callOptions = traceloopInitializeCalls[0];
-    expect(callOptions).toBeDefined();
-    expect(sdk.getTracerProvider).toHaveBeenCalled();
-    mod._resetOptionalRequireForTesting();
-  });
-
-  it('should add OpenLLMetry instrumentations when selectiveInstrumentation is false', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    const mockTraceloop = {
-      initialize: vi.fn(),
-      instrumentations: [{ name: 'openai' }, { name: 'langchain' }],
-    };
-
-    mod._setOptionalRequireForTesting(() => mockTraceloop);
-
-    mod.init({
-      service: 'test-app',
-      openllmetry: { enabled: true },
-      autoInstrumentations: false,
-      sdkFactory: sdk.sdkFactory,
-    });
-
-    const options = sdk.calls.at(-1) as Record<string, unknown>;
-    const instrumentations = options.instrumentations as unknown[];
-
-    expect(instrumentations).toBeDefined();
-    expect(mockTraceloop.instrumentations).toBeDefined();
-    mod._resetOptionalRequireForTesting();
-  });
-
-  it('should handle missing @traceloop/node-server-sdk gracefully', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    mod._setOptionalRequireForTesting(() => undefined);
-
-    expect(() => {
-      mod.init({
-        service: 'test-app',
-        openllmetry: { enabled: true },
-        sdkFactory: sdk.sdkFactory,
-      });
-    }).not.toThrow();
-    mod._resetOptionalRequireForTesting();
-  });
-
-  it('should initialize OpenLLMetry after SDK start', async () => {
-    const mod = await loadInitModule();
-    const sdk = createSdkFactory();
-    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
-
-    mod._setOptionalRequireForTesting(() => ({
-      initialize: (options?: Record<string, unknown>) =>
-        traceloopInitializeCalls.push(options ?? {}),
-    }));
-
-    mod.init({
-      service: 'test-app',
-      openllmetry: { enabled: true },
-      sdkFactory: sdk.sdkFactory,
-    });
-
-    // Verify SDK started (synchronously in init)
-    expect(sdk.calls).toHaveLength(1);
-    expect(sdk.start).toHaveBeenCalled();
-
-    // Verify OpenLLMetry was initialized (synchronously via safeRequire)
-    expect(traceloopInitializeCalls).toHaveLength(1);
-    mod._resetOptionalRequireForTesting();
-  });
-});