autotel 4.0.0 → 4.2.0

package/src/functional.types.test.ts

@@ -1,135 +0,0 @@
-/**
- * Type inference tests for trace() function
- *
- * These tests verify that TypeScript correctly infers return types
- * for various trace() call signatures.
- *
- * Run with: pnpm run type-check
- */
-
-import { describe, it, expect } from 'vitest';
-import { trace } from './functional';
-import type { TraceContext } from './trace-helpers';
-
-describe('trace() type inference', () => {
-  // Helper to ensure we're getting the expected type
-  // If the type is `unknown`, accessing .foo will cause a type error
-  // This is a compile-time check
-
-  it('trace(fn) - single argument factory should infer return type', async () => {
-    // This SHOULD work - returns Promise<{ foo: string }>
-    const fn1 = trace((_ctx: TraceContext) => async () => {
-      return { foo: 'bar' };
-    });
-
-    const result1 = await fn1();
-    // If type is correct, this compiles. If unknown, this errors.
-    expect(result1.foo).toBe('bar');
-  });
-
-  it('trace(fn) - without explicit ctx type should infer return type', async () => {
-    // Test from bug report: ctx without explicit type annotation
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const fn1 = trace((ctx) => async () => {
-      return { foo: 'bar' };
-    });
-
-    const result1 = await fn1();
-    // If type is correct, this compiles. If unknown, this errors.
-    expect(result1.foo).toBe('bar');
-  });
-
-  it('trace(name, fn) - two argument factory should infer return type', async () => {
-    // BUG: This SHOULD return Promise<{ foo: string }> but might return unknown
-    const fn2 = trace('my-span-name', (_ctx: TraceContext) => async () => {
-      return { foo: 'bar' };
-    });
-
-    const result2 = await fn2();
-    // If the bug exists, TypeScript will error here because result2 is `unknown`
-    // and we can't access .foo on unknown
-    expect(result2.foo).toBe('bar');
-  });
-
-  it('trace(name, fn) - without explicit ctx type should infer return type', async () => {
-    // Exact reproduction from bug report
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const fn2 = trace('my-span-name', (ctx) => async () => {
-      return { foo: 'bar' };
-    });
-
-    const result2 = await fn2();
-    // If the type is properly inferred as { foo: string }, accessing .foo should work.
-    // If the bug exists and type is `unknown`, TypeScript will error here.
-    // Adding @ts-expect-error would make the type check pass ONLY if there's an error.
-    expect(result2.foo).toBe('bar');
-  });
-
-  it('BUG VERIFICATION: trace(name, fn) returns unknown type', async () => {
-    // This test uses @ts-expect-error to VERIFY the bug exists
-    // If @ts-expect-error is "unused", that means the bug is FIXED
-    // If @ts-expect-error is needed, the bug EXISTS
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const fn2 = trace('my-span-name', (ctx) => async () => {
-      return { foo: 'bar' };
-    });
-
-    const result2 = await fn2();
-
-    // If result2 is inferred as `unknown`, we'd need @ts-expect-error
-    // If result2 is inferred as `{ foo: string }`, this line works without error
-    // BUG FIXED: No @ts-expect-error needed anymore!
-    const _fooValue: string = result2.foo;
-    expect(_fooValue).toBe('bar');
-  });
-
-  it('trace(fn) with args should infer return type', async () => {
-    const fn3 = trace(
-      (_ctx: TraceContext) => async (name: string, age: number) => {
-        return { name, age };
-      },
-    );
-
-    const result3 = await fn3('Alice', 30);
-    expect(result3.name).toBe('Alice');
-    expect(result3.age).toBe(30);
-  });
-
-  it('trace(name, fn) with args should infer return type', async () => {
-    // BUG: This should also infer correctly
-    const fn4 = trace(
-      'user.create',
-      (_ctx: TraceContext) => async (name: string, age: number) => {
-        return { name, age };
-      },
-    );
-
-    const result4 = await fn4('Bob', 25);
-    // If type is correct, this compiles. If unknown, this errors.
-    expect(result4.name).toBe('Bob');
-    expect(result4.age).toBe(25);
-  });
-
-  it('trace(name, fn) sync factory should infer return type', () => {
-    const fn5 = trace('sync.operation', (_ctx: TraceContext) => () => {
-      return 42;
-    });
-
-    const result5 = fn5();
-    // Type should be number, not unknown
-    const numResult: number = result5;
-    expect(numResult).toBe(42);
-  });
-
-  it('trace(name, fn) plain function should infer return type', async () => {
-    // Plain function (no ctx) with name
-    const fn6 = trace('plain.function', async (a: number, b: number) => {
-      return a + b;
-    });
-
-    const result6 = await fn6(2, 3);
-    // Type should be number, not unknown
-    const numResult: number = result6;
-    expect(numResult).toBe(5);
-  });
-});

package/src/hook.mjs

@@ -1,15 +0,0 @@
-/**
- * ESM loader hook re-export for OpenTelemetry auto-instrumentation
- *
- * This file re-exports the OpenTelemetry ESM loader hook so users don't need
- * to install @opentelemetry/instrumentation as a direct dependency.
- *
- * Usage (Node 22+):
- *   NODE_OPTIONS="--experimental-loader=autotel/hook.mjs --import ./instrumentation.ts" tsx src/index.ts
- *
- * For supported Node versions, prefer using autotel/register instead which uses the newer
- * module.register() API and doesn't require NODE_OPTIONS.
- *
- * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md
- */
-export * from '@opentelemetry/instrumentation/hook.mjs';

package/src/http.test.ts

@@ -1,485 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  HttpInstrumented,
-  traceHttpRequest,
-  injectTraceContext,
-  extractTraceContext,
-} from './http';
-import { configure, resetConfig } from './config';
-
-describe('HttpInstrumented', () => {
-  beforeEach(() => {
-    resetConfig();
-  });
-
-  it('should instrument HTTP methods', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, fn) => fn(mockSpan)),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    @HttpInstrumented({ serviceName: 'api-client' })
-    class ApiClient {
-      async getUser(userId: string) {
-        return { status: 200, data: { id: userId, name: 'Test' } };
-      }
-    }
-
-    const client = new ApiClient();
-    const result = await client.getUser('123');
-
-    expect(result.data).toEqual({ id: '123', name: 'Test' });
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'HTTP GET 123',
-      expect.any(Function),
-    );
-    expect(mockSpan.setAttributes).toHaveBeenCalledWith(
-      expect.objectContaining({
-        'http.method': 'GET',
-        'service.name': 'api-client',
-        'operation.name': 'api-client.getUser',
-      }),
-    );
-    expect(mockSpan.setAttribute).toHaveBeenCalledWith('http.status_code', 200);
-    expect(mockSpan.end).toHaveBeenCalled();
-  });
-
-  it('should infer HTTP methods from method names', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, fn) => fn(mockSpan)),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    @HttpInstrumented()
-    class ApiClient {
-      async fetchData() {
-        return { status: 200 };
-      }
-      async createUser() {
-        return { status: 201 };
-      }
-      async updateProfile() {
-        return { status: 200 };
-      }
-      async deleteAccount() {
-        return { status: 204 };
-      }
-    }
-
-    const client = new ApiClient();
-
-    await client.fetchData();
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'HTTP GET',
-      expect.any(Function),
-    );
-
-    await client.createUser();
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'HTTP POST',
-      expect.any(Function),
-    );
-
-    await client.updateProfile();
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'HTTP PUT',
-      expect.any(Function),
-    );
-
-    await client.deleteAccount();
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'HTTP DELETE',
-      expect.any(Function),
-    );
-  });
-
-  it('should extract URL and parse it', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, fn) => fn(mockSpan)),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    @HttpInstrumented()
-    class ApiClient {
-      async getUser(url: string) {
-        return { status: 200, url };
-      }
-    }
-
-    const client = new ApiClient();
-    await client.getUser('https://api.example.com/users/123?include=profile');
-
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'HTTP GET /users/123',
-      expect.any(Function),
-    );
-    expect(mockSpan.setAttributes).toHaveBeenCalledWith(
-      expect.objectContaining({
-        'http.scheme': 'https',
-        'http.host': 'api.example.com',
-        'http.target': '/users/123?include=profile',
-      }),
-    );
-  });
-
-  it('should mark slow requests', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, fn) => fn(mockSpan)),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    @HttpInstrumented({ slowRequestThresholdMs: 10 })
-    class ApiClient {
-      async slowRequest() {
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        return { status: 200 };
-      }
-    }
-
-    const client = new ApiClient();
-    await client.slowRequest();
-
-    expect(mockSpan.setAttribute).toHaveBeenCalledWith(
-      'http.slow_request',
-      true,
-    );
-    expect(mockSpan.setAttribute).toHaveBeenCalledWith(
-      'http.slow_request_threshold_ms',
-      10,
-    );
-  });
-
-  it('should mark 4xx/5xx as errors', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, fn) => fn(mockSpan)),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    @HttpInstrumented()
-    class ApiClient {
-      async notFound() {
-        return { status: 404 };
-      }
-    }
-
-    const client = new ApiClient();
-    await client.notFound();
-
-    expect(mockSpan.setStatus).toHaveBeenCalledWith({
-      code: 2, // SpanStatusCode.ERROR
-      message: 'HTTP 404',
-    });
-  });
-
-  it('should handle errors correctly', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, fn) => fn(mockSpan)),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    @HttpInstrumented()
-    class ApiClient {
-      async failingRequest() {
-        throw new Error('Network timeout');
-      }
-    }
-
-    const client = new ApiClient();
-
-    await expect(client.failingRequest()).rejects.toThrow('Network timeout');
-
-    expect(mockSpan.setStatus).toHaveBeenCalledWith({
-      code: 2, // SpanStatusCode.ERROR
-      message: 'Network timeout',
-    });
-    expect(mockSpan.end).toHaveBeenCalled();
-  });
-});
-
-describe('traceHttpRequest', () => {
-  beforeEach(() => {
-    resetConfig();
-  });
-
-  it('should trace HTTP requests', async () => {
-    const mockSpan = {
-      setStatus: vi.fn(),
-      setAttributes: vi.fn(),
-      end: vi.fn(),
-    };
-
-    const mockTracer = {
-      startActiveSpan: vi.fn((name, optionsOrFn, maybeFn) => {
-        const fn = typeof optionsOrFn === 'function' ? optionsOrFn : maybeFn;
-        return fn(mockSpan);
-      }),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    const result = await traceHttpRequest(
-      'GET /api/users',
-      async () => ({ data: [1, 2, 3] }),
-      {
-        'http.method': 'GET',
-        'http.target': '/api/users',
-      },
-    );
-
-    expect(result).toEqual({ data: [1, 2, 3] });
-    expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-      'GET /api/users',
-      expect.any(Function),
-    );
-    expect(mockSpan.setAttributes).toHaveBeenCalledWith({
-      'http.method': 'GET',
-      'http.target': '/api/users',
-    });
-    expect(mockSpan.end).toHaveBeenCalled();
-  });
-});
-
-describe('injectTraceContext', () => {
-  beforeEach(() => {
-    resetConfig();
-  });
-
-  afterEach(async () => {
-    // Clean up any SDK that might have been initialized
-    const { shutdown } = await import('./shutdown');
-    await shutdown().catch(() => {
-      // Ignore errors if SDK wasn't initialized
-    });
-    resetConfig();
-  });
-
-  it('should inject trace headers using propagation.inject', async () => {
-    const { propagation } = await import('@opentelemetry/api');
-
-    // Mock propagation.inject to simulate W3C trace context injection
-    const injectSpy = vi
-      .spyOn(propagation, 'inject')
-      .mockImplementation((ctx, carrier) => {
-        // Simulate W3C trace context propagation
-        (carrier as Record<string, string>)['traceparent'] =
-          '00-0123456789abcdef0123456789abcdef-0123456789abcdef-01';
-      });
-
-    const headers = injectTraceContext({
-      'Content-Type': 'application/json',
-    });
-
-    expect(injectSpy).toHaveBeenCalled();
-    expect(headers['traceparent']).toBe(
-      '00-0123456789abcdef0123456789abcdef-0123456789abcdef-01',
-    );
-    expect(headers['Content-Type']).toBe('application/json');
-  });
-
-  it('should work with empty headers', async () => {
-    const { propagation } = await import('@opentelemetry/api');
-    const injectSpy = vi.spyOn(propagation, 'inject');
-
-    const headers = injectTraceContext();
-
-    expect(injectSpy).toHaveBeenCalled();
-    expect(headers).toBeDefined();
-  });
-
-  it('should inject baggage header when baggage is present', async () => {
-    const { propagation } = await import('@opentelemetry/api');
-
-    // Mock propagation.inject to simulate baggage propagation
-    const injectSpy = vi
-      .spyOn(propagation, 'inject')
-      .mockImplementation((ctx, carrier) => {
-        (carrier as Record<string, string>)['traceparent'] =
-          '00-0123456789abcdef0123456789abcdef-0123456789abcdef-01';
-        (carrier as Record<string, string>)['baggage'] = 'tenant.id=tenant-123';
-      });
-
-    const headers = injectTraceContext({ 'Content-Type': 'application/json' });
-
-    expect(injectSpy).toHaveBeenCalled();
-    expect(headers['Content-Type']).toBe('application/json');
-    expect(headers['baggage']).toBe('tenant.id=tenant-123');
-  });
-
-  it('should inject baggage set via ctx.setBaggage()', async () => {
-    const { trace } = await import('./functional');
-    const { propagation, context: otelContext } =
-      await import('@opentelemetry/api');
-    const { init } = await import('./init');
-    const { shutdown } = await import('./shutdown');
-    const { InMemorySpanExporter } = await import('./exporters');
-    const { SimpleSpanProcessor } = await import('./processors');
-    const { AsyncLocalStorageContextManager } =
-      await import('@opentelemetry/context-async-hooks');
-
-    // Clean up any existing SDK first
-    await shutdown().catch(() => {
-      // Ignore errors if SDK wasn't initialized
-    });
-
-    // Set up proper OpenTelemetry SDK for this test
-    const exporter = new InMemorySpanExporter();
-    const contextManager = new AsyncLocalStorageContextManager();
-    contextManager.enable();
-    otelContext.setGlobalContextManager(contextManager);
-
-    init({
-      service: 'test',
-      spanProcessors: [new SimpleSpanProcessor(exporter)],
-      metrics: false,
-    });
-
-    try {
-      // Track what context was passed to propagation.inject
-      let injectedContext: unknown = null;
-      const injectSpy = vi
-        .spyOn(propagation, 'inject')
-        .mockImplementation((ctx, carrier) => {
-          injectedContext = ctx;
-          // Extract baggage from context to verify it's included
-          const baggage = propagation.getBaggage(ctx as any);
-          if (baggage) {
-            const baggageEntries: string[] = [];
-            for (const [key, entry] of baggage.getAllEntries()) {
-              baggageEntries.push(`${key}=${entry.value}`);
-            }
-            if (baggageEntries.length > 0) {
-              (carrier as Record<string, string>)['baggage'] =
-                baggageEntries.join(',');
-            }
-          }
-        });
-
-      const testFn = trace((ctx) => async () => {
-        // Set baggage via ctx.setBaggage()
-        ctx.setBaggage('tenant.id', 't1');
-        ctx.setBaggage('user.id', 'u1');
-
-        // Inject trace context - should include the baggage we just set
-        const headers = injectTraceContext();
-        return headers;
-      });
-
-      const headers = await testFn();
-
-      expect(injectSpy).toHaveBeenCalled();
-      expect(injectedContext).toBeTruthy();
-      // Verify baggage was included in the injected context
-      const baggage = propagation.getBaggage(injectedContext as any);
-      expect(baggage).toBeTruthy();
-      expect(baggage?.getEntry('tenant.id')?.value).toBe('t1');
-      expect(baggage?.getEntry('user.id')?.value).toBe('u1');
-      expect(headers['baggage']).toContain('tenant.id=t1');
-      expect(headers['baggage']).toContain('user.id=u1');
-
-      injectSpy.mockRestore();
-    } finally {
-      // Clean up
-      await shutdown().catch(() => {
-        // Ignore errors
-      });
-      // Reset config for other tests
-      resetConfig();
-    }
-  });
-});
-
-describe('extractTraceContext', () => {
-  it('should extract trace context from headers', () => {
-    const headers = {
-      traceparent: '00-0123456789abcdef0123456789abcdef-0123456789abcdef-01',
-      baggage: 'tenant.id=tenant-123',
-    };
-
-    const extractedContext = extractTraceContext(headers);
-
-    // Context should be extracted (actual validation depends on propagator)
-    expect(extractedContext).toBeDefined();
-  });
-
-  it('should handle array headers', () => {
-    const headers = {
-      traceparent: ['00-0123456789abcdef0123456789abcdef-0123456789abcdef-01'],
-      baggage: ['tenant.id=tenant-123'],
-    };
-
-    const extractedContext = extractTraceContext(headers);
-
-    expect(extractedContext).toBeDefined();
-  });
-
-  it('should handle missing headers gracefully', () => {
-    const headers = {};
-
-    const extractedContext = extractTraceContext(headers);
-
-    // Should return a context even if no trace headers are present
-    expect(extractedContext).toBeDefined();
-  });
-});