autotel-cloudflare 2.1.0

package/src/global/fetch.test.ts

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

package/src/global/fetch.ts

@@ -0,0 +1,134 @@
+/**
+ * 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);
+
+  return {
+    'http.request.method': request.method.toUpperCase(),
+    'url.full': request.url,
+    'url.scheme': url.protocol.replace(':', ''),
+    'server.address': url.host,
+    'url.path': url.pathname,
+    'url.query': 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

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