autotel-cloudflare 3.0.0 → 4.0.0

package/src/handlers/durable-objects.ts

@@ -1,250 +0,0 @@
-/**
- * Durable Objects instrumentation for Cloudflare Workers
- * 
- * Note: This file uses Cloudflare Workers types (DurableObjectId, DurableObjectState, etc.)
- * which are globally available via @cloudflare/workers-types when listed in tsconfig.json.
- * These types are devDependencies only - they're not runtime dependencies.
- * At runtime, Cloudflare Workers runtime provides the actual implementations.
- */
-
-import {
-  trace,
-  context as api_context,
-  propagation,
-  SpanStatusCode,
-  SpanKind,
-} from '@opentelemetry/api';
-import type { ConfigurationOption } from 'autotel-edge';
-import { createInitialiser, setConfig, WorkerTracer } from 'autotel-edge';
-import { wrap } from '../bindings/common';
-
-// Durable Object types
-type DOFetchFn = (request: Request) => Response | Promise<Response>;
-type DOAlarmFn = () => void | Promise<void>;
-
-/**
- * Track cold starts per DO class
- */
-const coldStarts = new WeakMap<any, boolean>();
-
-function isColdStart(doClass: any): boolean {
-  if (!coldStarts.has(doClass)) {
-    coldStarts.set(doClass, true);
-    return true;
-  }
-  return false;
-}
-
-/**
- * Instrument a Durable Object fetch method
- */
-function instrumentDOFetch(
-  fetchFn: DOFetchFn,
-  id: DurableObjectId,
-  doClass: any,
-): DOFetchFn {
-  return async function instrumentedFetch(
-    this: any,
-    request: Request,
-  ): Promise<Response> {
-    const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-    // Extract parent context from request headers
-    const parentContext = propagation.extract(
-      api_context.active(),
-      request.headers,
-    );
-
-    const url = new URL(request.url);
-    const spanName = `DO ${id.name || id.toString()}: ${request.method} ${url.pathname}`;
-
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.SERVER,
-        attributes: {
-          'http.request.method': request.method,
-          'url.full': request.url,
-          'do.id': id.toString(),
-          'do.id.name': id.name || '',
-          'faas.trigger': 'http',
-          'faas.coldstart': isColdStart(doClass),
-        },
-      },
-      parentContext,
-      async (span) => {
-        try {
-          const response = await fetchFn.call(this, request);
-
-          span.setAttributes({
-            'http.response.status_code': response.status,
-          });
-
-          if (response.ok) {
-            span.setStatus({ code: SpanStatusCode.OK });
-          } else {
-            span.setStatus({ code: SpanStatusCode.ERROR });
-          }
-
-          return response;
-        } 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();
-        }
-      },
-    );
-  };
-}
-
-/**
- * Instrument a Durable Object alarm method
- */
-function instrumentDOAlarm(
-  alarmFn: DOAlarmFn,
-  id: DurableObjectId,
-  doClass: any,
-): DOAlarmFn {
-  return async function instrumentedAlarm(this: any): Promise<void> {
-    const tracer = trace.getTracer('autotel-edge') as WorkerTracer;
-
-    const spanName = `DO ${id.name || id.toString()}: alarm`;
-
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.INTERNAL,
-        attributes: {
-          'do.id': id.toString(),
-          'do.id.name': id.name || '',
-          'faas.trigger': 'timer',
-          'faas.coldstart': isColdStart(doClass),
-        },
-      },
-      async (span) => {
-        try {
-          await alarmFn.call(this);
-          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();
-        }
-      },
-    );
-  };
-}
-
-/**
- * Instrument a Durable Object instance
- */
-function instrumentDOInstance(
-  doInstance: any,
-  state: DurableObjectState,
-  _env: any,
-  doClass: any,
-): any {
-  const instanceHandler: ProxyHandler<any> = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-
-      if (prop === 'fetch' && typeof value === 'function') {
-        return instrumentDOFetch(value.bind(target), state.id, doClass);
-      }
-
-      if (prop === 'alarm' && typeof value === 'function') {
-        return instrumentDOAlarm(value.bind(target), state.id, doClass);
-      }
-
-      // Bind other methods to the target
-      if (typeof value === 'function') {
-        return value.bind(target);
-      }
-
-      return value;
-    },
-  };
-
-  return wrap(doInstance, instanceHandler);
-}
-
-/**
- * Instrument a Durable Object class
- *
- * This wraps the DO class to automatically trace all fetch and alarm calls,
- * as well as initialize the telemetry configuration.
- *
- * **Usage:**
- * ```typescript
- * import { DurableObject } from 'cloudflare:workers'
- * import { instrumentDO } from 'autotel-edge'
- *
- * export class Counter extends DurableObject<Env> {
- *   async fetch(request: Request) {
- *     // Your DO logic here
- *     return new Response('OK')
- *   }
- * }
- *
- * // Wrap the class before exporting
- * export const CounterDO = instrumentDO(Counter, (env: Env) => ({
- *   exporter: {
- *     url: env.OTLP_ENDPOINT,
- *     headers: { 'x-api-key': env.API_KEY }
- *   },
- *   service: {
- *     name: 'my-durable-object',
- *     version: '1.0.0'
- *   }
- * }))
- * ```
- *
- * **What you get:**
- * - 🎯 Automatic spans for fetch() calls with HTTP attributes
- * - ⏰ Automatic spans for alarm() calls
- * - 🥶 Cold start tracking
- * - 🔗 Context propagation from incoming requests
- * - ⚡ Automatic span lifecycle management
- *
- * @param doClass - The Durable Object class to instrument
- * @param config - Configuration or configuration function
- * @returns Instrumented Durable Object class
- */
-export function instrumentDO<C extends new (state: DurableObjectState, env: any) => any>(
-  doClass: C,
-  config: ConfigurationOption,
-): C {
-  const initialiser = createInitialiser(config);
-
-  const classHandler: ProxyHandler<C> = {
-    construct(target, [state, env]: [DurableObjectState, any]) {
-      // Initialize config for this DO instance
-      const trigger = {
-        id: state.id.toString(),
-        name: state.id.name,
-      };
-      const doConfig = initialiser(env, trigger);
-      const context = setConfig(doConfig);
-
-      // Create the DO instance within the config context
-      const doInstance = api_context.with(context, () => {
-        return new target(state, env);
-      });
-
-      // Instrument the instance
-      return instrumentDOInstance(doInstance, state, env, doClass);
-    },
-  };
-
-  return wrap(doClass, classHandler);
-}

package/src/handlers/index.ts

@@ -1,6 +0,0 @@
-/**
- * Handler instrumentation for Cloudflare Workers
- */
-
-export { instrumentDO } from './durable-objects';
-export { instrumentWorkflow } from './workflows';

package/src/handlers/workflows.test.ts

@@ -1,411 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { instrumentWorkflow } from './workflows';
-import { getWorkflowLogger } from '../execution-logger';
-import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-
-describe('Workflow 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(),
-      addLink: vi.fn(),
-      addLinks: vi.fn(),
-    };
-
-    mockTracer = {
-      startActiveSpan: vi.fn((name, options, context, fn) => {
-        if (typeof options === 'function') return options(mockSpan);
-        if (typeof context === 'function') return context(mockSpan);
-        if (typeof fn === 'function') return fn(mockSpan);
-        return Promise.resolve();
-      }),
-    };
-
-    getTracerSpy = vi.spyOn(trace, 'getTracer').mockReturnValue(mockTracer as any);
-  });
-
-  afterEach(() => {
-    getTracerSpy.mockRestore();
-  });
-
-  describe('instrumentWorkflow()', () => {
-    it('should wrap workflow class constructor', () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run() {}
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'test-workflow', {
-        service: { name: 'test' },
-      });
-
-      expect(Instrumented).toBeDefined();
-      expect(typeof Instrumented).toBe('function');
-    });
-
-    it('should create workflow instance with instrumented run()', () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run() { return 'done'; }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'test-workflow', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-
-      expect(instance).toBeDefined();
-      expect(typeof instance.run).toBe('function');
-    });
-
-    it('should accept static config', () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run() {}
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'test-workflow', {
-        service: { name: 'test', version: '1.0.0' },
-        exporter: { url: 'http://localhost:4318/v1/traces' },
-      });
-
-      expect(Instrumented).toBeDefined();
-    });
-
-    it('should accept config function', () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run() {}
-      }
-
-      interface Env {
-        OTLP_ENDPOINT: string;
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'test-workflow', (env: Env) => ({
-        service: { name: 'test' },
-        exporter: { url: env.OTLP_ENDPOINT },
-      }));
-
-      expect(Instrumented).toBeDefined();
-    });
-  });
-
-  describe('run() instrumentation', () => {
-    it('should preserve run() return value', async () => {
-      const output = { status: 'ok', orderId: 'ord-123' };
-
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {
-          return output;
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'return-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-return' };
-      const step = { do: vi.fn(), sleep: vi.fn(), sleepUntil: vi.fn() };
-
-      await expect(instance.run(event, step)).resolves.toEqual(output);
-    });
-
-    it('should create span for run() with workflow attributes', async () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {}
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'test-workflow', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: { foo: 'bar' }, timestamp: new Date(), instanceId: 'wf-123' };
-      const step = { do: vi.fn(), sleep: vi.fn(), sleepUntil: vi.fn() };
-
-      await instance.run(event, step);
-
-      expect(mockTracer.startActiveSpan).toHaveBeenCalled();
-
-      const spanName = mockTracer.startActiveSpan.mock.calls[0][0];
-      expect(spanName).toBe('Workflow test-workflow: run');
-
-      const options = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(options.kind).toBe(SpanKind.INTERNAL);
-      expect(options.attributes['workflow.name']).toBe('test-workflow');
-      expect(options.attributes['workflow.instance_id']).toBe('wf-123');
-      expect(options.attributes['faas.trigger']).toBe('workflow');
-    });
-
-    it('should track cold starts', async () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {}
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'cold-test', {
-        service: { name: 'test' },
-      });
-
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-1' };
-      const step = { do: vi.fn(), sleep: vi.fn(), sleepUntil: vi.fn() };
-
-      const instance1 = new Instrumented({}, {});
-      await instance1.run(event, step);
-      const firstOptions = mockTracer.startActiveSpan.mock.calls[0][1];
-      expect(firstOptions.attributes['faas.coldstart']).toBe(true);
-
-      const instance2 = new Instrumented({}, {});
-      await instance2.run(event, step);
-      const secondOptions = mockTracer.startActiveSpan.mock.calls[1][1];
-      expect(secondOptions.attributes['faas.coldstart']).toBe(false);
-    });
-
-    it('should handle run() errors', async () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run() {
-          throw new Error('Workflow failed');
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'error-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-err' };
-      const step = { do: vi.fn(), sleep: vi.fn(), sleepUntil: vi.fn() };
-
-      await expect(instance.run(event, step)).rejects.toThrow('Workflow failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: SpanStatusCode.ERROR,
-        message: 'Workflow failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('should make getWorkflowLogger() available inside run()', async () => {
-      const getActiveSpanSpy = vi
-        .spyOn(trace, 'getActiveSpan')
-        .mockReturnValue(mockSpan as any);
-
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run() {
-          const log = getWorkflowLogger();
-          log.set({ workflow: { id: 'wf-logger' } });
-          log.info('workflow started', { provider: { name: 'curvepay' } });
-          return log.emitNow({ outcome: 'running' });
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'logger-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-logger' };
-      const step = { do: vi.fn(), sleep: vi.fn(), sleepUntil: vi.fn() };
-
-      const snapshot = await instance.run(event, step);
-
-      expect(snapshot).toMatchObject({
-        traceId: 'test-trace-id',
-        spanId: 'test-span-id',
-        context: {
-          workflow: { id: 'wf-logger' },
-          outcome: 'running',
-        },
-      });
-      expect(mockSpan.setAttributes).toHaveBeenCalledWith({
-        'workflow.id': 'wf-logger',
-      });
-      expect(mockSpan.addEvent).toHaveBeenCalledWith('log.info', {
-        message: 'workflow started',
-        'provider.name': 'curvepay',
-      });
-
-      getActiveSpanSpy.mockRestore();
-    });
-  });
-
-  describe('step.do() instrumentation', () => {
-    it('should create span for step.do() calls', async () => {
-      const stepDoResult = { paymentId: 'pay_123' };
-      const mockStepDo = vi.fn().mockResolvedValue(stepDoResult);
-
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {
-          return await step.do('process payment', async () => stepDoResult);
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'step-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-step' };
-      const step = {
-        do: vi.fn(async (_name: string, cb: () => Promise<any>) => cb()),
-        sleep: vi.fn(),
-        sleepUntil: vi.fn(),
-      };
-
-      await instance.run(event, step);
-
-      // Should have spans for both run() and step.do()
-      expect(mockTracer.startActiveSpan.mock.calls.length).toBeGreaterThanOrEqual(2);
-
-      const stepSpanCall = mockTracer.startActiveSpan.mock.calls[1];
-      expect(stepSpanCall[0]).toBe('Workflow step-test: process payment');
-      expect(stepSpanCall[1].attributes['workflow.step.name']).toBe('process payment');
-      expect(stepSpanCall[1].attributes['workflow.name']).toBe('step-test');
-    });
-
-    it('should handle step.do() errors', async () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {
-          await step.do('failing step', async () => {
-            throw new Error('Step failed');
-          });
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'step-err', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-step-err' };
-      const step = {
-        do: vi.fn(async (_name: string, cb: () => Promise<any>) => cb()),
-        sleep: vi.fn(),
-        sleepUntil: vi.fn(),
-      };
-
-      await expect(instance.run(event, step)).rejects.toThrow('Step failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalled();
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('step.sleep() instrumentation', () => {
-    it('should create span for step.sleep() calls', async () => {
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {
-          await step.sleep('wait for settlement', '2 hours');
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'sleep-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-sleep' };
-      const step = {
-        do: vi.fn(),
-        sleep: vi.fn().mockResolvedValue(undefined),
-        sleepUntil: vi.fn(),
-      };
-
-      await instance.run(event, step);
-
-      const sleepSpanCall = mockTracer.startActiveSpan.mock.calls[1];
-      expect(sleepSpanCall[0]).toBe('Workflow sleep-test: sleep wait for settlement');
-      expect(sleepSpanCall[1].attributes['workflow.sleep.name']).toBe('wait for settlement');
-      expect(sleepSpanCall[1].attributes['workflow.sleep.duration']).toBe('2 hours');
-      expect(sleepSpanCall[1].attributes['workflow.name']).toBe('sleep-test');
-    });
-
-    it('should create span for step.sleepUntil() calls', async () => {
-      const wakeAt = new Date('2026-04-09T10:00:00.000Z');
-
-      class TestWorkflow {
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {
-          await step.sleepUntil('wait until tomorrow', wakeAt);
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'sleep-until-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-sleep-until' };
-      const step = {
-        do: vi.fn(),
-        sleep: vi.fn(),
-        sleepUntil: vi.fn().mockResolvedValue(undefined),
-      };
-
-      await instance.run(event, step);
-
-      const sleepUntilSpanCall = mockTracer.startActiveSpan.mock.calls[1];
-      expect(sleepUntilSpanCall[0]).toBe(
-        'Workflow sleep-until-test: sleepUntil wait until tomorrow',
-      );
-      expect(sleepUntilSpanCall[1].attributes['workflow.sleep.name']).toBe(
-        'wait until tomorrow',
-      );
-      expect(sleepUntilSpanCall[1].attributes['workflow.sleep.until']).toBe(
-        '2026-04-09T10:00:00.000Z',
-      );
-      expect(sleepUntilSpanCall[1].attributes['workflow.name']).toBe(
-        'sleep-until-test',
-      );
-    });
-  });
-
-  describe('this binding', () => {
-    it('should preserve this context in run()', async () => {
-      class TestWorkflow {
-        private value = 42;
-        constructor(public ctx: any, public env: any) {}
-        async run(event: any, step: any) {
-          return this.value;
-        }
-      }
-
-      const Instrumented = instrumentWorkflow(TestWorkflow, 'this-test', {
-        service: { name: 'test' },
-      });
-
-      const instance = new Instrumented({}, {});
-      const event = { payload: {}, timestamp: new Date(), instanceId: 'wf-this' };
-      const step = { do: vi.fn(), sleep: vi.fn(), sleepUntil: vi.fn() };
-
-      // Should not throw — this.value should be accessible
-      await expect(instance.run(event, step)).resolves.not.toThrow();
-    });
-  });
-});