@timo972/cc-router 0.12.1 → 0.12.2-rc.0

package/dist/telemetry/otel-exporters.js

@@ -0,0 +1,289 @@
+import { SpanKind, SpanStatusCode, TraceFlags } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ExporterMetrics, OTLPExporterBase, createOtlpNetworkExportDelegate, } from "@opentelemetry/otlp-exporter-base";
+import { JsonLogsSerializer, LogsExporterMetricsHelper, ProtobufTraceSerializer, TraceExporterMetricsHelper, } from "@opentelemetry/otlp-transformer";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { POSTHOG_HOST, POSTHOG_PROJECT_TOKEN, POSTHOG_REQUEST_TIMEOUT_MS, } from "./contracts.js";
+import { fromOtelAttributes, LOG_ATTRIBUTE_KEYS, RESOURCE_ATTRIBUTE_KEYS, reconstructLog, reconstructResource, reconstructSpan, SPAN_ATTRIBUTE_KEYS, toOtelAttributes, } from "./privacy.js";
+const SUCCESS = { code: 0 };
+const FAILED = { code: 1 };
+const EXPORT_TIMEOUT_MS = POSTHOG_REQUEST_TIMEOUT_MS;
+const LIFECYCLE_TIMEOUT_MS = 2_000;
+const MAX_BATCH_SIZE = 100;
+const POSTHOG_TRACE_URL = `${POSTHOG_HOST}/i/v1/traces`;
+const POSTHOG_LOG_URL = `${POSTHOG_HOST}/i/v1/logs`;
+function own(input, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+async function settleWithin(operation, timeoutMs) {
+    let timer;
+    try {
+        await Promise.race([
+            Promise.resolve().then(operation).catch(() => undefined),
+            new Promise(resolve => {
+                timer = setTimeout(resolve, timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    catch {
+        // Telemetry lifecycle failures are isolated from application behavior.
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function hrTimeToMilliseconds(time) {
+    return time[0] * 1_000 + time[1] / 1_000_000;
+}
+function millisecondsToHrTime(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1_000);
+    return [seconds, Math.round((milliseconds - seconds * 1_000) * 1_000_000)];
+}
+function spanKindName(kind) {
+    switch (kind) {
+        case SpanKind.INTERNAL: return "internal";
+        case SpanKind.SERVER: return "server";
+        case SpanKind.CLIENT: return "client";
+        default: return undefined;
+    }
+}
+function otelSpanKind(kind) {
+    switch (kind) {
+        case "internal": return SpanKind.INTERNAL;
+        case "server": return SpanKind.SERVER;
+        case "client": return SpanKind.CLIENT;
+    }
+}
+function spanStatusName(code) {
+    switch (code) {
+        case SpanStatusCode.UNSET: return "unset";
+        case SpanStatusCode.OK: return "ok";
+        case SpanStatusCode.ERROR: return "error";
+        default: return undefined;
+    }
+}
+function otelSpanStatus(code) {
+    switch (code) {
+        case "unset": return SpanStatusCode.UNSET;
+        case "ok": return SpanStatusCode.OK;
+        case "error": return SpanStatusCode.ERROR;
+    }
+}
+function severityName(value) {
+    switch (value) {
+        case SeverityNumber.INFO: return "info";
+        case SeverityNumber.WARN: return "warn";
+        case SeverityNumber.ERROR: return "error";
+        case SeverityNumber.FATAL: return "fatal";
+        default: return undefined;
+    }
+}
+function otelSeverity(value) {
+    switch (value) {
+        case "info": return { text: "INFO", number: SeverityNumber.INFO };
+        case "warn": return { text: "WARN", number: SeverityNumber.WARN };
+        case "error": return { text: "ERROR", number: SeverityNumber.ERROR };
+        case "fatal": return { text: "FATAL", number: SeverityNumber.FATAL };
+    }
+}
+function safeResource(candidate, installationId) {
+    return reconstructResource(fromOtelAttributes(RESOURCE_ATTRIBUTE_KEYS, candidate.attributes), { installationId });
+}
+function rebuildSpan(candidate, snapshot) {
+    try {
+        const context = candidate.spanContext();
+        const resource = safeResource(candidate.resource, snapshot.state.installId);
+        const safe = reconstructSpan({
+            scope: candidate.instrumentationScope.name,
+            operation: own(candidate.attributes, "cc_router.operation"),
+            traceId: context.traceId,
+            spanId: context.spanId,
+            parentSpanId: candidate.parentSpanContext?.spanId,
+            kind: spanKindName(candidate.kind),
+            startTimeMs: hrTimeToMilliseconds(candidate.startTime),
+            durationMs: hrTimeToMilliseconds(candidate.duration),
+            statusCode: spanStatusName(candidate.status.code),
+            attributes: fromOtelAttributes(SPAN_ATTRIBUTE_KEYS, candidate.attributes),
+        });
+        if (!resource || !safe)
+            return undefined;
+        return newReadableSpan(safe, resource);
+    }
+    catch {
+        return undefined;
+    }
+}
+function newReadableSpan(safe, resource) {
+    const spanContext = { traceId: safe.traceId, spanId: safe.spanId, traceFlags: TraceFlags.SAMPLED };
+    return {
+        name: safe.name,
+        kind: otelSpanKind(safe.kind),
+        spanContext: () => ({ ...spanContext }),
+        ...(safe.parentSpanId === undefined ? {} : {
+            parentSpanContext: {
+                traceId: safe.traceId,
+                spanId: safe.parentSpanId,
+                traceFlags: TraceFlags.SAMPLED,
+            },
+        }),
+        startTime: millisecondsToHrTime(safe.startTimeMs),
+        endTime: millisecondsToHrTime(safe.startTimeMs + safe.durationMs),
+        duration: millisecondsToHrTime(safe.durationMs),
+        status: { code: otelSpanStatus(safe.statusCode) },
+        attributes: toOtelAttributes(SPAN_ATTRIBUTE_KEYS, safe.attributes),
+        links: [],
+        events: [],
+        ended: true,
+        resource: resourceFromAttributes({ ...resource }),
+        instrumentationScope: { name: safe.scope },
+        droppedAttributesCount: 0,
+        droppedEventsCount: 0,
+        droppedLinksCount: 0,
+    };
+}
+function rebuildLog(candidate, snapshot) {
+    try {
+        const resource = safeResource(candidate.resource, snapshot.state.installId);
+        // The diagnostic id is a per-attempt random UUID; reconstructLog still
+        // validates it and rejects anything equal to the install identity.
+        const diagnosticId = own(candidate.attributes, LOG_ATTRIBUTE_KEYS.diagnosticId);
+        const safe = reconstructLog({
+            scope: candidate.instrumentationScope.name,
+            body: candidate.body,
+            severity: severityName(candidate.severityNumber),
+            timestampMs: hrTimeToMilliseconds(candidate.hrTime),
+            traceId: candidate.spanContext?.traceId,
+            spanId: candidate.spanContext?.spanId,
+            attributes: fromOtelAttributes(LOG_ATTRIBUTE_KEYS, candidate.attributes),
+        }, {
+            installationId: snapshot.state.installId,
+            ...(typeof diagnosticId === "string" ? { diagnosticId } : {}),
+        });
+        if (!resource || !safe)
+            return undefined;
+        return newReadableLog(safe, resource);
+    }
+    catch {
+        return undefined;
+    }
+}
+function newReadableLog(safe, resource) {
+    const severity = otelSeverity(safe.severity);
+    const hrTime = millisecondsToHrTime(safe.timestampMs);
+    return {
+        hrTime,
+        hrTimeObserved: [...hrTime],
+        ...(safe.traceId && safe.spanId
+            ? { spanContext: { traceId: safe.traceId, spanId: safe.spanId, traceFlags: TraceFlags.SAMPLED } }
+            : {}),
+        severityText: severity.text,
+        severityNumber: severity.number,
+        body: safe.body,
+        resource: resourceFromAttributes({ ...resource }),
+        instrumentationScope: { name: safe.scope },
+        attributes: toOtelAttributes(LOG_ATTRIBUTE_KEYS, safe.attributes),
+        droppedAttributesCount: 0,
+    };
+}
+/**
+ * Wrap an OTLP delegate so nothing reaches the network unless consent still
+ * holds, and only records rebuilt from the closed allowlist are handed over.
+ */
+function gatedExporter(getSnapshot, rebuild, delegate) {
+    return {
+        export(records, callback) {
+            let settled = false;
+            let timer;
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                callback(result);
+            };
+            try {
+                const snapshot = getSnapshot();
+                if (!snapshot) {
+                    settle(SUCCESS);
+                    return;
+                }
+                const safe = records.slice(0, MAX_BATCH_SIZE).flatMap(record => {
+                    const rebuilt = rebuild(record, snapshot);
+                    return rebuilt ? [rebuilt] : [];
+                });
+                // Re-check: an opt-out during reconstruction must still drop the batch.
+                if (safe.length === 0 || !getSnapshot()) {
+                    settle(SUCCESS);
+                    return;
+                }
+                timer = setTimeout(() => settle(FAILED), EXPORT_TIMEOUT_MS);
+                timer.unref?.();
+                delegate.export(safe, result => settle(result.code === 0 ? SUCCESS : FAILED));
+            }
+            catch {
+                settle(FAILED);
+            }
+        },
+        async forceFlush() {
+            if (!getSnapshot())
+                return;
+            await settleWithin(() => delegate.forceFlush?.(), LIFECYCLE_TIMEOUT_MS);
+        },
+        async shutdown() {
+            await settleWithin(() => delegate.shutdown(), LIFECYCLE_TIMEOUT_MS);
+        },
+    };
+}
+/**
+ * One HTTP POST per export, consent re-read immediately before it. The SDK's
+ * stock exporters wrap their transport in a retrying layer that would resend a
+ * batch after a 503 without consulting consent again; this transport never
+ * reports a retryable result, so nothing is transmitted twice.
+ */
+function consentGatedTransport(url, contentType, getSnapshot) {
+    return {
+        async send(data, timeoutMillis) {
+            if (!getSnapshot()?.enabled)
+                return { status: "success" };
+            try {
+                const response = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "content-type": contentType,
+                        authorization: `Bearer ${POSTHOG_PROJECT_TOKEN}`,
+                    },
+                    body: new Uint8Array(data),
+                    signal: AbortSignal.timeout(Math.max(1, timeoutMillis)),
+                });
+                if (response.ok)
+                    return { status: "success" };
+                return { status: "failure", error: new Error(`OTLP export rejected with HTTP ${response.status}`) };
+            }
+            catch {
+                // The raw transport error may name hosts or addresses; it stays local.
+                return { status: "failure", error: new Error("OTLP export failed") };
+            }
+        },
+        shutdown() { },
+    };
+}
+function otlpExporter(url, contentType, serializer, metricsHelper, getSnapshot) {
+    const options = { timeoutMillis: POSTHOG_REQUEST_TIMEOUT_MS, concurrencyLimit: 1, compression: "none" };
+    return new OTLPExporterBase(createOtlpNetworkExportDelegate(options, serializer, new ExporterMetrics({
+        componentType: "cc_router_otlp_exporter",
+        metricsHelper,
+        url,
+        meterProvider: undefined,
+        responseAttributesFromError: () => ({}),
+    }), consentGatedTransport(url, contentType, getSnapshot)));
+}
+export function createPostHogOtlpExporters(options) {
+    const traceUrl = options.traceUrl ?? POSTHOG_TRACE_URL;
+    const logUrl = options.logUrl ?? POSTHOG_LOG_URL;
+    return {
+        spanExporter: gatedExporter(options.getSnapshot, rebuildSpan, otlpExporter(traceUrl, "application/x-protobuf", ProtobufTraceSerializer, TraceExporterMetricsHelper, options.getSnapshot)),
+        logExporter: gatedExporter(options.getSnapshot, rebuildLog, otlpExporter(logUrl, "application/json", JsonLogsSerializer, LogsExporterMetricsHelper, options.getSnapshot)),
+    };
+}

package/dist/telemetry/posthog-client.js

@@ -0,0 +1,398 @@
+import { PostHog } from "posthog-node";
+import { ERROR_KINDS, MAX_STACK_FRAMES, MAX_STACK_FRAME_PATH_LENGTH, OPERATIONS, POSTHOG_FLUSH_AT, POSTHOG_FLUSH_INTERVAL_MS, POSTHOG_HOST, POSTHOG_MAX_QUEUE_SIZE, POSTHOG_PROJECT_TOKEN, POSTHOG_REQUEST_TIMEOUT_MS, PROVIDERS, RUNTIME_MODES, SETUP_REASONS, SETUP_STAGES, SYSTEM_ERROR_CODES, } from "./contracts.js";
+import { reconstructAnalyticsEvent } from "./privacy.js";
+/** Stamped on every capture and re-checked in before_send against live consent. */
+const CONSENT_GENERATION_PROPERTY = "cc_router.consent_generation";
+const QUEUE_KEYS = ["queue", "ai_queue", "logs_queue"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function own(input, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function member(values, value) {
+    return typeof value === "string" && values.includes(value)
+        ? value
+        : undefined;
+}
+function uuid(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.toLowerCase();
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(normalized)
+        ? normalized
+        : undefined;
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+function httpStatusCode(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 100 && value <= 599
+        ? value
+        : undefined;
+}
+function optionalMember(values, value) {
+    if (value === undefined)
+        return { valid: true };
+    const normalized = member(values, value);
+    return normalized === undefined ? { valid: false } : { valid: true, value: normalized };
+}
+function safeFramePath(value) {
+    if (typeof value !== "string" || value.length === 0 || value.length > MAX_STACK_FRAME_PATH_LENGTH) {
+        return undefined;
+    }
+    if (!value.startsWith("dist/") && !value.startsWith("node_modules/"))
+        return undefined;
+    const segments = value.split("/");
+    if (segments.some(segment => segment.length === 0
+        || segment === "."
+        || segment === ".."
+        || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment)
+        || !/^[0-9A-Za-z@._+~-]+$/.test(segment))) {
+        return undefined;
+    }
+    if (segments[0] === "node_modules") {
+        const packageSegments = segments[1]?.startsWith("@") ? 2 : 1;
+        if (segments.length < packageSegments + 2)
+            return undefined;
+    }
+    return value;
+}
+function reconstructExceptionFrames(input) {
+    if (!Array.isArray(input) || input.length > MAX_STACK_FRAMES)
+        return undefined;
+    const frames = [];
+    for (const candidate of input) {
+        if (!isRecord(candidate))
+            return undefined;
+        const filename = safeFramePath(own(candidate, "filename"));
+        const line = positiveInteger(own(candidate, "lineno"));
+        const column = positiveInteger(own(candidate, "colno"));
+        if (!filename || !line || !column)
+            return undefined;
+        frames.push({ platform: "node:javascript", filename, lineno: line, colno: column });
+    }
+    return frames;
+}
+function reconstructExceptionList(input, reason) {
+    if (!Array.isArray(input) || input.length !== 1 || !isRecord(input[0]))
+        return undefined;
+    const exception = input[0];
+    const mechanism = own(exception, "mechanism");
+    if (own(exception, "type") !== "Error"
+        || own(exception, "value") !== reason
+        || !isRecord(mechanism)
+        || own(mechanism, "type") !== "generic"
+        || own(mechanism, "handled") !== true
+        || own(mechanism, "synthetic") !== false) {
+        return undefined;
+    }
+    const stacktrace = own(exception, "stacktrace");
+    if (stacktrace === undefined) {
+        return [{ type: "Error", value: reason, mechanism: { type: "generic", handled: true, synthetic: false } }];
+    }
+    if (!isRecord(stacktrace) || own(stacktrace, "type") !== "raw")
+        return undefined;
+    const frames = reconstructExceptionFrames(own(stacktrace, "frames"));
+    if (!frames)
+        return undefined;
+    return [{
+            type: "Error",
+            value: reason,
+            mechanism: { type: "generic", handled: true, synthetic: false },
+            stacktrace: { type: "raw", frames },
+        }];
+}
+/** Rebuild the SDK's own $exception payload from the closed allowlist. */
+function reconstructExceptionEvent(event, installationId) {
+    if (event.event !== "$exception" || !isRecord(event.properties))
+        return null;
+    const properties = event.properties;
+    const category = own(properties, "category");
+    const reason = member(SETUP_REASONS, own(properties, "reason"));
+    const errorKind = member(ERROR_KINDS, own(properties, "errorKind"));
+    const fingerprint = own(properties, "$exception_fingerprint");
+    const diagnosticId = uuid(own(properties, "diagnosticId"));
+    if ((category !== "setup" && category !== "runtime")
+        || !reason
+        || !errorKind
+        || typeof fingerprint !== "string"
+        || !/^[0-9a-f]{64}$/.test(fingerprint)
+        || !diagnosticId
+        || diagnosticId === installationId
+        || own(properties, "$exception_level") !== "error") {
+        return null;
+    }
+    const exceptionList = reconstructExceptionList(own(properties, "$exception_list"), reason);
+    if (!exceptionList)
+        return null;
+    const systemErrorCode = optionalMember(SYSTEM_ERROR_CODES, own(properties, "systemErrorCode"));
+    const operation = optionalMember(OPERATIONS, own(properties, "operation"));
+    const provider = optionalMember(PROVIDERS, own(properties, "provider"));
+    const setupStage = optionalMember(SETUP_STAGES, own(properties, "setupStage"));
+    const runtimeMode = optionalMember(RUNTIME_MODES, own(properties, "runtimeMode"));
+    const statusCandidate = own(properties, "httpStatusCode");
+    const status = statusCandidate === undefined ? undefined : httpStatusCode(statusCandidate);
+    if (!systemErrorCode.valid || !operation.valid || !provider.valid || !setupStage.valid || !runtimeMode.valid
+        || (statusCandidate !== undefined && status === undefined)) {
+        return null;
+    }
+    const safeProperties = {
+        $exception_list: exceptionList,
+        $exception_level: "error",
+        $exception_fingerprint: fingerprint,
+        category,
+        reason,
+        errorKind,
+    };
+    if (systemErrorCode.value !== undefined)
+        safeProperties.systemErrorCode = systemErrorCode.value;
+    if (status !== undefined)
+        safeProperties.httpStatusCode = status;
+    if (operation.value !== undefined)
+        safeProperties.operation = operation.value;
+    if (provider.value !== undefined)
+        safeProperties.provider = provider.value;
+    if (setupStage.value !== undefined)
+        safeProperties.setupStage = setupStage.value;
+    if (runtimeMode.value !== undefined)
+        safeProperties.runtimeMode = runtimeMode.value;
+    safeProperties.diagnosticId = diagnosticId;
+    safeProperties.$process_person_profile = false;
+    safeProperties.$geoip_disable = true;
+    return { event: "$exception", distinctId: installationId, disableGeoip: true, properties: safeProperties };
+}
+function noOpResponse() {
+    return { status: 204, text: async () => "", json: async () => ({}), headers: { get: () => null } };
+}
+function boundedDeadline(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+async function settleWithin(operation, deadlineMs) {
+    let timeout;
+    try {
+        await Promise.race([
+            Promise.resolve().then(operation).catch(() => undefined),
+            new Promise(resolve => { timeout = setTimeout(resolve, boundedDeadline(deadlineMs)); }),
+        ]);
+    }
+    catch {
+        // Telemetry lifecycle failures must never affect application behavior.
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function exceptionProperties(exception, consentGeneration) {
+    const properties = {
+        $exception_fingerprint: exception.fingerprint,
+        category: exception.category,
+        reason: exception.reason,
+        errorKind: exception.errorKind,
+        diagnosticId: exception.diagnosticId,
+        $process_person_profile: false,
+        $geoip_disable: true,
+        [CONSENT_GENERATION_PROPERTY]: consentGeneration,
+    };
+    if (exception.systemErrorCode !== undefined)
+        properties.systemErrorCode = exception.systemErrorCode;
+    if (exception.httpStatusCode !== undefined)
+        properties.httpStatusCode = exception.httpStatusCode;
+    if (exception.operation !== undefined)
+        properties.operation = exception.operation;
+    if (exception.provider !== undefined)
+        properties.provider = exception.provider;
+    if (exception.setupStage !== undefined)
+        properties.setupStage = exception.setupStage;
+    if (exception.runtimeMode !== undefined)
+        properties.runtimeMode = exception.runtimeMode;
+    return properties;
+}
+/**
+ * posthog-node wrapper pinned to the EU host with no person profiles and no
+ * GeoIP. Consent is enforced three times: when a capture is prepared, in
+ * before_send (which also rebuilds every event from the closed allowlist), and
+ * in the transport, which answers 204 without a request once consent is gone.
+ */
+export function createPostHogTelemetryClient(options) {
+    const getSnapshot = options.getSnapshot;
+    const transport = options.fetch ?? ((url, init) => globalThis.fetch(url, init));
+    const createSdkClient = options.createSdkClient
+        ?? ((token, sdkOptions) => new PostHog(token, sdkOptions));
+    let sdkClient;
+    let initializationFailed = false;
+    let shutdownStarted = false;
+    const activeTransports = new Set();
+    const abortActiveTransports = () => {
+        for (const controller of activeTransports)
+            controller.abort();
+        activeTransports.clear();
+    };
+    const discardPending = () => {
+        abortActiveTransports();
+        for (const key of QUEUE_KEYS) {
+            try {
+                sdkClient?.setPersistedProperty(key, []);
+            }
+            catch {
+                // Queue cleanup failures are still caught by the transport gate.
+            }
+        }
+    };
+    const beforeSend = (event) => {
+        try {
+            if (!event || !isRecord(event.properties))
+                return null;
+            const snapshot = getSnapshot();
+            const installationId = snapshot && uuid(snapshot.state.installId);
+            if (!snapshot || !installationId)
+                return null;
+            if (own(event.properties, CONSENT_GENERATION_PROPERTY) !== snapshot.state.consentGeneration) {
+                return null;
+            }
+            if (event.event === "$exception")
+                return reconstructExceptionEvent(event, installationId);
+            const diagnosticId = own(event.properties, "diagnosticId");
+            const safe = reconstructAnalyticsEvent({
+                event: event.event,
+                properties: event.properties,
+            }, {
+                installationId,
+                ...(typeof diagnosticId === "string" ? { diagnosticId } : {}),
+            });
+            if (!safe)
+                return null;
+            return {
+                event: safe.event,
+                distinctId: safe.installationId,
+                disableGeoip: true,
+                properties: { ...safe.properties, $process_person_profile: false, $geoip_disable: true },
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const gatedFetch = async (url, fetchOptions) => {
+        try {
+            // Consent is re-read immediately before every transmission so a batch
+            // the SDK queued before an opt-out never leaves the process.
+            if (!getSnapshot()?.enabled)
+                return noOpResponse();
+            const controller = new AbortController();
+            const inherited = fetchOptions.signal;
+            const forwardAbort = () => { controller.abort(); };
+            if (inherited?.aborted)
+                controller.abort();
+            else
+                inherited?.addEventListener("abort", forwardAbort, { once: true });
+            activeTransports.add(controller);
+            try {
+                return await transport(url, { ...fetchOptions, signal: controller.signal });
+            }
+            finally {
+                inherited?.removeEventListener("abort", forwardAbort);
+                activeTransports.delete(controller);
+            }
+        }
+        catch {
+            throw new Error("PostHog transport failed");
+        }
+    };
+    const activeClient = (capturedConsentGeneration) => {
+        if (shutdownStarted || initializationFailed)
+            return undefined;
+        const snapshot = getSnapshot();
+        const installationId = snapshot && uuid(snapshot.state.installId);
+        if (!snapshot || !installationId)
+            return undefined;
+        if (snapshot.state.consentGeneration !== capturedConsentGeneration)
+            return undefined;
+        if (!sdkClient) {
+            try {
+                sdkClient = createSdkClient(POSTHOG_PROJECT_TOKEN, {
+                    host: POSTHOG_HOST,
+                    disableGeoip: true,
+                    enableExceptionAutocapture: false,
+                    disableRemoteConfig: true,
+                    disableRemoteFeatureFlags: true,
+                    flushAt: POSTHOG_FLUSH_AT,
+                    maxQueueSize: POSTHOG_MAX_QUEUE_SIZE,
+                    flushInterval: POSTHOG_FLUSH_INTERVAL_MS,
+                    requestTimeout: POSTHOG_REQUEST_TIMEOUT_MS,
+                    fetchRetryCount: 0,
+                    disableCompression: true,
+                    before_send: beforeSend,
+                    fetch: gatedFetch,
+                });
+            }
+            catch {
+                initializationFailed = true;
+                return undefined;
+            }
+        }
+        return { client: sdkClient, installationId };
+    };
+    return {
+        captureAnalytics(event, consentGeneration) {
+            try {
+                const active = activeClient(consentGeneration);
+                active?.client.capture({
+                    event: event.event,
+                    distinctId: active.installationId,
+                    disableGeoip: true,
+                    properties: {
+                        ...event.properties,
+                        $process_person_profile: false,
+                        $geoip_disable: true,
+                        [CONSENT_GENERATION_PROPERTY]: consentGeneration,
+                    },
+                });
+            }
+            catch {
+                // Capture is best effort only.
+            }
+        },
+        captureException(exception, consentGeneration) {
+            try {
+                const active = activeClient(consentGeneration);
+                active?.client.captureException(exception.error, active.installationId, exceptionProperties(exception, consentGeneration));
+            }
+            catch {
+                // Capture is best effort only.
+            }
+        },
+        async captureExceptionImmediate(exception, consentGeneration) {
+            try {
+                const active = activeClient(consentGeneration);
+                if (!active)
+                    return;
+                await active.client.captureExceptionImmediate(exception.error, active.installationId, exceptionProperties(exception, consentGeneration));
+            }
+            catch {
+                // A crash-path capture must not change process behavior.
+            }
+        },
+        async flushWithin(deadlineMs) {
+            const client = sdkClient;
+            if (!client)
+                return;
+            if (!getSnapshot()) {
+                discardPending();
+                return;
+            }
+            await settleWithin(() => client.flush(), deadlineMs);
+        },
+        async shutdownWithin(deadlineMs) {
+            const client = sdkClient;
+            shutdownStarted = true;
+            if (!client)
+                return;
+            await settleWithin(() => client.shutdown(boundedDeadline(deadlineMs)), deadlineMs);
+            abortActiveTransports();
+            sdkClient = undefined;
+        },
+        discardPending,
+    };
+}