@obtrace/browser 1.0.0

package/dist/browser_entry.js

@@ -0,0 +1,3 @@
+export { initBrowserSDK } from "./browser/index";
+export { SemanticMetrics } from "./shared/semantic_metrics";
+export { isSemanticMetricName } from "./shared/semantic_metrics";

package/dist/core/client.js

@@ -0,0 +1,80 @@
+import { enqueueOffline } from "../browser/offline";
+export class ObtraceClient {
+    config;
+    active = true;
+    replayTimer = null;
+    constructor(config) {
+        if (!config.apiKey || !config.ingestBaseUrl || !config.serviceName) {
+            throw new Error("apiKey, ingestBaseUrl and serviceName are required");
+        }
+        this.config = {
+            requestTimeoutMs: 5000,
+            defaultHeaders: {},
+            ...config,
+            apiKey: config.apiKey,
+            ingestBaseUrl: config.ingestBaseUrl.replace(/\/$/, ""),
+            serviceName: config.serviceName,
+        };
+    }
+    stop() {
+        this.active = false;
+        if (this.replayTimer) {
+            clearInterval(this.replayTimer);
+            this.replayTimer = null;
+        }
+    }
+    async shutdown() {
+        this.stop();
+    }
+    replayChunk(chunk) {
+        if (!this.active)
+            return;
+        this.sendReplay("/ingest/replay/chunk", JSON.stringify(chunk));
+    }
+    replayRecipes(steps) {
+        if (!this.active)
+            return;
+        this.sendReplay("/ingest/replay/recipes", JSON.stringify({ steps }));
+    }
+    injectPropagation(headers, context) {
+        const h = new Headers(headers);
+        if (this.config.propagation?.enabled === false) {
+            return h;
+        }
+        const sessionHeader = this.config.propagation?.sessionHeaderName ?? "x-obtrace-session-id";
+        if (context?.sessionId && !h.has(sessionHeader)) {
+            h.set(sessionHeader, context.sessionId);
+        }
+        return h;
+    }
+    sendReplay(endpoint, body) {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), this.config.requestTimeoutMs);
+        const hdrs = {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "Content-Type": "application/json",
+            ...this.config.defaultHeaders,
+        };
+        if (this.config.appId)
+            hdrs["X-Obtrace-App-ID"] = this.config.appId;
+        if (this.config.env)
+            hdrs["X-Obtrace-Env"] = this.config.env;
+        if (this.config.serviceName)
+            hdrs["X-Obtrace-Service-Name"] = this.config.serviceName;
+        const url = `${this.config.ingestBaseUrl}${endpoint}`;
+        fetch(url, {
+            method: "POST",
+            headers: hdrs,
+            body,
+            signal: ctrl.signal,
+        })
+            .then((res) => {
+            if (!res.ok)
+                throw new Error(`${res.status}`);
+        })
+            .catch(() => {
+            enqueueOffline(url, body, hdrs).catch(() => { });
+        })
+            .finally(() => clearTimeout(t));
+    }
+}

package/dist/core/otel-web-setup.js

@@ -0,0 +1,93 @@
+import { trace, metrics } from "@opentelemetry/api";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import { BatchSpanProcessor, TraceIdRatioBasedSampler, ParentBasedSampler } from "@opentelemetry/sdk-trace-web";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
+import { XMLHttpRequestInstrumentation } from "@opentelemetry/instrumentation-xml-http-request";
+import { DocumentLoadInstrumentation } from "@opentelemetry/instrumentation-document-load";
+import { UserInteractionInstrumentation } from "@opentelemetry/instrumentation-user-interaction";
+import { ZoneContextManager } from "@opentelemetry/context-zone";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+export function setupOtelWeb(config) {
+    const baseUrl = config.ingestBaseUrl.replace(/\/$/, "");
+    const authHeaders = {
+        Authorization: `Bearer ${config.apiKey}`,
+        ...(config.appId ? { "X-Obtrace-App-ID": config.appId } : {}),
+        ...(config.env ? { "X-Obtrace-Env": config.env } : {}),
+        ...(config.serviceName ? { "X-Obtrace-Service-Name": config.serviceName } : {}),
+        ...config.defaultHeaders,
+    };
+    const resource = new Resource({
+        [ATTR_SERVICE_NAME]: config.serviceName,
+        [ATTR_SERVICE_VERSION]: config.serviceVersion ?? "0.0.0",
+        "deployment.environment": config.env ?? "dev",
+        ...(config.tenantId ? { "obtrace.tenant_id": config.tenantId } : {}),
+        ...(config.projectId ? { "obtrace.project_id": config.projectId } : {}),
+        ...(config.appId ? { "obtrace.app_id": config.appId } : {}),
+        ...(config.env ? { "obtrace.env": config.env } : {}),
+        "runtime.name": "browser",
+    });
+    const traceExporter = new OTLPTraceExporter({
+        url: `${baseUrl}/otlp/v1/traces`,
+        headers: authHeaders,
+    });
+    const sampleRate = config.tracesSampleRate ?? 1;
+    const sampler = sampleRate < 1
+        ? new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(sampleRate) })
+        : undefined;
+    const tracerProvider = new WebTracerProvider({
+        resource,
+        spanProcessors: [new BatchSpanProcessor(traceExporter)],
+        ...(sampler ? { sampler } : {}),
+    });
+    tracerProvider.register({
+        contextManager: new ZoneContextManager(),
+    });
+    const metricExporter = new OTLPMetricExporter({
+        url: `${baseUrl}/otlp/v1/metrics`,
+        headers: authHeaders,
+    });
+    const meterProvider = new MeterProvider({
+        resource,
+        readers: [
+            new PeriodicExportingMetricReader({
+                exporter: metricExporter,
+                exportIntervalMillis: config.flushIntervalMs ?? 2000,
+            }),
+        ],
+    });
+    metrics.setGlobalMeterProvider(meterProvider);
+    const ingestPattern = new RegExp(`^${baseUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
+    const instrumentations = [];
+    if (config.instrumentGlobalFetch !== false) {
+        instrumentations.push(new FetchInstrumentation({
+            propagateTraceHeaderCorsUrls: /.*/,
+            ignoreUrls: [ingestPattern],
+            clearTimingResources: true,
+        }));
+    }
+    if (config.instrumentXHR !== false) {
+        instrumentations.push(new XMLHttpRequestInstrumentation({
+            propagateTraceHeaderCorsUrls: /.*/,
+            ignoreUrls: [ingestPattern],
+            clearTimingResources: true,
+        }));
+    }
+    instrumentations.push(new DocumentLoadInstrumentation());
+    instrumentations.push(new UserInteractionInstrumentation());
+    registerInstrumentations({
+        tracerProvider,
+        instrumentations,
+    });
+    const tracer = trace.getTracer("@obtrace/sdk-browser", "1.1.0");
+    const meter = metrics.getMeter("@obtrace/sdk-browser", "1.1.0");
+    const shutdown = async () => {
+        await tracerProvider.shutdown();
+        await meterProvider.shutdown();
+    };
+    return { tracer, meter, shutdown };
+}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { initBrowserSDK } from "./browser/index";
+export { SemanticMetrics } from "./shared/semantic_metrics";
+export { isSemanticMetricName } from "./shared/semantic_metrics";
+export { initNextBrowserSDK, withNextFetchInstrumentation } from "./wrappers/frontend/next";
+export { initViteBrowserSDK, createViteConfigFromImportMetaEnv } from "./wrappers/frontend/vite";
+export { obtrace, getObtrace, obtraceLog, obtraceMetric, obtraceError } from "./wrappers/frontend/react";

package/dist/shared/semantic_metrics.js

@@ -0,0 +1,28 @@
+export const SemanticMetrics = {
+    throughput: "http_requests_total",
+    errorRate: "http_5xx_total",
+    latencyP95: "latency_p95",
+    runtimeCpuUtilization: "runtime.cpu.utilization",
+    runtimeMemoryUsage: "runtime.memory.usage",
+    runtimeThreadCount: "runtime.thread.count",
+    runtimeGcPause: "runtime.gc.pause",
+    runtimeEventloopLag: "runtime.eventloop.lag",
+    clusterCpuUtilization: "cluster.cpu.utilization",
+    clusterMemoryUsage: "cluster.memory.usage",
+    clusterNodeCount: "cluster.node.count",
+    clusterPodCount: "cluster.pod.count",
+    dbOperationLatency: "db.operation.latency",
+    dbClientErrors: "db.client.errors",
+    dbConnectionsUsage: "db.connections.usage",
+    messagingConsumerLag: "messaging.consumer.lag",
+    webVitalLcp: "web.vital.lcp",
+    webVitalFcp: "web.vital.fcp",
+    webVitalInp: "web.vital.inp",
+    webVitalCls: "web.vital.cls",
+    webVitalTtfb: "web.vital.ttfb",
+    userActions: "obtrace.sim.web.react.actions",
+};
+const semanticMetricSet = new Set(Object.values(SemanticMetrics));
+export function isSemanticMetricName(name) {
+    return semanticMetricSet.has(name);
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils.js

@@ -0,0 +1,112 @@
+export function nowUnixNano() {
+    const ms = BigInt(Date.now());
+    return (ms * 1000000n).toString();
+}
+export function hex(bytes) {
+    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function randomHex(lenBytes) {
+    const out = new Uint8Array(lenBytes);
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+        crypto.getRandomValues(out);
+    }
+    else {
+        for (let i = 0; i < lenBytes; i += 1) {
+            out[i] = Math.floor(Math.random() * 256);
+        }
+    }
+    return hex(out);
+}
+export function toBase64(input) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(input, "utf8").toString("base64");
+    }
+    if (typeof btoa !== "undefined") {
+        return btoa(unescape(encodeURIComponent(input)));
+    }
+    throw new Error("base64 encoder unavailable");
+}
+export function truncate(input, max) {
+    if (input.length <= max) {
+        return input;
+    }
+    return input.slice(0, max);
+}
+export function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return '"[unserializable]"';
+    }
+}
+export function sanitizeHeaders(headers) {
+    const out = {};
+    const deny = new Set(["authorization", "cookie", "set-cookie", "x-api-key", "api-key"]);
+    if (!headers) {
+        return out;
+    }
+    if (headers instanceof Headers) {
+        headers.forEach((v, k) => {
+            if (!deny.has(k.toLowerCase())) {
+                out[k] = v;
+            }
+        });
+        return out;
+    }
+    for (const [k, v] of Object.entries(headers)) {
+        if (!deny.has(k.toLowerCase())) {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+export function stripQuery(url) {
+    try {
+        const u = new URL(url, "http://local");
+        u.search = "";
+        if (u.origin === "http://local") {
+            return `${u.pathname}${u.hash}`;
+        }
+        return u.toString();
+    }
+    catch {
+        return url;
+    }
+}
+export function createTraceparent(traceId, spanId) {
+    const t = traceId && traceId.length === 32 ? traceId : randomHex(16);
+    const s = spanId && spanId.length === 16 ? spanId : randomHex(8);
+    return `00-${t}-${s}-01`;
+}
+export function parseTraceparent(value) {
+    if (!value) {
+        return null;
+    }
+    const m = value.trim().match(/^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/i);
+    if (!m) {
+        return null;
+    }
+    return {
+        traceId: m[2].toLowerCase(),
+        parentSpanId: m[3].toLowerCase(),
+        flags: m[4].toLowerCase()
+    };
+}
+function readHeader(headers, key) {
+    const v = headers.get(key);
+    if (!v) {
+        return undefined;
+    }
+    return v;
+}
+export function extractPropagation(headers) {
+    const h = new Headers(headers);
+    const tp = parseTraceparent(readHeader(h, "traceparent"));
+    return {
+        traceId: tp?.traceId,
+        parentSpanId: tp?.parentSpanId,
+        traceState: readHeader(h, "tracestate"),
+        baggage: readHeader(h, "baggage")
+    };
+}

package/dist/sourcemaps.js

@@ -0,0 +1,32 @@
+export async function uploadSourceMaps(options) {
+    const baseUrl = options.ingestBaseUrl.replace(/\/$/, "");
+    const errors = [];
+    let uploaded = 0;
+    for (const file of options.files) {
+        try {
+            const res = await fetch(`${baseUrl}/ingest/sourcemaps`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${options.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    release: options.release,
+                    url: file.url,
+                    sourcemap: file.sourcemap,
+                    source: file.source,
+                }),
+            });
+            if (res.ok) {
+                uploaded++;
+            }
+            else {
+                errors.push(`${file.url}: ${res.status} ${res.statusText}`);
+            }
+        }
+        catch (err) {
+            errors.push(`${file.url}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { uploaded, errors };
+}

package/dist/types/auto.d.ts

@@ -0,0 +1,13 @@
+import { type BrowserSDK } from "./browser/index";
+declare global {
+    interface Window {
+        __OBTRACE_CONFIG__?: {
+            apiKey?: string;
+            ingestBaseUrl?: string;
+            serviceName?: string;
+            appId?: string;
+            env?: string;
+        };
+    }
+}
+export declare function getObtrace(): BrowserSDK | null;

package/dist/types/browser/breadcrumbs.d.ts

@@ -0,0 +1,12 @@
+export interface Breadcrumb {
+    timestamp: number;
+    category: string;
+    message: string;
+    level: "debug" | "info" | "warn" | "error" | "fatal";
+    data?: Record<string, unknown>;
+}
+export declare function addBreadcrumb(crumb: Breadcrumb): void;
+export declare function getBreadcrumbs(): Breadcrumb[];
+export declare function clearBreadcrumbs(): void;
+export declare function getElementSelector(el: Element | null): string;
+export declare function installClickBreadcrumbs(): () => void;

package/dist/types/browser/clicks.d.ts

@@ -0,0 +1,2 @@
+import type { Tracer } from "@opentelemetry/api";
+export declare function installClickTracking(tracer: Tracer, sessionId: string): () => void;

package/dist/types/browser/console.d.ts

@@ -0,0 +1,2 @@
+import type { Tracer } from "@opentelemetry/api";
+export declare function installConsoleCapture(tracer: Tracer, sessionId: string): () => void;

package/dist/types/browser/errors.d.ts

@@ -0,0 +1,2 @@
+import { type Tracer } from "@opentelemetry/api";
+export declare function installBrowserErrorHooks(tracer: Tracer, sessionId?: string): () => void;

package/dist/types/browser/index.d.ts

@@ -0,0 +1,25 @@
+import { ObtraceClient } from "../core/client";
+import type { ObtraceSDKConfig, ReplayStep, SDKContext } from "../shared/types";
+import { type Breadcrumb } from "./breadcrumbs";
+export type UserContext = {
+    id?: string;
+    email?: string;
+    name?: string;
+    [key: string]: unknown;
+};
+export interface BrowserSDK {
+    client: ObtraceClient;
+    sessionId: string;
+    log: (level: "debug" | "info" | "warn" | "error" | "fatal", message: string, context?: SDKContext) => void;
+    metric: (name: string, value: number, unit?: string, context?: SDKContext) => void;
+    captureException: (error: unknown, context?: SDKContext) => void;
+    captureError: (error: unknown, context?: SDKContext) => void;
+    captureReplayEvent: (type: string, payload: Record<string, unknown>) => void;
+    flushReplay: () => void;
+    captureRecipe: (step: ReplayStep) => void;
+    instrumentFetch: () => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    shutdown: () => Promise<void>;
+    setUser: (user: UserContext) => void;
+    addBreadcrumb: (crumb: Breadcrumb) => void;
+}
+export declare function initBrowserSDK(config: ObtraceSDKConfig): BrowserSDK;

package/dist/types/browser/longtasks.d.ts

@@ -0,0 +1,2 @@
+import type { Tracer } from "@opentelemetry/api";
+export declare function installLongTaskDetection(tracer: Tracer): () => void;

package/dist/types/browser/memory.d.ts

@@ -0,0 +1,2 @@
+import type { Meter } from "@opentelemetry/api";
+export declare function installMemoryTracking(meter: Meter): () => void;

package/dist/types/browser/offline.d.ts

@@ -0,0 +1,3 @@
+export declare function enqueueOffline(url: string, payload: string, headers: Record<string, string>): Promise<boolean>;
+export declare function drainOfflineQueue(): Promise<void>;
+export declare function installOfflineSupport(): () => void;

package/dist/types/browser/replay.d.ts

@@ -0,0 +1,24 @@
+import type { eventWithTime } from "@rrweb/types";
+import type { HTTPRecord, ReplayChunk, ReplayStep } from "../shared/types";
+export interface ReplayBufferConfig {
+    maxChunkBytes: number;
+    flushIntervalMs: number;
+    sessionStorageKey: string;
+}
+export declare class BrowserReplayBuffer {
+    private readonly cfg;
+    private readonly replayId;
+    private seq;
+    private events;
+    private bytesEstimate;
+    private chunkStartedAt;
+    constructor(cfg: ReplayBufferConfig);
+    get sessionId(): string;
+    pushRrwebEvent(event: eventWithTime): ReplayChunk | null;
+    pushCustomEvent(tag: string, payload: Record<string, unknown>): ReplayChunk | null;
+    flush(): ReplayChunk | null;
+    toRecipeStep(index: number, record: HTTPRecord): ReplayStep;
+    asNetworkEvent(record: HTTPRecord): Record<string, unknown>;
+    encodeBody(body: unknown): string | undefined;
+    private resolveReplayId;
+}

package/dist/types/browser/resources.d.ts

@@ -0,0 +1,2 @@
+import type { Meter } from "@opentelemetry/api";
+export declare function installResourceTiming(meter: Meter): () => void;

package/dist/types/browser/vitals.d.ts

@@ -0,0 +1,2 @@
+import type { Meter } from "@opentelemetry/api";
+export declare function installWebVitals(meter: Meter, reportAllChanges: boolean): () => void;

package/dist/types/browser_entry.d.ts

@@ -0,0 +1,6 @@
+export { initBrowserSDK } from "./browser/index";
+export type { BrowserSDK } from "./browser/index";
+export { SemanticMetrics } from "./shared/semantic_metrics";
+export { isSemanticMetricName } from "./shared/semantic_metrics";
+export type { SemanticMetricName } from "./shared/semantic_metrics";
+export type { ObtraceSDKConfig, SDKContext, ReplayStep } from "./shared/types";

package/dist/types/core/client.d.ts

@@ -0,0 +1,19 @@
+import type { ObtraceSDKConfig, ReplayChunk, ReplayStep } from "../shared/types";
+export declare class ObtraceClient {
+    private readonly config;
+    private active;
+    replayTimer: ReturnType<typeof setInterval> | null;
+    constructor(config: ObtraceSDKConfig);
+    stop(): void;
+    shutdown(): Promise<void>;
+    replayChunk(chunk: ReplayChunk): void;
+    replayRecipes(steps: ReplayStep[]): void;
+    injectPropagation(headers?: HeadersInit, context?: {
+        traceId?: string;
+        spanId?: string;
+        traceState?: string;
+        baggage?: string;
+        sessionId?: string;
+    }): Headers;
+    private sendReplay;
+}

package/dist/types/core/otel-web-setup.d.ts

@@ -0,0 +1,8 @@
+import { type Tracer, type Meter } from "@opentelemetry/api";
+import type { ObtraceSDKConfig } from "../shared/types";
+export interface OtelHandles {
+    tracer: Tracer;
+    meter: Meter;
+    shutdown: () => Promise<void>;
+}
+export declare function setupOtelWeb(config: ObtraceSDKConfig): OtelHandles;

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export { initBrowserSDK } from "./browser/index";
+export type { BrowserSDK } from "./browser/index";
+export { SemanticMetrics } from "./shared/semantic_metrics";
+export { isSemanticMetricName } from "./shared/semantic_metrics";
+export type { SemanticMetricName } from "./shared/semantic_metrics";
+export { initNextBrowserSDK, withNextFetchInstrumentation } from "./wrappers/frontend/next";
+export { initViteBrowserSDK, createViteConfigFromImportMetaEnv } from "./wrappers/frontend/vite";
+export { obtrace, getObtrace, obtraceLog, obtraceMetric, obtraceError } from "./wrappers/frontend/react";
+export type { ObtraceSDKConfig, SDKContext, ReplayStep } from "./shared/types";

package/dist/types/shared/semantic_metrics.d.ts

@@ -0,0 +1,26 @@
+export declare const SemanticMetrics: {
+    readonly throughput: "http_requests_total";
+    readonly errorRate: "http_5xx_total";
+    readonly latencyP95: "latency_p95";
+    readonly runtimeCpuUtilization: "runtime.cpu.utilization";
+    readonly runtimeMemoryUsage: "runtime.memory.usage";
+    readonly runtimeThreadCount: "runtime.thread.count";
+    readonly runtimeGcPause: "runtime.gc.pause";
+    readonly runtimeEventloopLag: "runtime.eventloop.lag";
+    readonly clusterCpuUtilization: "cluster.cpu.utilization";
+    readonly clusterMemoryUsage: "cluster.memory.usage";
+    readonly clusterNodeCount: "cluster.node.count";
+    readonly clusterPodCount: "cluster.pod.count";
+    readonly dbOperationLatency: "db.operation.latency";
+    readonly dbClientErrors: "db.client.errors";
+    readonly dbConnectionsUsage: "db.connections.usage";
+    readonly messagingConsumerLag: "messaging.consumer.lag";
+    readonly webVitalLcp: "web.vital.lcp";
+    readonly webVitalFcp: "web.vital.fcp";
+    readonly webVitalInp: "web.vital.inp";
+    readonly webVitalCls: "web.vital.cls";
+    readonly webVitalTtfb: "web.vital.ttfb";
+    readonly userActions: "obtrace.sim.web.react.actions";
+};
+export type SemanticMetricName = (typeof SemanticMetrics)[keyof typeof SemanticMetrics];
+export declare function isSemanticMetricName(name: string): name is SemanticMetricName;

package/dist/types/shared/types.d.ts

@@ -0,0 +1,104 @@
+export type Signal = "traces" | "logs" | "metrics";
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export interface ObtraceResource {
+    serviceName?: string;
+    serviceVersion?: string;
+    deploymentEnv?: string;
+    runtimeName?: string;
+    runtimeVersion?: string;
+    appNamespace?: string;
+    appName?: string;
+    appInstanceId?: string;
+    [k: string]: string | number | boolean | undefined;
+}
+export interface ObtraceSDKConfig {
+    apiKey: string;
+    ingestBaseUrl: string;
+    tenantId?: string;
+    projectId?: string;
+    appId?: string;
+    env?: string;
+    serviceName: string;
+    serviceVersion?: string;
+    defaultHeaders?: Record<string, string>;
+    requestTimeoutMs?: number;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+    maxQueueBytes?: number;
+    replay?: {
+        enabled: boolean;
+        flushIntervalMs?: number;
+        maxChunkBytes?: number;
+        captureNetworkRecipes?: boolean;
+        sessionStorageKey?: string;
+        blockClass?: string;
+        maskTextClass?: string;
+        maskAllInputs?: boolean;
+        sampling?: ReplaySamplingConfig;
+    };
+    vitals?: {
+        enabled: boolean;
+        reportAllChanges?: boolean;
+    };
+    propagation?: {
+        enabled: boolean;
+        headerName?: string;
+        sessionHeaderName?: string;
+    };
+    validateSemanticMetrics?: boolean;
+    debug?: boolean;
+    instrumentGlobalFetch?: boolean;
+    instrumentXHR?: boolean;
+    patchConsole?: boolean;
+    captureConsole?: boolean;
+    tracesSampleRate?: number;
+    replaySampleRate?: number;
+}
+export interface SDKContext {
+    traceId?: string;
+    spanId?: string;
+    traceState?: string;
+    baggage?: string;
+    sessionId?: string;
+    routeTemplate?: string;
+    endpoint?: string;
+    method?: string;
+    statusCode?: number;
+    attrs?: Record<string, string | number | boolean>;
+}
+export interface ReplayStep {
+    step_id: number;
+    method: string;
+    url_template: string;
+    headers?: Record<string, string>;
+    body_b64?: string;
+}
+export interface ReplayChunk {
+    replay_id: string;
+    seq: number;
+    started_at_ms: number;
+    ended_at_ms: number;
+    events: import("@rrweb/types").eventWithTime[];
+    metadata?: Record<string, unknown>;
+}
+export interface ReplaySamplingConfig {
+    mousemove?: boolean | number;
+    scroll?: number;
+    input?: "all" | "last";
+}
+export interface HTTPRecord {
+    ts: number;
+    method: string;
+    url: string;
+    status?: number;
+    dur_ms?: number;
+    req_headers?: Record<string, string>;
+    res_headers?: Record<string, string>;
+    req_body_b64?: string;
+    res_body_b64?: string;
+}
+export interface QueuedPayload {
+    endpoint: string;
+    contentType: string;
+    body: string;
+}