autotel-cloudflare 3.0.0 → 4.0.0

package/src/bindings/images.test.ts

@@ -1,262 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { instrumentImages } from './images';
-
-describe('Images Binding Instrumentation', () => {
-  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();
-  });
-
-  function createMockImages() {
-    const mockTransformer: any = {
-      transform: vi.fn(function (this: any) {
-        return mockTransformer;
-      }),
-      draw: vi.fn(function (this: any) {
-        return mockTransformer;
-      }),
-      output: vi.fn(async () => ({
-        response: () => new Response('image-data'),
-        blob: async () => new Blob(['image-data']),
-        arrayBuffer: async () => new ArrayBuffer(8),
-      })),
-    };
-
-    return {
-      images: {
-        info: vi.fn(async () => ({ width: 800, height: 600, format: 'png' })),
-        input: vi.fn(() => mockTransformer),
-        someOtherMethod: vi.fn(() => 'passthrough'),
-        someProperty: 'test-value',
-      },
-      mockTransformer,
-    };
-  }
-
-  describe('info()', () => {
-    it('should create its own span with correct attributes', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      await instrumented.info(new ArrayBuffer(8));
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('Images my-images: info');
-      expect(options.kind).toBe(SpanKind.CLIENT);
-      expect(options.attributes['images.system']).toBe('cloudflare-images');
-      expect(options.attributes['images.operation']).toBe('info');
-    });
-
-    it('should record width, height, format from result', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      await instrumented.info(new ArrayBuffer(8));
-
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('images.width', 800);
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('images.height', 600);
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('images.format', 'png');
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle errors', async () => {
-      const { images } = createMockImages();
-      const testError = new Error('Image info failed');
-      images.info = vi.fn(async () => {
-        throw testError;
-      });
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      await expect(instrumented.info(new ArrayBuffer(8))).rejects.toThrow('Image info failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Image info failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('pipeline: input() -> output()', () => {
-    it('should create a single span at output() with operation_count = 0', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      const transformer = instrumented.input(new ArrayBuffer(8));
-      await transformer.output();
-
-      // Only one span created at output(), not at input()
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('Images my-images: output');
-      expect(options.attributes['images.system']).toBe('cloudflare-images');
-      expect(options.attributes['images.pipeline.operation_count']).toBe(0);
-    });
-  });
-
-  describe('pipeline: input() -> transform() -> output()', () => {
-    it('should create span with operation_count = 1', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      const transformer = instrumented.input(new ArrayBuffer(8));
-      const transformed = transformer.transform({ width: 400 });
-      await transformed.output();
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(options.attributes['images.pipeline.operation_count']).toBe(1);
-    });
-  });
-
-  describe('pipeline: input() -> transform() -> draw() -> output()', () => {
-    it('should create span with operation_count = 2', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      const transformer = instrumented.input(new ArrayBuffer(8));
-      const transformed = transformer.transform({ width: 400 });
-      const drawn = transformed.draw({});
-      await drawn.output();
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(options.attributes['images.pipeline.operation_count']).toBe(2);
-    });
-  });
-
-  describe('output() format capture', () => {
-    it('should capture format from string arg', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      const transformer = instrumented.input(new ArrayBuffer(8));
-      await transformer.output('webp');
-
-      const [, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(options.attributes['images.output.format']).toBe('webp');
-    });
-
-    it('should capture format from options object', async () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      const transformer = instrumented.input(new ArrayBuffer(8));
-      await transformer.output({ format: 'avif' });
-
-      const [, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(options.attributes['images.output.format']).toBe('avif');
-    });
-
-    it('should handle errors in output()', async () => {
-      const { images, mockTransformer } = createMockImages();
-      const testError = new Error('Output failed');
-      mockTransformer.output = vi.fn(async () => {
-        throw testError;
-      });
-
-      const instrumented = instrumentImages(images as any, 'my-images');
-      const transformer = instrumented.input(new ArrayBuffer(8));
-
-      await expect(transformer.output()).rejects.toThrow('Output failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Output failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  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();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      const result = (instrumented as any).someOtherMethod();
-
-      expect(result).toBe('passthrough');
-      expect(images.someOtherMethod).toHaveBeenCalled();
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-
-    it('should pass through non-instrumented properties unchanged', () => {
-      const { images } = createMockImages();
-      const instrumented = instrumentImages(images as any, 'my-images');
-
-      expect((instrumented as any).someProperty).toBe('test-value');
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/bindings/images.ts

@@ -1,182 +0,0 @@
-/**
- * Images binding instrumentation
- *
- * The Images binding uses a fluent chain: input() -> transform() -> draw() -> output()
- * We only create a span at the terminal output() call to avoid intermediate noise.
- * info() is a standalone operation and gets its own span.
- */
-
-import {
-  trace,
-  SpanKind,
-  SpanStatusCode,
-} from '@opentelemetry/api';
-import type { WorkerTracer } from 'autotel-edge';
-import { wrap, setAttr } from './common';
-
-const pipelineMetaSymbol = Symbol('images-pipeline-meta');
-
-interface PipelineMeta {
-  operationCount: number;
-}
-
-interface ImagesLike {
-  info(blob: ReadableStream | ArrayBuffer | Blob): Promise<{ width: number; height: number; format: string }>;
-  input(blob: ReadableStream | ArrayBuffer | Blob): ImageTransformerLike;
-}
-
-interface ImageTransformerLike {
-  transform(options: unknown): ImageTransformerLike;
-  draw(image: unknown, options?: unknown): ImageTransformerLike;
-  output(options?: unknown): Promise<ImageOutputLike>;
-}
-
-interface ImageOutputLike {
-  response(): Response;
-  blob(): Promise<Blob>;
-  arrayBuffer(): Promise<ArrayBuffer>;
-}
-
-function proxyTransformer(transformer: ImageTransformerLike, meta: PipelineMeta, bindingName: string): ImageTransformerLike {
-  const handler: ProxyHandler<ImageTransformerLike> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if ((prop === 'transform' || prop === 'draw') && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            meta.operationCount++;
-            const result = Reflect.apply(fnTarget, target, args);
-            // If the result is the transformer itself (fluent chain), return our proxy
-            if (result === target || (result && typeof result === 'object' && 'output' in result)) {
-              return proxyTransformer(result as ImageTransformerLike, meta, bindingName);
-            }
-            return result;
-          },
-        });
-      }
-
-      if (prop === 'output' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-            const [formatOrOptions] = args;
-
-            const attributes: Record<string, string | number> = {
-              'images.system': 'cloudflare-images',
-              'images.pipeline.operation_count': meta.operationCount,
-            };
-
-            // Capture output format
-            if (typeof formatOrOptions === 'string') {
-              attributes['images.output.format'] = formatOrOptions;
-            } else if (formatOrOptions && typeof formatOrOptions === 'object') {
-              const fmt = (formatOrOptions as any).format;
-              if (fmt) attributes['images.output.format'] = fmt;
-            }
-
-            return tracer.startActiveSpan(
-              `Images ${bindingName}: output`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes,
-              },
-              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;
-    },
-  };
-
-  const proxy = new Proxy(transformer, handler);
-  Object.defineProperty(proxy, pipelineMetaSymbol, {
-    value: meta,
-    writable: false,
-    enumerable: false,
-    configurable: false,
-  });
-  return proxy;
-}
-
-/**
- * Instrument Images binding
- */
-export function instrumentImages<T extends ImagesLike>(images: T, bindingName?: string): T {
-  const name = bindingName || 'images';
-
-  const handler: ProxyHandler<T> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (prop === 'info' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            return tracer.startActiveSpan(
-              `Images ${name}: info`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                  'images.system': 'cloudflare-images',
-                  'images.operation': 'info',
-                },
-              },
-              async (span) => {
-                try {
-                  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);
-                  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 === 'input' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const transformer = Reflect.apply(fnTarget, target, args) as ImageTransformerLike;
-            const meta: PipelineMeta = { operationCount: 0 };
-            return proxyTransformer(transformer, meta, name);
-          },
-        });
-      }
-
-      return value;
-    },
-  };
-
-  return wrap(images, handler);
-}

package/src/bindings/index.ts

@@ -1,20 +0,0 @@
-/**
- * Bindings instrumentation for Cloudflare Workers
- * Auto-instrument KV, R2, D1, Service Bindings, and more
- */
-
-export {
-  instrumentKV,
-  instrumentR2,
-  instrumentD1,
-  instrumentServiceBinding,
-  instrumentBindings,
-} from './bindings';
-export { instrumentAI } from './ai';
-export { instrumentVectorize } from './vectorize';
-export { instrumentHyperdrive } from './hyperdrive';
-export { instrumentQueueProducer } from './queue-producer';
-export { instrumentAnalyticsEngine } from './analytics-engine';
-export { instrumentImages } from './images';
-export { instrumentRateLimiter } from './rate-limiter';
-export { instrumentBrowserRendering } from './browser-rendering';

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

@@ -1,224 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { instrumentQueueProducer } from './queue-producer';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-
-describe('Queue Producer Binding Instrumentation', () => {
-  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();
-  });
-
-  function createMockQueue(overrides: Partial<Queue> = {}): Queue {
-    return {
-      send: vi.fn(async () => ({ messageId: 'msg-123', outcome: 'ok' })),
-      sendBatch: vi.fn(async () => ({})),
-      ...overrides,
-    } as unknown as Queue;
-  }
-
-  describe('send()', () => {
-    it('should create span with PRODUCER kind and correct attributes', async () => {
-      const mockQueue = createMockQueue();
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      await instrumented.send({ data: 'test-payload' });
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('Queue my-queue: send');
-      expect(options.kind).toBe(SpanKind.PRODUCER);
-      expect(options.attributes['messaging.system']).toBe('cloudflare-queues');
-      expect(options.attributes['messaging.operation.type']).toBe('publish');
-      expect(options.attributes['messaging.operation']).toBe('send');
-      expect(options.attributes['messaging.destination.name']).toBe('my-queue');
-    });
-
-    it('should record messageId from result when available', async () => {
-      const mockQueue = createMockQueue({
-        send: vi.fn(async () => ({ messageId: 'msg-456', outcome: 'ok' })) as any,
-      });
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      await instrumented.send({ data: 'test-payload' });
-
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('messaging.message.id', 'msg-456');
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should not set messageId attribute when result has no messageId', async () => {
-      const mockQueue = createMockQueue({
-        send: vi.fn(async () => ({})) as any,
-      });
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      await instrumented.send({ data: 'test-payload' });
-
-      // setAttr uses the common helper which skips undefined/null values
-      const messageIdCalls = mockSpan.setAttribute.mock.calls.filter(
-        (call: any) => call[0] === 'messaging.message.id'
-      );
-      expect(messageIdCalls.length).toBe(0);
-    });
-
-    it('should handle errors in send()', async () => {
-      const sendError = new Error('Queue full');
-      const mockQueue = createMockQueue({
-        send: vi.fn(async () => {
-          throw sendError;
-        }) as any,
-      });
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      await expect(instrumented.send({ data: 'test-payload' })).rejects.toThrow('Queue full');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(sendError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Queue full',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should use default queue name when none provided', async () => {
-      const mockQueue = createMockQueue();
-      const instrumented = instrumentQueueProducer(mockQueue);
-
-      await instrumented.send({ data: 'test-payload' });
-
-      const [spanName, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('Queue queue: send');
-      expect(options.attributes['messaging.destination.name']).toBe('queue');
-    });
-  });
-
-  describe('sendBatch()', () => {
-    it('should create span with batch_message_count', async () => {
-      const mockQueue = createMockQueue();
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      const messages = [
-        { body: { data: 'msg-1' } },
-        { body: { data: 'msg-2' } },
-        { body: { data: 'msg-3' } },
-      ];
-
-      await instrumented.sendBatch(messages);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('Queue my-queue: sendBatch');
-      expect(options.kind).toBe(SpanKind.PRODUCER);
-      expect(options.attributes['messaging.system']).toBe('cloudflare-queues');
-      expect(options.attributes['messaging.operation.type']).toBe('publish');
-      expect(options.attributes['messaging.operation']).toBe('sendBatch');
-      expect(options.attributes['messaging.destination.name']).toBe('my-queue');
-      expect(options.attributes['messaging.batch.message_count']).toBe(3);
-    });
-
-    it('should set OK status and end span on success', async () => {
-      const mockQueue = createMockQueue();
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      await instrumented.sendBatch([{ body: { data: 'msg-1' } }]);
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle errors in sendBatch()', async () => {
-      const batchError = new Error('Batch limit exceeded');
-      const mockQueue = createMockQueue({
-        sendBatch: vi.fn(async () => {
-          throw batchError;
-        }) as any,
-      });
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      const messages = [{ body: { data: 'msg-1' } }, { body: { data: 'msg-2' } }];
-
-      await expect(instrumented.sendBatch(messages)).rejects.toThrow('Batch limit exceeded');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(batchError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Batch limit exceeded',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  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();
-      (mockQueue as any).customProp = 'test-value';
-
-      const instrumented = instrumentQueueProducer(mockQueue, 'my-queue');
-
-      expect((instrumented as any).customProp).toBe('test-value');
-    });
-  });
-});