@traffic-twin/sdk 0.0.0-stage → 0.1.0

package/dist/esm/capture/outbound-http.js

@@ -0,0 +1,193 @@
+// Outbound capture for node:http / node:https clients through diagnostics_channel
+// (`http.client.request.start`, `http.client.response.finish`, `http.client.request.error`).
+import diagnostics_channel from 'node:diagnostics_channel';
+import { BodyTap } from './body.js';
+import { hrNow, internal, internalAgents, netErrorOf, outboundTrace, outgoingHeadersWire, withTtS, } from './common.js';
+import { als, newSpanId } from './context.js';
+import { tapPush, tapWrites } from './inbound.js';
+const EMPTY = Buffer.alloc(0);
+/** How long an unread response body is waited for before the exchange is closed as not consumed. */
+export const UNREAD_BODY_TIMEOUT_MS = 60_000;
+const kState = Symbol('traffic-twin.outbound');
+const kSeen = Symbol('traffic-twin.outbound.seen');
+export function installOutboundHttp(host) {
+    // `http.client.request.created` (Node >= 22.12 / 23.2) fires in the ClientRequest
+    // constructor, before the app can write or end: body capture and the optional baggage
+    // member work there. On older runtimes `start` fires once a socket is assigned, which may
+    // be after end(): the body is then reported as unknown and nothing is injected.
+    const onCreated = (message) => {
+        if (internal.depth > 0)
+            return;
+        const t = hrNow();
+        try {
+            const request = message.request;
+            if (request[kSeen])
+                return;
+            request[kSeen] = true;
+            if (request.agent && internalAgents.has(request.agent))
+                return;
+            start(host, request, t);
+        }
+        catch {
+            host.noteError('capture_outbound_start');
+        }
+    };
+    const onStart = onCreated;
+    const onResponse = (message) => {
+        try {
+            const { request, response } = message;
+            const st = request[kState];
+            if (!st || st.done)
+                return;
+            st.response = response;
+            tapPush(response, st.resTap);
+            response.once('end', () => complete(host, request, true));
+            response.once('close', () => complete(host, request, false));
+            st.timer = setTimeout(() => complete(host, request, false), UNREAD_BODY_TIMEOUT_MS);
+            st.timer.unref();
+        }
+        catch {
+            host.noteError('capture_outbound_response');
+        }
+    };
+    const onError = (message) => {
+        try {
+            const { request, error } = message;
+            const st = request[kState];
+            if (st && !st.response)
+                st.netError = netErrorOf(error);
+        }
+        catch {
+            // ignore
+        }
+    };
+    diagnostics_channel.subscribe('http.client.request.created', onCreated);
+    diagnostics_channel.subscribe('http.client.request.start', onStart);
+    diagnostics_channel.subscribe('http.client.response.finish', onResponse);
+    diagnostics_channel.subscribe('http.client.request.error', onError);
+    return () => {
+        diagnostics_channel.unsubscribe('http.client.request.created', onCreated);
+        diagnostics_channel.unsubscribe('http.client.request.start', onStart);
+        diagnostics_channel.unsubscribe('http.client.response.finish', onResponse);
+        diagnostics_channel.unsubscribe('http.client.request.error', onError);
+    };
+}
+/** Authority when the request has no Host header: the host option, bracketed if it is an IPv6 literal. */
+function fallbackAuthority(request) {
+    const h = String(request.host ?? '');
+    return h.includes(':') && !h.startsWith('[') ? '[' + h + ']' : h;
+}
+function start(host, request, t) {
+    const san = host.active();
+    if (!san)
+        return;
+    host.noteSeen();
+    const ctx = als.getStore();
+    if (ctx !== undefined && !ctx.sampled && !host.propagates()) {
+        // Inherited "not sampled" and nothing to inject: no work at all for this call.
+        host.noteOverhead(hrNow() - t);
+        return;
+    }
+    const hostHeader = request.getHeader('host');
+    const proto = typeof request.protocol === 'string' ? request.protocol : 'http:';
+    // The host as the client sees it (spec v1.5, point 9): the Host header as is, a trailing dot and
+    // an `xn--` form untouched, IPv6 with its brackets. No IDN conversion, no dot stripping.
+    const urlBase = proto + '//' + (typeof hostHeader === 'string' ? hostHeader : fallbackAuthority(request));
+    const tr = outboundTrace(ctx);
+    const decision = san.decide({ dir: 'outbound', req_headers: [], trace_id: tr.samplingTraceId, inherited: ctx?.sampled });
+    if (host.mayPropagate(urlBase) && !request.headersSent) {
+        try {
+            const prev = request.getHeader('baggage');
+            request.setHeader('baggage', withTtS(typeof prev === 'string' ? prev : Array.isArray(prev) ? prev.join(',') : undefined, decision.sampled));
+        }
+        catch {
+            // headers already flushed: leave the request untouched
+        }
+    }
+    if (!decision.sampled) {
+        host.noteOverhead(hrNow() - t);
+        return;
+    }
+    host.noteSampled();
+    const limit = san.policy.captureLimit; // max(max_body_bytes, bodies.max_large_body_bytes) + 1 (sanitizer.md 9.0, 22.5)
+    const st = {
+        san,
+        decision,
+        urlBase,
+        traceId: tr.traceId,
+        spanId: newSpanId(),
+        parentSpanId: tr.parentSpanId,
+        t0: performance.now(),
+        tsMs: Date.now(),
+        reqTap: new BodyTap(limit),
+        resTap: new BodyTap(limit),
+        done: false,
+        late: typeof request._header === 'string' || request.writableEnded || request.writableLength > 0,
+        overheadNs: 0,
+    };
+    tapWrites(request, st.reqTap);
+    request[kState] = st;
+    // 'close' never changes the app's error handling (unlike an 'error' listener).
+    request.once('close', () => {
+        if (!st.response)
+            complete(host, request, false);
+    });
+    st.overheadNs = hrNow() - t;
+}
+function complete(host, request, ended) {
+    const st = request[kState];
+    if (!st || st.done)
+        return;
+    const t = hrNow();
+    st.done = true;
+    request[kState] = undefined;
+    if (st.timer)
+        clearTimeout(st.timer);
+    try {
+        const latencyMs = Math.max(0, Math.floor(performance.now() - st.t0));
+        const res = st.response;
+        const netError = res ? undefined : st.netError ?? 'other';
+        const status = res?.statusCode;
+        const resConsumed = ended && st.resTap.ended;
+        const reqBody = st.reqTap.bytes();
+        const resBody = res && resConsumed ? st.resTap.bytes() : EMPTY;
+        const wire = {
+            dir: 'outbound',
+            url_base: st.urlBase,
+            method: request.method ?? 'GET',
+            target: request.path ?? '/',
+            inherited: st.decision.by === 'inherited' ? st.decision.sampled : undefined,
+            req_headers: outgoingHeadersWire(request),
+            req_body: reqBody,
+            req_body_total: st.late ? 'unknown' : st.reqTap.total,
+        };
+        if (netError) {
+            wire.net_error = netError;
+        }
+        else {
+            wire.status = status;
+            wire.resp_headers = res.rawHeaders;
+            wire.resp_body = resBody;
+            wire.resp_body_total = st.resTap.total;
+            wire.resp_body_consumed = resConsumed;
+        }
+        host.submit({
+            sanitizer: st.san,
+            decision: st.decision,
+            dir: 'outbound',
+            tsMs: st.tsMs,
+            latencyMs,
+            traceId: st.traceId,
+            spanId: st.spanId,
+            parentSpanId: st.parentSpanId,
+            status,
+            netError,
+            heldBytes: reqBody.length + resBody.length,
+            wire,
+        });
+    }
+    catch {
+        host.noteError('capture_outbound_complete');
+    }
+    host.noteOverhead(st.overheadNs + (hrNow() - t));
+}

package/dist/esm/capture/outbound-undici.d.ts

@@ -0,0 +1,2 @@
+import { type CaptureHost } from './common.js';
+export declare function installOutboundUndici(host: CaptureHost): () => void;

package/dist/esm/capture/outbound-undici.js

@@ -0,0 +1,236 @@
+// Outbound capture for fetch / undici through its diagnostics channels
+// (`undici:request:create`, `:headers`, `:bodyChunkSent`, `:bodyChunkReceived`,
+// `:trailers`, `:error`). Body chunk channels exist in recent undici releases (Node 24);
+// where they are missing, bodies the SDK cannot see are reported as unknown length
+// (sanitizer.md 9.0: `trunc:size`), never guessed.
+//
+// Response chunks are observed before fetch removes the content-encoding, so the body is
+// passed as encoded bytes (`*_body_decoded = false`) and decoded by the sanitizer.
+import diagnostics_channel from 'node:diagnostics_channel';
+import { BodyTap } from './body.js';
+import { hrNow, internal, netErrorOf, outboundTrace, withTtS } from './common.js';
+import { als, newSpanId } from './context.js';
+import { UNREAD_BODY_TIMEOUT_MS } from './outbound-http.js';
+const EMPTY = Buffer.alloc(0);
+const states = new WeakMap();
+/** undici headers (flat array of Buffer/string, or a header block string) as flat latin1 [name, value, ...] strings. */
+function headerFlat(h) {
+    const out = [];
+    if (Array.isArray(h)) {
+        for (let i = 0; i + 1 < h.length; i += 2) {
+            const k = h[i];
+            const v = h[i + 1];
+            const name = Buffer.isBuffer(k) ? k.toString('latin1') : String(k);
+            if (Array.isArray(v))
+                for (const one of v)
+                    out.push(name, Buffer.isBuffer(one) ? one.toString('latin1') : String(one));
+            else
+                out.push(name, Buffer.isBuffer(v) ? v.toString('latin1') : String(v));
+        }
+    }
+    else if (typeof h === 'string') {
+        for (const line of h.split('\r\n')) {
+            const c = line.indexOf(':');
+            if (c > 0)
+                out.push(line.slice(0, c), line.slice(c + 1));
+        }
+    }
+    return out;
+}
+function hasHeader(h, lower) {
+    const f = headerFlat(h);
+    for (let i = 0; i + 1 < f.length; i += 2)
+        if (f[i].toLowerCase() === lower)
+            return f[i + 1];
+    return undefined;
+}
+export function installOutboundUndici(host) {
+    const subs = [];
+    const on = (name, fn) => {
+        const h = (m) => {
+            try {
+                fn(m);
+            }
+            catch {
+                host.noteError('capture_undici');
+            }
+        };
+        diagnostics_channel.subscribe(name, h);
+        subs.push([name, h]);
+    };
+    // Whether this undici publishes body chunks is learnt from the first chunk seen.
+    const seen = { sent: false, received: false };
+    on('undici:request:create', ({ request }) => {
+        if (internal.depth > 0)
+            return;
+        const t = hrNow();
+        const san = host.active();
+        if (!san)
+            return;
+        host.noteSeen();
+        const ctx = als.getStore();
+        if (ctx !== undefined && !ctx.sampled && !host.propagates()) {
+            host.noteOverhead(hrNow() - t);
+            return;
+        }
+        const origin = String(request.origin ?? '');
+        const tr = outboundTrace(ctx);
+        const decision = san.decide({ dir: 'outbound', req_headers: [], trace_id: tr.samplingTraceId, inherited: ctx?.sampled });
+        if (host.mayPropagate(origin) && typeof request.addHeader === 'function') {
+            const prev = hasHeader(request.headers, 'baggage');
+            if (prev === undefined)
+                request.addHeader('baggage', withTtS(undefined, decision.sampled));
+            else
+                request.addHeader('baggage', 'tt.s=' + (decision.sampled ? '1' : '0'));
+        }
+        if (!decision.sampled) {
+            host.noteOverhead(hrNow() - t);
+            return;
+        }
+        host.noteSampled();
+        const limit = san.policy.captureLimit; // max(max_body_bytes, bodies.max_large_body_bytes) + 1 (sanitizer.md 9.0, 22.5)
+        const st = {
+            san,
+            decision,
+            urlBase: origin,
+            method: String(request.method ?? 'GET'),
+            path: String(request.path ?? '/'),
+            traceId: tr.traceId,
+            spanId: newSpanId(),
+            parentSpanId: tr.parentSpanId,
+            t0: performance.now(),
+            tsMs: Date.now(),
+            reqTap: new BodyTap(limit),
+            reqBodyKnown: false,
+            resTap: new BodyTap(limit),
+            done: false,
+            overheadNs: 0,
+        };
+        const b = request.body;
+        if (b === null || b === undefined) {
+            st.reqBodyKnown = true;
+        }
+        else if (typeof b === 'string' || b instanceof Uint8Array) {
+            st.reqTap.add(b);
+            st.reqBodyKnown = true;
+        }
+        // Streamed bodies are counted by bodyChunkSent, when this undici publishes it.
+        states.set(request, st);
+        st.overheadNs = hrNow() - t;
+    });
+    on('undici:request:bodyChunkSent', ({ request, chunk }) => {
+        seen.sent = true;
+        const st = states.get(request);
+        if (!st)
+            return;
+        const b = request.body;
+        if (typeof b === 'string' || b instanceof Uint8Array)
+            return; // already taken from the request object
+        st.reqTap.add(chunk);
+    });
+    on('undici:request:headers', ({ request, response }) => {
+        const st = states.get(request);
+        if (!st)
+            return;
+        const r = response;
+        st.status = typeof r.statusCode === 'number' ? r.statusCode : undefined;
+        st.respHeaders = headerFlat(r.headers);
+        st.reqHeaders = headerFlat(request.headers);
+        st.timer = setTimeout(() => complete(host, request, false), UNREAD_BODY_TIMEOUT_MS);
+        st.timer.unref();
+    });
+    on('undici:request:bodyChunkReceived', ({ request, chunk }) => {
+        seen.received = true;
+        const st = states.get(request);
+        if (st)
+            st.resTap.add(chunk);
+    });
+    on('undici:request:trailers', ({ request }) => {
+        const st = states.get(request);
+        if (!st)
+            return;
+        st.resTap.ended = true;
+        complete(host, request, true);
+    });
+    on('undici:request:error', ({ request, error }) => {
+        const st = states.get(request);
+        if (!st)
+            return;
+        if (st.status === undefined)
+            st.netError = netErrorOf(error);
+        complete(host, request, false);
+    });
+    // Without the received-chunk channel the response body is never visible: a response is
+    // complete only if chunks were seen, the channel is known to work, or it declares no body.
+    const respBodyVisible = (st) => {
+        if (st.resTap.total > 0 || seen.received)
+            return true;
+        const rh = st.respHeaders ?? [];
+        for (let i = 0; i + 1 < rh.length; i += 2)
+            if (rh[i].toLowerCase() === 'content-length')
+                return rh[i + 1].trim() === '0';
+        return false;
+    };
+    function complete(h, request, ended) {
+        const st = states.get(request);
+        if (!st || st.done)
+            return;
+        const t = hrNow();
+        st.done = true;
+        states.delete(request);
+        if (st.timer)
+            clearTimeout(st.timer);
+        try {
+            const latencyMs = Math.max(0, Math.floor(performance.now() - st.t0));
+            const netError = st.status === undefined ? st.netError ?? 'other' : undefined;
+            const consumed = ended && respBodyVisible(st);
+            if (!st.reqBodyKnown && (st.reqTap.total > 0 || seen.sent))
+                st.reqBodyKnown = true;
+            const reqHeaders = st.reqHeaders ?? headerFlat(request.headers);
+            const reqBody = st.reqTap.bytes();
+            const resBody = consumed ? st.resTap.bytes() : EMPTY;
+            const wire = {
+                dir: 'outbound',
+                url_base: st.urlBase,
+                method: st.method,
+                target: st.path,
+                inherited: st.decision.by === 'inherited' ? st.decision.sampled : undefined,
+                req_headers: reqHeaders,
+                req_body: reqBody,
+                req_body_total: st.reqBodyKnown ? st.reqTap.total : 'unknown',
+            };
+            if (netError) {
+                wire.net_error = netError;
+            }
+            else {
+                wire.status = st.status;
+                wire.resp_headers = st.respHeaders ?? [];
+                wire.resp_body = resBody;
+                wire.resp_body_total = st.resTap.total;
+                wire.resp_body_consumed = consumed;
+            }
+            h.submit({
+                sanitizer: st.san,
+                decision: st.decision,
+                dir: 'outbound',
+                tsMs: st.tsMs,
+                latencyMs,
+                traceId: st.traceId,
+                spanId: st.spanId,
+                parentSpanId: st.parentSpanId,
+                status: st.status,
+                netError,
+                heldBytes: reqBody.length + resBody.length,
+                wire,
+            });
+        }
+        catch {
+            h.noteError('capture_undici_complete');
+        }
+        h.noteOverhead(st.overheadNs + (hrNow() - t));
+    }
+    return () => {
+        for (const [name, fn] of subs)
+            diagnostics_channel.unsubscribe(name, fn);
+    };
+}

package/dist/esm/capture/wire.d.ts

@@ -0,0 +1,27 @@
+import type { Exchange, NetError } from '../sanitizer/sanitizer.js';
+/** Flat [name, value, name, value ...] latin1 strings, or a serialized HTTP header block. */
+export type WireHeaders = string[] | string;
+export interface WireExchange {
+    dir: 'inbound' | 'outbound';
+    service_name?: string;
+    url_base?: string;
+    method: string;
+    /** Request target as received/sent (path and optional query). */
+    target: string;
+    framework?: string;
+    framework_route?: string;
+    trace_id?: string;
+    inherited?: boolean;
+    req_headers: WireHeaders;
+    req_body: Uint8Array;
+    req_body_total?: number | 'unknown';
+    req_body_consumed?: boolean;
+    status?: number;
+    net_error?: NetError;
+    resp_headers?: WireHeaders;
+    resp_body?: Uint8Array;
+    resp_body_total?: number | 'unknown';
+    resp_body_consumed?: boolean;
+}
+/** Wire exchange to the sanitizer's input (sanitizer.md 1). */
+export declare function wireToExchange(w: WireExchange): Exchange;

package/dist/esm/capture/wire.js

@@ -0,0 +1,65 @@
+// Wire form of a captured exchange: plain strings, numbers and byte arrays only, so it can
+// be posted to a sanitizer worker thread (structured clone) or converted in place.
+//
+// The capture hooks fill this in with the least possible work (they keep references to the
+// strings Node already built); the conversion to the sanitizer's `Exchange` (header
+// buffers, request-target split, header-block parsing) happens later, off the request
+// path, and on the worker thread when one is used.
+import { parseHeaderBlock, splitTarget } from './common.js';
+function pairs(h) {
+    if (h === undefined)
+        return [];
+    if (typeof h === 'string')
+        return parseHeaderBlock(h);
+    const out = [];
+    for (let i = 0; i + 1 < h.length; i += 2)
+        out.push([h[i], Buffer.from(h[i + 1], 'latin1')]);
+    return out;
+}
+/** Zero-copy view of body bytes that arrived through a message port or the tap. */
+function asBuffer(b) {
+    if (b === undefined)
+        return undefined;
+    return Buffer.isBuffer(b) ? b : Buffer.from(b.buffer, b.byteOffset, b.byteLength);
+}
+/** Wire exchange to the sanitizer's input (sanitizer.md 1). */
+export function wireToExchange(w) {
+    const { path, query } = splitTarget(w.target);
+    const ex = {
+        dir: w.dir,
+        method: w.method,
+        raw_path: path,
+        raw_query: query,
+        req_headers: pairs(w.req_headers),
+        req_body: asBuffer(w.req_body),
+    };
+    if (w.service_name !== undefined)
+        ex.service_name = w.service_name;
+    if (w.url_base !== undefined)
+        ex.url_base = w.url_base;
+    if (w.framework_route !== undefined) {
+        ex.framework = w.framework ?? 'express';
+        ex.framework_route = w.framework_route;
+    }
+    if (w.trace_id !== undefined)
+        ex.trace_id = w.trace_id;
+    if (w.inherited !== undefined)
+        ex.inherited = w.inherited;
+    if (w.req_body_total !== undefined)
+        ex.req_body_total = w.req_body_total;
+    if (w.req_body_consumed !== undefined)
+        ex.req_body_consumed = w.req_body_consumed;
+    if (w.net_error) {
+        ex.net_error = w.net_error;
+    }
+    else {
+        ex.status = w.status;
+        ex.resp_headers = pairs(w.resp_headers);
+        ex.resp_body = asBuffer(w.resp_body);
+        if (w.resp_body_total !== undefined)
+            ex.resp_body_total = w.resp_body_total;
+        if (w.resp_body_consumed !== undefined)
+            ex.resp_body_consumed = w.resp_body_consumed;
+    }
+    return ex;
+}

package/dist/esm/export/event.d.ts

@@ -0,0 +1,46 @@
+import { type OMap } from '../sanitizer/json.js';
+import { type NetError } from '../sanitizer/sanitizer.js';
+export interface EventMeta {
+    policyId: string;
+    policyVersion: number;
+    policyHash: string;
+    sourceId: string;
+    dir: 'inbound' | 'outbound';
+    tsMs: number;
+    latencyMs: number;
+    status?: number;
+    netError?: NetError;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+}
+/**
+ * Full canonical event from the sanitizer output (a map or its serialized top-level members)
+ * and the fields the source fills. Null if it exceeds 512 KiB (counted as sanitizer error).
+ */
+export declare function buildEvent(out: OMap | Map<string, string>, m: EventMeta): string | null;
+/** Marks a map of already serialized members (Result.parts) for buildEvent. */
+export declare function serializedParts(parts: Map<string, string>): Map<string, string>;
+export interface QueuedEvent {
+    /** Canonical event JSON. Empty when `record` already carries it (worker pipeline). */
+    json: string;
+    tsMs: number;
+    traceId?: string;
+    spanId?: string;
+    policyHash: string;
+    /** Ready-made OTLP logRecord (see makeRecord): the batch body is then only joined. */
+    record?: string;
+    /** Bytes charged to the export queue; defaults to json.length. */
+    size?: number;
+}
+export interface Resource {
+    serviceName: string;
+    sourceId: string;
+}
+/**
+ * OTLP/HTTP JSON logRecord for one event (event.md 4.2), written by hand: the canonical
+ * event is escaped once, here, and the batch body is a join of ready-made records.
+ */
+export declare function makeRecord(e: QueuedEvent, observedMs: number): string;
+/** OTLP/HTTP JSON body for a batch of events. */
+export declare function otlpBody(events: QueuedEvent[], res: Resource, nowMs: number): string;

package/dist/esm/export/event.js

@@ -0,0 +1,85 @@
+// Event assembly (event.md 1) and the OTLP/HTTP JSON logs body (event.md 4.2), written by hand.
+import { CNum, writeCanonical } from '../sanitizer/json.js';
+import { MAX_EVENT_BYTES, composeCanonical } from '../sanitizer/sanitizer.js';
+import { SDK_VERSION, SOURCE_KIND } from '../version.js';
+const HEX32 = /^[0-9a-f]{32}$/;
+const HEX16 = /^[0-9a-f]{16}$/;
+/**
+ * Full canonical event from the sanitizer output (a map or its serialized top-level members)
+ * and the fields the source fills. Null if it exceeds 512 KiB (counted as sanitizer error).
+ */
+export function buildEvent(out, m) {
+    const parts = new Map();
+    const pre = isSerialized(out);
+    for (const [k, v] of out)
+        parts.set(k, pre ? v : writeCanonical(v));
+    const set = (k, v) => parts.set(k, writeCanonical(v));
+    set('schema', 'tt.http.exchange/v1');
+    set('policy', new Map([['id', m.policyId], ['version', new CNum(String(m.policyVersion))], ['hash', m.policyHash]]));
+    set('source', new Map([['kind', SOURCE_KIND], ['version', SDK_VERSION], ['id', m.sourceId]]));
+    set('ts', new Date(m.tsMs).toISOString());
+    set('latency_ms', new CNum(String(Math.max(0, Math.floor(m.latencyMs)))));
+    set('dir', m.dir);
+    if (m.netError) {
+        set('net_error', m.netError);
+        parts.delete('resp');
+    }
+    else if (typeof m.status === 'number' && m.status >= 100 && m.status <= 599) {
+        set('status', new CNum(String(m.status)));
+    }
+    else {
+        return null;
+    }
+    if (m.traceId && HEX32.test(m.traceId))
+        set('trace_id', m.traceId);
+    if (m.spanId && HEX16.test(m.spanId))
+        set('span_id', m.spanId);
+    if (m.parentSpanId && HEX16.test(m.parentSpanId))
+        set('parent_span_id', m.parentSpanId);
+    const s = composeCanonical(parts);
+    return s.length > MAX_EVENT_BYTES ? null : s;
+}
+const serialized = new WeakSet();
+/** Marks a map of already serialized members (Result.parts) for buildEvent. */
+export function serializedParts(parts) {
+    serialized.add(parts);
+    return parts;
+}
+function isSerialized(m) {
+    return serialized.has(m);
+}
+const attr = (key, value) => ({ key, value: { stringValue: value } });
+const nanos = (ms) => (ms > 0 ? String(Math.trunc(ms)) + '000000' : '0');
+/**
+ * OTLP/HTTP JSON logRecord for one event (event.md 4.2), written by hand: the canonical
+ * event is escaped once, here, and the batch body is a join of ready-made records.
+ */
+export function makeRecord(e, observedMs) {
+    let r = '{"timeUnixNano":"' + nanos(e.tsMs) + '","observedTimeUnixNano":"' + nanos(observedMs)
+        + '","severityNumber":9,"severityText":"INFO","eventName":"tt.http.exchange"';
+    if (e.traceId && HEX32.test(e.traceId))
+        r += ',"traceId":"' + e.traceId + '"';
+    if (e.spanId && HEX16.test(e.spanId))
+        r += ',"spanId":"' + e.spanId + '"';
+    r += ',"attributes":[{"key":"tt.schema","value":{"stringValue":"tt.http.exchange/v1"}},{"key":"tt.policy.hash","value":{"stringValue":'
+        + JSON.stringify(e.policyHash) + '}}],"body":{"stringValue":' + JSON.stringify(e.json) + '}}';
+    return r;
+}
+/** OTLP/HTTP JSON body for a batch of events. */
+export function otlpBody(events, res, nowMs) {
+    let recs = '';
+    for (let i = 0; i < events.length; i++) {
+        const e = events[i];
+        if (i > 0)
+            recs += ',';
+        recs += e.record ?? makeRecord(e, nowMs);
+    }
+    return '{"resourceLogs":[{"resource":' + JSON.stringify({
+        attributes: [
+            attr('service.name', res.serviceName),
+            attr('tt.source.kind', SOURCE_KIND),
+            attr('tt.source.version', SDK_VERSION),
+            attr('tt.source.id', res.sourceId),
+        ],
+    }) + ',"scopeLogs":[{"scope":' + JSON.stringify({ name: 'traffic-twin', version: SDK_VERSION }) + ',"logRecords":[' + recs + ']}]}]}';
+}