autotel-cloudflare 2.15.0 → 2.16.0

package/src/bindings/bindings.ts

@@ -22,7 +22,7 @@ import {
   SpanKind,
   SpanStatusCode,
 } from '@opentelemetry/api';
-import { WorkerTracer } from 'autotel-edge';
+import { WorkerTracer, getActiveConfig } from 'autotel-edge';
 import { wrap, isWrapped } from './common';
 import { instrumentAI } from './ai';
 import { instrumentVectorize } from './vectorize';
@@ -31,6 +31,20 @@ import { instrumentQueueProducer } from './queue-producer';
 import { instrumentAnalyticsEngine } from './analytics-engine';
 import { instrumentImages } from './images';
 
+type DbStatementCapture = 'off' | 'obfuscated' | 'full';
+
+/**
+ * Sanitize a SQL statement based on the capture mode.
+ * - 'full': returns the statement as-is
+ * - 'obfuscated': replaces string literals and numbers with '?'
+ * - 'off': returns undefined (attribute not set)
+ */
+function sanitizeStatement(query: string, mode: DbStatementCapture): string | undefined {
+  if (mode === 'off') return undefined;
+  if (mode === 'obfuscated') return query.replaceAll(/'[^']*'/g, "'?'").replaceAll(/\b\d+\b/g, '?');
+  return query;
+}
+
 /**
  * Instrument KV namespace
  */
@@ -43,10 +57,10 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
       
       if (prop === 'get' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [key, options] = args as [string, KVNamespaceGetOptions<unknown> | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `KV ${name}: get`,
               {
@@ -61,7 +75,7 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setAttribute('db.result.type', result === null ? 'null' : typeof result);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
@@ -83,10 +97,10 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
       
       if (prop === 'put' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [key] = args as [string, unknown, KVNamespacePutOptions | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `KV ${name}: put`,
               {
@@ -100,7 +114,7 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
                 } catch (error) {
@@ -121,10 +135,10 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
       
       if (prop === 'delete' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [key] = args as [string];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `KV ${name}: delete`,
               {
@@ -138,7 +152,7 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
                 } catch (error) {
@@ -159,10 +173,10 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
       
       if (prop === 'list' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [options] = args as [KVNamespaceListOptions | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `KV ${name}: list`,
               {
@@ -177,7 +191,7 @@ export function instrumentKV<K extends KVNamespace>(kv: K, namespaceName?: strin
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setAttribute('db.result.keys_count', result.keys.length);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
@@ -216,10 +230,10 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
       
       if (prop === 'get' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [key] = args as [string, R2GetOptions | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `R2 ${name}: get`,
               {
@@ -233,7 +247,7 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   if (result) {
                     span.setAttribute('db.result.size', result.size);
                     span.setAttribute('db.result.etag', result.etag);
@@ -261,10 +275,10 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
       
       if (prop === 'put' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [key] = args as [string, ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob, R2PutOptions | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `R2 ${name}: put`,
               {
@@ -278,7 +292,7 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setAttribute('db.result.etag', result.etag);
                   span.setAttribute('db.result.uploaded', result.uploaded);
                   span.setStatus({ code: SpanStatusCode.OK });
@@ -301,10 +315,10 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
       
       if (prop === 'delete' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const keys = args as string[];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `R2 ${name}: delete`,
               {
@@ -318,7 +332,7 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
                 } catch (error) {
@@ -339,10 +353,10 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
       
       if (prop === 'list' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [options] = args as [R2ListOptions | undefined];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `R2 ${name}: list`,
               {
@@ -357,7 +371,7 @@ export function instrumentR2<R extends R2Bucket>(r2: R, bucketName?: string): R
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setAttribute('db.result.objects_count', result.objects.length);
                   span.setAttribute('db.result.truncated', result.truncated);
                   span.setStatus({ code: SpanStatusCode.OK });
@@ -397,11 +411,11 @@ export function instrumentD1<D extends D1Database>(d1: D, databaseName?: string)
       
       if (prop === 'prepare' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [query] = args as [string];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
-            const prepared = Reflect.apply(fnTarget, thisArg, args);
+
+            const prepared = Reflect.apply(fnTarget, target, args);
             
             // Instrument the prepared statement
             const preparedHandler: ProxyHandler<typeof prepared> = {
@@ -410,21 +424,27 @@ export function instrumentD1<D extends D1Database>(d1: D, databaseName?: string)
                 
                 if (prop === 'first' || prop === 'run' || prop === 'all' || prop === 'raw') {
                   return new Proxy(value, {
-                    apply: (fnTarget, thisArg, args) => {
+                    apply: (fnTarget, _thisArg, args) => {
+                      const activeConfig = getActiveConfig();
+                      const captureMode: DbStatementCapture = activeConfig?.dataSafety?.captureDbStatement ?? 'full';
+                      const statement = sanitizeStatement(query, captureMode);
+                      const attributes: Record<string, any> = {
+                        'db.system': 'cloudflare-d1',
+                        'db.operation': prop,
+                        'db.name': name,
+                      };
+                      if (statement !== undefined) {
+                        attributes['db.statement'] = statement;
+                      }
                       return tracer.startActiveSpan(
                         `D1 ${name}: ${prop}`,
                         {
                           kind: SpanKind.CLIENT,
-                          attributes: {
-                            'db.system': 'cloudflare-d1',
-                            'db.operation': prop,
-                            'db.name': name,
-                            'db.statement': query,
-                          },
+                          attributes,
                         },
                         async (span) => {
                           try {
-                            const result = await Reflect.apply(fnTarget, thisArg, args);
+                            const result = await Reflect.apply(fnTarget, target, args);
                             if (prop === 'all' && Array.isArray(result)) {
                               span.setAttribute('db.result.rows_count', result.length);
                             } else if (prop === 'first' && result) {
@@ -459,24 +479,30 @@ export function instrumentD1<D extends D1Database>(d1: D, databaseName?: string)
       
       if (prop === 'exec' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [query] = args as [string];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+            const activeConfig = getActiveConfig();
+            const captureMode: DbStatementCapture = activeConfig?.dataSafety?.captureDbStatement ?? 'full';
+            const statement = sanitizeStatement(query, captureMode);
+            const attributes: Record<string, any> = {
+              'db.system': 'cloudflare-d1',
+              'db.operation': 'exec',
+              'db.name': name,
+            };
+            if (statement !== undefined) {
+              attributes['db.statement'] = statement;
+            }
+
             return tracer.startActiveSpan(
               `D1 ${name}: exec`,
               {
                 kind: SpanKind.CLIENT,
-                attributes: {
-                  'db.system': 'cloudflare-d1',
-                  'db.operation': 'exec',
-                  'db.name': name,
-                  'db.statement': query,
-                },
+                attributes,
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setAttribute('db.result.count', result.count);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
@@ -515,11 +541,11 @@ export function instrumentServiceBinding<F extends Fetcher>(fetcher: F, serviceN
       
       if (prop === 'fetch' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [input, init] = args as [RequestInfo | URL, RequestInit | undefined];
             const request = new Request(input, init);
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            
+
             return tracer.startActiveSpan(
               `Service ${name}: ${request.method}`,
               {
@@ -533,7 +559,7 @@ export function instrumentServiceBinding<F extends Fetcher>(fetcher: F, serviceN
               },
               async (span) => {
                 try {
-                  const response = await Reflect.apply(fnTarget, thisArg, args);
+                  const response = await Reflect.apply(fnTarget, target, args);
                   span.setAttribute('http.response.status_code', response.status);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return response;
@@ -588,7 +614,12 @@ const hasExactMethods = (obj: any, methods: string[]): boolean =>
  * - Rate Limiter — limit() alone too generic
  * - Browser Rendering — indistinguishable from Service Binding
  */
+const envCache = new WeakMap<object, Record<string, any>>();
+
 export function instrumentBindings(env: Record<string, any>): Record<string, any> {
+  const cached = envCache.get(env);
+  if (cached) return cached;
+
   const instrumented: Record<string, any> = {};
 
   for (const [key, value] of Object.entries(env)) {
@@ -667,6 +698,7 @@ export function instrumentBindings(env: Record<string, any>): Record<string, any
     instrumented[key] = value;
   }
 
+  envCache.set(env, instrumented);
   return instrumented;
 }
 

package/src/bindings/browser-rendering.test.ts

@@ -129,6 +129,22 @@ describe('Browser Rendering Instrumentation', () => {
     });
   });
 
+  describe('this-binding', () => {
+    it('should invoke fetch() with original object as this, not the proxy', async () => {
+      let receivedThis: any;
+      const mockBrowserObj = {
+        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 });
+        }),
+      };
+      const instrumented = instrumentBrowserRendering(mockBrowserObj, 'test');
+      await instrumented.fetch('https://example.com');
+      expect(receivedThis).toBe(mockBrowserObj);
+    });
+  });
+
   describe('Non-instrumented methods', () => {
     it('should pass through non-instrumented methods unchanged', () => {
       const instrumented = instrumentBrowserRendering(mockBrowser, 'my-browser');

package/src/bindings/browser-rendering.ts

@@ -26,7 +26,7 @@ export function instrumentBrowserRendering<T extends BrowserRenderingLike>(brows
 
       if (prop === 'fetch' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [input] = args as [RequestInfo | URL, RequestInit | undefined];
             const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
@@ -42,7 +42,7 @@ export function instrumentBrowserRendering<T extends BrowserRenderingLike>(brows
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   setAttr(span, 'http.response.status_code', result?.status);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;

package/src/bindings/hyperdrive.test.ts

@@ -113,6 +113,28 @@ describe('Hyperdrive Binding Instrumentation', () => {
     });
   });
 
+  describe('this-binding', () => {
+    it('should invoke connect() with original object as this, not the proxy', async () => {
+      let receivedThis: any;
+      const mockHyperdrive = {
+        connect: vi.fn(async function(this: any) {
+          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
+          receivedThis = this;
+          return {} as Socket;
+        }),
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        host: 'host',
+        port: 5432,
+        user: 'user',
+        password: 'pass',
+        database: 'db',
+      } as unknown as Hyperdrive;
+      const instrumented = instrumentHyperdrive(mockHyperdrive, 'test');
+      await instrumented.connect();
+      expect(receivedThis).toBe(mockHyperdrive);
+    });
+  });
+
   describe('non-instrumented properties', () => {
     it('should pass through non-instrumented properties', () => {
       const mockHyperdrive = createMockHyperdrive();

package/src/bindings/hyperdrive.ts

@@ -22,7 +22,7 @@ export function instrumentHyperdrive<T extends Hyperdrive>(hyperdrive: T, bindin
 
       if (prop === 'connect' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
             const attributes: Record<string, string | number> = {
@@ -47,7 +47,7 @@ export function instrumentHyperdrive<T extends Hyperdrive>(hyperdrive: T, bindin
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
                 } catch (error) {

package/src/bindings/images.test.ts

@@ -206,6 +206,39 @@ describe('Images Binding Instrumentation', () => {
     });
   });
 
+  describe('this-binding', () => {
+    it('should invoke info() with original object as this, not the proxy', async () => {
+      let receivedThis: any;
+      const mockImagesObj = {
+        info: vi.fn(async function(this: any) {
+          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
+          receivedThis = this;
+          return { width: 800, height: 600, format: 'png' };
+        }),
+        input: vi.fn(() => ({ transform: vi.fn(), draw: vi.fn(), output: vi.fn() })),
+      };
+      const instrumented = instrumentImages(mockImagesObj as any, 'test');
+      await instrumented.info(new ArrayBuffer(8));
+      expect(receivedThis).toBe(mockImagesObj);
+    });
+
+    it('should invoke input() with original object as this, not the proxy', () => {
+      let receivedThis: any;
+      const mockTransformer = { transform: vi.fn(), draw: vi.fn(), output: vi.fn(async () => ({})) };
+      const mockImagesObj = {
+        info: vi.fn(async () => ({ width: 800, height: 600, format: 'png' })),
+        input: vi.fn(function(this: any) {
+          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
+          receivedThis = this;
+          return mockTransformer;
+        }),
+      };
+      const instrumented = instrumentImages(mockImagesObj as any, 'test');
+      instrumented.input(new ArrayBuffer(8));
+      expect(receivedThis).toBe(mockImagesObj);
+    });
+  });
+
   describe('non-instrumented methods', () => {
     it('should pass through non-instrumented methods unchanged', () => {
       const { images } = createMockImages();

package/src/bindings/images.ts

@@ -128,7 +128,7 @@ export function instrumentImages<T extends ImagesLike>(images: T, bindingName?:
 
       if (prop === 'info' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
             return tracer.startActiveSpan(
@@ -142,7 +142,7 @@ export function instrumentImages<T extends ImagesLike>(images: T, bindingName?:
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   setAttr(span, 'images.width', result?.width);
                   setAttr(span, 'images.height', result?.height);
                   setAttr(span, 'images.format', result?.format);
@@ -166,8 +166,8 @@ export function instrumentImages<T extends ImagesLike>(images: T, bindingName?:
 
       if (prop === 'input' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
-            const transformer = Reflect.apply(fnTarget, thisArg, args) as ImageTransformerLike;
+          apply: (fnTarget, _thisArg, args) => {
+            const transformer = Reflect.apply(fnTarget, target, args) as ImageTransformerLike;
             const meta: PipelineMeta = { operationCount: 0 };
             return proxyTransformer(transformer, meta, name);
           },

package/src/bindings/queue-producer.test.ts

@@ -179,6 +179,38 @@ describe('Queue Producer Binding Instrumentation', () => {
     });
   });
 
+  describe('this-binding', () => {
+    it('should invoke send() with original object as this, not the proxy', async () => {
+      let receivedThis: any;
+      const mockQueue = {
+        send: vi.fn(async function(this: any) {
+          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
+          receivedThis = this;
+          return { messageId: 'msg-123' };
+        }),
+        sendBatch: vi.fn(async () => ({})),
+      } as unknown as Queue;
+      const instrumented = instrumentQueueProducer(mockQueue, 'test');
+      await instrumented.send({ data: 'test' });
+      expect(receivedThis).toBe(mockQueue);
+    });
+
+    it('should invoke sendBatch() with original object as this, not the proxy', async () => {
+      let receivedThis: any;
+      const mockQueue = {
+        send: vi.fn(async () => ({ messageId: 'msg-123' })),
+        sendBatch: vi.fn(async function(this: any) {
+          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
+          receivedThis = this;
+          return {};
+        }),
+      } as unknown as Queue;
+      const instrumented = instrumentQueueProducer(mockQueue, 'test');
+      await instrumented.sendBatch([{ body: { data: 'test' } }]);
+      expect(receivedThis).toBe(mockQueue);
+    });
+  });
+
   describe('non-instrumented methods', () => {
     it('should pass through non-instrumented properties', () => {
       const mockQueue = createMockQueue();

package/src/bindings/queue-producer.ts

@@ -22,7 +22,7 @@ export function instrumentQueueProducer<T extends Queue>(queue: T, queueName?: s
 
       if (prop === 'send' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
             return tracer.startActiveSpan(
@@ -38,7 +38,7 @@ export function instrumentQueueProducer<T extends Queue>(queue: T, queueName?: s
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   setAttr(span, 'messaging.message.id', (result as any)?.messageId);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
@@ -60,7 +60,7 @@ export function instrumentQueueProducer<T extends Queue>(queue: T, queueName?: s
 
       if (prop === 'sendBatch' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [messages] = args as [{ body: unknown }[]];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
@@ -78,7 +78,7 @@ export function instrumentQueueProducer<T extends Queue>(queue: T, queueName?: s
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;
                 } catch (error) {

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

@@ -109,6 +109,22 @@ describe('Rate Limiter Instrumentation', () => {
     });
   });
 
+  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');

package/src/bindings/rate-limiter.ts

@@ -26,7 +26,7 @@ export function instrumentRateLimiter<T extends RateLimiterLike>(limiter: T, bin
 
       if (prop === 'limit' && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const [options] = args as [{ key: string }];
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
@@ -41,7 +41,7 @@ export function instrumentRateLimiter<T extends RateLimiterLike>(limiter: T, bin
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
                   setAttr(span, 'rate_limiter.success', result?.success);
                   span.setStatus({ code: SpanStatusCode.OK });
                   return result;

package/src/bindings/vectorize.test.ts

@@ -205,6 +205,28 @@ describe('Vectorize Binding Instrumentation', () => {
     });
   });
 
+  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 () => {

package/src/bindings/vectorize.ts

@@ -24,7 +24,7 @@ export function instrumentVectorize<T extends VectorizeIndex>(vectorize: T, inde
 
       if (typeof prop === 'string' && TRACED_METHODS.includes(prop as any) && typeof value === 'function') {
         return new Proxy(value, {
-          apply: (fnTarget, thisArg, args) => {
+          apply: (fnTarget, _thisArg, args) => {
             const operation = prop as string;
             const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
 
@@ -54,7 +54,7 @@ export function instrumentVectorize<T extends VectorizeIndex>(vectorize: T, inde
               },
               async (span) => {
                 try {
-                  const result = await Reflect.apply(fnTarget, thisArg, args);
+                  const result = await Reflect.apply(fnTarget, target, args);
 
                   if (operation === 'query' && result?.matches) {
                     setAttr(span, 'db.vectorize.matches_count', result.matches.length);