autotel-cloudflare 2.15.0 → 2.17.0

package/src/bindings/ai.ts

@@ -22,7 +22,7 @@ export function instrumentAI<T extends Ai>(ai: T, bindingName?: string): T {
 
       if (prop === 'run' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [model] = args as [string, unknown, unknown];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
@@ -38,7 +38,7 @@ export function instrumentAI<T extends Ai>(ai: T, bindingName?: string): T {
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   if (result?.usage?.prompt_tokens !== undefined) {
                     setAttr(span, 'gen_ai.usage.input_tokens', Number(result.usage.prompt_tokens));
                   }

package/src/bindings/analytics-engine.test.ts

@@ -145,6 +145,21 @@ describe('Analytics Engine Instrumentation', () => {
     });
   });
 
+  describe('this-binding', () => {
+    it('should invoke writeDataPoint() with original object as this, not the proxy', () => {
+      let receivedThis: any;
+      const mockAEObj = {
+        writeDataPoint: vi.fn(function(this: any) {
+          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
+          receivedThis = this;
+        }),
+      };
+      const instrumented = instrumentAnalyticsEngine(mockAEObj as any, 'test');
+      instrumented.writeDataPoint({ indexes: ['idx1'] });
+      expect(receivedThis).toBe(mockAEObj);
+    });
+  });
+
   describe('Non-instrumented methods', () => {
     it('should pass through non-instrumented methods unchanged', () => {
       const instrumented = instrumentAnalyticsEngine(mockAE, 'my-dataset');

package/src/bindings/analytics-engine.ts

@@ -22,7 +22,7 @@ export function instrumentAnalyticsEngine<T extends AnalyticsEngineDataset>(ae:
 
       if (prop === 'writeDataPoint' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [dataPoint] = args as [AnalyticsEngineDataPoint | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
@@ -52,7 +52,7 @@ export function instrumentAnalyticsEngine<T extends AnalyticsEngineDataset>(ae:
               (span) => {
                 try {
                   // writeDataPoint is synchronous/void
-                  Reflect.apply(fnTarget, thisArg, args);
+                  Reflect.apply(fnTarget, target, args);
                   span.setStatus({ code: SpanStatusCode.OK });
                 } catch (error) {
                   span.recordException(error as Error);

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

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { trace } from '@opentelemetry/api';
+import { instrumentBindings } from './bindings';
+import { isWrapped } from './common';
+
+describe('instrumentBindings() caching', () => {
+  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 return the same instrumented object for the same env reference', () => {
+    const env = {
+      MY_KV: { get: vi.fn(), put: vi.fn(), delete: vi.fn(), list: vi.fn() },
+    };
+
+    const first = instrumentBindings(env);
+    const second = instrumentBindings(env);
+
+    expect(first).toBe(second);
+  });
+
+  it('should return different instrumented objects for different env references', () => {
+    const env1 = {
+      MY_KV: { get: vi.fn(), put: vi.fn(), delete: vi.fn(), list: vi.fn() },
+    };
+    const env2 = {
+      MY_KV: { get: vi.fn(), put: vi.fn(), delete: vi.fn(), list: vi.fn() },
+    };
+
+    const first = instrumentBindings(env1);
+    const second = instrumentBindings(env2);
+
+    expect(first).not.toBe(second);
+  });
+
+  it('should correctly instrument bindings even when returning from cache', () => {
+    const env = {
+      MY_KV: { get: vi.fn(), put: vi.fn(), delete: vi.fn(), list: vi.fn() },
+      API_KEY: 'secret',
+    };
+
+    const first = instrumentBindings(env);
+    const second = instrumentBindings(env);
+
+    // Cached result should have instrumented bindings
+    expect(isWrapped(second.MY_KV)).toBe(true);
+    // Non-object values pass through
+    expect(second.API_KEY).toBe('secret');
+  });
+});

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

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