autotel-vitest 0.1.0

package/dist/reporter.js.map

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

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "autotel-vitest",
+  "version": "0.1.0",
+  "description": "Vitest fixture for OpenTelemetry: one span per test so all instrumented code is filterable by test run",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./reporter": {
+      "types": "./dist/reporter.d.ts",
+      "import": "./dist/reporter.js",
+      "require": "./dist/reporter.cjs"
+    }
+  },
+  "files": ["dist", "src", "README.md"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:compat": "vitest run --config integration/vitest.config.ts",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "clean": "rimraf dist"
+  },
+  "dependencies": {
+    "autotel": "workspace:*"
+  },
+  "peerDependencies": {
+    "vitest": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jagreehal/autotel",
+    "directory": "packages/autotel-vitest"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+type FixtureFn = (
+  args: { task: { name: string; file?: { name: string }; suite?: { name: string }; meta: Record<string, unknown> } },
+  use: (span: unknown) => Promise<void>,
+) => Promise<void>;
+
+type Fixtures = {
+  _otelTestSpan?: FixtureFn | [FixtureFn, { auto: true }];
+};
+
+const state: { fixtures?: Fixtures } = {};
+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('vitest', async () => {
+  const actual = await vi.importActual<typeof import('vitest')>('vitest');
+  return {
+    ...actual,
+    test: {
+      ...actual.test,
+      extend: (fixtures: Fixtures) => {
+        state.fixtures = fixtures;
+        return fixtures;
+      },
+    },
+  };
+});
+
+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(() => {
+    state.fixtures = undefined;
+    createdSpans.length = 0;
+    spanIdCounter = 0;
+    mockDrainResult = [];
+    vi.resetModules();
+  });
+
+  it('creates a span for each test via the _otelTestSpan fixture', async () => {
+    await import('./index');
+
+    const spanFixture = state.fixtures?._otelTestSpan;
+    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
+    expect(spanFixtureFn).toBeTypeOf('function');
+
+    await spanFixtureFn?.(
+      {
+        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 () => {
+    await import('./index');
+
+    const spanFixture = state.fixtures?._otelTestSpan;
+    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
+
+    let spanDuringTest: unknown;
+
+    await spanFixtureFn?.(
+      {
+        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 () => {
+    await import('./index');
+
+    const spanFixture = state.fixtures?._otelTestSpan;
+    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
+
+    const err = new Error('test failure');
+
+    await expect(
+      spanFixtureFn?.(
+        {
+          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' },
+    ];
+
+    await import('./index');
+
+    const spanFixture = state.fixtures?._otelTestSpan;
+    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
+
+    const meta: Record<string, unknown> = {};
+    await spanFixtureFn?.(
+      {
+        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 () => {
+    await import('./index');
+
+    const spanFixture = state.fixtures?._otelTestSpan;
+    expect(Array.isArray(spanFixture)).toBe(true);
+    if (Array.isArray(spanFixture)) {
+      expect(spanFixture[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

@@ -0,0 +1,105 @@
+/**
+ * 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 {
+  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;
+
+function ensureCollector(): TestSpanCollector {
+  if (!collector) {
+    collector = new TestSpanCollector();
+    const provider = getAutotelTracerProvider();
+    if ('addSpanProcessor' in provider) {
+      (provider as any).addSpanProcessor(new SimpleSpanProcessor(collector));
+    }
+  }
+  return collector;
+}
+
+export const test = base.extend({
+  _otelTestSpan: [
+    async ({ task }, use) => {
+      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 },
+  ],
+});
+
+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

@@ -0,0 +1,193 @@
+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();
+  });
+});