autotel-cloudflare 3.1.0 → 4.0.1

package/src/global/cache.ts

@@ -1,164 +0,0 @@
-/**
- * Global Cache API instrumentation for Cloudflare Workers
- *
- * Automatically traces cache operations:
- * - cache.match() - Read from cache
- * - cache.put() - Write to cache
- * - cache.delete() - Delete from cache
- */
-
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { wrap } from '../bindings/common';
-import { WorkerTracer } from 'autotel-edge';
-
-type CacheOperation = 'match' | 'put' | 'delete';
-
-/**
- * Sanitize URL for span attributes (remove query params that might contain sensitive data)
- */
-function sanitizeURL(url: string): string {
-  const u = new URL(url);
-  return `${u.protocol}//${u.host}${u.pathname}`;
-}
-
-/**
- * Instrument a cache method (match, put, delete)
- */
-function instrumentCacheMethod<T extends Function>(
-  fn: T,
-  cacheName: string,
-  operation: CacheOperation,
-): T {
-  const handler: ProxyHandler<T> = {
-    async apply(target, thisArg, argArray) {
-      const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-      // Extract URL from first argument (Request or string)
-      const firstArg = argArray[0];
-      const url =
-        firstArg instanceof Request
-          ? firstArg.url
-          : typeof firstArg === 'string'
-            ? firstArg
-            : undefined;
-
-      const spanName = `Cache ${cacheName}.${operation}`;
-
-      return tracer.startActiveSpan(
-        spanName,
-        {
-          kind: SpanKind.CLIENT,
-          attributes: {
-            'cache.name': cacheName,
-            'cache.operation': operation,
-            'cache.key': url ? sanitizeURL(url) : undefined,
-          },
-        },
-        async (span) => {
-          try {
-            const result = await Reflect.apply(target, thisArg, argArray);
-
-            // For match operations, record whether it was a hit or miss
-            if (operation === 'match') {
-              span.setAttribute('cache.hit', !!result);
-            }
-
-            span.setStatus({ code: SpanStatusCode.OK });
-            return result;
-          } catch (error) {
-            span.recordException(error as Error);
-            span.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-          } finally {
-            span.end();
-          }
-        },
-      );
-    },
-  };
-
-  return wrap(fn, handler);
-}
-
-/**
- * Instrument a Cache instance
- */
-function instrumentCache(cache: Cache, cacheName: string): Cache {
-  const handler: ProxyHandler<Cache> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      // Instrument the cache operation methods
-      if (
-        (prop === 'match' || prop === 'put' || prop === 'delete') &&
-        typeof value === 'function'
-      ) {
-        return instrumentCacheMethod(
-          value.bind(target),
-          cacheName,
-          prop as CacheOperation,
-        );
-      }
-
-      // Bind other methods to preserve `this` context
-      if (typeof value === 'function') {
-        return value.bind(target);
-      }
-
-      return value;
-    },
-  };
-
-  return wrap(cache, handler);
-}
-
-/**
- * Instrument caches.open()
- */
-function instrumentCachesOpen(
-  openFn: CacheStorage['open'],
-): CacheStorage['open'] {
-  const handler: ProxyHandler<CacheStorage['open']> = {
-    async apply(target, thisArg, argArray) {
-      const cacheName = argArray[0];
-      const cache = await Reflect.apply(target, thisArg, argArray);
-      return instrumentCache(cache, cacheName);
-    },
-  };
-
-  return wrap(openFn, handler);
-}
-
-/**
- * Instrument the global caches API
- *
- * This wraps globalThis.caches to automatically create spans for all cache operations.
- *
- * **Note:** This is called automatically when the library is initialized with
- * `instrumentation.instrumentGlobalCache: true` (default).
- */
-export function instrumentGlobalCache(): void {
-  const handler: ProxyHandler<typeof caches> = {
-    get(target, prop) {
-      if (prop === 'default') {
-        // Wrap the default cache
-        return instrumentCache(target.default, 'default');
-      } else if (prop === 'open') {
-        // Wrap the open method
-        const openFn = Reflect.get(target, prop);
-        if (typeof openFn === 'function') {
-          return instrumentCachesOpen(openFn.bind(target));
-        }
-      }
-
-      return Reflect.get(target, prop);
-    },
-  };
-
-  // Replace global caches
-  // @ts-ignore - TypeScript doesn't like reassigning globalThis.caches
-  globalThis.caches = wrap(caches, handler);
-}

package/src/global/fetch.test.ts

@@ -1,399 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { instrumentGlobalFetch } from './fetch';
-import { trace, SpanStatusCode, SpanKind, context as api_context } from '@opentelemetry/api';
-import { setConfig, parseConfig } from 'autotel-edge';
-
-describe('Global Fetch Instrumentation', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: any;
-  let originalFetch: typeof globalThis.fetch;
-
-  beforeEach(() => {
-    // Save original fetch
-    originalFetch = globalThis.fetch;
-
-    mockSpan = {
-      spanContext: () => ({
-        traceId: 'test-trace-id',
-        spanId: 'test-span-id',
-        traceFlags: 1,
-      }),
-      setAttribute: vi.fn(),
-      setAttributes: vi.fn(),
-      setStatus: vi.fn(),
-      recordException: vi.fn(),
-      end: vi.fn(),
-      isRecording: () => true,
-      updateName: vi.fn(),
-      addEvent: vi.fn(),
-    };
-
-    mockTracer = {
-      startActiveSpan: vi.fn((name, options, fn) => {
-        return fn(mockSpan);
-      }),
-    };
-
-    getTracerSpy = vi.spyOn(trace, 'getTracer').mockReturnValue(mockTracer as any);
-
-    // Mock underlying fetch to return test responses
-    globalThis.fetch = vi.fn(async (_input) => {
-      return new Response('{"data": "test"}', {
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-      });
-    }) as any;
-  });
-
-  afterEach(() => {
-    // Restore original fetch
-    globalThis.fetch = originalFetch;
-    getTracerSpy.mockRestore();
-  });
-
-  describe('instrumentGlobalFetch()', () => {
-    it('should wrap globalThis.fetch', () => {
-      const originalFetch = globalThis.fetch;
-      instrumentGlobalFetch();
-
-      expect(globalThis.fetch).not.toBe(originalFetch);
-      expect(typeof globalThis.fetch).toBe('function');
-    });
-
-    it('should create span for HTTP requests', async () => {
-      // Set up config
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users');
-
-        expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-        const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-        expect(spanName).toContain('api.example.com');
-        expect(spanName).toContain('GET');
-      });
-    });
-
-    it('should add HTTP attributes (method, URL, status, headers)', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users', {
-          method: 'POST',
-          headers: { 'user-agent': 'test-client/1.0' },
-        });
-
-        const options = mockTracer.startActiveSpan.mock.calls[0][1];
-        expect(options.kind).toBe(SpanKind.CLIENT);
-        expect(options.attributes['http.request.method']).toBe('POST');
-        expect(options.attributes['url.full']).toBe('https://api.example.com/users');
-        expect(options.attributes['server.address']).toBe('api.example.com');
-        expect(options.attributes['url.scheme']).toBe('https');
-      });
-    });
-
-    it('should add response attributes', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users');
-
-        expect(mockSpan.setAttributes).toHaveBeenCalled();
-
-        // Find the call with response attributes
-        const responseAttributesCall = mockSpan.setAttributes.mock.calls.find(
-          (call: any) => call[0]['http.response.status_code'] !== undefined
-        );
-
-        expect(responseAttributesCall).toBeDefined();
-        expect(responseAttributesCall[0]['http.response.status_code']).toBe(200);
-      });
-    });
-
-    it('should inject traceparent header for context propagation by default', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users');
-
-        // Span should have been created
-        expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-        // In a real scenario, traceparent would be injected via propagation.inject()
-        // For this test, we just verify the span was created
-        expect(mockSpan.end).toHaveBeenCalled();
-      });
-    });
-
-    it('should NOT inject traceparent when includeTraceContext = false', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-        fetch: { includeTraceContext: false },
-      });
-      setConfig(config);
-
-      instrumentGlobalFetch();
-
-      // Create a spy to check if headers.set was called
-      const headersSpy = vi.spyOn(Headers.prototype, 'set');
-
-      await fetch('https://api.example.com/users');
-
-      // Should not have tried to inject traceparent
-      const traceparentCalls = headersSpy.mock.calls.filter(
-        (call) => call[0] === 'traceparent'
-      );
-      expect(traceparentCalls.length).toBe(0);
-
-      headersSpy.mockRestore();
-    });
-
-    it('should skip non-HTTP requests (file://, data://)', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      setConfig(config);
-
-      instrumentGlobalFetch();
-
-      // Try to fetch a file:// URL (should skip instrumentation)
-      try {
-        await fetch('file:///path/to/file.txt');
-      } catch (_e) {
-        // file:// will fail, that's expected
-      }
-
-      // Should not have created a span
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-
-    it('should skip when no active config (not initialized)', async () => {
-      // Don't set config
-      setConfig(null as any);
-
-      instrumentGlobalFetch();
-
-      await fetch('https://api.example.com/users');
-
-      // Should not have created a span
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-
-      // Original fetch should have been called (returning mocked response)
-      // We can't easily verify this without more complex mocking,
-      // but the key assertion is that no span was created
-    });
-
-    it('should handle successful responses (200-299)', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      // Mock successful response
-      globalThis.fetch = vi.fn(async () => {
-        return new Response('OK', { status: 200 });
-      }) as any;
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users');
-
-        expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-        expect(mockSpan.end).toHaveBeenCalled();
-      });
-    });
-
-    it('should handle error responses (400-599)', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      // Mock error response
-      globalThis.fetch = vi.fn(async () => {
-        return new Response('Not Found', { status: 404 });
-      }) as any;
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users');
-
-        expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });
-        expect(mockSpan.end).toHaveBeenCalled();
-      });
-    });
-
-    it('should handle network errors', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      // Mock network error
-      globalThis.fetch = vi.fn(async () => {
-        throw new Error('Network error');
-      }) as any;
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await expect(fetch('https://api.example.com/users')).rejects.toThrow('Network error');
-
-        expect(mockSpan.recordException).toHaveBeenCalled();
-        expect(mockSpan.setStatus).toHaveBeenCalledWith({
-          code: SpanStatusCode.ERROR,
-          message: 'Network error',
-        });
-        expect(mockSpan.end).toHaveBeenCalled();
-      });
-    });
-
-    it('should allow custom includeTraceContext function', async () => {
-      const includeTraceContextFn = vi.fn((request: Request) => {
-        // Only include for specific domains
-        return request.url.includes('internal.example.com');
-      });
-
-      const config = parseConfig({
-        service: { name: 'test-service' },
-        fetch: { includeTraceContext: includeTraceContextFn },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        // Fetch internal domain - should include context
-        await fetch('https://internal.example.com/api');
-        expect(includeTraceContextFn).toHaveBeenCalledTimes(1);
-
-        // Fetch external domain - should not include context
-        await fetch('https://external.com/api');
-        expect(includeTraceContextFn).toHaveBeenCalledTimes(2);
-      });
-    });
-
-    it('should handle Request objects as input', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        const request = new Request('https://api.example.com/users', {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ name: 'test' }),
-        });
-
-        await fetch(request);
-
-        expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-        const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-        expect(spanName).toContain('POST');
-        expect(spanName).toContain('api.example.com');
-      });
-    });
-
-    it('should handle URL objects as input', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        const url = new URL('https://api.example.com/users');
-        await fetch(url);
-
-        expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-        const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-        expect(spanName).toContain('api.example.com');
-      });
-    });
-  });
-
-  describe('dataSafety.redactQueryParams', () => {
-    it('should capture full URL and query string by default', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users?token=secret&page=1');
-
-        const options = mockTracer.startActiveSpan.mock.calls[0][1];
-        expect(options.attributes['url.full']).toBe('https://api.example.com/users?token=secret&page=1');
-        expect(options.attributes['url.query']).toBe('?token=secret&page=1');
-      });
-    });
-
-    it('should redact query params when redactQueryParams is true', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-        dataSafety: { redactQueryParams: true },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users?token=secret&page=1');
-
-        const options = mockTracer.startActiveSpan.mock.calls[0][1];
-        expect(options.attributes['url.full']).toBe('https://api.example.com/users');
-        expect(options.attributes['url.query']).toBe('[REDACTED]');
-      });
-    });
-
-    it('should handle URLs without query string when redactQueryParams is true', async () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-        dataSafety: { redactQueryParams: true },
-      });
-      const ctx = setConfig(config);
-
-      instrumentGlobalFetch();
-
-      await api_context.with(ctx, async () => {
-        await fetch('https://api.example.com/users');
-
-        const options = mockTracer.startActiveSpan.mock.calls[0][1];
-        expect(options.attributes['url.full']).toBe('https://api.example.com/users');
-        expect(options.attributes['url.query']).toBe('');
-      });
-    });
-  });
-});

package/src/global/fetch.ts

@@ -1,136 +0,0 @@
-/**
- * Global fetch() instrumentation for autotel-edge
- *
- * Automatically traces all outgoing fetch() calls with:
- * - HTTP method, URL, status code
- * - Request/response headers
- * - Automatic context propagation
- * - Error tracking
- */
-
-import {
-  trace,
-  context as api_context,
-  propagation,
-  SpanStatusCode,
-  SpanKind,
-} from '@opentelemetry/api';
-import { getActiveConfig, WorkerTracer } from 'autotel-edge';
-
-/**
- * Gather HTTP request attributes following OpenTelemetry semantic conventions
- */
-function gatherRequestAttributes(request: Request): Record<string, any> {
-  const url = new URL(request.url);
-  const config = getActiveConfig();
-  const redactQuery = config?.dataSafety?.redactQueryParams === true;
-
-  return {
-    'http.request.method': request.method.toUpperCase(),
-    'url.full': redactQuery ? `${url.origin}${url.pathname}` : request.url,
-    'url.scheme': url.protocol.replace(':', ''),
-    'server.address': url.host,
-    'url.path': url.pathname,
-    'url.query': redactQuery ? (url.search ? '[REDACTED]' : '') : url.search,
-    'network.protocol.name': 'http',
-    'user_agent.original': request.headers.get('user-agent') || undefined,
-  };
-}
-
-/**
- * Gather HTTP response attributes
- */
-function gatherResponseAttributes(response: Response): Record<string, any> {
-  return {
-    'http.response.status_code': response.status,
-    'http.response.body.size': response.headers.get('content-length') || undefined,
-  };
-}
-
-/**
- * Instrument the global fetch function
- *
- * This wraps globalThis.fetch to automatically create spans for all outgoing HTTP requests.
- *
- * **Note:** This is called automatically when the library is initialized with
- * `instrumentation.instrumentGlobalFetch: true` (default).
- */
-export function instrumentGlobalFetch(): void {
-  const originalFetch = globalThis.fetch;
-
-  const instrumentedFetch = function fetch(
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ): Promise<Response> {
-    const request = new Request(input, init);
-
-    // Skip non-HTTP requests
-    if (!request.url.startsWith('http')) {
-      return originalFetch(input, init);
-    }
-
-    // Skip if no active config (not initialized yet)
-    const config = getActiveConfig();
-    if (!config) {
-      return originalFetch(input, init);
-    }
-
-    const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-    const url = new URL(request.url);
-    const spanName = `${request.method} ${url.host}`;
-
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.CLIENT,
-        attributes: gatherRequestAttributes(request),
-      },
-      async (span) => {
-        try {
-          // Inject trace context into request headers for distributed tracing
-          const shouldIncludeContext =
-            typeof config.fetch?.includeTraceContext === 'function'
-              ? config.fetch.includeTraceContext(request)
-              : (config.fetch?.includeTraceContext ?? true);
-
-          if (shouldIncludeContext) {
-            propagation.inject(api_context.active(), request.headers, {
-              set: (headers, key, value) => {
-                if (typeof value === 'string') {
-                  headers.set(key, value);
-                }
-              },
-            });
-          }
-
-          // Make the actual fetch call
-          const response = await originalFetch(request);
-
-          // Add response attributes
-          span.setAttributes(gatherResponseAttributes(response));
-
-          // Set span status based on response
-          if (response.ok) {
-            span.setStatus({ code: SpanStatusCode.OK });
-          } else {
-            span.setStatus({ code: SpanStatusCode.ERROR });
-          }
-
-          return response;
-        } catch (error) {
-          span.recordException(error as Error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error),
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      },
-    );
-  };
-
-  // Replace global fetch
-  globalThis.fetch = instrumentedFetch as typeof fetch;
-}

package/src/global/index.ts

@@ -1,7 +0,0 @@
-/**
- * Global instrumentation for Cloudflare Workers
- * Automatically instrument fetch() and cache APIs
- */
-
-export { instrumentGlobalFetch } from './fetch';
-export { instrumentGlobalCache } from './cache';