autotel-cloudflare 3.1.0 → 4.0.1

package/src/bindings/ai.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { instrumentAI } from './ai';
-
-describe('AI Binding Instrumentation', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: any;
-  let mockAI: 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);
-
-    mockAI = {
-      run: vi.fn(async () => ({ response: 'Hello world' })),
-      someOtherMethod: vi.fn(() => 'passthrough'),
-      someProperty: 'test-value',
-    };
-  });
-
-  afterEach(() => {
-    getTracerSpy.mockRestore();
-  });
-
-  describe('instrumentAI()', () => {
-    it('should wrap AI binding with proxy', () => {
-      const instrumented = instrumentAI(mockAI);
-
-      expect(instrumented).not.toBe(mockAI);
-      expect(typeof instrumented.run).toBe('function');
-    });
-
-    it('should create span with correct name and attributes for run()', async () => {
-      const instrumented = instrumentAI(mockAI, 'my-ai');
-
-      await instrumented.run('@cf/meta/llama-2-7b-chat-int8', { prompt: 'Hello' });
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, options] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('AI my-ai: run @cf/meta/llama-2-7b-chat-int8');
-      expect(options.kind).toBe(SpanKind.CLIENT);
-      expect(options.attributes['gen_ai.provider.name']).toBe('cloudflare-workers-ai');
-      expect(options.attributes['gen_ai.operation.name']).toBe('run');
-      expect(options.attributes['gen_ai.request.model']).toBe('@cf/meta/llama-2-7b-chat-int8');
-    });
-
-    it('should use default binding name "ai" when no name is provided', async () => {
-      const instrumented = instrumentAI(mockAI);
-
-      await instrumented.run('@cf/meta/llama-2-7b-chat-int8', { prompt: 'Hello' });
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('AI ai: run @cf/meta/llama-2-7b-chat-int8');
-    });
-
-    it('should record token usage when result has usage.prompt_tokens and usage.completion_tokens', async () => {
-      mockAI.run = vi.fn(async () => ({
-        response: 'Hello world',
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 25,
-        },
-      }));
-
-      const instrumented = instrumentAI(mockAI);
-
-      await instrumented.run('@cf/meta/llama-2-7b-chat-int8', { prompt: 'Hello' });
-
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('gen_ai.usage.input_tokens', 10);
-      expect(mockSpan.setAttribute).toHaveBeenCalledWith('gen_ai.usage.output_tokens', 25);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should NOT set token attributes when usage is not present', async () => {
-      mockAI.run = vi.fn(async () => ({
-        response: 'Hello world',
-      }));
-
-      const instrumented = instrumentAI(mockAI);
-
-      await instrumented.run('@cf/meta/llama-2-7b-chat-int8', { prompt: 'Hello' });
-
-      expect(mockSpan.setAttribute).not.toHaveBeenCalledWith(
-        'gen_ai.usage.input_tokens',
-        expect.anything(),
-      );
-      expect(mockSpan.setAttribute).not.toHaveBeenCalledWith(
-        'gen_ai.usage.output_tokens',
-        expect.anything(),
-      );
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle errors correctly', async () => {
-      const testError = new Error('AI model failed');
-      mockAI.run = vi.fn(async () => {
-        throw testError;
-      });
-
-      const instrumented = instrumentAI(mockAI);
-
-      await expect(
-        instrumented.run('@cf/meta/llama-2-7b-chat-int8', { prompt: 'Hello' }),
-      ).rejects.toThrow('AI model failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'AI model failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should invoke run() with original object as this, not the proxy', async () => {
-      let receivedThis: any;
-      const mockAIObj = {
-        run: vi.fn(async function(this: any) {
-          // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-          receivedThis = this;
-          return { response: 'Hello' };
-        }),
-      };
-      const instrumented = instrumentAI(mockAIObj as any, 'test');
-      await instrumented.run('@cf/meta/llama-2-7b-chat-int8', { prompt: 'Hello' });
-      expect(receivedThis).toBe(mockAIObj);
-    });
-
-    it('should pass through non-instrumented methods unchanged', () => {
-      const instrumented = instrumentAI(mockAI);
-
-      const result = instrumented.someOtherMethod();
-
-      expect(result).toBe('passthrough');
-      expect(mockAI.someOtherMethod).toHaveBeenCalled();
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-
-    it('should pass through non-instrumented properties unchanged', () => {
-      const instrumented = instrumentAI(mockAI);
-
-      expect(instrumented.someProperty).toBe('test-value');
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/bindings/ai.ts

@@ -1,73 +0,0 @@
-/**
- * Workers AI binding instrumentation
- */
-
-import {
-  trace,
-  SpanKind,
-  SpanStatusCode,
-} from '@opentelemetry/api';
-import type { WorkerTracer } from 'autotel-edge';
-import { wrap, setAttr } from './common';
-
-/**
- * Instrument Workers AI binding
- */
-export function instrumentAI<T extends Ai>(ai: T, bindingName?: string): T {
-  const name = bindingName || 'ai';
-
-  const handler: ProxyHandler<T> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (prop === 'run' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const [model] = args as [string, unknown, unknown];
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            return tracer.startActiveSpan(
-              `AI ${name}: run ${model}`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                  // Canonical GenAI provider attribute (replaces deprecated
-                  // `gen_ai.system`).
-                  'gen_ai.provider.name': 'cloudflare-workers-ai',
-                  'gen_ai.operation.name': 'run',
-                  'gen_ai.request.model': model,
-                },
-              },
-              async (span) => {
-                try {
-                  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));
-                  }
-                  if (result?.usage?.completion_tokens !== undefined) {
-                    setAttr(span, 'gen_ai.usage.output_tokens', Number(result.usage.completion_tokens));
-                  }
-                  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(ai, handler);
-}

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

@@ -1,175 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { instrumentAnalyticsEngine } from './analytics-engine';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-
-describe('Analytics Engine Instrumentation', () => {
-  let mockTracer: any;
-  let mockSpan: any;
-  let getTracerSpy: any;
-  let mockAE: 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);
-
-    mockAE = {
-      writeDataPoint: vi.fn(),
-      someOtherMethod: vi.fn(() => 'passthrough-value'),
-    };
-  });
-
-  afterEach(() => {
-    getTracerSpy.mockRestore();
-  });
-
-  describe('writeDataPoint()', () => {
-    it('should create span with correct attributes', () => {
-      const instrumented = instrumentAnalyticsEngine(mockAE, 'my-dataset');
-
-      instrumented.writeDataPoint({
-        indexes: ['idx1'],
-        doubles: [1, 2],
-        blobs: ['blob1'],
-      });
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const [spanName, spanOptions] = mockTracer.startActiveSpan.mock.calls[0];
-      expect(spanName).toBe('AnalyticsEngine my-dataset: writeDataPoint');
-      expect(spanOptions.kind).toBe(SpanKind.CLIENT);
-      expect(spanOptions.attributes['analytics.system']).toBe('cloudflare-analytics-engine');
-      expect(spanOptions.attributes['analytics.operation']).toBe('writeDataPoint');
-    });
-
-    it('should record indexes_count, doubles_count, blobs_count', () => {
-      const instrumented = instrumentAnalyticsEngine(mockAE, 'my-dataset');
-
-      instrumented.writeDataPoint({
-        indexes: ['idx1', 'idx2'],
-        doubles: [1, 2, 3],
-        blobs: ['blob1'],
-      });
-
-      const spanOptions = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(spanOptions.attributes['analytics.indexes_count']).toBe(2);
-      expect(spanOptions.attributes['analytics.doubles_count']).toBe(3);
-      expect(spanOptions.attributes['analytics.blobs_count']).toBe(1);
-    });
-
-    it('should handle a single index (non-array) by recording indexes_count as 1', () => {
-      const instrumented = instrumentAnalyticsEngine(mockAE, 'my-dataset');
-
-      instrumented.writeDataPoint({
-        indexes: 'single-index' as any,
-      });
-
-      const spanOptions = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(spanOptions.attributes['analytics.indexes_count']).toBe(1);
-    });
-
-    it('should work with no datapoint argument', () => {
-      const instrumented = instrumentAnalyticsEngine(mockAE);
-
-      instrumented.writeDataPoint(undefined as any);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalledTimes(1);
-
-      const spanOptions = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(spanOptions.attributes['analytics.system']).toBe('cloudflare-analytics-engine');
-      expect(spanOptions.attributes['analytics.operation']).toBe('writeDataPoint');
-      // No count attributes should be set when no datapoint
-      expect(spanOptions.attributes['analytics.indexes_count']).toBeUndefined();
-      expect(spanOptions.attributes['analytics.doubles_count']).toBeUndefined();
-      expect(spanOptions.attributes['analytics.blobs_count']).toBeUndefined();
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should handle errors by recording exception and rethrowing', () => {
-      const error = new Error('writeDataPoint failed');
-      mockAE.writeDataPoint = vi.fn(() => {
-        throw error;
-      });
-
-      const instrumented = instrumentAnalyticsEngine(mockAE, 'my-dataset');
-
-      expect(() => instrumented.writeDataPoint({ indexes: ['idx1'] })).toThrow('writeDataPoint failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(error);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'writeDataPoint failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should use default dataset name when none provided', () => {
-      const instrumented = instrumentAnalyticsEngine(mockAE);
-
-      instrumented.writeDataPoint({ indexes: ['idx1'] });
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('AnalyticsEngine analytics-engine: writeDataPoint');
-    });
-
-    it('should set OK status and end span on success', () => {
-      const instrumented = instrumentAnalyticsEngine(mockAE, 'my-dataset');
-
-      instrumented.writeDataPoint({ doubles: [42] });
-
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.OK });
-      expect(mockSpan.end).toHaveBeenCalled();
-      expect(mockAE.writeDataPoint).toHaveBeenCalledWith({ doubles: [42] });
-    });
-  });
-
-  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');
-
-      const result = instrumented.someOtherMethod();
-
-      expect(result).toBe('passthrough-value');
-      expect(mockAE.someOtherMethod).toHaveBeenCalled();
-      // No span should be created for non-instrumented methods
-      expect(mockTracer.startActiveSpan).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/bindings/analytics-engine.ts

@@ -1,78 +0,0 @@
-/**
- * Analytics Engine binding instrumentation
- */
-
-import {
-  trace,
-  SpanKind,
-  SpanStatusCode,
-} from '@opentelemetry/api';
-import type { WorkerTracer } from 'autotel-edge';
-import { wrap } from './common';
-
-/**
- * Instrument Analytics Engine binding
- */
-export function instrumentAnalyticsEngine<T extends AnalyticsEngineDataset>(ae: T, datasetName?: string): T {
-  const name = datasetName || 'analytics-engine';
-
-  const handler: ProxyHandler<T> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (prop === 'writeDataPoint' && typeof value === 'function') {
-        return new Proxy(value, {
-          apply: (fnTarget, _thisArg, args) => {
-            const [dataPoint] = args as [AnalyticsEngineDataPoint | undefined];
-            const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-            const attributes: Record<string, string | number> = {
-              'analytics.system': 'cloudflare-analytics-engine',
-              'analytics.operation': 'writeDataPoint',
-            };
-
-            if (dataPoint) {
-              if (dataPoint.indexes) {
-                attributes['analytics.indexes_count'] = Array.isArray(dataPoint.indexes) ? dataPoint.indexes.length : 1;
-              }
-              if (dataPoint.doubles) {
-                attributes['analytics.doubles_count'] = dataPoint.doubles.length;
-              }
-              if (dataPoint.blobs) {
-                attributes['analytics.blobs_count'] = dataPoint.blobs.length;
-              }
-            }
-
-            return tracer.startActiveSpan(
-              `AnalyticsEngine ${name}: writeDataPoint`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes,
-              },
-              (span) => {
-                try {
-                  // writeDataPoint is synchronous/void
-                  Reflect.apply(fnTarget, target, args);
-                  span.setStatus({ code: SpanStatusCode.OK });
-                } 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(ae, handler);
-}

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

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