@unpolarize/code-sessions 0.1.0

package/src/store/writer.test.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { parseSession, type Turn } from '@unpolarize/code-sessions-schema';
+import { withTempDir } from '../test/tmp';
+import { envelopeFile, sessionDir } from './paths';
+import { computeEnvelope, readTurns, rebuildEnvelope, writeTurnFile } from './writer';
+
+function mkTurn(i: number, over: Partial<Turn> = {}): Turn {
+  return {
+    schema: 'session-store/turn@1',
+    session_id: 'sess-1',
+    host: 'test-host',
+    agent: 'claude-code',
+    turn_index: i,
+    ts: `2026-06-20T08:0${i}:00Z`,
+    role: i % 2 === 0 ? 'user' : 'assistant',
+    text: `turn ${i}`,
+    tool_calls: [],
+    usage: { input_tokens: 100, output_tokens: 10, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null,
+    ...over,
+  };
+}
+
+describe('writeTurnFile', () => {
+  it('writes immutably and never overwrites', () => {
+    withTempDir((store) => {
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      const first = writeTurnFile(dir, mkTurn(0, { text: 'original' }));
+      expect(first.written).toBe(true);
+      const second = writeTurnFile(dir, mkTurn(0, { text: 'CLOBBER' }));
+      expect(second.written).toBe(false);
+      const onDisk = JSON.parse(readFileSync(first.path, 'utf8')) as Turn;
+      expect(onDisk.text).toBe('original');
+    });
+  });
+});
+
+describe('computeEnvelope', () => {
+  it('aggregates totals, counts, and timestamps from turns', () => {
+    const turns = [
+      mkTurn(0),
+      mkTurn(1, {
+        tool_calls: [{ name: 'Edit' }],
+        telemetry: { cost_usd: 0.5 },
+      }),
+    ];
+    const env = computeEnvelope(
+      turns,
+      { model: 'claude-opus-4-8', project_path: '/p', git_branch: 'main', title: 'T' },
+      { session_id: 'sess-1', host: 'test-host', agent: 'claude-code', native_uuid: 'sess-1' },
+    );
+    expect(env.turn_count).toBe(2);
+    expect(env.tool_call_count).toBe(1);
+    expect(env.totals.input_tokens).toBe(200);
+    expect(env.totals.cost_usd).toBe(0.5);
+    expect(env.started_at).toBe('2026-06-20T08:00:00Z');
+    expect(env.ended_at).toBe('2026-06-20T08:01:00Z');
+    expect(env.model).toBe('claude-opus-4-8');
+    expect(env.title).toBe('T');
+    expect(() => parseSession(env)).not.toThrow();
+  });
+
+  it('preserves prior labels from an existing envelope', () => {
+    const env = computeEnvelope([mkTurn(0)], {}, {
+      session_id: 'sess-1',
+      host: 'h',
+      agent: 'claude-code',
+      native_uuid: 'sess-1',
+    }, { labels: ['debugging'] });
+    expect(env.labels).toEqual(['debugging']);
+  });
+});
+
+describe('rebuildEnvelope', () => {
+  it('reads turns from disk and writes session.json', () => {
+    withTempDir((store) => {
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      writeTurnFile(dir, mkTurn(0));
+      writeTurnFile(dir, mkTurn(1));
+      const env = rebuildEnvelope(store, 'test-host', '2026-06', 'sess-1', { model: 'claude-opus-4-8' }, {
+        session_id: 'sess-1',
+        host: 'test-host',
+        agent: 'claude-code',
+        native_uuid: 'sess-1',
+      });
+      expect(env.turn_count).toBe(2);
+      expect(existsSync(envelopeFile(dir))).toBe(true);
+      expect(readTurns(dir)).toHaveLength(2);
+    });
+  });
+});

package/src/store/writer.ts

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  SCHEMA_VERSIONS,
+  type AgentKind,
+  type SessionEnvelope,
+  type Turn,
+} from '@unpolarize/code-sessions-schema';
+import type { ClaudeSessionMeta } from '@unpolarize/code-sessions-schema';
+import { envelopeFile, rawBlobFile, sessionDir, turnFile } from './paths';
+
+function ensureDir(filePath: string): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+}
+
+function writeJsonAtomic(filePath: string, value: unknown): void {
+  ensureDir(filePath);
+  const tmp = `${filePath}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`);
+  renameSync(tmp, filePath); // atomic on the same filesystem
+}
+
+export interface WriteTurnResult {
+  path: string;
+  written: boolean;
+}
+
+/** Write an immutable per-turn file. Never overwrites an existing turn. */
+export function writeTurnFile(dir: string, turn: Turn): WriteTurnResult {
+  const path = turnFile(dir, turn.turn_index);
+  if (existsSync(path)) return { path, written: false };
+  ensureDir(path);
+  writeFileSync(path, `${JSON.stringify(turn, null, 2)}\n`);
+  return { path, written: true };
+}
+
+/** Write a content-addressed blob (idempotent). */
+export function writeBlobFile(dir: string, sha: string, content: string): string {
+  const path = rawBlobFile(dir, sha);
+  if (!existsSync(path)) {
+    ensureDir(path);
+    writeFileSync(path, content);
+  }
+  return path;
+}
+
+export function readTurns(dir: string): Turn[] {
+  const turnsDir = `${dir}/turns`;
+  if (!existsSync(turnsDir)) return [];
+  return readdirSync(turnsDir)
+    .filter((f) => f.endsWith('.json') && !f.endsWith('.tmp'))
+    .sort()
+    .map((f) => JSON.parse(readFileSync(`${turnsDir}/${f}`, 'utf8')) as Turn);
+}
+
+export interface EnvelopeIdentity {
+  session_id: string;
+  host: string;
+  agent: AgentKind;
+  native_uuid: string;
+}
+
+/** Pure: derive a session envelope from its turns + extracted metadata. */
+export function computeEnvelope(
+  turns: Turn[],
+  meta: ClaudeSessionMeta,
+  identity: EnvelopeIdentity,
+  existing?: Partial<SessionEnvelope>,
+): SessionEnvelope {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cost = 0;
+  let toolCalls = 0;
+  for (const t of turns) {
+    inputTokens += t.usage.input_tokens;
+    outputTokens += t.usage.output_tokens;
+    toolCalls += t.tool_calls.length;
+    cost += t.telemetry?.cost_usd ?? 0;
+  }
+  const first = turns[0];
+  const last = turns[turns.length - 1];
+
+  const env: SessionEnvelope = {
+    schema: SCHEMA_VERSIONS.session,
+    session_id: identity.session_id,
+    host: identity.host,
+    agent: identity.agent,
+    project_path: meta.project_path ?? existing?.project_path ?? '',
+    turn_count: turns.length,
+    tool_call_count: toolCalls,
+    totals: {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cost_usd: Math.round(cost * 1e6) / 1e6,
+    },
+    labels: existing?.labels ?? [],
+    native_ref: { format: 'claude-jsonl', uuid: identity.native_uuid },
+  };
+  const branch = meta.git_branch ?? existing?.git_branch;
+  if (branch) env.git_branch = branch;
+  const model = meta.model ?? existing?.model;
+  if (model) env.model = model;
+  const startedAt = meta.started_at ?? first?.ts ?? existing?.started_at;
+  if (startedAt) env.started_at = startedAt;
+  const endedAt = meta.ended_at ?? last?.ts ?? existing?.ended_at;
+  if (endedAt) env.ended_at = endedAt;
+  const title = meta.title ?? existing?.title;
+  if (title) env.title = title;
+  return env;
+}
+
+/** Read turns from disk, derive the envelope (preserving prior labels/title), and write session.json. */
+export function rebuildEnvelope(
+  storeDir: string,
+  host: string,
+  month: string,
+  sessionId: string,
+  meta: ClaudeSessionMeta,
+  identity: EnvelopeIdentity,
+): SessionEnvelope {
+  const dir = sessionDir(storeDir, host, month, sessionId);
+  const turns = readTurns(dir);
+  const envPath = envelopeFile(dir);
+  let existing: Partial<SessionEnvelope> | undefined;
+  if (existsSync(envPath)) {
+    try {
+      existing = JSON.parse(readFileSync(envPath, 'utf8')) as SessionEnvelope;
+    } catch {
+      /* ignore */
+    }
+  }
+  const env = computeEnvelope(turns, meta, identity, existing);
+  writeJsonAtomic(envPath, env);
+  return env;
+}

package/src/tail.test.ts

@@ -0,0 +1,50 @@
+import { appendFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { readNewLines } from './tail';
+import { withTempDir } from './test/tmp';
+
+describe('readNewLines', () => {
+  it('returns empty for a missing file', () => {
+    const r = readNewLines('/no/such/file.jsonl', 0);
+    expect(r.records).toEqual([]);
+    expect(r.newOffset).toBe(0);
+  });
+
+  it('reads complete lines and advances the offset', () => {
+    withTempDir((dir) => {
+      const f = join(dir, 's.jsonl');
+      writeFileSync(f, '{"a":1}\n{"b":2}\n');
+      const r = readNewLines(f, 0);
+      expect(r.records).toEqual([{ a: 1 }, { b: 2 }]);
+      expect(r.newOffset).toBe(16);
+      // re-read from new offset yields nothing
+      expect(readNewLines(f, r.newOffset).records).toEqual([]);
+    });
+  });
+
+  it('does not consume a trailing partial line', () => {
+    withTempDir((dir) => {
+      const f = join(dir, 's.jsonl');
+      writeFileSync(f, '{"a":1}\n{"b":2'); // second line incomplete
+      const r = readNewLines(f, 0);
+      expect(r.records).toEqual([{ a: 1 }]);
+      expect(r.newOffset).toBe(8);
+      // complete the line; next read picks it up
+      appendFileSync(f, '}\n');
+      const r2 = readNewLines(f, r.newOffset);
+      expect(r2.records).toEqual([{ b: 2 }]);
+    });
+  });
+
+  it('counts parse errors but still advances', () => {
+    withTempDir((dir) => {
+      const f = join(dir, 's.jsonl');
+      writeFileSync(f, 'not json\n{"ok":1}\n');
+      const r = readNewLines(f, 0);
+      expect(r.parseErrors).toBe(1);
+      expect(r.records).toEqual([{ ok: 1 }]);
+      expect(r.newOffset).toBe(18);
+    });
+  });
+});

package/src/tail.ts

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync } from 'node:fs';
+
+export interface TailResult {
+  /** parsed JSON objects for each complete new line */
+  records: unknown[];
+  /** raw text of each complete new line (parse failures still advance offset) */
+  rawLines: string[];
+  /** new byte offset to persist (only advances past complete, newline-terminated lines) */
+  newOffset: number;
+  /** number of lines that failed to JSON.parse */
+  parseErrors: number;
+}
+
+/**
+ * Read newly-appended complete lines from a JSONL file starting at a byte
+ * offset. A trailing partial line (no terminating newline) is left unconsumed
+ * so the next read picks it up once it's complete.
+ */
+export function readNewLines(filePath: string, fromOffset: number): TailResult {
+  const empty: TailResult = { records: [], rawLines: [], newOffset: fromOffset, parseErrors: 0 };
+  if (!existsSync(filePath)) return empty;
+
+  const buf = readFileSync(filePath);
+  if (fromOffset >= buf.length) return { ...empty, newOffset: buf.length };
+
+  const slice = buf.subarray(fromOffset);
+  const lastNewline = slice.lastIndexOf(0x0a); // '\n'
+  if (lastNewline < 0) return empty; // no complete line yet
+
+  const complete = slice.subarray(0, lastNewline + 1).toString('utf8');
+  const consumedBytes = Buffer.byteLength(complete, 'utf8');
+
+  const records: unknown[] = [];
+  const rawLines: string[] = [];
+  let parseErrors = 0;
+  for (const line of complete.split('\n')) {
+    if (line.trim().length === 0) continue;
+    rawLines.push(line);
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      parseErrors++;
+    }
+  }
+
+  return { records, rawLines, newOffset: fromOffset + consumedBytes, parseErrors };
+}

package/src/telemetry/exporter.test.ts

@@ -0,0 +1,104 @@
+import { createServer, type Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { describe, expect, it } from 'vitest';
+import type { Turn } from '@unpolarize/code-sessions-schema';
+import { rebuildEnvelope, writeTurnFile } from '../store/writer';
+import { sessionDir } from '../store/paths';
+import { makeConfig, withTempDirAsync } from '../test/tmp';
+import { exportSession, exportStore } from './exporter';
+
+function turn(i: number, over: Partial<Turn> = {}): Turn {
+  return {
+    schema: 'session-store/turn@1',
+    session_id: 's1',
+    host: 'h',
+    agent: 'claude-code',
+    turn_index: i,
+    ts: `2026-06-20T08:0${i}:00Z`,
+    role: 'assistant',
+    text: '',
+    tool_calls: [],
+    usage: { input_tokens: 100, output_tokens: 10, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null,
+    ...over,
+  };
+}
+
+function seed(store: string): string {
+  const dir = sessionDir(store, 'h', '2026-06', 's1');
+  writeTurnFile(dir, turn(0, { role: 'user', text: 'hi' }));
+  writeTurnFile(dir, turn(1, { telemetry: { cost_usd: 0.3 } }));
+  rebuildEnvelope(store, 'h', '2026-06', 's1', { model: 'claude-opus-4-8' }, {
+    session_id: 's1',
+    host: 'h',
+    agent: 'claude-code',
+    native_uuid: 's1',
+  });
+  return dir;
+}
+
+async function withCollector<T>(fn: (endpoint: string, paths: string[]) => Promise<T>): Promise<T> {
+  const paths: string[] = [];
+  const server = createServer((req, res) => {
+    let body = '';
+    req.on('data', (c) => (body += c));
+    req.on('end', () => {
+      paths.push(req.url ?? '');
+      res.writeHead(200).end('{}');
+    });
+  });
+  await new Promise<void>((r) => server.listen(0, r));
+  const port = (server.address() as AddressInfo).port;
+  try {
+    return await fn(`http://127.0.0.1:${port}`, paths);
+  } finally {
+    await new Promise<void>((r) => (server as Server).close(() => r()));
+  }
+}
+
+describe('exportSession', () => {
+  it('ships traces + metrics to the collector', async () => {
+    await withTempDirAsync(async (store) => {
+      const dir = seed(store);
+      await withCollector(async (endpoint, paths) => {
+        const cfg = makeConfig(store, { telemetry: { enabled: true, endpoint } });
+        const res = await exportSession(cfg, dir);
+        expect(res.ok).toBe(true);
+        expect(paths.sort()).toEqual(['/v1/metrics', '/v1/traces']);
+      });
+    });
+  });
+
+  it('skips when telemetry is disabled', async () => {
+    await withTempDirAsync(async (store) => {
+      const dir = seed(store);
+      const res = await exportSession(makeConfig(store, { telemetry: { enabled: false } }), dir);
+      expect(res.skipped).toBe(true);
+    });
+  });
+
+  it('is resilient when the collector is down', async () => {
+    await withTempDirAsync(async (store) => {
+      const dir = seed(store);
+      const cfg = makeConfig(store, { telemetry: { enabled: true, endpoint: 'http://127.0.0.1:9', timeoutMs: 400 } });
+      const res = await exportSession(cfg, dir);
+      expect(res.ok).toBe(false); // failed but did not throw
+    });
+  });
+});
+
+describe('exportStore', () => {
+  it('exports every session', async () => {
+    await withTempDirAsync(async (store) => {
+      seed(store);
+      await withCollector(async (endpoint) => {
+        const cfg = makeConfig(store, { telemetry: { enabled: true, endpoint } });
+        const res = await exportStore(cfg);
+        expect(res.total).toBe(1);
+        expect(res.exported).toBe(1);
+        expect(res.failed).toBe(0);
+      });
+    });
+  });
+});

package/src/telemetry/exporter.ts

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { safeParseSession, type SessionEnvelope } from '@unpolarize/code-sessions-schema';
+import type { CodeSessionsConfig } from '../config';
+import { envelopeFile } from '../store/paths';
+import { listSessionDirs } from '../store/scan';
+import { readTurns } from '../store/writer';
+import { buildMetricPayload, buildTracePayload, postOtlp, type PostResult } from './otlp';
+
+export interface SessionExportResult {
+  ok: boolean;
+  skipped?: boolean;
+  traces?: PostResult;
+  metrics?: PostResult;
+  reason?: string;
+}
+
+function loadEnvelope(sessionDir: string): SessionEnvelope | undefined {
+  const path = envelopeFile(sessionDir);
+  if (!existsSync(path)) return undefined;
+  try {
+    const parsed = safeParseSession(JSON.parse(readFileSync(path, 'utf8')));
+    return parsed.success ? parsed.data : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Export one session's traces + metrics over OTLP/HTTP. Resilient: never throws. */
+export async function exportSession(
+  cfg: CodeSessionsConfig,
+  sessionDir: string,
+): Promise<SessionExportResult> {
+  if (!cfg.telemetry.enabled) return { ok: false, skipped: true, reason: 'telemetry disabled' };
+  const envelope = loadEnvelope(sessionDir);
+  if (!envelope) return { ok: false, reason: 'no envelope' };
+  const turns = readTurns(sessionDir);
+  const { endpoint, serviceName, timeoutMs } = cfg.telemetry;
+
+  const traces = await postOtlp(endpoint, '/v1/traces', buildTracePayload(envelope, turns, serviceName), timeoutMs);
+  const metrics = await postOtlp(endpoint, '/v1/metrics', buildMetricPayload(envelope, turns, serviceName), timeoutMs);
+  return { ok: traces.ok && metrics.ok, traces, metrics };
+}
+
+export interface StoreExportResult {
+  total: number;
+  exported: number;
+  failed: number;
+}
+
+/** Export telemetry for every session in the store (backfill path). */
+export async function exportStore(
+  cfg: CodeSessionsConfig,
+  opts: { sinceMonth?: string } = {},
+): Promise<StoreExportResult> {
+  const refs = listSessionDirs(cfg.storeDir, opts.sinceMonth ? { sinceMonth: opts.sinceMonth } : {});
+  let exported = 0;
+  let failed = 0;
+  for (const ref of refs) {
+    const res = await exportSession(cfg, ref.dir);
+    if (res.ok) exported++;
+    else if (!res.skipped) failed++;
+  }
+  return { total: refs.length, exported, failed };
+}

package/src/telemetry/index.ts

@@ -0,0 +1,2 @@
+export * from './otlp';
+export * from './exporter';

package/src/telemetry/otlp.test.ts

@@ -0,0 +1,123 @@
+import { createServer, type Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { describe, expect, it } from 'vitest';
+import type { SessionEnvelope, Turn } from '@unpolarize/code-sessions-schema';
+import { buildMetricPayload, buildTracePayload, isoNano, postOtlp } from './otlp';
+
+const envelope: SessionEnvelope = {
+  schema: 'session-store/session@1',
+  session_id: 'sess-otlp',
+  host: 'h',
+  agent: 'claude-code',
+  project_path: '/p',
+  model: 'claude-opus-4-8',
+  started_at: '2026-06-20T08:00:00Z',
+  ended_at: '2026-06-20T08:05:00Z',
+  turn_count: 2,
+  tool_call_count: 1,
+  totals: { input_tokens: 1100, output_tokens: 30, cost_usd: 0.5 },
+  title: 'demo',
+  labels: [],
+  native_ref: { format: 'claude-jsonl', uuid: 'sess-otlp' },
+};
+
+const turns: Turn[] = [
+  {
+    schema: 'session-store/turn@1',
+    session_id: 'sess-otlp',
+    host: 'h',
+    agent: 'claude-code',
+    turn_index: 0,
+    ts: '2026-06-20T08:00:00Z',
+    role: 'user',
+    text: 'hi',
+    tool_calls: [],
+    usage: { input_tokens: 100, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null,
+  },
+  {
+    schema: 'session-store/turn@1',
+    session_id: 'sess-otlp',
+    host: 'h',
+    agent: 'claude-code',
+    turn_index: 1,
+    ts: '2026-06-20T08:00:05Z',
+    role: 'assistant',
+    text: 'ok',
+    tool_calls: [{ name: 'Edit' }],
+    usage: { input_tokens: 1000, output_tokens: 30, cache_read_tokens: 0, cache_write_tokens: 0 },
+    telemetry: { cost_usd: 0.5 },
+    scrubbed: false,
+    raw_ref: null,
+  },
+];
+
+describe('isoNano', () => {
+  it('converts ISO timestamps to unix nanoseconds', () => {
+    expect(isoNano('2026-06-20T08:00:00Z')).toBe(`${Date.parse('2026-06-20T08:00:00Z')}000000`);
+    expect(isoNano(undefined)).toBe('0');
+    expect(isoNano('not-a-date')).toBe('0');
+  });
+});
+
+describe('buildTracePayload', () => {
+  it('emits a root span + one span per turn with valid ids', () => {
+    const p = buildTracePayload(envelope, turns, 'code-sessions') as any;
+    const spans = p.resourceSpans[0].scopeSpans[0].spans;
+    expect(spans).toHaveLength(3); // root + 2 turns
+    const [root, ...turnSpans] = spans;
+    expect(root.traceId).toMatch(/^[0-9a-f]{32}$/);
+    expect(root.spanId).toMatch(/^[0-9a-f]{16}$/);
+    expect(turnSpans.every((s: any) => s.parentSpanId === root.spanId)).toBe(true);
+    // resource carries service + host
+    const attrs = p.resourceSpans[0].resource.attributes;
+    expect(attrs.find((a: any) => a.key === 'service.name').value.stringValue).toBe('code-sessions');
+    expect(attrs.find((a: any) => a.key === 'host.name').value.stringValue).toBe('h');
+    // root carries token totals
+    const inTok = root.attributes.find((a: any) => a.key === 'gen_ai.usage.input_tokens');
+    expect(inTok.value.intValue).toBe(1100);
+  });
+});
+
+describe('buildMetricPayload', () => {
+  it('emits token sum + cost gauge + turn count', () => {
+    const p = buildMetricPayload(envelope, turns, 'code-sessions') as any;
+    const metrics = p.resourceMetrics[0].scopeMetrics[0].metrics;
+    const byName = Object.fromEntries(metrics.map((m: any) => [m.name, m]));
+    expect(byName['code_sessions.tokens'].sum.dataPoints).toHaveLength(4);
+    expect(byName['code_sessions.cost_usd'].gauge.dataPoints[0].asDouble).toBe(0.5);
+    expect(byName['code_sessions.turns'].sum.dataPoints[0].asInt).toBe(2);
+  });
+});
+
+describe('postOtlp', () => {
+  it('posts JSON to the collector and reports success', async () => {
+    const received: { path: string; body: string }[] = [];
+    const server = createServer((req, res) => {
+      let body = '';
+      req.on('data', (c) => (body += c));
+      req.on('end', () => {
+        received.push({ path: req.url ?? '', body });
+        res.writeHead(200).end('{}');
+      });
+    });
+    await new Promise<void>((r) => server.listen(0, r));
+    const port = (server.address() as AddressInfo).port;
+    try {
+      const res = await postOtlp(`http://127.0.0.1:${port}`, '/v1/traces', { hello: 1 }, 2000);
+      expect(res.ok).toBe(true);
+      expect(res.status).toBe(200);
+      expect(received[0]!.path).toBe('/v1/traces');
+      expect(JSON.parse(received[0]!.body)).toEqual({ hello: 1 });
+    } finally {
+      await new Promise<void>((r) => (server as Server).close(() => r()));
+    }
+  });
+
+  it('is resilient when the collector is unreachable (no throw)', async () => {
+    const res = await postOtlp('http://127.0.0.1:9', '/v1/metrics', {}, 500);
+    expect(res.ok).toBe(false);
+    expect(res.error).toBeTruthy();
+  });
+});