autotel-vitest 0.4.33 → 0.4.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-vitest",
-  "version": "0.4.33",
+  "version": "0.4.35",
   "description": "Vitest fixture for OpenTelemetry: one span per test so all instrumented code is filterable by test run",
   "license": "MIT",
   "type": "module",
@@ -21,12 +21,11 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "skills"
   ],
   "dependencies": {
-    "autotel": "4.1.0"
+    "autotel": "4.2.1"
   },
   "peerDependencies": {
     "vitest": ">=4.1.8"

package/src/fixture.ts

@@ -1,70 +0,0 @@
-import {
-  getTracer,
-  getAutotelTracerProvider,
-  context as otelContext,
-  otelTrace,
-  SpanStatusCode,
-} from 'autotel';
-import { TestSpanCollector } from 'autotel/test-span-collector';
-import { SimpleSpanProcessor } from 'autotel/processors';
-
-const TRACER_NAME = 'vitest-tests';
-const TRACER_VERSION = '0.1.0';
-
-let collector: TestSpanCollector | null = null;
-
-interface TracerProviderWithProcessor {
-  addSpanProcessor(processor: unknown): void;
-}
-
-function ensureCollector(): TestSpanCollector {
-  if (!collector) {
-    collector = new TestSpanCollector();
-    const provider = getAutotelTracerProvider();
-    if ('addSpanProcessor' in provider) {
-      (provider as TracerProviderWithProcessor).addSpanProcessor(
-        new SimpleSpanProcessor(collector),
-      );
-    }
-  }
-  return collector;
-}
-
-export type OtelFixtureFn = (
-  args: { task: { name: string; file?: { name: string }; suite?: { name: string }; meta: Record<string, unknown> } },
-  use: (span: unknown) => Promise<void>,
-) => Promise<void>;
-
-export const otelTestSpanFixture: [OtelFixtureFn, { auto: true }] = [
-  async (
-    { task }: { task: { name: string; file?: { name: string }; suite?: { name: string }; meta: Record<string, unknown> } },
-    use: (span: unknown) => Promise<void>,
-  ) => {
-    ensureCollector();
-    const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-    const span = tracer.startSpan(`test:${task.name}`, {
-      attributes: {
-        'test.name': task.name,
-        'test.file': task.file?.name ?? '',
-        'test.suite': task.suite?.name ?? '',
-      },
-    });
-    const ctx = otelTrace.setSpan(otelContext.active(), span);
-    try {
-      await otelContext.with(ctx, () => use(span));
-    } catch (error) {
-      span.setStatus({ code: SpanStatusCode.ERROR });
-      span.recordException(error instanceof Error ? error : new Error(String(error)));
-      throw error;
-    } finally {
-      span.end();
-      const traceId = span.spanContext().traceId;
-      const rootSpanId = span.spanContext().spanId;
-      const spans = collector!.drainTrace(traceId, rootSpanId);
-      if (spans.length > 0) {
-        (task.meta as Record<string, unknown>).otelSpans = spans;
-      }
-    }
-  },
-  { auto: true },
-];

package/src/index.test.ts

@@ -1,197 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-let spanIdCounter = 0;
-const createdSpans: Array<{
-  end: ReturnType<typeof vi.fn>;
-  recordException: ReturnType<typeof vi.fn>;
-  setStatus: ReturnType<typeof vi.fn>;
-  spanContext: () => { traceId: string; spanId: string };
-}> = [];
-
-vi.mock('autotel', () => ({
-  SpanStatusCode: { UNSET: 0, OK: 1, ERROR: 2 },
-  context: {
-    active: () => ({}),
-    with: (_ctx: unknown, fn: () => Promise<unknown>) => fn(),
-  },
-  getTracer: () => ({
-    startSpan: (_name: string, _options?: unknown) => {
-      const id = String(++spanIdCounter);
-      const span = {
-        end: vi.fn(),
-        recordException: vi.fn(),
-        setStatus: vi.fn(),
-        spanContext: () => ({ traceId: `trace-${id}`, spanId: `span-${id}` }),
-      };
-      createdSpans.push(span);
-      return span;
-    },
-  }),
-  otelTrace: {
-    setSpan: () => ({}),
-  },
-  getAutotelTracerProvider: vi.fn(() => ({})),
-  getTraceContext: vi.fn(() => null),
-  resolveTraceUrl: vi.fn(() => undefined),
-  isTracing: vi.fn(() => false),
-  enrichWithTraceContext: vi.fn((obj: unknown) => obj),
-}));
-
-let mockDrainResult: unknown[] = [];
-vi.mock('autotel/test-span-collector', () => ({
-  TestSpanCollector: class {
-    export = vi.fn();
-    drainTrace = vi.fn(() => mockDrainResult);
-    shutdown = vi.fn(() => Promise.resolve());
-    forceFlush = vi.fn(() => Promise.resolve());
-  },
-}));
-
-vi.mock('autotel/processors', () => ({
-  SimpleSpanProcessor: class {
-    constructor() {}
-  },
-}));
-
-describe('autotel-vitest fixture', () => {
-  afterEach(() => {
-    createdSpans.length = 0;
-    spanIdCounter = 0;
-    mockDrainResult = [];
-    vi.resetModules();
-  });
-
-  async function getFixture() {
-    const { otelTestSpanFixture } = await import('./fixture');
-    const [fixtureFn, options] = otelTestSpanFixture;
-    return { fixtureFn, options, fixture: otelTestSpanFixture };
-  }
-
-  it('creates a span for each test via the _otelTestSpan fixture', async () => {
-    const { fixtureFn } = await getFixture();
-    expect(fixtureFn).toBeTypeOf('function');
-
-    await fixtureFn(
-      {
-        task: {
-          name: 'creates user',
-          file: { name: 'user.test.ts' },
-          suite: { name: 'UserService' },
-          meta: {},
-        },
-      },
-      async () => {},
-    );
-
-    expect(createdSpans).toHaveLength(1);
-    expect(createdSpans[0].end).toHaveBeenCalledTimes(1);
-  });
-
-  it('ends the span after the test completes', async () => {
-    const { fixtureFn } = await getFixture();
-
-    let spanDuringTest: unknown;
-
-    await fixtureFn(
-      {
-        task: {
-          name: 'test end timing',
-          file: { name: 'timing.test.ts' },
-          suite: { name: '' },
-          meta: {},
-        },
-      },
-      async (span) => {
-        spanDuringTest = span;
-        // Span should not yet be ended during the test
-        expect(createdSpans[0].end).not.toHaveBeenCalled();
-      },
-    );
-
-    // Span should be ended after use() resolves
-    expect(spanDuringTest).toBeDefined();
-    expect(createdSpans[0].end).toHaveBeenCalledTimes(1);
-  });
-
-  it('sets error status when the test throws', async () => {
-    const { fixtureFn } = await getFixture();
-
-    const err = new Error('test failure');
-
-    await expect(
-      fixtureFn(
-        {
-          task: {
-            name: 'failing test',
-            file: { name: 'fail.test.ts' },
-            suite: { name: '' },
-            meta: {},
-          },
-        },
-        async () => {
-          throw err;
-        },
-      ),
-    ).rejects.toThrow('test failure');
-
-    const span = createdSpans[0];
-    expect(span.setStatus).toHaveBeenCalledWith({ code: 2 });
-    expect(span.recordException).toHaveBeenCalledWith(err);
-    expect(span.end).toHaveBeenCalledTimes(1);
-  });
-
-  it('attaches otelSpans to task.meta when collector returns spans', async () => {
-    mockDrainResult = [
-      { spanId: 'span-1', name: 'test:my-test', startTimeMs: 1000, durationMs: 100, status: 'ok' },
-    ];
-
-    const { fixtureFn } = await getFixture();
-
-    const meta: Record<string, unknown> = {};
-    await fixtureFn(
-      {
-        task: {
-          name: 'my-test',
-          file: { name: 'test.ts' },
-          suite: { name: '' },
-          meta,
-        },
-      },
-      async () => {},
-    );
-
-    expect(meta.otelSpans).toEqual([
-      { spanId: 'span-1', name: 'test:my-test', startTimeMs: 1000, durationMs: 100, status: 'ok' },
-    ]);
-  });
-
-  it('uses auto: true to activate for every test', async () => {
-    const { fixture } = await getFixture();
-    expect(Array.isArray(fixture)).toBe(true);
-    if (Array.isArray(fixture)) {
-      expect(fixture[1]).toEqual({ auto: true });
-    }
-  });
-});
-
-describe('trace context helper re-exports', () => {
-  it('re-exports getTraceContext', async () => {
-    const mod = await import('./index');
-    expect(mod.getTraceContext).toBeTypeOf('function');
-  });
-
-  it('re-exports resolveTraceUrl', async () => {
-    const mod = await import('./index');
-    expect(mod.resolveTraceUrl).toBeTypeOf('function');
-  });
-
-  it('re-exports isTracing', async () => {
-    const mod = await import('./index');
-    expect(mod.isTracing).toBeTypeOf('function');
-  });
-
-  it('re-exports enrichWithTraceContext', async () => {
-    const mod = await import('./index');
-    expect(mod.enrichWithTraceContext).toBeTypeOf('function');
-  });
-});

package/src/index.ts

@@ -1,52 +0,0 @@
-/**
- * autotel-vitest
- *
- * Vitest fixture that creates one OTel span per test so all autotel-instrumented
- * code executed during a test automatically creates child spans under it;
- * making every test run filterable in your OTLP backend.
- *
- * @example
- * // vitest.config.ts: globalSetup calls init({ service: 'unit-tests' })
- * // In spec:
- * import { test, expect } from 'autotel-vitest';
- * test('creates user', async () => {
- *   await userService.createUser({ email: 'test@example.com' });
- *   // All trace()/span() calls become children of the test span
- * });
- */
-
-import { test as base } from 'vitest';
-import { otelTestSpanFixture } from './fixture';
-
-export const test = base.extend({
-  _otelTestSpan: otelTestSpanFixture as never,
-});
-
-export { expect, describe, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
-
-// Re-export all autotel/testing utilities
-export {
-  createTraceCollector,
-  assertTraceCreated,
-  assertTraceSucceeded,
-  assertTraceFailed,
-  assertNoErrors,
-  assertTraceDuration,
-  waitForTrace,
-  getTraceDuration,
-  createMockLogger,
-  type TraceCollector,
-  type TestSpan,
-  type LogCollector,
-  type LogEntry,
-} from 'autotel/testing';
-
-// Re-export trace context helpers for DX convenience
-export {
-  getTraceContext,
-  resolveTraceUrl,
-  isTracing,
-  enrichWithTraceContext,
-} from 'autotel';
-
-export type { OtelTraceContext } from 'autotel';

package/src/reporter.test.ts

@@ -1,193 +0,0 @@
-import { afterEach, describe, it, expect, vi } from 'vitest';
-
-const spans: Array<{
-  end: ReturnType<typeof vi.fn>;
-  recordException: ReturnType<typeof vi.fn>;
-  setStatus: ReturnType<typeof vi.fn>;
-}> = [];
-
-vi.mock('autotel', () => ({
-  SpanStatusCode: { ERROR: 2 },
-  context: {
-    active: () => ({}),
-    with: (_ctx: unknown, fn: () => void) => fn(),
-  },
-  getTracer: () => ({
-    startSpan: (_name: string, _options?: unknown) => {
-      const span = {
-        end: vi.fn(),
-        recordException: vi.fn(),
-        setStatus: vi.fn(),
-      };
-      spans.push(span);
-      return span;
-    },
-  }),
-  otelTrace: {
-    setSpan: () => ({}),
-  },
-}));
-
-function makeTestCase(overrides: {
-  id: string;
-  name: string;
-  moduleId?: string;
-  result?: { state: string; errors?: Array<{ message?: string; stack?: string }> };
-}) {
-  return {
-    id: overrides.id,
-    name: overrides.name,
-    fullName: overrides.name,
-    module: { moduleId: overrides.moduleId ?? 'test.ts' },
-    result: () => overrides.result ?? { state: 'passed', errors: undefined },
-  } as any;
-}
-
-function makeTestSuite(overrides: {
-  id: string;
-  name: string;
-  moduleId?: string;
-  state?: string;
-}) {
-  return {
-    id: overrides.id,
-    name: overrides.name,
-    module: { moduleId: overrides.moduleId ?? 'test.ts' },
-    state: () => overrides.state ?? 'passed',
-  } as any;
-}
-
-describe('OtelReporter', () => {
-  afterEach(() => {
-    spans.length = 0;
-    vi.resetModules();
-  });
-
-  it('creates a span on test ready and ends it on test result', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const testCase = makeTestCase({ id: 'test-1', name: 'my test' });
-
-    reporter.onTestCaseReady!(testCase);
-    expect(spans).toHaveLength(1);
-    expect(spans[0].end).not.toHaveBeenCalled();
-
-    reporter.onTestCaseResult!(testCase);
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-  });
-
-  it('sets error status and records exception on failure', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const testCase = makeTestCase({
-      id: 'test-fail',
-      name: 'failing test',
-      result: {
-        state: 'failed',
-        errors: [{ message: 'assertion failed', stack: 'Error: assertion failed\n  at ...' }],
-      },
-    });
-
-    reporter.onTestCaseReady!(testCase);
-    reporter.onTestCaseResult!(testCase);
-
-    const span = spans[0];
-    expect(span.setStatus).toHaveBeenCalledWith({ code: 2 });
-    expect(span.recordException).toHaveBeenCalled();
-    expect(span.end).toHaveBeenCalledTimes(1);
-  });
-
-  it('tracks parallel tests independently (no key collisions)', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const testA = makeTestCase({ id: 'test-a', name: 'shared title' });
-    const testB = makeTestCase({ id: 'test-b', name: 'shared title' });
-
-    reporter.onTestCaseReady!(testA);
-    reporter.onTestCaseReady!(testB);
-
-    reporter.onTestCaseResult!(testA);
-
-    expect(spans).toHaveLength(2);
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-    expect(spans[1].end).not.toHaveBeenCalled();
-  });
-
-  it('creates suite spans', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const suite = makeTestSuite({ id: 'suite-1', name: 'UserService' });
-
-    reporter.onTestSuiteReady!(suite);
-    expect(spans).toHaveLength(1);
-
-    reporter.onTestSuiteResult!(suite);
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-  });
-
-  it('marks suite span as error when suite fails', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const suite = makeTestSuite({ id: 'suite-fail', name: 'FailingSuite', state: 'failed' });
-
-    reporter.onTestSuiteReady!(suite);
-    reporter.onTestSuiteResult!(suite);
-
-    expect(spans[0].setStatus).toHaveBeenCalledWith({ code: 2 });
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not error when onTestCaseResult is called without onTestCaseReady', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const testCase = makeTestCase({ id: 'orphan', name: 'orphan test' });
-
-    // Should not throw
-    reporter.onTestCaseResult!(testCase);
-    expect(spans).toHaveLength(0);
-  });
-
-  it('does not end test spans from other modules when a module ends', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const moduleA = { moduleId: 'a.test.ts' } as any;
-
-    const testInA = makeTestCase({ id: 'a-1', name: 'test a', moduleId: 'a.test.ts' });
-    const testInB = makeTestCase({ id: 'b-1', name: 'test b', moduleId: 'b.test.ts' });
-
-    reporter.onTestCaseReady!(testInA);
-    reporter.onTestCaseReady!(testInB);
-
-    reporter.onTestModuleEnd!(moduleA);
-
-    expect(spans).toHaveLength(2);
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-    expect(spans[1].end).not.toHaveBeenCalled();
-  });
-
-  it('does not end suite spans from other modules when a module ends', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const moduleA = { moduleId: 'a.test.ts' } as any;
-
-    const suiteInA = makeTestSuite({ id: 'suite-a', name: 'suite a', moduleId: 'a.test.ts' });
-    const suiteInB = makeTestSuite({ id: 'suite-b', name: 'suite b', moduleId: 'b.test.ts' });
-
-    reporter.onTestSuiteReady!(suiteInA);
-    reporter.onTestSuiteReady!(suiteInB);
-
-    reporter.onTestModuleEnd!(moduleA);
-
-    expect(spans).toHaveLength(2);
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-    expect(spans[1].end).not.toHaveBeenCalled();
-  });
-});

package/src/reporter.ts

@@ -1,119 +0,0 @@
-/**
- * Optional Vitest reporter that creates OTel spans for each test and suite.
- * Runs in the runner process; ensure autotel.init() is called in globalSetup so spans are exported.
- *
- * Use when you want test/suite timing and hierarchy in OTLP from the runner side.
- * For "test → instrumented code" in one trace (worker side), use the test fixture.
- *
- * @example
- * // vitest.config.ts
- * import { defineConfig } from 'vitest/config';
- *
- * export default defineConfig({
- *   test: {
- *     reporters: ['default', 'autotel-vitest/reporter'],
- *     globalSetup: './globalSetup.ts', // must call init()
- *   },
- * });
- */
-
-import type { Reporter, TestCase, TestModule, TestSuite } from 'vitest/node';
-import { getTracer, SpanStatusCode } from 'autotel';
-
-const TRACER_NAME = 'vitest-reporter';
-const TRACER_VERSION = '0.1.0';
-
-type SpanEntry = {
-  span: ReturnType<ReturnType<typeof getTracer>['startSpan']>;
-  moduleId: string;
-};
-
-/** Convert a vitest TestError-like object to a standard Error for OTel. */
-function toError(testError: { message?: string; stack?: string }): Error {
-  const err = new Error(testError.message ?? 'Unknown error');
-  if (testError.stack) err.stack = testError.stack;
-  return err;
-}
-
-/**
- * Vitest Reporter that creates one span per test and one per suite (as parents).
- * Requires autotel.init() in globalSetup so spans are exported.
- */
-class OtelReporter implements Reporter {
-  private testSpans = new Map<string, SpanEntry>();
-  private suiteSpans = new Map<string, SpanEntry>();
-
-  onTestCaseReady(testCase: TestCase): void {
-    const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-    const moduleId = testCase.module.moduleId ?? '';
-    const span = tracer.startSpan(`test:${testCase.name}`, {
-      attributes: {
-        'test.name': testCase.name,
-        'test.fullName': testCase.fullName,
-        'test.file': moduleId,
-      },
-    });
-    this.testSpans.set(testCase.id, { span, moduleId });
-  }
-
-  onTestCaseResult(testCase: TestCase): void {
-    const entry = this.testSpans.get(testCase.id);
-    if (!entry) return;
-
-    const result = testCase.result();
-    if (result.state === 'failed') {
-      entry.span.setStatus({ code: SpanStatusCode.ERROR });
-      if (result.errors && result.errors.length > 0) {
-        for (const error of result.errors) {
-          entry.span.recordException(toError(error));
-        }
-      }
-    }
-    entry.span.end();
-    this.testSpans.delete(testCase.id);
-  }
-
-  onTestSuiteReady(testSuite: TestSuite): void {
-    const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-    const moduleId = testSuite.module.moduleId ?? '';
-    const span = tracer.startSpan(`suite:${testSuite.name}`, {
-      attributes: {
-        'suite.name': testSuite.name,
-        'suite.file': moduleId,
-      },
-    });
-    this.suiteSpans.set(testSuite.id, { span, moduleId });
-  }
-
-  onTestSuiteResult(testSuite: TestSuite): void {
-    const entry = this.suiteSpans.get(testSuite.id);
-    if (!entry) return;
-
-    const state = testSuite.state();
-    if (state === 'failed') {
-      entry.span.setStatus({ code: SpanStatusCode.ERROR });
-    }
-    entry.span.end();
-    this.suiteSpans.delete(testSuite.id);
-  }
-
-  onTestModuleEnd(testModule: TestModule): void {
-    const moduleId = testModule.moduleId;
-    // Clean up any remaining spans for this specific module
-    for (const [key, entry] of this.testSpans) {
-      if (entry.moduleId === moduleId) {
-        entry.span.end();
-        this.testSpans.delete(key);
-      }
-    }
-    for (const [key, entry] of this.suiteSpans) {
-      if (entry.moduleId === moduleId) {
-        entry.span.end();
-        this.suiteSpans.delete(key);
-      }
-    }
-  }
-}
-
-export { OtelReporter };
-export default OtelReporter;

package/src/wiring.test.ts

@@ -1,59 +0,0 @@
-/**
- * Wiring test: verifies the public `test` export from index.ts
- * actually registers the _otelTestSpan fixture with auto: true.
- *
- * Uses the exported `test` (not vitest's base) to define tests,
- * so if index.ts stops calling base.extend() or drops the fixture,
- * these tests will fail.
- */
-import { expect, vi } from 'vitest';
-
-vi.mock('autotel', () => ({
-  SpanStatusCode: { UNSET: 0, OK: 1, ERROR: 2 },
-  context: {
-    active: () => ({}),
-    with: (_ctx: unknown, fn: () => Promise<unknown>) => fn(),
-  },
-  getTracer: () => ({
-    startSpan: () => ({
-      end: vi.fn(),
-      recordException: vi.fn(),
-      setStatus: vi.fn(),
-      spanContext: () => ({ traceId: 'wiring-trace', spanId: 'wiring-span' }),
-    }),
-  }),
-  otelTrace: {
-    setSpan: () => ({}),
-  },
-  getAutotelTracerProvider: vi.fn(() => ({})),
-  getTraceContext: vi.fn(() => null),
-  resolveTraceUrl: vi.fn(() => undefined),
-  isTracing: vi.fn(() => false),
-  enrichWithTraceContext: vi.fn((obj: unknown) => obj),
-}));
-
-vi.mock('autotel/test-span-collector', () => ({
-  TestSpanCollector: class {
-    export = vi.fn();
-    drainTrace = vi.fn(() => []);
-    shutdown = vi.fn(() => Promise.resolve());
-    forceFlush = vi.fn(() => Promise.resolve());
-  },
-}));
-
-vi.mock('autotel/processors', () => ({
-  SimpleSpanProcessor: class {
-    constructor() {}
-  },
-}));
-
-// Import the PUBLIC test — not vitest's base test.
-// If index.ts doesn't wire otelTestSpanFixture via base.extend(),
-// _otelTestSpan won't be available and these tests fail.
-import { test } from './index';
-
-test('_otelTestSpan fixture is registered and auto-activates', ({ _otelTestSpan }) => {
-  // auto: true means the fixture injects automatically.
-  // If the fixture key is missing from base.extend(), this will be undefined.
-  expect(_otelTestSpan).toBeDefined();
-});