autotel-playwright 0.4.39 → 0.4.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-playwright",
-  "version": "0.4.39",
+  "version": "0.4.40",
   "description": "Playwright fixture for OpenTelemetry: one span per test and trace context injected into API requests",
   "license": "MIT",
   "type": "module",
@@ -21,12 +21,11 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "skills"
   ],
   "dependencies": {
-    "autotel": "4.1.0"
+    "autotel": "4.2.0"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.60.0"

package/src/index.test.ts

@@ -1,426 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-type Fixtures = {
-  _otelTestSpan?: TestSpanFixtureFn | [TestSpanFixtureFn, { scope: 'test' }];
-  requestWithTrace?: (
-    args: { request: unknown; _otelTestSpan: unknown },
-    use: (wrapped: any) => Promise<void>,
-  ) => Promise<void>;
-};
-
-type TestSpanFixtureFn = (
-  args: Record<string, never>,
-  use: (spanData: unknown) => Promise<void>,
-  testInfo: {
-    annotations: Array<{ type: string; description?: string }>;
-    file?: string;
-    line?: number;
-    project: { name: string };
-    title: string;
-  },
-) => Promise<void>;
-
-const state: { fixtures?: Fixtures } = {};
-let spanIdCounter = 0;
-let mockDrainResult: unknown[] = [];
-const contextWithSpy = vi.fn((_ctx: unknown, fn: () => Promise<unknown>) => fn());
-const createdSpans: Array<{
-  end: ReturnType<typeof vi.fn>;
-  recordException: ReturnType<typeof vi.fn>;
-  setAttribute: ReturnType<typeof vi.fn>;
-  setStatus: ReturnType<typeof vi.fn>;
-  spanContext: () => { traceId: string; spanId: string };
-}> = [];
-
-vi.mock('@playwright/test', () => ({
-  expect,
-  test: {
-    extend: (fixtures: Fixtures) => {
-      state.fixtures = fixtures;
-      return fixtures;
-    },
-  },
-}));
-
-vi.mock('autotel', () => ({
-  SpanStatusCode: { UNSET: 0, OK: 1, ERROR: 2 },
-  context: {
-    active: () => ({}),
-    with: contextWithSpy,
-  },
-  getTracer: () => ({
-    startSpan: () => {
-      const id = String(++spanIdCounter);
-      const span = {
-        end: vi.fn(),
-        recordException: vi.fn(),
-        setAttribute: vi.fn(),
-        setStatus: vi.fn(),
-        spanContext: () => ({ traceId: `trace-${id}`, spanId: `span-${id}` }),
-      };
-      createdSpans.push(span);
-      return span;
-    },
-  }),
-  propagation: {
-    inject: (_ctx: unknown, carrier: Record<string, string>) => {
-      carrier.traceparent = '00-testtrace-testspan-01';
-    },
-  },
-  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(() => mockDrainResult);
-    shutdown = vi.fn(() => Promise.resolve());
-    forceFlush = vi.fn(() => Promise.resolve());
-  },
-}));
-
-vi.mock('autotel/processors', () => ({
-  SimpleSpanProcessor: class {
-    constructor() {}
-  },
-}));
-
-describe('autotel-playwright requestWithTrace.fetch', () => {
-  afterEach(() => {
-    delete process.env.API_BASE_URL;
-    delete process.env.AUTOTEL_PLAYWRIGHT_API_ORIGIN;
-    state.fixtures = undefined;
-    createdSpans.length = 0;
-    spanIdCounter = 0;
-    mockDrainResult = [];
-    contextWithSpy.mockClear();
-    vi.resetModules();
-  });
-
-  it('injects trace headers for string URLs', async () => {
-    await import('./index');
-
-    const requestWithTraceFixture = state.fixtures?.requestWithTrace;
-    expect(requestWithTraceFixture).toBeTypeOf('function');
-
-    const fetchSpy = vi.fn(async () => ({ ok: true }));
-    const request = { fetch: fetchSpy } as any;
-    let wrapped: any;
-
-    await requestWithTraceFixture?.(
-      {
-        request,
-        _otelTestSpan: {
-          apiBaseUrls: ['http://localhost:3000'],
-          carrier: { traceparent: '00-testtrace-testspan-01' },
-          testInfo: { title: 'fetch string url' },
-        },
-      },
-      async (value) => {
-        wrapped = value;
-      },
-    );
-
-    await wrapped.fetch('http://localhost:3000/health');
-
-    expect(fetchSpy).toHaveBeenCalledWith(
-      'http://localhost:3000/health',
-      expect.objectContaining({
-        headers: expect.objectContaining({
-          traceparent: '00-testtrace-testspan-01',
-          'x-test-name': 'fetch string url',
-        }),
-      }),
-    );
-  });
-
-  it('injects trace headers for Playwright Request objects', async () => {
-    await import('./index');
-
-    const requestWithTraceFixture = state.fixtures?.requestWithTrace;
-    expect(requestWithTraceFixture).toBeTypeOf('function');
-
-    const fetchSpy = vi.fn(async () => ({ ok: true }));
-    const request = { fetch: fetchSpy } as any;
-    let wrapped: any;
-
-    await requestWithTraceFixture?.(
-      {
-        request,
-        _otelTestSpan: {
-          apiBaseUrls: ['http://localhost:3000'],
-          carrier: { traceparent: '00-testtrace-testspan-01' },
-          testInfo: { title: 'fetch request object' },
-        },
-      },
-      async (value) => {
-        wrapped = value;
-      },
-    );
-
-    const playwrightRequestLike = {
-      url: () => 'http://localhost:3000/health',
-    };
-
-    await wrapped.fetch(playwrightRequestLike);
-
-    expect(fetchSpy).toHaveBeenCalledWith(
-      playwrightRequestLike,
-      expect.objectContaining({
-        headers: expect.objectContaining({
-          traceparent: '00-testtrace-testspan-01',
-          'x-test-name': 'fetch request object',
-        }),
-      }),
-    );
-  });
-});
-
-describe('autotel-playwright annotations', () => {
-  afterEach(() => {
-    delete process.env.API_BASE_URL;
-    delete process.env.AUTOTEL_PLAYWRIGHT_API_ORIGIN;
-    state.fixtures = undefined;
-    createdSpans.length = 0;
-    spanIdCounter = 0;
-    mockDrainResult = [];
-    contextWithSpy.mockClear();
-    vi.resetModules();
-  });
-
-  it('supports semicolon-delimited autotel.attribute key-value pairs', async () => {
-    await import('./index');
-
-    const spanFixture = state.fixtures?._otelTestSpan;
-    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
-    expect(spanFixtureFn).toBeTypeOf('function');
-
-    await spanFixtureFn?.(
-      {},
-      async () => {},
-      {
-        annotations: [
-          {
-            type: 'autotel.attribute',
-            description: 'team=checkout;flow=signup',
-          },
-        ],
-        project: { name: 'chromium' },
-        title: 'annotation parsing',
-      },
-    );
-
-    const span = createdSpans[0];
-    expect(span).toBeDefined();
-    expect(span.setAttribute).toHaveBeenCalledWith('team', 'checkout');
-    expect(span.setAttribute).toHaveBeenCalledWith('flow', 'signup');
-  });
-
-  it('attaches otel-spans annotation to testInfo when collector returns spans', async () => {
-    mockDrainResult = [
-      { spanId: 's1', name: 'e2e:test', startTimeMs: 1000, durationMs: 100, status: 'ok' },
-    ];
-
-    await import('./index');
-
-    const spanFixture = state.fixtures?._otelTestSpan;
-    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
-
-    const annotations: Array<{ type: string; description?: string }> = [];
-    await spanFixtureFn?.(
-      {},
-      async () => {},
-      {
-        annotations,
-        project: { name: 'chromium' },
-        title: 'otel-spans test',
-      },
-    );
-
-    const spansAnnotation = annotations.find((a) => a.type === 'otel-spans');
-    expect(spansAnnotation).toBeDefined();
-    expect(JSON.parse(spansAnnotation!.description!)).toEqual([
-      { spanId: 's1', name: 'e2e:test', startTimeMs: 1000, durationMs: 100, status: 'ok' },
-    ]);
-  });
-
-  it('marks the test span as error and records exception when test body throws', async () => {
-    await import('./index');
-
-    const spanFixture = state.fixtures?._otelTestSpan;
-    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
-    expect(spanFixtureFn).toBeTypeOf('function');
-
-    const testError = new Error('fixture blew up');
-    await expect(
-      spanFixtureFn?.(
-        {},
-        async () => {
-          throw testError;
-        },
-        {
-          annotations: [],
-          project: { name: 'chromium' },
-          title: 'failing fixture test',
-        },
-      ),
-    ).rejects.toThrow('fixture blew up');
-
-    const span = createdSpans[0];
-    expect(span).toBeDefined();
-    expect(span.setStatus).toHaveBeenCalled();
-    expect(span.recordException).toHaveBeenCalledWith(testError);
-  });
-
-  it('runs test body inside the test span context', async () => {
-    await import('./index');
-
-    const spanFixture = state.fixtures?._otelTestSpan;
-    const spanFixtureFn = Array.isArray(spanFixture) ? spanFixture[0] : spanFixture;
-    expect(spanFixtureFn).toBeTypeOf('function');
-
-    await spanFixtureFn?.(
-      {},
-      async () => {},
-      {
-        annotations: [],
-        project: { name: 'chromium' },
-        title: 'context propagation test',
-      },
-    );
-
-    // Once to build carrier, once to run the test body under the span context.
-    expect(contextWithSpy).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('autotel-playwright step', () => {
-  afterEach(() => {
-    createdSpans.length = 0;
-    vi.resetModules();
-  });
-
-  it('marks step span as error and records exception when the step throws', async () => {
-    const { step } = await import('./index');
-    const err = new Error('step failed');
-
-    await expect(step('boom', async () => Promise.reject(err))).rejects.toThrow('step failed');
-
-    const stepSpan = createdSpans.at(-1);
-    expect(stepSpan).toBeDefined();
-    expect(stepSpan?.setStatus).toHaveBeenCalled();
-    expect(stepSpan?.recordException).toHaveBeenCalledWith(err);
-  });
-});
-
-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');
-  });
-});
-
-// Minimal APIRequestContext mock for createTestSpansClient tests
-function makeRequest(responseBody: unknown, status = 200) {
-  const mockResponse = {
-    ok: () => status >= 200 && status < 300,
-    status: () => status,
-    json: async () => responseBody,
-  };
-  return {
-    get: vi.fn().mockResolvedValue(mockResponse),
-    delete: vi.fn().mockResolvedValue(mockResponse),
-  };
-}
-
-describe('createTestSpansClient', () => {
-  afterEach(() => {
-    vi.resetModules();
-  });
-
-  it('getSpans calls GET /api/test-spans', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const mockSpan = {
-      name: 'sendMoney.handler',
-      spanId: 'abc',
-      traceId: 'trace',
-      attributes: {},
-      status: { code: 0 },
-      durationMs: 100,
-    };
-    const req = makeRequest({ spans: [mockSpan] });
-    const client = createTestSpansClient('http://localhost:3100');
-    const spans = await client.getSpans(req as any);
-    expect(req.get).toHaveBeenCalledWith('http://localhost:3100/api/test-spans');
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe('sendMoney.handler');
-  });
-
-  it('getSpans uses custom path when provided', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const req = makeRequest({ spans: [] });
-    const client = createTestSpansClient('http://localhost:3100', { path: '/custom/spans' });
-    await client.getSpans(req as any);
-    expect(req.get).toHaveBeenCalledWith('http://localhost:3100/custom/spans');
-  });
-
-  it('getSpans throws when response not ok', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const req = makeRequest({ error: 'not found' }, 404);
-    const client = createTestSpansClient('http://localhost:3100');
-    await expect(client.getSpans(req as any)).rejects.toThrow('GET /api/test-spans failed: 404');
-  });
-
-  it('clearSpans calls DELETE /api/test-spans', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const req = makeRequest({ ok: true });
-    const client = createTestSpansClient('http://localhost:3100');
-    await client.clearSpans(req as any);
-    expect(req.delete).toHaveBeenCalledWith('http://localhost:3100/api/test-spans');
-  });
-
-  it('clearSpans uses custom path when provided', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const req = makeRequest({ ok: true });
-    const client = createTestSpansClient('http://localhost:3100', { path: '/custom/spans' });
-    await client.clearSpans(req as any);
-    expect(req.delete).toHaveBeenCalledWith('http://localhost:3100/custom/spans');
-  });
-
-  it('clearSpans throws when response not ok', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const req = makeRequest({ error: 'not found' }, 404);
-    const client = createTestSpansClient('http://localhost:3100');
-    await expect(client.clearSpans(req as any)).rejects.toThrow('DELETE /api/test-spans failed: 404');
-  });
-
-  it('strips trailing slash from baseUrl', async () => {
-    const { createTestSpansClient } = await import('./index');
-    const req = makeRequest({ spans: [] });
-    const client = createTestSpansClient('http://localhost:3100/');
-    await client.getSpans(req as any);
-    expect(req.get).toHaveBeenCalledWith('http://localhost:3100/api/test-spans');
-  });
-});

package/src/index.ts

@@ -1,369 +0,0 @@
-/**
- * autotel-playwright
- *
- * Playwright fixture that creates one OTel span per test and injects W3C trace
- * context into requests to your API so "test → API" appears as one trace.
- *
- * @example
- * // globalSetup.ts: init({ service: 'e2e-tests' });
- * // In spec:
- * import { test, expect } from 'autotel-playwright';
- * test('checks health', async ({ page }) => {
- *   await page.goto(API_BASE_URL + '/health'); // request gets traceparent
- * });
- * // Node-side API calls with trace context:
- * test('api health', async ({ requestWithTrace }) => {
- *   const res = await requestWithTrace.get(API_BASE_URL + '/health');
- *   expect(res.ok()).toBeTruthy();
- * });
- */
-
-import { test as base } from '@playwright/test';
-import type { Page, APIRequestContext, Request as PlaywrightRequest } from '@playwright/test';
-import type { TestInfo } from '@playwright/test';
-import type { AutotelConfig } from 'autotel';
-import {
-  getTracer,
-  getAutotelTracerProvider,
-  context as otelContext,
-  propagation,
-  otelTrace,
-  SpanStatusCode,
-} from 'autotel';
-import { TestSpanCollector } from 'autotel/test-span-collector';
-import { SimpleSpanProcessor } from 'autotel/processors';
-
-const TRACER_NAME = 'playwright-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;
-}
-
-/** Env keys for API base URL (requests to this origin get trace context injected). */
-const ENV_API_BASE_URL = 'API_BASE_URL';
-const ENV_API_ORIGIN = 'AUTOTEL_PLAYWRIGHT_API_ORIGIN';
-
-function getApiBaseUrls(): string[] {
-  const a = process.env[ENV_API_BASE_URL];
-  const b = process.env[ENV_API_ORIGIN];
-  const urls: string[] = [];
-  if (a) urls.push(a.replace(/\/$/, ''));
-  if (b) urls.push(b.replace(/\/$/, ''));
-  return [...new Set(urls)];
-}
-
-/**
- * Returns true if requestUrl should receive trace headers for the given apiBaseUrls.
- * When a base URL includes a path (e.g. http://localhost:3000/api), only requests
- * whose path starts with that path segment match; same-origin but different path
- * (e.g. /health) must not match to avoid leaking trace context to unrelated endpoints.
- */
-function urlMatchesApiOrigin(requestUrl: string, apiBaseUrls: string[]): boolean {
-  if (apiBaseUrls.length === 0) return false;
-  try {
-    const u = new URL(requestUrl);
-    const requestOrigin = u.origin;
-    const requestPathname = u.pathname;
-    return apiBaseUrls.some((base) => {
-      try {
-        const b = new URL(base);
-        if (requestOrigin !== b.origin) return false;
-        const basePathname = b.pathname.replace(/\/$/, '') || '/';
-        if (basePathname === '/') return true;
-        return (
-          requestPathname === basePathname || requestPathname.startsWith(basePathname + '/')
-        );
-      } catch {
-        return requestUrl.startsWith(base);
-      }
-    });
-  } catch {
-    return apiBaseUrls.some((base) => requestUrl.startsWith(base));
-  }
-}
-
-/** Annotation type for custom span attributes: description should be "key=value" or "key=value1;key2=value2". */
-export const AUTOTEL_ATTRIBUTE_ANNOTATION = 'autotel.attribute';
-
-function setAttributesFromAnnotations(
-  span: { setAttribute: (k: string, v: string | number | boolean) => void },
-  testInfo: { annotations: Array<{ type: string; description?: string }> },
-): void {
-  for (const a of testInfo.annotations) {
-    if (a.type !== AUTOTEL_ATTRIBUTE_ANNOTATION || !a.description) continue;
-    const entries = a.description.split(';');
-    for (const entry of entries) {
-      const parts = entry.split('=');
-      if (parts.length >= 2) {
-        const key = parts[0].trim();
-        const value = parts.slice(1).join('=').trim();
-        span.setAttribute(key, value);
-      }
-    }
-  }
-}
-
-/** Internal: options for get/post/put/patch/delete/head/fetch that may include headers. */
-type RequestOptions = Record<string, unknown> & { headers?: Record<string, string> };
-
-function mergeTraceHeaders(
-  url: string,
-  options: RequestOptions | undefined,
-  apiBaseUrls: string[],
-  carrier: Record<string, string>,
-  testName: string,
-): RequestOptions {
-  const opts = options ?? {};
-  if (!urlMatchesApiOrigin(url, apiBaseUrls)) return opts;
-  return {
-    ...opts,
-    headers: { ...(opts.headers as Record<string, string>), ...carrier, 'x-test-name': testName },
-  };
-}
-
-/** Wraps APIRequestContext so requests to API_BASE_URL get trace context injected. */
-function createRequestWithTrace(
-  request: APIRequestContext,
-  apiBaseUrls: string[],
-  carrier: Record<string, string>,
-  testInfo: TestInfo,
-): APIRequestContext {
-  const merge = (url: string, options?: RequestOptions) =>
-    mergeTraceHeaders(url, options, apiBaseUrls, carrier, testInfo.title);
-
-  return {
-    get: (url: string, options?: RequestOptions) => request.get(url, merge(url, options)),
-    post: (url: string, options?: RequestOptions) => request.post(url, merge(url, options)),
-    put: (url: string, options?: RequestOptions) => request.put(url, merge(url, options)),
-    patch: (url: string, options?: RequestOptions) => request.patch(url, merge(url, options)),
-    delete: (url: string, options?: RequestOptions) => request.delete(url, merge(url, options)),
-    head: (url: string, options?: RequestOptions) => request.head(url, merge(url, options)),
-    fetch: (urlOrRequest: string | PlaywrightRequest, options?: RequestOptions) =>
-      request.fetch(urlOrRequest, merge(typeof urlOrRequest === 'string' ? urlOrRequest : urlOrRequest.url(), options)),
-    storageState: (options?: { path?: string }) => request.storageState(options),
-    dispose: () => request.dispose(),
-  } as APIRequestContext;
-}
-
-type OtelTestSpan = {
-  carrier: Record<string, string>;
-  apiBaseUrls: string[];
-  testInfo: TestInfo;
-};
-
-export const test = base.extend<{
-  page: Page;
-  requestWithTrace: APIRequestContext;
-  _otelTestSpan: OtelTestSpan;
-}>({
-  _otelTestSpan: [
-    // eslint-disable-next-line no-empty-pattern
-    async ({}, use, testInfo) => {
-      ensureCollector();
-      const apiBaseUrls = getApiBaseUrls();
-      const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-      const spanName = `e2e:${testInfo.title}`;
-      const span = tracer.startSpan(spanName, {
-        attributes: {
-          'test.title': testInfo.title,
-          'test.project': testInfo.project.name,
-          'test.file': testInfo.file ?? '',
-          'test.line': testInfo.line ?? 0,
-        },
-      });
-      setAttributesFromAnnotations(span, testInfo);
-      const ctx = otelTrace.setSpan(otelContext.active(), span);
-      const carrier: Record<string, string> = {};
-      otelContext.with(ctx, () => {
-        propagation.inject(otelContext.active(), carrier);
-      });
-      try {
-        await otelContext.with(ctx, () => use({ carrier, apiBaseUrls, testInfo }));
-      } catch (error) {
-        span.setStatus({ code: SpanStatusCode.ERROR, message: error instanceof Error ? error.message : 'Unknown 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) {
-          testInfo.annotations.push({
-            type: 'otel-spans',
-            description: JSON.stringify(spans),
-          });
-        }
-      }
-    },
-    { scope: 'test' },
-  ],
-
-  page: async ({ page, _otelTestSpan }, use) => {
-    const { carrier, apiBaseUrls, testInfo } = _otelTestSpan;
-    if (apiBaseUrls.length > 0) {
-      await page.route('**/*', async (route) => {
-        const request = route.request();
-        const url = request.url();
-        if (urlMatchesApiOrigin(url, apiBaseUrls)) {
-          const headers = {
-            ...request.headers(),
-            ...carrier,
-            'x-test-name': testInfo.title,
-          };
-          await route.continue({ headers });
-        } else {
-          await route.continue();
-        }
-      });
-    }
-    await use(page);
-  },
-
-  requestWithTrace: async ({ request, _otelTestSpan }, use) => {
-    const wrapped = createRequestWithTrace(
-      request,
-      _otelTestSpan.apiBaseUrls,
-      _otelTestSpan.carrier,
-      _otelTestSpan.testInfo,
-    );
-    await use(wrapped);
-  },
-});
-
-export { expect } from '@playwright/test';
-
-// Re-export trace context helpers for DX convenience
-export {
-  getTraceContext,
-  resolveTraceUrl,
-  isTracing,
-  enrichWithTraceContext,
-} from 'autotel';
-
-export type { OtelTraceContext } from 'autotel';
-
-/**
- * Runs a named step as a child span of the current test span. Use inside a test to get
- * step-level spans (e.g. "step:login", "step:navigate") under the test span in the same trace.
- *
- * @example
- * test('user flow', async ({ page }) => {
- *   await step('login', async () => {
- *     await page.click('button[type=submit]');
- *   });
- *   await step('open profile', async () => {
- *     await page.goto('/profile');
- *   });
- * });
- */
-export async function step<T>(name: string, fn: () => Promise<T>): Promise<T> {
-  const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-  const span = tracer.startSpan(`step:${name}`, {
-    attributes: { 'step.name': name },
-  });
-  try {
-    return await otelContext.with(otelTrace.setSpan(otelContext.active(), span), fn);
-  } catch (error) {
-    span.setStatus({ code: SpanStatusCode.ERROR, message: error instanceof Error ? error.message : 'Unknown error' });
-    span.recordException(error instanceof Error ? error : new Error(String(error)));
-    throw error;
-  } finally {
-    span.end();
-  }
-}
-
-/**
- * Returns a function suitable for Playwright globalSetup that inits autotel.
- * Call autotel.init() with the given options (or defaults) so test spans are exported.
- */
-export function createGlobalSetup(initOptions?: AutotelConfig): () => Promise<void> {
-  return async () => {
-    const { init } = await import('autotel');
-    init({
-      service: 'e2e-tests',
-      debug: true,
-      ...initOptions,
-    });
-  };
-}
-
-/**
- * Serialized span returned by the test-spans endpoint (matches autotel-tanstack/testing SerializedSpan).
- */
-export interface SerializedSpan {
-  name: string;
-  spanId: string;
-  traceId: string;
-  parentSpanId?: string;
-  attributes?: Record<string, unknown>;
-  status: { code: number; message?: string };
-  durationMs: number;
-}
-
-/**
- * Creates a typed client for the test-spans HTTP endpoint.
- *
- * Pairs with `createTestSpansHandlers()` from `autotel-tanstack/testing`.
- *
- * @param baseUrl - Base URL of the app under test (e.g. 'http://localhost:3100')
- * @param options.path - Path of the test-spans endpoint (default: '/api/test-spans')
- *
- * @example
- * ```typescript
- * const spansClient = createTestSpansClient('http://localhost:3100');
- *
- * test('server function is traced', async ({ request }) => {
- *   await spansClient.clearSpans(request);
- *   await page.goto('/');
- *   // ... trigger action ...
- *   const spans = await spansClient.getSpans(request);
- *   expect(spans.find(s => s.name === 'sendMoney.handler')).toBeDefined();
- * });
- * ```
- */
-export function createTestSpansClient(
-  baseUrl: string,
-  options?: { path?: string },
-): {
-  getSpans(request: APIRequestContext): Promise<SerializedSpan[]>;
-  clearSpans(request: APIRequestContext): Promise<void>;
-} {
-  const base = baseUrl.replace(/\/$/, '');
-  const path = options?.path ?? '/api/test-spans';
-  const url = `${base}${path}`;
-
-  return {
-    async getSpans(request: APIRequestContext): Promise<SerializedSpan[]> {
-      const res = await request.get(url);
-      if (!res.ok()) {
-        throw new Error(`GET ${path} failed: ${res.status()}`);
-      }
-      const body = await res.json() as { spans: SerializedSpan[] };
-      return body.spans;
-    },
-
-    async clearSpans(request: APIRequestContext): Promise<void> {
-      const res = await request.delete(url);
-      if (!res.ok()) {
-        throw new Error(`DELETE ${path} failed: ${res.status()}`);
-      }
-    },
-  };
-}

package/src/reporter.test.ts

@@ -1,81 +0,0 @@
-import { afterEach, describe, it, expect, vi } from 'vitest';
-
-const spans: Array<{ end: ReturnType<typeof vi.fn> }> = [];
-
-vi.mock('autotel', () => ({
-  SpanStatusCode: { ERROR: 2 },
-  context: {
-    active: () => ({}),
-    with: (_ctx: unknown, fn: () => void) => fn(),
-  },
-  getTracer: () => ({
-    startSpan: () => {
-      const span = {
-        end: vi.fn(),
-        recordException: vi.fn(),
-        setStatus: vi.fn(),
-      };
-      spans.push(span);
-      return span;
-    },
-  }),
-  otelTrace: {
-    setSpan: () => ({}),
-  },
-}));
-
-describe('OtelReporter', () => {
-  afterEach(() => {
-    spans.length = 0;
-    vi.resetModules();
-  });
-
-  it('tracks same file/line/title tests independently (no key collisions)', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const testA = {
-      id: 'project-a-id',
-      title: 'shared title',
-      location: { file: 'e2e/spec.ts', line: 7 },
-    } as any;
-    const testB = {
-      id: 'project-b-id',
-      title: 'shared title',
-      location: { file: 'e2e/spec.ts', line: 7 },
-    } as any;
-
-    reporter.onTestBegin(testA, {} as any);
-    reporter.onTestBegin(testB, {} as any);
-
-    reporter.onTestEnd(testA, { status: 'passed' } as any);
-
-    expect(spans).toHaveLength(2);
-    expect(spans[0].end).toHaveBeenCalledTimes(1);
-    expect(spans[1].end).not.toHaveBeenCalled();
-  });
-
-  it('marks a step span as error when step.error exists even if result.status is passed', async () => {
-    const { OtelReporter } = await import('./reporter');
-    const reporter = new OtelReporter();
-
-    const test = {
-      id: 'project-a-id',
-      title: 'step failure case',
-      location: { file: 'e2e/spec.ts', line: 12 },
-    } as any;
-
-    const step = {
-      title: 'failing step',
-      error: { message: 'boom', stack: 'stack' },
-    } as any;
-
-    reporter.onTestBegin(test, {} as any);
-    reporter.onStepBegin(test, {} as any, step);
-    reporter.onStepEnd(test, { status: 'passed' } as any, step);
-
-    const stepSpan = spans[1] as any;
-    expect(stepSpan.recordException).toHaveBeenCalled();
-    expect(stepSpan.setStatus).toHaveBeenCalledWith({ code: 2 });
-  });
-});

package/src/reporter.ts

@@ -1,105 +0,0 @@
-/**
- * Optional Playwright reporter that creates OTel spans for each test and step.
- * Runs in the runner process; ensure autotel.init() is called in globalSetup so spans are exported.
- *
- * Use when you want test/step timing and hierarchy in OTLP from the runner side.
- * For "test → API" in one trace (worker side), use the test fixture and requestWithTrace.
- *
- * @example
- * // playwright.config.ts
- * import { defineConfig } from '@playwright/test';
- *
- * export default defineConfig({
- *   reporter: [['list'], ['autotel-playwright/reporter']],
- *   globalSetup: './globalSetup.ts', // must call init()
- * });
- */
-
-import type {
-  FullConfig,
-  FullResult,
-  Reporter,
-  Suite,
-  TestCase,
-  TestResult,
-  TestStep,
-} from '@playwright/test/reporter';
-import { getTracer, context as otelContext, otelTrace, SpanStatusCode } from 'autotel';
-
-const TRACER_NAME = 'playwright-reporter';
-const TRACER_VERSION = '0.1.0';
-
-function testKey(test: TestCase): string {
-  return test.id;
-}
-
-/** Convert Playwright TestError (no `name` field) 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;
-}
-
-/**
- * Playwright Reporter that creates one span per test and one per step (as children).
- * Requires autotel.init() in globalSetup so spans are exported.
- */
-class OtelReporter implements Reporter {
-  private testSpans = new Map<string, ReturnType<ReturnType<typeof getTracer>['startSpan']>>();
-  private stepSpans = new WeakMap<TestStep, ReturnType<ReturnType<typeof getTracer>['startSpan']>>();
-
-  onTestBegin(test: TestCase, _result: TestResult): void {
-    const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-    const span = tracer.startSpan(`e2e:${test.title}`, {
-      attributes: {
-        'test.title': test.title,
-        'test.file': test.location?.file ?? '',
-        'test.line': test.location?.line ?? 0,
-      },
-    });
-    this.testSpans.set(testKey(test), span);
-  }
-
-  onTestEnd(test: TestCase, result: TestResult): void {
-    const key = testKey(test);
-    const span = this.testSpans.get(key);
-    if (span) {
-      if (result.status !== 'passed' && result.status !== 'skipped') {
-        span.setStatus({ code: SpanStatusCode.ERROR });
-        if (result.error) span.recordException(toError(result.error));
-      }
-      span.end();
-      this.testSpans.delete(key);
-    }
-  }
-
-  onStepBegin(test: TestCase, _result: TestResult, step: TestStep): void {
-    const testSpan = this.testSpans.get(testKey(test));
-    if (!testSpan) return;
-    otelContext.with(otelTrace.setSpan(otelContext.active(), testSpan), () => {
-      const tracer = getTracer(TRACER_NAME, TRACER_VERSION);
-      const span = tracer.startSpan(`step:${step.title}`, {
-        attributes: { 'step.name': step.title },
-      });
-      this.stepSpans.set(step, span);
-    });
-  }
-
-  onStepEnd(_test: TestCase, result: TestResult, step: TestStep): void {
-    const span = this.stepSpans.get(step);
-    if (span) {
-      if (step.error) {
-        span.recordException(toError(step.error));
-        span.setStatus({ code: SpanStatusCode.ERROR });
-      }
-      span.end();
-      this.stepSpans.delete(step);
-    }
-  }
-
-  onBegin?(_config: FullConfig, _suite: Suite): void {}
-  onEnd?(_result: FullResult): void {}
-}
-
-export { OtelReporter };
-export default OtelReporter;