@oxy.so/telemetry 1.1.1 → 2.0.0

package/dist/types/edge.d.ts

@@ -1,32 +0,0 @@
-/** Server-only bindings; never expose them through frontend build variables. */
-export interface EdgeActivityEnv {
-    OXY_EDGE_ACTIVITY_ENABLED?: string;
-    OXY_EDGE_ACTIVITY_API_KEY?: string;
-    OXY_EDGE_ACTIVITY_API_SECRET?: string;
-    OXY_EDGE_ACTIVITY_API_URL?: string;
-}
-export interface EdgeActivityContext {
-    waitUntil(promise: Promise<unknown>): void;
-}
-export interface EdgeActivityOptions {
-    service: string;
-    request: Request & {
-        cf?: {
-            colo?: unknown;
-        };
-    };
-    env: EdgeActivityEnv;
-    ctx: EdgeActivityContext;
-    next: () => Response | Promise<Response>;
-    credential?: () => Promise<string>;
-    fetcher?: typeof fetch;
-    /** Only supply after existing authentication verified this service identity. */
-    peer?: {
-        service: string;
-        region?: string;
-    };
-    /** Fixed message only: never credentials, URLs or upstream error bodies. */
-    onError?: (message: string) => void;
-}
-/** Returns the original response/stream and preserves original handler errors. */
-export declare function observeEdgeRequest(options: EdgeActivityOptions): Promise<Response>;

package/src/__tests__/edge.test.ts

@@ -1,110 +0,0 @@
-/** @jest-environment node */
-import { observeEdgeRequest, type EdgeActivityEnv } from '../edge';
-
-function setup(path = '/private-name.png?email=secret@example.com') {
-  const request = new Request(`https://example.com${path}`, { headers: { 'CF-Connecting-IP': '203.0.113.8', 'X-Oxy-Source-Region': 'eu-west-1', Authorization: 'private' } });
-  Object.assign(request, { cf: { colo: 'MAD', country: 'ES' } });
-  const tasks: Promise<unknown>[] = [];
-  const env: EdgeActivityEnv = { OXY_EDGE_ACTIVITY_ENABLED: 'true', OXY_EDGE_ACTIVITY_API_KEY: 'key', OXY_EDGE_ACTIVITY_API_SECRET: 'secret' };
-  const fetcher = jest.fn(async (input: RequestInfo | URL) => String(input).endsWith('service-token') ? Response.json({ token: 'token', expiresIn: 3600 }) : new Response(null, { status: 204 }));
-  return { request, env, tasks, fetcher, ctx: { waitUntil: (task: Promise<unknown>) => tasks.push(task) }, service: 'noted', onError: jest.fn() };
-}
-
-test('preserves the response stream, cache headers and media type without personal metadata', async () => {
-  const state = setup();
-  const response = new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode('image')); c.close(); } }), { headers: { 'Content-Type': 'image/png', 'Cache-Control': 'public,max-age=3600' } });
-  expect(await observeEdgeRequest({ ...state, next: () => response })).toBe(response);
-  expect(response.bodyUsed).toBe(false);
-  await Promise.all(state.tasks);
-  const calls = state.fetcher.mock.calls as unknown as [URL, RequestInit][];
-  expect(JSON.parse(String(calls[0][1].body))).toEqual({ apiKey: 'key', apiSecret: 'secret' });
-  const events = JSON.parse(String(calls[1][1].body));
-  expect(events).toHaveLength(2);
-  expect(events[0]).toMatchObject({ region: 'edge-mad', scope: 'external', direction: 'inbound', activityType: 'media', targetRegion: 'edge-mad' });
-  expect(events[1]).toMatchObject({ direction: 'outbound', sourceRegion: 'edge-mad' });
-  expect(events[0].sourceRegion).toBeUndefined();
-  expect(JSON.stringify(events)).not.toMatch(/private|secret|203\.0|example|email|eu-west/);
-  expect(await response.text()).toBe('image');
-});
-
-test('preserves handler errors and only reports received activity', async () => {
-  const state = setup(); const error = new Error('upstream');
-  await expect(observeEdgeRequest({ ...state, next: () => { throw error; } })).rejects.toBe(error);
-  await Promise.all(state.tasks);
-  const calls = state.fetcher.mock.calls as unknown as [URL, RequestInit][];
-  expect(JSON.parse(String(calls[1][1].body)).map((x: {direction:string}) => x.direction)).toEqual(['inbound']);
-});
-
-test.each(['/health', '/api/ready', '/internal/activity', '/auth/service-token', '/cdn-cgi/trace'])('excludes control route %s', async (path) => {
-  const state = setup(path); const response = new Response(null);
-  expect(await observeEdgeRequest({ ...state, next: () => response })).toBe(response);
-  expect(state.tasks).toHaveLength(0);
-});
-
-test('disabled bindings bypass publishing and missing enabled credentials report a fixed error', async () => {
-  const state = setup(); state.env = {};
-  await observeEdgeRequest({ ...state, next: () => new Response(null) });
-  expect(state.tasks).toHaveLength(0);
-  state.env.OXY_EDGE_ACTIVITY_ENABLED = 'true';
-  await observeEdgeRequest({ ...state, next: () => new Response(null) });
-  await Promise.all(state.tasks);
-  expect(state.onError).toHaveBeenCalledWith('Edge activity publication failed');
-  expect(state.fetcher).not.toHaveBeenCalled();
-});
-
-test('verified peer is internal independently of inbound/outbound', async () => {
-  const state = setup();
-  await observeEdgeRequest({ ...state, peer: {service:'mention', region:'us-west-2'}, next: () => new Response(null) });
-  await Promise.all(state.tasks);
-  const calls = state.fetcher.mock.calls as unknown as [URL, RequestInit][];
-  expect(JSON.parse(String(calls[1][1].body))).toEqual([
-    expect.objectContaining({scope:'internal', direction:'inbound', sourceRegion:'us-west-2', sourceService:'mention'}),
-    expect.objectContaining({scope:'internal', direction:'outbound', targetRegion:'us-west-2', targetService:'mention'}),
-  ]);
-});
-
-test('caches token values and invalidates on ingestion 401 without retrying a batch', async () => {
-  const state = setup();
-  const fetcher = jest.fn(async (input: RequestInfo | URL) => String(input).endsWith('service-token') ? Response.json({token:'token',expiresIn:3600}) : new Response(null, {status:401}));
-  for (let i=0;i<2;i++) { await observeEdgeRequest({...state, fetcher, next:()=>new Response(null)}); await Promise.all(state.tasks); }
-  expect(fetcher.mock.calls.map(([url])=>String(url))).toEqual(['https://api.oxy.so/auth/service-token','https://api.oxy.so/internal/activity','https://api.oxy.so/auth/service-token','https://api.oxy.so/internal/activity']);
-});
-
-test('unknown colo stays unknown even when caller spoofs geo headers', async () => {
-  const state = setup(); Object.assign(state.request, {cf:undefined});
-  await observeEdgeRequest({...state, credential:async()=>'injected', next:()=>new Response(null)}); await Promise.all(state.tasks);
-  const calls = state.fetcher.mock.calls as unknown as [URL, RequestInit][];
-  expect(calls).toHaveLength(1);
-  expect(JSON.parse(String(calls[0][1].body))[0].region).toBe('unknown');
-});
-
-test('reuses only a token value on later requests and refreshes after credential rotation', async () => {
-  const state = setup();
-  for (let i=0;i<2;i++) { await observeEdgeRequest({...state,next:()=>new Response(null)}); await Promise.all(state.tasks); }
-  expect(state.fetcher.mock.calls).toHaveLength(3);
-  state.env.OXY_EDGE_ACTIVITY_API_SECRET = 'rotated';
-  await observeEdgeRequest({...state,next:()=>new Response(null)}); await Promise.all(state.tasks);
-  expect(state.fetcher.mock.calls).toHaveLength(5);
-});
-
-test('bounds an injected credential that never resolves without delaying the response', async () => {
-  jest.useFakeTimers();
-  try {
-    const state = setup(); const response = new Response(null);
-    expect(await observeEdgeRequest({...state,credential:()=>new Promise(()=>{}),next:()=>response})).toBe(response);
-    await jest.advanceTimersByTimeAsync(4_000);
-    await Promise.all(state.tasks);
-    expect(state.onError).toHaveBeenCalledTimes(1);
-    expect(state.fetcher).not.toHaveBeenCalled();
-    expect(jest.getTimerCount()).toBe(0);
-  } finally { jest.useRealTimers(); }
-});
-
-test('bounds token response size and never publishes credentials in diagnostics', async () => {
-  const state = setup();
-  const fetcher = jest.fn(async()=>new Response('secret'.repeat(4000)));
-  await observeEdgeRequest({...state,fetcher,next:()=>new Response(null)});
-  await Promise.all(state.tasks);
-  expect(fetcher).toHaveBeenCalledTimes(1);
-  expect(state.onError).toHaveBeenCalledWith('Edge activity publication failed');
-});

package/src/edge.ts

@@ -1,117 +0,0 @@
-import { trafficType, type TrafficAggregate } from './collector.js';
-import { normalizeEdgePop } from './server.js';
-
-/** Server-only bindings; never expose them through frontend build variables. */
-export interface EdgeActivityEnv {
-  OXY_EDGE_ACTIVITY_ENABLED?: string;
-  OXY_EDGE_ACTIVITY_API_KEY?: string;
-  OXY_EDGE_ACTIVITY_API_SECRET?: string;
-  OXY_EDGE_ACTIVITY_API_URL?: string;
-}
-export interface EdgeActivityContext { waitUntil(promise: Promise<unknown>): void }
-export interface EdgeActivityOptions {
-  service: string;
-  request: Request & { cf?: { colo?: unknown } };
-  env: EdgeActivityEnv;
-  ctx: EdgeActivityContext;
-  next: () => Response | Promise<Response>;
-  credential?: () => Promise<string>;
-  fetcher?: typeof fetch;
-  /** Only supply after existing authentication verified this service identity. */
-  peer?: { service: string; region?: string };
-  /** Fixed message only: never credentials, URLs or upstream error bodies. */
-  onError?: (message: string) => void;
-}
-interface CachedToken { key: string; secret: string; origin: string; token: string; expiresAt: number }
-// Share values only: Workers prohibit I/O promises/bodies crossing request contexts.
-const tokens = new WeakMap<EdgeActivityEnv, CachedToken>();
-const CONTROL = /^\/(?:api\/)?(?:health|ready|live|platform-stats|platform-activity|platform-infrastructure|infra-status|internal\/activity|auth\/service-token|cdn-cgi)(?:\/|$)/;
-
-async function smallJson(response: Response): Promise<unknown> {
-  if (!response.body) throw new Error('Missing token response');
-  const reader = response.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      size += value.byteLength;
-      if (size > 16_384) { await reader.cancel(); throw new Error('Oversized token response'); }
-      chunks.push(value);
-    }
-  } finally { reader.releaseLock(); }
-  const bytes = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
-  return JSON.parse(new TextDecoder().decode(bytes));
-}
-
-async function publish(options: EdgeActivityOptions, events: TrafficAggregate[]): Promise<void> {
-  const { env } = options;
-  const base = new URL(env.OXY_EDGE_ACTIVITY_API_URL ?? 'https://api.oxy.so');
-  if (base.protocol !== 'https:' || base.username || base.password || base.pathname !== '/' || base.search || base.hash) throw new Error('Invalid activity origin');
-  const fetcher = options.fetcher ?? fetch;
-  const abort = new AbortController();
-  const timeout = setTimeout(() => abort.abort(), 4_000);
-  try {
-    let token: string;
-    if (options.credential) token = await Promise.race([
-      options.credential(),
-      new Promise<never>((_, reject) => abort.signal.addEventListener('abort', () => reject(new Error('Activity credential timeout')), { once: true })),
-    ]);
-    else {
-      const key = env.OXY_EDGE_ACTIVITY_API_KEY;
-      const secret = env.OXY_EDGE_ACTIVITY_API_SECRET;
-      if (!key || !secret) throw new Error('Missing edge activity credentials');
-      const cached = tokens.get(env);
-      if (cached && cached.key === key && cached.secret === secret && cached.origin === base.origin && cached.expiresAt > Date.now() + 60_000) token = cached.token;
-      else {
-        // Same exchange and expiry margin as OxyServices.getServiceToken().
-        const response = await fetcher(new URL('/auth/service-token', base), {
-          method: 'POST', headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ apiKey: key, apiSecret: secret }), signal: abort.signal,
-        });
-        if (!response.ok) { await response.body?.cancel(); throw new Error('Activity authentication failed'); }
-        const data = await smallJson(response) as { token?: unknown; expiresIn?: unknown };
-        if (typeof data.token !== 'string' || !data.token || typeof data.expiresIn !== 'number' || !Number.isFinite(data.expiresIn) || data.expiresIn <= 0) throw new Error('Invalid activity token');
-        token = data.token;
-        tokens.set(env, { key, secret, origin: base.origin, token, expiresAt: Date.now() + data.expiresIn * 1_000 });
-      }
-    }
-    const response = await fetcher(new URL('/internal/activity', base), {
-      method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
-      body: JSON.stringify(events), signal: abort.signal,
-    });
-    if (response.status === 401) tokens.delete(env);
-    await response.body?.cancel();
-    if (!response.ok) throw new Error('Activity ingestion failed');
-  } finally { clearTimeout(timeout); }
-}
-
-/** Returns the original response/stream and preserves original handler errors. */
-export async function observeEdgeRequest(options: EdgeActivityOptions): Promise<Response> {
-  const report = () => { try { (options.onError ?? console.error)('Edge activity publication failed'); } catch { /* Never break serving. */ } };
-  const enabled = options.env.OXY_EDGE_ACTIVITY_ENABLED;
-  if (enabled === undefined || enabled === 'false') return options.next();
-  if (enabled !== 'true' || !/^[a-z][a-z0-9-]{0,39}$/.test(options.service)) { report(); return options.next(); }
-  const path = new URL(options.request.url).pathname;
-  if (CONTROL.test(path)) return options.next();
-  const pop = normalizeEdgePop(typeof options.request.cf?.colo === 'string' ? options.request.cf.colo : undefined);
-  const region = pop ? `edge-${pop}` : 'unknown';
-  const startedAt = new Date().toISOString();
-  const complete = (response?: Response) => {
-    const contentType = response?.headers.get('Content-Type') ?? '';
-    const activityType = /^(?:image|audio|video)\//i.test(contentType) ? 'media' : trafficType(path);
-    const common = { service: options.service, region, scope: options.peer ? 'internal' as const : 'external' as const, activityType, requests: 1, windowStartedAt: startedAt, emittedAt: new Date().toISOString() };
-    // The serving PoP is infrastructure metadata. Do not invent visitor location.
-    const events: TrafficAggregate[] = [{ ...common, direction: 'inbound', sourceRegion: options.peer?.region, sourceService: options.peer?.service, targetRegion: region, targetService: options.service }];
-    if (response) events.push({ ...common, direction: 'outbound', sourceRegion: region, sourceService: options.service, targetRegion: options.peer?.region, targetService: options.peer?.service });
-    try { options.ctx.waitUntil(publish(options, events).catch(report)); } catch { report(); }
-  };
-  let response: Response;
-  try { response = await options.next(); }
-  catch (error) { complete(); throw error; }
-  complete(response);
-  return response;
-}