autotel 4.0.0 → 4.2.0

package/src/drain-toolkit.test.ts

@@ -1,113 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { defineDrain, defineHttpDrain } from './drain-toolkit';
-
-describe('defineDrain', () => {
-  it('calls send with transformed payloads', async () => {
-    const send = vi.fn(async () => {});
-    const drain = defineDrain<
-      { event: { id: string } },
-      { key: string },
-      string
-    >({
-      name: 'test',
-      resolve: async () => ({ key: 'k' }),
-      transform: (contexts) => contexts.map((c) => c.event.id),
-      send,
-    });
-
-    await drain({ event: { id: 'a' } });
-    expect(send).toHaveBeenCalledWith(['a'], { key: 'k' });
-  });
-
-  it('skips send when resolve returns null', async () => {
-    const send = vi.fn(async () => {});
-    const drain = defineDrain({
-      name: 'test',
-      resolve: async () => null,
-      send,
-    });
-
-    await drain({ event: { id: 'a' } });
-    expect(send).not.toHaveBeenCalled();
-  });
-
-  it('isolates send errors', async () => {
-    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const drain = defineDrain({
-      name: 'test',
-      resolve: async () => ({ ok: true }),
-      send: async () => {
-        throw new Error('fail');
-      },
-    });
-
-    await expect(drain({ event: { id: 'a' } })).resolves.toBeUndefined();
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
-  });
-});
-
-describe('defineHttpDrain', () => {
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it('encodes payload and posts via fetch', async () => {
-    const fetchMock = vi.fn(async () => new Response(null, { status: 200 }));
-    globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-    const drain = defineHttpDrain<
-      { event: { id: string } },
-      { token: string },
-      { id: string }
-    >({
-      name: 'http-drain',
-      resolve: async () => ({ token: 't' }),
-      transform: (contexts) => contexts.map((c) => c.event),
-      encode: (payloads, config) => ({
-        url: 'https://example.com/ingest',
-        headers: {
-          'content-type': 'application/json',
-          authorization: `Bearer ${config.token}`,
-        },
-        body: JSON.stringify(payloads),
-      }),
-      retries: 1,
-      timeoutMs: 2000,
-    });
-
-    await drain({ event: { id: 'evt_1' } });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(fetchMock.mock.calls[0]?.[0]).toBe('https://example.com/ingest');
-  });
-
-  it('retries failed requests', async () => {
-    const fetchMock = vi
-      .fn()
-      .mockRejectedValueOnce(new Error('network'))
-      .mockResolvedValueOnce(new Response(null, { status: 200 }));
-    globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-    const drain = defineHttpDrain({
-      name: 'http-drain',
-      resolve: async () => ({ ok: true }),
-      encode: () => ({
-        url: 'https://example.com/ingest',
-        headers: { 'content-type': 'application/json' },
-        body: '[]',
-      }),
-      retries: 2,
-      timeoutMs: 2000,
-    });
-
-    await drain({ event: { id: 'evt_1' } });
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-});

package/src/drain-toolkit.ts

@@ -1,129 +0,0 @@
-export interface DrainOptions<TContext, TConfig, TPayload = TContext> {
-  /** Stable identifier used in error logs. */
-  name: string;
-  /** Return null to skip draining (e.g. missing API key in dev). */
-  resolve: () => TConfig | null | Promise<TConfig | null>;
-  /** Transform contexts into payloads. Defaults to identity. */
-  transform?: (contexts: TContext[]) => TPayload[];
-  /** Transport implementation. */
-  send: (payloads: TPayload[], config: TConfig) => Promise<void>;
-}
-
-export interface HttpDrainRequest {
-  url: string;
-  headers: Record<string, string>;
-  body: string;
-}
-
-export interface HttpDrainOptions<
-  TContext,
-  TConfig,
-  TPayload = TContext,
-> extends Omit<DrainOptions<TContext, TConfig, TPayload>, 'send'> {
-  encode: (payloads: TPayload[], config: TConfig) => HttpDrainRequest | null;
-  timeoutMs?: number;
-  retries?: number;
-  resolveTimeoutMs?: (config: TConfig) => number | undefined;
-  resolveRetries?: (config: TConfig) => number | undefined;
-}
-
-const DEFAULT_TIMEOUT_MS = 5000;
-const DEFAULT_RETRIES = 2;
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    t.unref?.();
-  });
-}
-
-async function postWithRetry(options: {
-  name: string;
-  request: HttpDrainRequest;
-  timeoutMs: number;
-  retries: number;
-}): Promise<void> {
-  const { name, request, timeoutMs, retries } = options;
-  const attempts = Math.max(1, retries);
-  let lastError: unknown;
-
-  for (let attempt = 1; attempt <= attempts; attempt++) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    timeout.unref?.();
-    try {
-      const response = await fetch(request.url, {
-        method: 'POST',
-        headers: request.headers,
-        body: request.body,
-        signal: controller.signal,
-      });
-      if (!response.ok) {
-        throw new Error(
-          `[autotel/${name}] HTTP ${response.status} draining ${request.url}`,
-        );
-      }
-      return;
-    } catch (error) {
-      lastError = error;
-      if (attempt < attempts) {
-        await delay(100 * attempt);
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  throw lastError;
-}
-
-export function defineDrain<TContext, TConfig, TPayload = TContext>(
-  options: DrainOptions<TContext, TConfig, TPayload>,
-): (ctx: TContext | TContext[]) => Promise<void> {
-  return async (ctx: TContext | TContext[]) => {
-    const contexts = Array.isArray(ctx) ? ctx : [ctx];
-    if (contexts.length === 0) return;
-
-    const config = await options.resolve();
-    if (!config) return;
-
-    const payloads = options.transform
-      ? options.transform(contexts)
-      : (contexts as unknown as TPayload[]);
-
-    if (payloads.length === 0) return;
-
-    try {
-      await options.send(payloads, config);
-    } catch (error) {
-      console.error(`[autotel/${options.name}] drain failed:`, error);
-    }
-  };
-}
-
-export function defineHttpDrain<TContext, TConfig, TPayload = TContext>(
-  options: HttpDrainOptions<TContext, TConfig, TPayload>,
-): (ctx: TContext | TContext[]) => Promise<void> {
-  return defineDrain<TContext, TConfig, TPayload>({
-    name: options.name,
-    resolve: options.resolve,
-    transform: options.transform,
-    send: async (payloads, config) => {
-      const request = options.encode(payloads, config);
-      if (!request) return;
-      const timeoutMs =
-        options.resolveTimeoutMs?.(config) ??
-        options.timeoutMs ??
-        DEFAULT_TIMEOUT_MS;
-      const retries =
-        options.resolveRetries?.(config) ?? options.retries ?? DEFAULT_RETRIES;
-
-      await postWithRetry({
-        name: options.name,
-        request,
-        timeoutMs,
-        retries,
-      });
-    },
-  });
-}

package/src/enricher-toolkit.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { defineEnricher } from './enricher-toolkit';
-
-describe('defineEnricher', () => {
-  it('merges computed values into existing field by default', () => {
-    const enricher = defineEnricher({
-      name: 'tenant-enricher',
-      field: 'tenant',
-      compute: () => ({ plan: 'pro' }),
-    });
-
-    const ctx = {
-      event: { tenant: { id: 't_1' } },
-    };
-
-    enricher(ctx);
-    expect(ctx.event).toEqual({ tenant: { id: 't_1', plan: 'pro' } });
-  });
-
-  it('overwrites field when overwrite=true', () => {
-    const enricher = defineEnricher(
-      {
-        name: 'tenant-enricher',
-        field: 'tenant',
-        compute: () => ({ plan: 'pro' }),
-      },
-      { overwrite: true },
-    );
-
-    const ctx = {
-      event: { tenant: { id: 't_1' } },
-    };
-
-    enricher(ctx);
-    expect(ctx.event).toEqual({ tenant: { plan: 'pro' } });
-  });
-
-  it('skips enrichment when compute returns undefined', () => {
-    const enricher = defineEnricher({
-      name: 'noop-enricher',
-      field: 'tenant',
-      compute: () => undefined,
-    });
-
-    const ctx = { event: { a: 1 } as Record<string, unknown> };
-    enricher(ctx);
-    expect(ctx.event).toEqual({ a: 1 });
-  });
-
-  it('isolates compute errors and logs them', () => {
-    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const enricher = defineEnricher({
-      name: 'broken-enricher',
-      field: 'tenant',
-      compute: () => {
-        throw new Error('boom');
-      },
-    });
-
-    const ctx = { event: {} as Record<string, unknown> };
-    enricher(ctx);
-
-    expect(ctx.event).toEqual({});
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
-  });
-});

package/src/enricher-toolkit.ts

@@ -1,79 +0,0 @@
-export interface EnrichContext<TEvent extends Record<string, unknown>> {
-  event: TEvent;
-  request?: {
-    method?: string;
-    path?: string;
-    requestId?: string;
-  };
-  response?: {
-    status?: number;
-  };
-  headers?: Record<string, string>;
-}
-
-export interface EnricherDefinition<
-  TEvent extends Record<string, unknown>,
-  TValue extends object,
-> {
-  /** Stable identifier used in error logs. */
-  name: string;
-  /** Top-level field to merge computed values into. */
-  field: keyof TEvent & string;
-  /** Return undefined to skip enrichment. */
-  compute: (ctx: EnrichContext<TEvent>) => TValue | undefined;
-}
-
-export interface EnricherOptions {
-  /** Replace existing field value instead of merge. Default false. */
-  overwrite?: boolean;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-function mergeInto(
-  target: Record<string, unknown>,
-  source: Record<string, unknown>,
-): void {
-  for (const key in source) {
-    const sourceVal = source[key];
-    if (sourceVal === undefined) continue;
-    const targetVal = target[key];
-    if (isPlainObject(sourceVal) && isPlainObject(targetVal)) {
-      mergeInto(targetVal, sourceVal);
-    } else {
-      target[key] = sourceVal;
-    }
-  }
-}
-
-export function defineEnricher<
-  TEvent extends Record<string, unknown>,
-  TValue extends object,
->(
-  def: EnricherDefinition<TEvent, TValue>,
-  options: EnricherOptions = {},
-): (ctx: EnrichContext<TEvent>) => void {
-  return (ctx: EnrichContext<TEvent>) => {
-    let computed: TValue | undefined;
-    try {
-      computed = def.compute(ctx);
-    } catch (error) {
-      console.error(`[autotel/${def.name}] enrich failed:`, error);
-      return;
-    }
-
-    if (!computed) return;
-
-    if (options.overwrite || !isPlainObject(ctx.event[def.field])) {
-      (ctx.event as Record<string, unknown>)[def.field] = computed;
-      return;
-    }
-
-    mergeInto(
-      ctx.event[def.field] as unknown as Record<string, unknown>,
-      computed as unknown as Record<string, unknown>,
-    );
-  };
-}

package/src/enrichers.test.ts

@@ -1,150 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { userAgent, geo, requestSize } from './enrichers';
-
-describe('enrichers', () => {
-  describe('userAgent', () => {
-    it('parses Chrome on macOS', () => {
-      const result = userAgent({
-        'user-agent':
-          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-      });
-
-      expect(result).toMatchObject({
-        'user_agent.browser': 'Chrome 120.0.0.0',
-        'user_agent.os': 'macOS 10.15.7',
-        'user_agent.device': 'desktop',
-      });
-      expect(result?.['user_agent.raw']).toBeDefined();
-    });
-
-    it('parses Firefox on Windows', () => {
-      const result = userAgent({
-        'user-agent':
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
-      });
-
-      expect(result).toMatchObject({
-        'user_agent.browser': 'Firefox 121.0',
-        'user_agent.os': 'Windows 10.0',
-        'user_agent.device': 'desktop',
-      });
-    });
-
-    it('detects mobile device', () => {
-      const result = userAgent({
-        'user-agent':
-          'Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1',
-      });
-
-      expect(result?.['user_agent.device']).toBe('mobile');
-      expect(result?.['user_agent.os']).toBe('iOS 17.2');
-    });
-
-    it('detects bot', () => {
-      const result = userAgent({
-        'user-agent': 'Googlebot/2.1 (+http://www.google.com/bot.html)',
-      });
-
-      expect(result?.['user_agent.device']).toBe('bot');
-    });
-
-    it('returns undefined when no user-agent header', () => {
-      expect(userAgent({})).toBeUndefined();
-    });
-
-    it('accepts mixed-case User-Agent header names', () => {
-      const result = userAgent({
-        'User-Agent':
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
-      });
-
-      expect(result).toMatchObject({
-        'user_agent.browser': 'Firefox 121.0',
-        'user_agent.os': 'Windows 10.0',
-      });
-    });
-  });
-
-  describe('geo', () => {
-    it('extracts Vercel geo headers', () => {
-      const result = geo({
-        'x-vercel-ip-country': 'US',
-        'x-vercel-ip-country-region': 'CA',
-        'x-vercel-ip-city': 'San%20Francisco',
-        'x-vercel-ip-latitude': '37.7749',
-        'x-vercel-ip-longitude': '-122.4194',
-      });
-
-      expect(result).toEqual({
-        'geo.country': 'US',
-        'geo.region': 'CA',
-        'geo.city': 'San Francisco',
-        'geo.latitude': '37.7749',
-        'geo.longitude': '-122.4194',
-      });
-    });
-
-    it('extracts Cloudflare country header', () => {
-      const result = geo({ 'cf-ipcountry': 'GB' });
-
-      expect(result).toEqual({ 'geo.country': 'GB' });
-    });
-
-    it('does not throw on malformed encoded city values', () => {
-      expect(() =>
-        geo({
-          'x-vercel-ip-country': 'US',
-          'x-vercel-ip-city': '%E0%A4%A',
-        }),
-      ).not.toThrow();
-    });
-
-    it('returns undefined when no geo headers', () => {
-      expect(geo({})).toBeUndefined();
-    });
-
-    it('returns longitude when it is the only geo signal', () => {
-      const result = geo({ 'x-vercel-ip-longitude': '-0.1276' });
-
-      expect(result).toEqual({ 'geo.longitude': '-0.1276' });
-    });
-  });
-
-  describe('requestSize', () => {
-    it('extracts request and response sizes', () => {
-      const result = requestSize(
-        { 'content-length': '1024' },
-        { 'content-length': '2048' },
-      );
-
-      expect(result).toEqual({
-        'http.request.body.size': 1024,
-        'http.response.body.size': 2048,
-      });
-    });
-
-    it('handles request-only size', () => {
-      const result = requestSize({ 'content-length': '512' });
-
-      expect(result).toEqual({ 'http.request.body.size': 512 });
-    });
-
-    it('returns undefined when no content-length headers', () => {
-      expect(requestSize({}, {})).toBeUndefined();
-    });
-
-    it('ignores non-numeric content-length', () => {
-      expect(requestSize({ 'content-length': 'abc' })).toBeUndefined();
-    });
-
-    it('ignores invalid numeric content-length values', () => {
-      expect(requestSize({ 'content-length': '-1' })).toBeUndefined();
-      expect(requestSize({ 'content-length': '12.5' })).toBeUndefined();
-    });
-
-    it('ignores non-digit numeric formats for content-length', () => {
-      expect(requestSize({ 'content-length': '1e3' })).toBeUndefined();
-      expect(requestSize({ 'content-length': '+10' })).toBeUndefined();
-    });
-  });
-});

package/src/enrichers.ts

@@ -1,145 +0,0 @@
-type Headers = Record<string, string | string[] | undefined>;
-
-function get(headers: Headers, key: string): string | undefined {
-  const lower = key.toLowerCase();
-  for (const [k, v] of Object.entries(headers)) {
-    if (k.toLowerCase() === lower) {
-      return Array.isArray(v) ? v[0] : v;
-    }
-  }
-  return undefined;
-}
-
-// --- User Agent ---
-
-export interface UserAgentAttributes {
-  'user_agent.raw': string;
-  'user_agent.browser'?: string;
-  'user_agent.os'?: string;
-  'user_agent.device'?: string;
-}
-
-const BROWSER_RE = /(Firefox|OPR|Edg|Chrome|Safari|MSIE|Trident)[\s/]?([\d.]*)/;
-const OS_RE =
-  /(Windows NT|Mac OS X|Linux|Android|iPhone OS|iPad|CrOS)[\s]?([\d._]*)/;
-
-function parseBrowser(ua: string): string | undefined {
-  const m = BROWSER_RE.exec(ua);
-  if (!m) return undefined;
-  const name =
-    m[1] === 'OPR'
-      ? 'Opera'
-      : m[1] === 'Edg'
-        ? 'Edge'
-        : m[1] === 'Trident'
-          ? 'IE'
-          : m[1];
-  return m[2] ? `${name} ${m[2]}` : name;
-}
-
-function parseOS(ua: string): string | undefined {
-  const m = OS_RE.exec(ua);
-  if (!m) return undefined;
-  const name =
-    m[1] === 'iPhone OS'
-      ? 'iOS'
-      : m[1] === 'Windows NT'
-        ? 'Windows'
-        : m[1] === 'Mac OS X'
-          ? 'macOS'
-          : m[1];
-  const ver = m[2]?.replaceAll('_', '.') || undefined;
-  return ver ? `${name} ${ver}` : name;
-}
-
-function parseDevice(ua: string): string | undefined {
-  if (/Mobi|Android.*Mobile|iPhone/.test(ua)) return 'mobile';
-  if (/iPad|Android(?!.*Mobile)|Tablet/.test(ua)) return 'tablet';
-  if (/Bot|Crawler|Spider|Lighthouse/i.test(ua)) return 'bot';
-  return 'desktop';
-}
-
-export function userAgent(headers: Headers): UserAgentAttributes | undefined {
-  const raw = get(headers, 'user-agent');
-  if (!raw) return undefined;
-
-  const attrs: UserAgentAttributes = { 'user_agent.raw': raw };
-  const browser = parseBrowser(raw);
-  if (browser) attrs['user_agent.browser'] = browser;
-  const os = parseOS(raw);
-  if (os) attrs['user_agent.os'] = os;
-  const device = parseDevice(raw);
-  if (device) attrs['user_agent.device'] = device;
-
-  return attrs;
-}
-
-// --- Geo ---
-
-export interface GeoAttributes {
-  'geo.country'?: string;
-  'geo.region'?: string;
-  'geo.city'?: string;
-  'geo.latitude'?: string;
-  'geo.longitude'?: string;
-}
-
-export function geo(headers: Headers): GeoAttributes | undefined {
-  const country =
-    get(headers, 'x-vercel-ip-country') ?? get(headers, 'cf-ipcountry');
-  const region = get(headers, 'x-vercel-ip-country-region');
-  const city = get(headers, 'x-vercel-ip-city');
-  const latitude = get(headers, 'x-vercel-ip-latitude');
-  const longitude = get(headers, 'x-vercel-ip-longitude');
-
-  if (!country && !region && !city && !latitude && !longitude) return undefined;
-
-  const attrs: GeoAttributes = {};
-  if (country) attrs['geo.country'] = country;
-  if (region) attrs['geo.region'] = region;
-  if (city) {
-    try {
-      attrs['geo.city'] = decodeURIComponent(city);
-    } catch {
-      attrs['geo.city'] = city;
-    }
-  }
-  if (latitude) attrs['geo.latitude'] = latitude;
-  if (longitude) attrs['geo.longitude'] = longitude;
-
-  return attrs;
-}
-
-// --- Request Size ---
-
-export interface RequestSizeAttributes {
-  'http.request.body.size'?: number;
-  'http.response.body.size'?: number;
-}
-
-const DIGITS_RE = /^\d+$/;
-
-function parseContentLength(value: string | undefined): number | undefined {
-  if (!value || !DIGITS_RE.test(value)) return undefined;
-  return Number(value);
-}
-
-export function requestSize(
-  requestHeaders: Headers,
-  responseHeaders?: Headers,
-): RequestSizeAttributes | undefined {
-  const reqLen = get(requestHeaders, 'content-length');
-  const resLen = responseHeaders
-    ? get(responseHeaders, 'content-length')
-    : undefined;
-
-  if (!reqLen && !resLen) return undefined;
-
-  const attrs: RequestSizeAttributes = {};
-  const reqBytes = parseContentLength(reqLen);
-  if (reqBytes !== undefined) attrs['http.request.body.size'] = reqBytes;
-  const resBytes = parseContentLength(resLen);
-  if (resBytes !== undefined) attrs['http.response.body.size'] = resBytes;
-
-  return Object.keys(attrs).length > 0 ? attrs : undefined;
-}