autotel-cloudflare 3.0.0 → 4.0.0

package/src/bindings/bindings-detection.test.ts

@@ -1,235 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { instrumentBindings } from './bindings';
-import { isWrapped, wrap } from './common';
-
-describe('instrumentBindings() detection logic', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: 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);
-  });
-
-  afterEach(() => {
-    getTracerSpy.mockRestore();
-  });
-
-  it('should detect R2 (object with get, put, delete, list, head methods)', () => {
-    const mockR2 = {
-      get: vi.fn(),
-      put: vi.fn(),
-      delete: vi.fn(),
-      list: vi.fn(),
-      head: vi.fn(),
-    };
-
-    const result = instrumentBindings({ MY_R2: mockR2 });
-
-    expect(result.MY_R2).not.toBe(mockR2);
-    expect(isWrapped(result.MY_R2)).toBe(true);
-  });
-
-  it('should detect KV (object with get, put, delete, list but NOT head)', () => {
-    const mockKV = {
-      get: vi.fn(),
-      put: vi.fn(),
-      delete: vi.fn(),
-      list: vi.fn(),
-    };
-
-    const result = instrumentBindings({ MY_KV: mockKV });
-
-    expect(result.MY_KV).not.toBe(mockKV);
-    expect(isWrapped(result.MY_KV)).toBe(true);
-  });
-
-  it('should detect D1 (object with prepare, exec methods)', () => {
-    const mockD1 = {
-      prepare: vi.fn(),
-      exec: vi.fn(),
-    };
-
-    const result = instrumentBindings({ MY_DB: mockD1 });
-
-    expect(result.MY_DB).not.toBe(mockD1);
-    expect(isWrapped(result.MY_DB)).toBe(true);
-  });
-
-  it('should detect Vectorize (object with query, insert, upsert, describe methods)', () => {
-    const mockVectorize = {
-      query: vi.fn(),
-      insert: vi.fn(),
-      upsert: vi.fn(),
-      describe: vi.fn(),
-    };
-
-    const result = instrumentBindings({ MY_INDEX: mockVectorize });
-
-    expect(result.MY_INDEX).not.toBe(mockVectorize);
-    expect(isWrapped(result.MY_INDEX)).toBe(true);
-  });
-
-  it('should detect AI (object with run method AND gateway property)', () => {
-    const mockAI = {
-      run: vi.fn(),
-      gateway: {},
-    };
-
-    const result = instrumentBindings({ AI: mockAI });
-
-    expect(result.AI).not.toBe(mockAI);
-    expect(isWrapped(result.AI)).toBe(true);
-  });
-
-  it('should detect Hyperdrive (object with connect method AND connectionString, host properties)', () => {
-    const mockHyperdrive = {
-      connect: vi.fn(),
-      connectionString: 'postgresql://user:pass@host:5432/db',
-      host: 'db.example.com',
-      port: 5432,
-      user: 'user',
-      password: 'pass',
-      database: 'db',
-    };
-
-    const result = instrumentBindings({ HYPERDRIVE: mockHyperdrive });
-
-    expect(result.HYPERDRIVE).not.toBe(mockHyperdrive);
-    expect(isWrapped(result.HYPERDRIVE)).toBe(true);
-  });
-
-  it('should detect Queue Producer (object with send, sendBatch but NOT get)', () => {
-    const mockQueue = {
-      send: vi.fn(),
-      sendBatch: vi.fn(),
-    };
-
-    const result = instrumentBindings({ MY_QUEUE: mockQueue });
-
-    expect(result.MY_QUEUE).not.toBe(mockQueue);
-    expect(isWrapped(result.MY_QUEUE)).toBe(true);
-  });
-
-  it('should detect Analytics Engine (object with writeDataPoint method)', () => {
-    const mockAE = {
-      writeDataPoint: vi.fn(),
-    };
-
-    const result = instrumentBindings({ ANALYTICS: mockAE });
-
-    expect(result.ANALYTICS).not.toBe(mockAE);
-    expect(isWrapped(result.ANALYTICS)).toBe(true);
-  });
-
-  it('should detect Images (object with info, input methods)', () => {
-    const mockImages = {
-      info: vi.fn(),
-      input: vi.fn(),
-    };
-
-    const result = instrumentBindings({ IMAGES: mockImages });
-
-    expect(result.IMAGES).not.toBe(mockImages);
-    expect(isWrapped(result.IMAGES)).toBe(true);
-  });
-
-  it('should detect Service Binding (object with fetch method) - last', () => {
-    const mockService = {
-      fetch: vi.fn(),
-    };
-
-    const result = instrumentBindings({ MY_SERVICE: mockService });
-
-    expect(result.MY_SERVICE).not.toBe(mockService);
-    expect(isWrapped(result.MY_SERVICE)).toBe(true);
-  });
-
-  it('should detect R2 before KV (object with head gets R2, without head gets KV)', () => {
-    const withHead = {
-      get: vi.fn(),
-      put: vi.fn(),
-      delete: vi.fn(),
-      list: vi.fn(),
-      head: vi.fn(),
-    };
-    const withoutHead = {
-      get: vi.fn(),
-      put: vi.fn(),
-      delete: vi.fn(),
-      list: vi.fn(),
-    };
-
-    const result = instrumentBindings({
-      R2_BUCKET: withHead,
-      KV_STORE: withoutHead,
-    });
-
-    // Both should be wrapped but detected as different types
-    expect(isWrapped(result.R2_BUCKET)).toBe(true);
-    expect(isWrapped(result.KV_STORE)).toBe(true);
-    expect(result.R2_BUCKET).not.toBe(withHead);
-    expect(result.KV_STORE).not.toBe(withoutHead);
-  });
-
-  it('should skip already-wrapped bindings', () => {
-    const mockKV = {
-      get: vi.fn(),
-      put: vi.fn(),
-      delete: vi.fn(),
-      list: vi.fn(),
-    };
-
-    // Pre-wrap the binding using the wrap helper
-    const preWrapped = wrap(mockKV, {
-      get(target, prop) {
-        return Reflect.get(target, prop);
-      },
-    });
-
-    const result = instrumentBindings({ MY_KV: preWrapped });
-
-    // Should be the same already-wrapped object, not double-wrapped
-    expect(result.MY_KV).toBe(preWrapped);
-    expect(isWrapped(result.MY_KV)).toBe(true);
-  });
-
-  it('should pass through non-object values (strings, numbers)', () => {
-    const result = instrumentBindings({
-      API_KEY: 'my-secret-key',
-      TIMEOUT: 5000,
-      ENABLED: true,
-      EMPTY: null,
-      UNDEF: undefined,
-    });
-
-    expect(result.API_KEY).toBe('my-secret-key');
-    expect(result.TIMEOUT).toBe(5000);
-    expect(result.ENABLED).toBe(true);
-    expect(result.EMPTY).toBe(null);
-    expect(result.UNDEF).toBe(undefined);
-  });
-});

package/src/bindings/bindings-this-binding.test.ts

@@ -1,294 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { instrumentKV, instrumentR2, instrumentD1, instrumentServiceBinding } from './bindings';
-
-describe('Bindings this-binding tests', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: 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);
-  });
-
-  afterEach(() => {
-    getTracerSpy.mockRestore();
-  });
-
-  describe('KV this-binding', () => {
-    it('should invoke get() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockKV = {
-        get: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return 'value';
-        }),
-        put: vi.fn(async () => undefined),
-        delete: vi.fn(async () => undefined),
-        list: vi.fn(async () => ({ keys: [], list_complete: true, cacheStatus: null })),
-      } as unknown as KVNamespace;
-      const instrumented = instrumentKV(mockKV, 'test');
-      await instrumented.get('key');
-      expect(receivedThis).toBe(mockKV);
-    });
-
-    it('should invoke put() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockKV = {
-        get: vi.fn(async () => null),
-        put: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-        }),
-        delete: vi.fn(async () => undefined),
-        list: vi.fn(async () => ({ keys: [], list_complete: true, cacheStatus: null })),
-      } as unknown as KVNamespace;
-      const instrumented = instrumentKV(mockKV, 'test');
-      await instrumented.put('key', 'value');
-      expect(receivedThis).toBe(mockKV);
-    });
-
-    it('should invoke delete() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockKV = {
-        get: vi.fn(async () => null),
-        put: vi.fn(async () => undefined),
-        delete: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-        }),
-        list: vi.fn(async () => ({ keys: [], list_complete: true, cacheStatus: null })),
-      } as unknown as KVNamespace;
-      const instrumented = instrumentKV(mockKV, 'test');
-      await instrumented.delete('key');
-      expect(receivedThis).toBe(mockKV);
-    });
-
-    it('should invoke list() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockKV = {
-        get: vi.fn(async () => null),
-        put: vi.fn(async () => undefined),
-        delete: vi.fn(async () => undefined),
-        list: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { keys: [], list_complete: true, cacheStatus: null };
-        }),
-      } as unknown as KVNamespace;
-      const instrumented = instrumentKV(mockKV, 'test');
-      await instrumented.list();
-      expect(receivedThis).toBe(mockKV);
-    });
-  });
-
-  describe('R2 this-binding', () => {
-    it('should invoke get() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockR2 = {
-        get: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { size: 100, etag: 'abc', httpMetadata: {} };
-        }),
-        put: vi.fn(async () => ({ etag: 'abc', uploaded: new Date() })),
-        delete: vi.fn(async () => undefined),
-        list: vi.fn(async () => ({ objects: [], truncated: false })),
-        head: vi.fn(async () => null),
-      } as unknown as R2Bucket;
-      const instrumented = instrumentR2(mockR2, 'test');
-      await instrumented.get('key');
-      expect(receivedThis).toBe(mockR2);
-    });
-
-    it('should invoke put() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockR2 = {
-        get: vi.fn(async () => null),
-        put: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { etag: 'abc', uploaded: new Date() };
-        }),
-        delete: vi.fn(async () => undefined),
-        list: vi.fn(async () => ({ objects: [], truncated: false })),
-        head: vi.fn(async () => null),
-      } as unknown as R2Bucket;
-      const instrumented = instrumentR2(mockR2, 'test');
-      await instrumented.put('key', 'value');
-      expect(receivedThis).toBe(mockR2);
-    });
-
-    it('should invoke delete() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockR2 = {
-        get: vi.fn(async () => null),
-        put: vi.fn(async () => ({ etag: 'abc', uploaded: new Date() })),
-        delete: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-        }),
-        list: vi.fn(async () => ({ objects: [], truncated: false })),
-        head: vi.fn(async () => null),
-      } as unknown as R2Bucket;
-      const instrumented = instrumentR2(mockR2, 'test');
-      await instrumented.delete('key');
-      expect(receivedThis).toBe(mockR2);
-    });
-
-    it('should invoke list() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockR2 = {
-        get: vi.fn(async () => null),
-        put: vi.fn(async () => ({ etag: 'abc', uploaded: new Date() })),
-        delete: vi.fn(async () => undefined),
-        list: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { objects: [], truncated: false };
-        }),
-        head: vi.fn(async () => null),
-      } as unknown as R2Bucket;
-      const instrumented = instrumentR2(mockR2, 'test');
-      await instrumented.list();
-      expect(receivedThis).toBe(mockR2);
-    });
-  });
-
-  describe('D1 this-binding', () => {
-    it('should invoke prepare() with original object as this, not the proxy', () => {
-      let receivedThis: any;
-      const mockPrepared = {
-        first: vi.fn(async () => null),
-        run: vi.fn(async () => ({})),
-        all: vi.fn(async () => []),
-        raw: vi.fn(async () => []),
-        bind: vi.fn(function() { return mockPrepared; }),
-      };
-      const mockD1 = {
-        prepare: vi.fn(function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return mockPrepared;
-        }),
-        exec: vi.fn(async () => ({ count: 0 })),
-      } as unknown as D1Database;
-      const instrumented = instrumentD1(mockD1, 'test');
-      instrumented.prepare('SELECT 1');
-      expect(receivedThis).toBe(mockD1);
-    });
-
-    it('should invoke prepared statement methods with original prepared object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockPrepared = {
-        first: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { id: 1 };
-        }),
-        run: vi.fn(async () => ({})),
-        all: vi.fn(async () => []),
-        raw: vi.fn(async () => []),
-        bind: vi.fn(function() { return mockPrepared; }),
-      };
-      const mockD1 = {
-        prepare: vi.fn(() => mockPrepared),
-        exec: vi.fn(async () => ({ count: 0 })),
-      } as unknown as D1Database;
-      const instrumented = instrumentD1(mockD1, 'test');
-      const stmt = instrumented.prepare('SELECT * FROM users WHERE id = ?');
-      await stmt.first();
-      expect(receivedThis).toBe(mockPrepared);
-    });
-
-    it('should invoke exec() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockD1 = {
-        prepare: vi.fn(() => ({ first: vi.fn(), run: vi.fn(), all: vi.fn(), raw: vi.fn() })),
-        exec: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { count: 1 };
-        }),
-      } as unknown as D1Database;
-      const instrumented = instrumentD1(mockD1, 'test');
-      await instrumented.exec('CREATE TABLE test (id INTEGER PRIMARY KEY)');
-      expect(receivedThis).toBe(mockD1);
-    });
-  });
-
-  describe('Service Binding this-binding', () => {
-    it('should invoke fetch() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockFetcher = {
-        fetch: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return new Response('ok', { status: 200 });
-        }),
-      } as unknown as Fetcher;
-      const instrumented = instrumentServiceBinding(mockFetcher, 'test');
-      await instrumented.fetch('https://example.com');
-      expect(receivedThis).toBe(mockFetcher);
-    });
-
-    it('should not throw "Illegal invocation" for native-like bindings that check this', async () => {
-      // Simulate a native Cloudflare Fetcher that throws when `this` is wrong.
-      // Native bindings use C++ checks that reject proxied `this` references.
-      class NativeFetcher {
-        async fetch(input: RequestInfo | URL, _init?: RequestInit): Promise<Response> {
-          // Native bindings validate `this` — throw if it's not the exact instance
-          if (!(this instanceof NativeFetcher)) {
-            throw new TypeError('Illegal invocation: function called with incorrect `this` reference');
-          }
-          return new Response('ok', { status: 200 });
-        }
-      }
-
-      const nativeFetcher = new NativeFetcher() as unknown as Fetcher;
-      const instrumented = instrumentServiceBinding(nativeFetcher, 'native-service');
-
-      // This should NOT throw — the fix ensures fetch() is called on the
-      // original target, preserving the native `this` binding
-      await expect(instrumented.fetch('https://example.com')).resolves.toBeInstanceOf(Response);
-    });
-
-    it('should bind non-fetch methods to the original target', () => {
-      let receivedThis: any;
-      const mockFetcher = {
-        fetch: vi.fn(async () => new Response('ok', { status: 200 })),
-        connect: vi.fn(function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return {};
-        }),
-      } as unknown as Fetcher;
-      const instrumented = instrumentServiceBinding(mockFetcher, 'test');
-      (instrumented as any).connect('https://example.com');
-      expect(receivedThis).toBe(mockFetcher);
-    });
-  });
-});