autotel-cloudflare 3.0.0 → 4.0.0

package/src/bindings/queue-producer.ts

@@ -1,105 +0,0 @@
-/**
- * Queue producer binding instrumentation
- */
-
-import {
-  trace,
-  SpanKind,
-  SpanStatusCode,
-} from '@opentelemetry/api';
-import type { WorkerTracer } from 'autotel-edge';
-import { wrap, setAttr } from './common';
-
-/**
- * Instrument Queue producer binding
- */
-export function instrumentQueueProducer<T extends Queue>(queue: T, queueName?: string): T {
-  const name = queueName || 'queue';
-
-  const handler: ProxyHandler<T> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (prop === 'send' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            return tracer.startActiveSpan(
-              `Queue ${name}: send`,
-              {
-                kind: SpanKind.PRODUCER,
-                attributes: {
-                  'messaging.system': 'cloudflare-queues',
-                  'messaging.operation.type': 'publish',
-                  'messaging.operation': 'send',
-                  'messaging.destination.name': name,
-                },
-              },
-              async (span) => {
-                try {
-                  const result = await Reflect.apply(fnTarget, target, args);
-                  setAttr(span, 'messaging.message.id', (result as any)?.messageId);
-                  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();
-                }
-              },
-            );
-          },
-        });
-      }
-
-      if (prop === 'sendBatch' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const [messages] = args as [{ body: unknown }[]];
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            return tracer.startActiveSpan(
-              `Queue ${name}: sendBatch`,
-              {
-                kind: SpanKind.PRODUCER,
-                attributes: {
-                  'messaging.system': 'cloudflare-queues',
-                  'messaging.operation.type': 'publish',
-                  'messaging.operation': 'sendBatch',
-                  'messaging.destination.name': name,
-                  'messaging.batch.message_count': Array.isArray(messages) ? messages.length : 0,
-                },
-              },
-              async (span) => {
-                try {
-                  const result = await Reflect.apply(fnTarget, target, args);
-                  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(queue, handler);
-}

package/src/bindings/rate-limiter.test.ts

@@ -1,140 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { instrumentRateLimiter } from './rate-limiter';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-
-describe('Rate Limiter Instrumentation', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: any;
-  let mockLimiter: any;
-
-  beforeEach(() => {
-    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);
-
-    mockLimiter = {
-      limit: vi.fn(async () => ({ success: true })),
-      someOtherMethod: vi.fn(() => 'passthrough-value'),
-    };
-  });
-
-  afterEach(() => {
-    getTracerSpy.mockRestore();
-  });
-
-  describe('limit()', () => {
-    it('should create span with correct attributes', async () => {
-      const instrumented = instrumentRateLimiter(mockLimiter, 'my-limiter');
-
-      await instrumented.limit({ key: 'user-123' });
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, spanOptions] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('RateLimiter my-limiter: limit');
-      expect(spanOptions.kind).toBe(SpanKind.CLIENT);
-      expect(spanOptions.attributes['rate_limiter.system']).toBe('cloudflare-rate-limiter');
-      expect(spanOptions.attributes['rate_limiter.key']).toBe('user-123');
-    });
-
-    it('should record success from result', async () => {
-      const instrumented = instrumentRateLimiter(mockLimiter, 'my-limiter');
-
-      await instrumented.limit({ key: 'user-123' });
-
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('rate_limiter.success', true);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should record success=false when rate limited', async () => {
-      mockLimiter.limit = vi.fn(async () => ({ success: false }));
-
-      const instrumented = instrumentRateLimiter(mockLimiter, 'my-limiter');
-
-      const result = await instrumented.limit({ key: 'user-456' });
-
-      expect(result.success).toBe(false);
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('rate_limiter.success', false);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle errors by recording exception and rethrowing', async () => {
-      const error = new Error('Rate limiter unavailable');
-      mockLimiter.limit = vi.fn(async () => {
-        throw error;
-      });
-
-      const instrumented = instrumentRateLimiter(mockLimiter, 'my-limiter');
-
-      await expect(instrumented.limit({ key: 'user-789' })).rejects.toThrow('Rate limiter unavailable');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(error);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Rate limiter unavailable',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should use default binding name when none provided', async () => {
-      const instrumented = instrumentRateLimiter(mockLimiter);
-
-      await instrumented.limit({ key: 'user-123' });
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('RateLimiter rate-limiter: limit');
-    });
-  });
-
-  describe('this-binding', () => {
-    it('should invoke limit() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockLim = {
-        limit: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { success: true };
-        }),
-      };
-      const instrumented = instrumentRateLimiter(mockLim, 'test');
-      await instrumented.limit({ key: 'user-123' });
-      expect(receivedThis).toBe(mockLim);
-    });
-  });
-
-  describe('Non-instrumented methods', () => {
-    it('should pass through non-instrumented methods unchanged', () => {
-      const instrumented = instrumentRateLimiter(mockLimiter, 'my-limiter');
-
-      const result = instrumented.someOtherMethod();
-
-      expect(result).toBe('passthrough-value');
-      expect(mockLimiter.someOtherMethod).toHaveBeenCalled();
-      // No span should be created for non-instrumented methods
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/bindings/rate-limiter.ts

@@ -1,69 +0,0 @@
-/**
- * Rate Limiter binding instrumentation
- */
-
-import {
-  trace,
-  SpanKind,
-  SpanStatusCode,
-} from '@opentelemetry/api';
-import type { WorkerTracer } from 'autotel-edge';
-import { wrap, setAttr } from './common';
-
-interface RateLimiterLike {
-  limit(options: { key: string }): Promise<{ success: boolean }>;
-}
-
-/**
- * Instrument Rate Limiter binding (manual only — not auto-detected)
- */
-export function instrumentRateLimiter<T extends RateLimiterLike>(limiter: T, bindingName?: string): T {
-  const name = bindingName || 'rate-limiter';
-
-  const handler: ProxyHandler<T> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (prop === 'limit' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const [options] = args as [{ key: string }];
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            return tracer.startActiveSpan(
-              `RateLimiter ${name}: limit`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                  'rate_limiter.system': 'cloudflare-rate-limiter',
-                  'rate_limiter.key': options?.key,
-                },
-              },
-              async (span) => {
-                try {
-                  const result = await Reflect.apply(fnTarget, target, args);
-                  setAttr(span, 'rate_limiter.success', result?.success);
-                  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(limiter, handler);
-}

package/src/bindings/vectorize.test.ts

@@ -1,362 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { instrumentVectorize } from './vectorize';
-
-describe('Vectorize Binding Instrumentation', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: any;
-  let mockVectorize: any;
-
-  beforeEach(() => {
-    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);
-
-    mockVectorize = {
-      query: vi.fn(async () => ({
-        matches: [
-          { id: 'vec-1', score: 0.95 },
-          { id: 'vec-2', score: 0.87 },
-          { id: 'vec-3', score: 0.72 },
-        ],
-        count: 3,
-      })),
-      insert: vi.fn(async () => ({ mutationId: 'mut-1', count: 2 })),
-      upsert: vi.fn(async () => ({ mutationId: 'mut-2', count: 3 })),
-      deleteByIds: vi.fn(async () => ({ mutationId: 'mut-3', count: 1 })),
-      getByIds: vi.fn(async () => [{ id: 'vec-1', values: [0.1, 0.2] }]),
-      describe: vi.fn(async () => ({
-        dimensions: 128,
-        vectorCount: 1000,
-        processedUpTo: 'ts-123',
-      })),
-      // Non-instrumented method
-      toString: vi.fn(() => 'VectorizeIndex'),
-    } as unknown as VectorizeIndex;
-  });
-
-  describe('query()', () => {
-    it('should create span with correct attributes', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      // The source reads topK from args[0], so we pass a query object as the first argument
-      await instrumented.query({ topK: 5 } as any, {} as any);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-        'Vectorize my-index: query',
-        expect.objectContaining({
-          kind: SpanKind.CLIENT,
-          attributes: expect.objectContaining({
-            'db.system': 'cloudflare-vectorize',
-            'db.operation': 'query',
-            'db.collection.name': 'my-index',
-            'db.vectorize.top_k': 5,
-          }),
-        }),
-        expect.any(Function),
-      );
-    });
-
-    it('should record matches_count from result', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await instrumented.query([0.1, 0.2, 0.3] as any, {} as any);
-
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('db.vectorize.matches_count', 3);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle query without topK in first argument', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await instrumented.query([0.1, 0.2, 0.3] as any, {} as any);
-
-      const attributes = mockTracer.startActiveSpan.mock.calls[0][1].attributes;
-      expect(attributes['db.vectorize.top_k']).toBeUndefined();
-    });
-  });
-
-  describe('insert()', () => {
-    it('should set vectors_count from input array length', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      const vectors = [
-        { id: 'vec-1', values: [0.1, 0.2] },
-        { id: 'vec-2', values: [0.3, 0.4] },
-      ];
-      await instrumented.insert(vectors as any);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-        'Vectorize my-index: insert',
-        expect.objectContaining({
-          kind: SpanKind.CLIENT,
-          attributes: expect.objectContaining({
-            'db.system': 'cloudflare-vectorize',
-            'db.operation': 'insert',
-            'db.collection.name': 'my-index',
-            'db.vectorize.vectors_count': 2,
-          }),
-        }),
-        expect.any(Function),
-      );
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('upsert()', () => {
-    it('should set vectors_count from input array length', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      const vectors = [
-        { id: 'vec-1', values: [0.1, 0.2] },
-        { id: 'vec-2', values: [0.3, 0.4] },
-        { id: 'vec-3', values: [0.5, 0.6] },
-      ];
-      await instrumented.upsert(vectors as any);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-        'Vectorize my-index: upsert',
-        expect.objectContaining({
-          kind: SpanKind.CLIENT,
-          attributes: expect.objectContaining({
-            'db.system': 'cloudflare-vectorize',
-            'db.operation': 'upsert',
-            'db.collection.name': 'my-index',
-            'db.vectorize.vectors_count': 3,
-          }),
-        }),
-        expect.any(Function),
-      );
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('deleteByIds()', () => {
-    it('should create correct span', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await instrumented.deleteByIds(['vec-1', 'vec-2']);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-        'Vectorize my-index: deleteByIds',
-        expect.objectContaining({
-          kind: SpanKind.CLIENT,
-          attributes: expect.objectContaining({
-            'db.system': 'cloudflare-vectorize',
-            'db.operation': 'deleteByIds',
-            'db.collection.name': 'my-index',
-          }),
-        }),
-        expect.any(Function),
-      );
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('describe()', () => {
-    it('should create correct span', async () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await instrumented.describe();
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-        'Vectorize my-index: describe',
-        expect.objectContaining({
-          kind: SpanKind.CLIENT,
-          attributes: expect.objectContaining({
-            'db.system': 'cloudflare-vectorize',
-            'db.operation': 'describe',
-            'db.collection.name': 'my-index',
-          }),
-        }),
-        expect.any(Function),
-      );
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('this-binding', () => {
-    it('should invoke methods with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockVec = {
-        query: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { matches: [], count: 0 };
-        }),
-        insert: vi.fn(async () => ({ mutationId: 'mut-1', count: 0 })),
-        upsert: vi.fn(async () => ({ mutationId: 'mut-2', count: 0 })),
-        deleteByIds: vi.fn(async () => ({ mutationId: 'mut-3', count: 0 })),
-        getByIds: vi.fn(async () => []),
-        describe: vi.fn(async () => ({ dimensions: 128, vectorCount: 0, processedUpTo: '' })),
-      } as unknown as VectorizeIndex;
-
-      const instrumented = instrumentVectorize(mockVec, 'test');
-      await instrumented.query([0.1, 0.2] as any, {} as any);
-      expect(receivedThis).toBe(mockVec);
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should record exception and set error status on query() failure', async () => {
-      mockVectorize.query = vi.fn(async () => {
-        throw new Error('Vectorize query failed');
-      });
-
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await expect(instrumented.query([0.1, 0.2] as any, {} as any)).rejects.toThrow('Vectorize query failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Vectorize query failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should record exception and set error status on insert() failure', async () => {
-      mockVectorize.insert = vi.fn(async () => {
-        throw new Error('Insert failed');
-      });
-
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await expect(instrumented.insert([{ id: 'v1', values: [0.1] }] as any)).rejects.toThrow('Insert failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Insert failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should record exception and set error status on upsert() failure', async () => {
-      mockVectorize.upsert = vi.fn(async () => {
-        throw new Error('Upsert failed');
-      });
-
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await expect(instrumented.upsert([{ id: 'v1', values: [0.1] }] as any)).rejects.toThrow('Upsert failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Upsert failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should record exception and set error status on deleteByIds() failure', async () => {
-      mockVectorize.deleteByIds = vi.fn(async () => {
-        throw new Error('Delete failed');
-      });
-
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await expect(instrumented.deleteByIds(['vec-1'])).rejects.toThrow('Delete failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Delete failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should record exception and set error status on describe() failure', async () => {
-      mockVectorize.describe = vi.fn(async () => {
-        throw new Error('Describe failed');
-      });
-
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await expect(instrumented.describe()).rejects.toThrow('Describe failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Describe failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle non-Error exceptions', async () => {
-      mockVectorize.query = vi.fn(async () => {
-        throw 'string error';
-      });
-
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      await expect(instrumented.query([0.1] as any, {} as any)).rejects.toThrow('string error');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'string error',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('Non-instrumented methods', () => {
-    it('should pass through non-traced methods without creating spans', () => {
-      const instrumented = instrumentVectorize(mockVectorize, 'my-index');
-
-      const result = instrumented.toString();
-
-      expect(result).toBe('VectorizeIndex');
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Default index name', () => {
-    it('should use "vectorize" as default index name when none provided', async () => {
-      const instrumented = instrumentVectorize(mockVectorize);
-
-      await instrumented.query([0.1, 0.2] as any, {} as any);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledWith(
-        'Vectorize vectorize: query',
-        expect.objectContaining({
-          attributes: expect.objectContaining({
-            'db.collection.name': 'vectorize',
-          }),
-        }),
-        expect.any(Function),
-      );
-    });
-  });
-});