autotel-edge 3.17.0 → 3.17.2

package/src/composition.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import {
-  composePostProcessors,
-  composeSpanProcessors,
-  composeSubscribers,
-  defineConfig,
-} from './composition';
-import type { EdgeEvent, EdgeSubscriber, PostProcessorFn, ReadableSpan } from './types';
-
-function makeSpan(name: string): ReadableSpan {
-  return { name } as unknown as ReadableSpan;
-}
-
-describe('defineConfig', () => {
-  it('returns its argument unchanged', () => {
-    const config = defineConfig({
-      service: { name: 'svc' },
-      exporter: { url: 'https://otlp.example' },
-    });
-    expect(config.service.name).toBe('svc');
-  });
-});
-
-describe('composeSubscribers', () => {
-  it('runs subscribers in order', async () => {
-    const calls: string[] = [];
-    const a: EdgeSubscriber = () => {
-      calls.push('a');
-    };
-    const b: EdgeSubscriber = () => {
-      calls.push('b');
-    };
-
-    await composeSubscribers([a, b])({ kind: 'span.start' } as EdgeEvent);
-    expect(calls).toEqual(['a', 'b']);
-  });
-
-  it('isolates errors so later subscribers still run', async () => {
-    const calls: string[] = [];
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    const a: EdgeSubscriber = () => {
-      throw new Error('boom');
-    };
-    const b: EdgeSubscriber = () => {
-      calls.push('b');
-    };
-
-    await composeSubscribers([a, b])({ kind: 'span.start' } as EdgeEvent);
-
-    expect(calls).toEqual(['b']);
-    expect(consoleSpy).toHaveBeenCalled();
-    consoleSpy.mockRestore();
-  });
-});
-
-describe('composePostProcessors', () => {
-  it('threads spans through each processor', () => {
-    const tag: PostProcessorFn = (spans) =>
-      spans.map((s) => ({ ...s, name: `${s.name}!` } as ReadableSpan));
-    const drop: PostProcessorFn = (spans) => spans.filter((s) => s.name !== 'b!');
-
-    const result = composePostProcessors([tag, drop])([
-      makeSpan('a'),
-      makeSpan('b'),
-    ]);
-
-    expect(result.map((s) => s.name)).toEqual(['a!']);
-  });
-
-  it('skips a failing processor and continues with the previous output', () => {
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    const ok: PostProcessorFn = (spans) => spans;
-    const broken: PostProcessorFn = () => {
-      throw new Error('bad');
-    };
-
-    const result = composePostProcessors([ok, broken, ok])([makeSpan('keep')]);
-
-    expect(result.map((s) => s.name)).toEqual(['keep']);
-    expect(consoleSpy).toHaveBeenCalled();
-    consoleSpy.mockRestore();
-  });
-});
-
-describe('composeSpanProcessors', () => {
-  it('forwards onStart/onEnd to every processor', () => {
-    const a = {
-      onStart: vi.fn(),
-      onEnd: vi.fn(),
-      forceFlush: vi.fn().mockResolvedValue(undefined),
-      shutdown: vi.fn().mockResolvedValue(undefined),
-    };
-    const b = { ...a, onStart: vi.fn(), onEnd: vi.fn() };
-
-    const composed = composeSpanProcessors([a as any, b as any]);
-    composed.onStart({} as any, {} as any);
-    composed.onEnd({} as any);
-
-    expect(a.onStart).toHaveBeenCalled();
-    expect(b.onStart).toHaveBeenCalled();
-    expect(a.onEnd).toHaveBeenCalled();
-    expect(b.onEnd).toHaveBeenCalled();
-  });
-
-  it('awaits all forceFlush results even when one rejects', async () => {
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    const a = {
-      onStart: vi.fn(),
-      onEnd: vi.fn(),
-      forceFlush: vi.fn().mockRejectedValue(new Error('flush fail')),
-      shutdown: vi.fn().mockResolvedValue(undefined),
-    };
-    const b = {
-      onStart: vi.fn(),
-      onEnd: vi.fn(),
-      forceFlush: vi.fn().mockResolvedValue(undefined),
-      shutdown: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const composed = composeSpanProcessors([a as any, b as any]);
-    await composed.forceFlush!();
-
-    expect(a.forceFlush).toHaveBeenCalled();
-    expect(b.forceFlush).toHaveBeenCalled();
-    consoleSpy.mockRestore();
-  });
-});

package/src/composition.ts

@@ -1,132 +0,0 @@
-/**
- * Composition helpers for building autotel pipelines from small, testable parts.
- *
- * The motivation is the same as for any pipeline library: you can author
- * subscribers, post-processors and span processors as standalone units and
- * stitch them together at config-construction time without inventing ad-hoc
- * wrappers in every package.
- *
- * None of these helpers change runtime behaviour by themselves — they only
- * combine functions / processors that already work in isolation.
- */
-import type { Span } from '@opentelemetry/api';
-import type { ReadableSpan as SdkReadableSpan, SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import type {
-  EdgeConfig,
-  EdgeEvent,
-  EdgeSubscriber,
-  PostProcessorFn,
-  ReadableSpan as EdgeReadableSpan,
-  ResolveConfigFn,
-} from './types';
-
-type Awaitable<T> = T | Promise<T>;
-
-/**
- * Identity helper for authoring an autotel configuration once with full
- * type-checking. Mirrors `defineConfig` patterns in tools like Vite / Vitest.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'autotel-edge'
- *
- * export const otelConfig = defineConfig({
- *   service: { name: 'checkout' },
- *   exporter: { url: process.env.OTLP_URL! },
- * })
- * ```
- */
-export function defineConfig<T extends EdgeConfig | ResolveConfigFn>(config: T): T {
-  return config;
-}
-
-/**
- * Run a list of subscribers in registration order. Errors thrown by an
- * individual subscriber are caught and logged so a buggy subscriber never
- * blocks the others — important because `subscribers` is the primary
- * extensibility point for in-process side effects.
- */
-export function composeSubscribers(
-  subscribers: Array<EdgeSubscriber>,
-  options: { name?: string } = {},
-): EdgeSubscriber {
-  const label = options.name ?? 'compose-subscribers';
-  return async (event: EdgeEvent) => {
-    for (const subscriber of subscribers) {
-      try {
-        await subscriber(event);
-      } catch (err) {
-        console.error(`[autotel-edge/${label}] subscriber failed:`, err);
-      }
-    }
-  };
-}
-
-/**
- * Chain post-processors so each one sees the output of the previous one.
- * This matches the standard OTel post-processor contract: take spans, return
- * spans (possibly filtered, redacted, or annotated).
- */
-export function composePostProcessors(
-  processors: Array<PostProcessorFn>,
-): PostProcessorFn {
-  return (spans: EdgeReadableSpan[]) => {
-    let current = spans;
-    for (const processor of processors) {
-      try {
-        current = processor(current);
-      } catch (err) {
-        console.error('[autotel-edge/compose-post-processors] failed:', err);
-      }
-    }
-    return current;
-  };
-}
-
-/**
- * Fan out span lifecycle events to multiple span processors. Any single
- * processor's failure is isolated so it cannot break the others.
- *
- * Useful when you want to attach, say, a sampling processor + a custom
- * attribute redactor + the default batch processor without having to author a
- * single processor that knows about all three.
- */
-export function composeSpanProcessors(processors: SpanProcessor[]): SpanProcessor {
-  const safe = (label: string, fn: () => Awaitable<void>) =>
-    Promise.resolve()
-      .then(fn)
-      .catch((err) => {
-        console.error(`[autotel-edge/compose-span-processors:${label}]`, err);
-      });
-
-  return {
-    onStart(span: Span, parentContext) {
-      for (const processor of processors) {
-        try {
-          processor.onStart(span as unknown as SdkReadableSpan & Span, parentContext);
-        } catch (err) {
-          console.error('[autotel-edge/compose-span-processors:onStart]', err);
-        }
-      }
-    },
-    onEnd(span: SdkReadableSpan) {
-      for (const processor of processors) {
-        try {
-          processor.onEnd(span);
-        } catch (err) {
-          console.error('[autotel-edge/compose-span-processors:onEnd]', err);
-        }
-      }
-    },
-    async forceFlush() {
-      await Promise.allSettled(
-        processors.map((p) => safe('forceFlush', () => p.forceFlush())),
-      );
-    },
-    async shutdown() {
-      await Promise.allSettled(
-        processors.map((p) => safe('shutdown', () => p.shutdown())),
-      );
-    },
-  } as SpanProcessor;
-}

package/src/core/buffer.ts

@@ -1,17 +0,0 @@
-/**
- * Buffer polyfill for edge environments
- *
- * Cloudflare Workers and other edge runtimes need the Buffer global
- * for OpenTelemetry OTLP serialization.
- */
-
-//@ts-ignore - node:buffer available in CF Workers with nodejs_compat
-import { Buffer } from 'node:buffer';
-
-//@ts-ignore
-globalThis.Buffer = Buffer;
-
-// Re-export the single imported binding. Importing AND re-exporting `Buffer`
-// from 'node:buffer' separately makes rolldown (tsdown) emit a dangling
-// `Buffer$1` reference, so keep exactly one binding.
-export { Buffer };

package/src/core/config.test.ts

@@ -1,413 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { parseConfig, createInitialiser, getActiveConfig, setConfig } from './config';
-import type { EdgeConfig } from '../types';
-import { context as api_context } from '@opentelemetry/api';
-
-describe('Config System', () => {
-  describe('parseConfig()', () => {
-    it('should parse minimal config (only service.name)', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.service.name).toBe('test-service');
-      expect(parsed.service.version).toBeUndefined();
-      expect(parsed.service.namespace).toBeUndefined();
-    });
-
-    it('should parse full service config', () => {
-      const config: EdgeConfig = {
-        service: {
-          name: 'test-service',
-          version: '1.2.3',
-          namespace: 'production',
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.service.name).toBe('test-service');
-      expect(parsed.service.version).toBe('1.2.3');
-      expect(parsed.service.namespace).toBe('production');
-    });
-
-    it('should parse exporter config (URL + headers)', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        exporter: {
-          url: 'https://api.honeycomb.io/v1/traces',
-          headers: { 'x-api-key': 'test-key' },
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.spanProcessors).toHaveLength(1);
-      expect(parsed.spanProcessors[0]).toBeDefined();
-    });
-
-    it('should create SpanProcessor from exporter', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        exporter: {
-          url: 'http://localhost:4318/v1/traces',
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.spanProcessors).toBeDefined();
-      expect(Array.isArray(parsed.spanProcessors)).toBe(true);
-      expect(parsed.spanProcessors.length).toBeGreaterThan(0);
-    });
-
-    it('should accept custom SpanProcessor array', () => {
-      const mockSpanProcessor = {
-        onStart: () => {},
-        onEnd: () => {},
-        forceFlush: async () => {},
-        shutdown: async () => {},
-      };
-
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        spanProcessors: [mockSpanProcessor as any],
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.spanProcessors).toHaveLength(1);
-      expect(parsed.spanProcessors[0]).toBe(mockSpanProcessor);
-    });
-
-    it('should use AlwaysOnSampler as default head sampler', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.sampling.headSampler).toBeDefined();
-      // Default is ParentBasedSampler with AlwaysOnSampler root
-      expect(parsed.sampling.headSampler.toString()).toContain('ParentBased');
-    });
-
-    it('should create ParentRatioSampler from ratio config', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        sampling: {
-          headSampler: {
-            ratio: 0.5,
-            acceptRemote: true,
-          },
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.sampling.headSampler).toBeDefined();
-      // Should be ParentBasedSampler wrapping ratio sampler
-      expect(parsed.sampling.headSampler.toString()).toContain('ParentBased');
-    });
-
-    it('should use default tail sampler (keep sampled or errors)', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.sampling.tailSampler).toBeDefined();
-      expect(typeof parsed.sampling.tailSampler).toBe('function');
-    });
-
-    it('should accept custom tail sampler', () => {
-      const customTailSampler = () => true;
-
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        sampling: {
-          tailSampler: customTailSampler,
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.sampling.tailSampler).toBe(customTailSampler);
-    });
-
-    it('should use W3CTraceContextPropagator as default', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.propagator).toBeDefined();
-      expect(parsed.propagator.constructor.name).toBe('W3CTraceContextPropagator');
-    });
-
-    it('should accept custom propagator', () => {
-      const mockPropagator = {
-        inject: () => {},
-        extract: () => ({} as any),
-        fields: () => [],
-      };
-
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        propagator: mockPropagator as any,
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.propagator).toBe(mockPropagator);
-    });
-
-    it('should enable global fetch instrumentation by default', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.instrumentation.instrumentGlobalFetch).toBe(true);
-    });
-
-    it('should disable global cache instrumentation by default', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.instrumentation.instrumentGlobalCache).toBe(false);
-    });
-
-    it('should allow enabling cache instrumentation', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        instrumentation: {
-          instrumentGlobalCache: true,
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.instrumentation.instrumentGlobalCache).toBe(true);
-    });
-
-    it('should use default fetch.includeTraceContext = true', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.fetch.includeTraceContext).toBe(true);
-    });
-
-    it('should accept custom fetch.includeTraceContext function', () => {
-      const customFn = (request: Request) => request.url.includes('internal');
-
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        fetch: {
-          includeTraceContext: customFn,
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.fetch.includeTraceContext).toBe(customFn);
-    });
-
-    it('should preserve fetch handler route filtering and service mappings', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-        handlers: {
-          fetch: {
-            include: ['/api/**'],
-            exclude: ['/api/internal/**'],
-            routes: {
-              '/api/auth/**': { service: 'auth-service' },
-              '/api/**': { service: 'api-service' },
-            },
-          },
-        },
-      };
-
-      const parsed = parseConfig(config);
-
-      expect(parsed.handlers.fetch.include).toEqual(['/api/**']);
-      expect(parsed.handlers.fetch.exclude).toEqual(['/api/internal/**']);
-      expect(parsed.handlers.fetch.routes).toEqual({
-        '/api/auth/**': { service: 'auth-service' },
-        '/api/**': { service: 'api-service' },
-      });
-    });
-  });
-
-  describe('createInitialiser()', () => {
-    it('should create initialiser from static config', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const initialiser = createInitialiser(config);
-
-      expect(typeof initialiser).toBe('function');
-
-      const resolved = initialiser({}, { request: null as any });
-
-      expect(resolved.service.name).toBe('test-service');
-    });
-
-    it('should create initialiser from config function', () => {
-      const configFn = (env: { SERVICE_NAME: string }) => ({
-        service: { name: env.SERVICE_NAME },
-      });
-
-      const initialiser = createInitialiser(configFn);
-
-      expect(typeof initialiser).toBe('function');
-
-      const resolved = initialiser({ SERVICE_NAME: 'dynamic-service' }, { request: null as any });
-
-      expect(resolved.service.name).toBe('dynamic-service');
-    });
-
-    it('should pass env and trigger to config function', () => {
-      const configFn = vi.fn((env: any, trigger: any) => ({
-        service: { name: 'test' },
-      }));
-
-      const initialiser = createInitialiser(configFn);
-
-      const mockEnv = { API_KEY: 'test-key' };
-      const mockTrigger = { request: new Request('http://example.com') };
-
-      initialiser(mockEnv, mockTrigger);
-
-      expect(configFn).toHaveBeenCalledWith(mockEnv, mockTrigger);
-    });
-  });
-
-  describe('getActiveConfig() / setConfig()', () => {
-    beforeEach(() => {
-      // Reset active config before each test
-      setConfig(null as any);
-    });
-
-    it('should store and retrieve active config', () => {
-      const config: EdgeConfig = {
-        service: { name: 'test-service' },
-      };
-
-      const parsed = parseConfig(config);
-      const ctx = setConfig(parsed);
-
-      // Use api_context.with() to activate the context
-      api_context.with(ctx, () => {
-        const active = getActiveConfig();
-        expect(active).toBe(parsed);
-        expect(active?.service.name).toBe('test-service');
-      });
-    });
-
-    it('should return null when no active config', () => {
-      const ctx = setConfig(null as any);
-
-      api_context.with(ctx, () => {
-        const active = getActiveConfig();
-        expect(active).toBeNull();
-      });
-    });
-
-    it('should allow updating active config', () => {
-      const config1 = parseConfig({
-        service: { name: 'service-1' },
-      });
-
-      const ctx1 = setConfig(config1);
-      api_context.with(ctx1, () => {
-        expect(getActiveConfig()?.service.name).toBe('service-1');
-      });
-
-      const config2 = parseConfig({
-        service: { name: 'service-2' },
-      });
-
-      const ctx2 = setConfig(config2);
-      api_context.with(ctx2, () => {
-        expect(getActiveConfig()?.service.name).toBe('service-2');
-      });
-    });
-  });
-
-  describe('Config context isolation', () => {
-    it('should isolate config per context using setConfig() return value', () => {
-      const config1 = parseConfig({
-        service: { name: 'service-1' },
-      });
-
-      const config2 = parseConfig({
-        service: { name: 'service-2' },
-      });
-
-      // Create separate contexts
-      const context1 = setConfig(config1);
-      const context2 = setConfig(config2);
-
-      // Verify contexts are different
-      expect(context1).not.toBe(context2);
-    });
-
-    it('should use OpenTelemetry context for storage', () => {
-      const config = parseConfig({
-        service: { name: 'test-service' },
-      });
-
-      const context = setConfig(config);
-
-      // setConfig should return a context object
-      expect(context).toBeDefined();
-      expect(typeof context).toBe('object');
-    });
-
-    it('should not have race conditions with context-based storage', () => {
-      // This test verifies the fix for the config race condition bug
-      // where module-level state caused request B to overwrite request A's config
-
-      const configA = parseConfig({
-        service: { name: 'request-a' },
-      });
-
-      const configB = parseConfig({
-        service: { name: 'request-b' },
-      });
-
-      // Simulate setting configs for different requests
-      const contextA = setConfig(configA);
-      const contextB = setConfig(configB);
-
-      // Both contexts should exist independently
-      expect(contextA).not.toBe(contextB);
-
-      // Each context has its own config that doesn't interfere with the other
-      api_context.with(contextA, () => {
-        const activeConfig = getActiveConfig();
-        expect(activeConfig?.service.name).toBe('request-a');
-      });
-
-      api_context.with(contextB, () => {
-        const activeConfig = getActiveConfig();
-        expect(activeConfig?.service.name).toBe('request-b');
-      });
-
-      // This demonstrates that configs are properly isolated per context
-    });
-  });
-});