autotel-cloudflare 3.1.0 → 4.0.1

package/src/bindings/vectorize.ts

@@ -1,86 +0,0 @@
-/**
- * Vectorize binding instrumentation
- */
-
-import {
-  trace,
-  SpanKind,
-  SpanStatusCode,
-} from '@opentelemetry/api';
-import type { WorkerTracer } from 'autotel-edge';
-import { wrap, setAttr } from './common';
-
-const TRACED_METHODS = ['query', 'insert', 'upsert', 'deleteByIds', 'getByIds', 'describe'] as const;
-
-/**
- * Instrument Vectorize index binding
- */
-export function instrumentVectorize<T extends VectorizeIndex>(vectorize: T, indexName?: string): T {
-  const name = indexName || 'vectorize';
-
-  const handler: ProxyHandler<T> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (typeof prop === 'string' && TRACED_METHODS.includes(prop as any) && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const operation = prop as string;
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            const attributes: Record<string, string | number> = {
-              'db.system': 'cloudflare-vectorize',
-              'db.operation': operation,
-              'db.collection.name': name,
-            };
-
-            // Per-operation attributes
-            if (operation === 'query') {
-              const queryInput = args[0] as { topK?: number } | undefined;
-              if (queryInput?.topK !== undefined) {
-                attributes['db.vectorize.top_k'] = queryInput.topK;
-              }
-            }
-
-            if ((operation === 'insert' || operation === 'upsert') && Array.isArray(args[0])) {
-              attributes['db.vectorize.vectors_count'] = args[0].length;
-            }
-
-            return tracer.startActiveSpan(
-              `Vectorize ${name}: ${operation}`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes,
-              },
-              async (span) => {
-                try {
-                  const result = await Reflect.apply(fnTarget, target, args);
-
-                  if (operation === 'query' && result?.matches) {
-                    setAttr(span, 'db.vectorize.matches_count', result.matches.length);
-                  }
-
-                  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 value;
-    },
-  };
-
-  return wrap(vectorize, handler);
-}

package/src/bindings.ts

@@ -1,6 +0,0 @@
-/**
- * Bindings instrumentation entry point
- * Entry point: autotel-cloudflare/bindings
- */
-
-export * from './bindings/index';

package/src/events.ts

@@ -1,6 +0,0 @@
-/**
- * Events system entry point (re-export from autotel-edge)
- * Entry point: autotel-cloudflare/events
- */
-
-export * from 'autotel-edge/events';

package/src/execution-logger.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import {
-  getRequestLogger,
-  getQueueLogger,
-  getWorkflowLogger,
-  getActorLogger,
-  createWorkersLogger,
-} from './execution-logger';
-
-const createMockContext = () => ({
-  traceId: 'trace-id',
-  spanId: 'span-id',
-  correlationId: 'corr-id',
-  setAttribute: vi.fn(),
-  setAttributes: vi.fn(),
-  setStatus: vi.fn(),
-  recordException: vi.fn(),
-  addEvent: vi.fn(),
-  addLink: vi.fn(),
-  addLinks: vi.fn(),
-  updateName: vi.fn(),
-  isRecording: vi.fn(() => true),
-});
-
-describe('cloudflare execution logger aliases', () => {
-  it('getRequestLogger delegates to the shared execution logger', () => {
-    const ctx = createMockContext();
-    const log = getRequestLogger(ctx);
-
-    log.set({ request: { id: 'req-123' } });
-
-    expect(ctx.setAttributes).toHaveBeenCalledWith({
-      'request.id': 'req-123',
-    });
-    expect(typeof log.fork).toBe('function');
-  });
-
-  it('getQueueLogger delegates to the shared execution logger', () => {
-    const ctx = createMockContext();
-    const log = getQueueLogger(ctx);
-
-    log.info('processing batch', { queue: { name: 'payments' } });
-
-    expect(ctx.addEvent).toHaveBeenCalledWith('log.info', {
-      message: 'processing batch',
-      'queue.name': 'payments',
-    });
-  });
-
-  it('getWorkflowLogger delegates to the shared execution logger', () => {
-    const ctx = createMockContext();
-    const log = getWorkflowLogger(ctx);
-    const first = log.emitNow({ workflow: { id: 'wf-123' } });
-    const second = log.emitNow({ workflow: { id: 'wf-123' } });
-
-    expect(first.traceId).toBe('trace-id');
-    expect(second).toBe(first);
-    expect(ctx.addEvent).toHaveBeenCalledWith('log.emit.manual', {
-      'workflow.id': 'wf-123',
-    });
-  });
-
-  it('getActorLogger delegates to the shared execution logger', () => {
-    const ctx = createMockContext();
-    const log = getActorLogger(ctx);
-
-    log.warn('alarm delayed', { actor: { class: 'Counter' } });
-
-    expect(ctx.setAttribute).toHaveBeenCalledWith('autotel.log.level', 'warn');
-    expect(ctx.addEvent).toHaveBeenCalledWith('log.warn', {
-      message: 'alarm delayed',
-      'actor.class': 'Counter',
-    });
-  });
-
-  it('createWorkersLogger pre-populates request and cf context fields', () => {
-    const ctx = createMockContext();
-    const request = new Request('https://example.com/api/orders/123?expand=1', {
-      method: 'POST',
-      headers: {
-        'cf-ray': 'ray-123',
-        traceparent: '00-abc-def-01',
-        authorization: 'Bearer should-not-include-by-default',
-        'x-request-id': 'req-789',
-      },
-    });
-
-    Object.defineProperty(request, 'cf', {
-      value: {
-        colo: 'LHR',
-        country: 'GB',
-        asn: 13335,
-        city: 'London',
-        region: 'England',
-      },
-    });
-
-    const log = createWorkersLogger(request, { headers: ['x-request-id'] }, ctx);
-
-    const fields = log.getContext();
-    expect(fields.request).toMatchObject({
-      method: 'POST',
-      path: '/api/orders/123',
-      url: 'https://example.com/api/orders/123?expand=1',
-      requestId: 'ray-123',
-      headers: { 'x-request-id': 'req-789' },
-    });
-    expect(fields.cfRay).toBe('ray-123');
-    expect(fields.traceparent).toBe('00-abc-def-01');
-    expect(fields.colo).toBe('LHR');
-    expect(fields.country).toBe('GB');
-    expect(fields.asn).toBe(13335);
-  });
-
-  it('createWorkersLogger honors explicit requestId override', () => {
-    const ctx = createMockContext();
-    const request = new Request('https://example.com/health', {
-      headers: { 'cf-ray': 'ray-default' },
-    });
-
-    const log = createWorkersLogger(request, { requestId: 'manual-id' }, ctx);
-
-    expect(log.getContext().request).toMatchObject({
-      requestId: 'manual-id',
-    });
-  });
-});

package/src/execution-logger.ts

@@ -1,112 +0,0 @@
-import {
-  type ExecutionLogger,
-  type ExecutionLoggerOptions,
-  type ExecutionLogSnapshot,
-  getExecutionLogger,
-  type TraceContext,
-} from 'autotel-edge/logger';
-
-export type {
-  ExecutionLogger,
-  ExecutionLoggerOptions,
-  ExecutionLogSnapshot,
-};
-
-export interface WorkersLoggerOptions {
-  /** Override derived request id (default: cf-ray header value when present). */
-  requestId?: string;
-  /** Optional request header allowlist to include in logger context. */
-  headers?: string[];
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function collectHeaders(
-  headers: Headers,
-  include: string[] | undefined,
-): Record<string, string> | undefined {
-  if (!include || include.length === 0) return undefined;
-
-  const allowlist = new Set(include.map((h) => h.toLowerCase()));
-  const out: Record<string, string> = {};
-  headers.forEach((value, key) => {
-    if (allowlist.has(key.toLowerCase())) {
-      out[key] = value;
-    }
-  });
-
-  return Object.keys(out).length > 0 ? out : undefined;
-}
-
-function pickCfContext(request: Request): Record<string, unknown> {
-  const cf = Reflect.get(request, 'cf');
-  if (!isRecord(cf)) return {};
-
-  const out: Record<string, unknown> = {};
-  if (typeof cf.colo === 'string') out.colo = cf.colo;
-  if (typeof cf.country === 'string') out.country = cf.country;
-  if (typeof cf.asn === 'number') out.asn = cf.asn;
-  if (typeof cf.city === 'string') out.city = cf.city;
-  if (typeof cf.region === 'string') out.region = cf.region;
-  return out;
-}
-
-/**
- * Create an execution logger pre-populated with common request context.
- * Best used from fetch handlers that already run inside autotel span context.
- */
-export function createWorkersLogger(
-  request: Request,
-  options: WorkersLoggerOptions = {},
-  ctx?: TraceContext,
-): ExecutionLogger {
-  const log = getExecutionLogger(ctx);
-  const url = new URL(request.url);
-  const cfRay = request.headers.get('cf-ray') ?? undefined;
-  const traceparent = request.headers.get('traceparent') ?? undefined;
-
-  log.set({
-    request: {
-      method: request.method,
-      path: url.pathname,
-      url: request.url,
-      requestId: options.requestId ?? cfRay,
-      headers: collectHeaders(request.headers, options.headers),
-    },
-    cfRay,
-    traceparent,
-    ...pickCfContext(request),
-  });
-
-  return log;
-}
-
-export function getRequestLogger(
-  ctx?: TraceContext,
-  options?: ExecutionLoggerOptions,
-): ExecutionLogger {
-  return getExecutionLogger(ctx, options);
-}
-
-export function getQueueLogger(
-  ctx?: TraceContext,
-  options?: ExecutionLoggerOptions,
-): ExecutionLogger {
-  return getExecutionLogger(ctx, options);
-}
-
-export function getWorkflowLogger(
-  ctx?: TraceContext,
-  options?: ExecutionLoggerOptions,
-): ExecutionLogger {
-  return getExecutionLogger(ctx, options);
-}
-
-export function getActorLogger(
-  ctx?: TraceContext,
-  options?: ExecutionLoggerOptions,
-): ExecutionLogger {
-  return getExecutionLogger(ctx, options);
-}

package/src/global/cache.test.ts

@@ -1,292 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { instrumentGlobalCache } from './cache';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-
-describe('Global Cache Instrumentation', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: any;
-  let originalCaches: typeof globalThis.caches;
-
-  beforeEach(() => {
-    // Save original caches
-    originalCaches = globalThis.caches;
-
-    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 caches API
-    const mockCache = {
-      match: vi.fn(async (key) => {
-        // Simulate cache hit/miss
-        const url = key instanceof Request ? key.url : key;
-        if (typeof url === 'string' && url.includes('cached')) {
-          return new Response('cached data');
-        }
-        return undefined;
-      }),
-      put: vi.fn(async () => {}),
-      delete: vi.fn(async () => true),
-      keys: vi.fn(async () => []),
-      add: vi.fn(async () => {}),
-      addAll: vi.fn(async () => {}),
-    };
-
-    (globalThis as any).caches = {
-      default: mockCache,
-      open: vi.fn(async (name: string) => mockCache),
-    };
-  });
-
-  afterEach(() => {
-    // Restore original caches
-    (globalThis as any).caches = originalCaches;
-    getTracerSpy.mockRestore();
-  });
-
-  describe('instrumentGlobalCache()', () => {
-    it('should wrap globalThis.caches', () => {
-      const originalCaches = globalThis.caches;
-      instrumentGlobalCache();
-
-      expect(globalThis.caches).not.toBe(originalCaches);
-      expect(globalThis.caches.default).toBeDefined();
-    });
-
-    it('should instrument caches.default', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      await caches.default.match(request);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toContain('Cache');
-      expect(spanName).toContain('default');
-      expect(spanName).toContain('match');
-    });
-  });
-
-  describe('cache.match() instrumentation', () => {
-    it('should create span for cache.match()', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/api/data');
-      await caches.default.match(request);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('Cache default.match');
-    });
-
-    it('should record cache hit (result found)', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/cached/data');
-      const result = await caches.default.match(request);
-
-      expect(result).toBeDefined();
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('cache.hit', true);
-    });
-
-    it('should record cache miss (result not found)', async () => {
-      // Create a mock that explicitly returns undefined
-      const missCache = {
-        match: vi.fn(async () => undefined),
-        put: vi.fn(async () => {}),
-        delete: vi.fn(async () => true),
-      };
-
-      (globalThis as any).caches = {
-        default: missCache,
-        open: vi.fn(),
-      };
-
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/uncached/data');
-      const result = await caches.default.match(request);
-
-      expect(result).toBeUndefined();
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('cache.hit', false);
-    });
-
-    it('should sanitize URL in attributes', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/api/data?secret=123&token=abc');
-      await caches.default.match(request);
-
-      const options = mockTracer.startActiveSpan.mock.calls[0][1];
-
-      // URL should be sanitized (query params removed)
-      expect(options.attributes['cache.key']).toBe('https://example.com/api/data');
-      expect(options.attributes['cache.key']).not.toContain('secret');
-      expect(options.attributes['cache.key']).not.toContain('token');
-    });
-
-    it('should add cache operation attributes', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      await caches.default.match(request);
-
-      const options = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(options.kind).toBe(SpanKind.CLIENT);
-      expect(options.attributes['cache.name']).toBe('default');
-      expect(options.attributes['cache.operation']).toBe('match');
-    });
-  });
-
-  describe('cache.put() instrumentation', () => {
-    it('should create span for cache.put()', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      const response = new Response('data');
-      await caches.default.put(request, response);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('Cache default.put');
-    });
-
-    it('should add cache name and operation attributes', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      const response = new Response('data');
-      await caches.default.put(request, response);
-
-      const options = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(options.attributes['cache.name']).toBe('default');
-      expect(options.attributes['cache.operation']).toBe('put');
-    });
-
-    it('should handle errors in cache.put()', async () => {
-      const errorCache = {
-        ...globalThis.caches.default,
-        put: vi.fn(async () => {
-          throw new Error('Cache error');
-        }),
-      };
-
-      (globalThis as any).caches = {
-        default: errorCache,
-        open: vi.fn(),
-      };
-
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      const response = new Response('data');
-
-      await expect(caches.default.put(request, response)).rejects.toThrow('Cache error');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Cache error',
-      });
-    });
-  });
-
-  describe('cache.delete() instrumentation', () => {
-    it('should create span for cache.delete()', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      await caches.default.delete(request);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('Cache default.delete');
-    });
-
-    it('should add cache operation attributes for delete', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      await caches.default.delete(request);
-
-      const options = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(options.attributes['cache.name']).toBe('default');
-      expect(options.attributes['cache.operation']).toBe('delete');
-    });
-  });
-
-  describe('caches.open() instrumentation', () => {
-    it('should wrap caches.open() to instrument named caches', async () => {
-      instrumentGlobalCache();
-
-      const namedCache = await caches.open('my-cache');
-
-      // After instrumentation, caches.open is wrapped
-      // The key is that we can still call it and get a cache back
-      expect(namedCache).toBeDefined();
-      expect(typeof namedCache.match).toBe('function');
-    });
-
-    it('should instrument operations on named caches', async () => {
-      instrumentGlobalCache();
-
-      const namedCache = await caches.open('my-custom-cache');
-      const request = new Request('https://example.com/test');
-      await namedCache.match(request);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('Cache my-custom-cache.match');
-    });
-  });
-
-  describe('Edge cases', () => {
-    it('should handle string keys for match()', async () => {
-      instrumentGlobalCache();
-
-      // Some implementations allow string keys
-      await caches.default.match('https://example.com/test');
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const options = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(options.attributes['cache.key']).toBe('https://example.com/test');
-    });
-
-    it('should set OK status on successful operations', async () => {
-      instrumentGlobalCache();
-
-      const request = new Request('https://example.com/test');
-      await caches.default.match(request);
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-});