@maple-dev/browser 0.12.0 → 0.14.0

package/dist/replay-session-Cg3U1RS0.mjs

@@ -1,596 +0,0 @@
-import { D as reserveKeepalive, F as withStartedTraceId, G as scrubUrl, K as mayUseStorage, M as safeEmit, N as activeTraceId, R as consentRevokedAt, T as postSessionMeta, W as isJsonObject, d as startEventSink, g as nextChunkSeq, h as markReplayTriggered, j as BLOCK_SELECTOR, k as warnDropped, m as markActivity, n as getObservedTraceIds, o as startSessionLifecycle, r as publishSessionSink, w as postSessionBlob, x as gzip } from "./sink-DbEuphC-.mjs";
-import { v as PENDING_CHUNK_KEY, y as clearPendingChunk } from "./src-DfU4Cnb1.mjs";
-import { t as installConsoleCapture } from "./console-Bkd3hBGp.mjs";
-import { record } from "rrweb";
-//#region ../browser-session/src/replay/capture/network.ts
-/** Only text is worth keeping; a body that is an image or a stream is not read. */
-const TEXT_CONTENT = /^(text\/|application\/(json|xml|x-www-form-urlencoded|[\w.+-]+\+(json|xml)))/i;
-/** Text, but never finished: reading a clone would hold the connection open after the app cancels. */
-const STREAMING_CONTENT = /^text\/event-stream/i;
-/** A slow body is given up on rather than kept in memory for as long as it trickles. */
-const BODY_READ_TIMEOUT_MS = 5e3;
-const isReadableText = (contentType) => TEXT_CONTENT.test(contentType) && !STREAMING_CONTENT.test(contentType);
-/** Patterns match the full URL, as documented: a relative `fetch("/api")` is resolved against the page. */
-const absoluteUrl = (url) => {
-	try {
-		return new URL(url, location.href).href;
-	} catch {
-		return url;
-	}
-};
-const matchesUrl = (url, patterns) => patterns.some((pattern) => {
-	if (typeof pattern === "string") return url.includes(pattern);
-	pattern.lastIndex = 0;
-	return pattern.test(url);
-});
-const cut = (text, maxLength) => text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
-/**
-* Capture fetch + XHR requests as session events, tagged with the active trace
-* id so each request links to its backend trace. `ignoreUrl` skips Maple's own
-* ingest endpoints (otherwise capturing the session-events POST would loop).
-* `bodies`, when set, keeps text request/response bodies of the URLs it lists.
-*/
-function installNetworkCapture(emit, ignoreUrl, bodies) {
-	const wantsBody = (url) => bodies !== void 0 && matchesUrl(absoluteUrl(url), bodies.urls);
-	const bodyAttrs = (request, response) => ({
-		...request && bodies?.requestBodies !== false ? { "request.body": cut(request, bodies?.maxLength ?? 0) } : void 0,
-		...response && bodies ? { "response.body": cut(response, bodies.maxLength) } : void 0
-	});
-	const origFetch = typeof window !== "undefined" ? window.fetch : void 0;
-	if (origFetch) window.fetch = async (input, init) => {
-		const url = requestUrl(input);
-		const method = requestMethod(input, init);
-		const ambientTraceId = activeTraceId();
-		const start = performance.now();
-		let traceId = ambientTraceId;
-		try {
-			const call = withStartedTraceId(() => origFetch(input, init));
-			traceId = call.traceId ?? ambientTraceId;
-			const res = await call.result;
-			if (!wantsBody(url)) {
-				record(url, method, res.status, start, traceId);
-				return res;
-			}
-			const requestBody = typeof init?.body === "string" ? init.body : void 0;
-			const done = performance.now();
-			const contentType = res.headers.get("content-type") ?? "";
-			(isReadableText(contentType) ? readPrefix(res.clone(), bodies?.maxLength ?? 0) : Promise.resolve(void 0)).catch(() => void 0).then((responseBody) => record(url, method, res.status, start, traceId, void 0, bodyAttrs(requestBody, responseBody), done));
-			return res;
-		} catch (error) {
-			record(url, method, 0, start, traceId, String(error));
-			throw error;
-		}
-	};
-	const record = (url, method, status, start, traceId, error, extra, end = performance.now()) => {
-		if (ignoreUrl(url)) return;
-		const attrs = {
-			...extra,
-			...error ? { error } : void 0
-		};
-		safeEmit(emit, {
-			type: "network",
-			net: {
-				method,
-				url,
-				status,
-				durationMs: Math.round(end - start)
-			},
-			traceId,
-			...Object.keys(attrs).length > 0 ? { attrs } : void 0
-		});
-	};
-	const XHR = typeof window !== "undefined" ? window.XMLHttpRequest : void 0;
-	const origOpen = XHR?.prototype.open;
-	const origSend = XHR?.prototype.send;
-	if (XHR && origOpen && origSend) {
-		XHR.prototype.open = function(method, url, ...rest) {
-			this.__mapleMethod = String(method).toUpperCase();
-			this.__mapleUrl = typeof url === "string" ? url : url.href;
-			const call = withStartedTraceId(() => origOpen.apply(this, [
-				method,
-				url,
-				...rest
-			]));
-			this.__mapleTraceId = call.traceId;
-			return call.result;
-		};
-		XHR.prototype.send = function(...args) {
-			const meta = this;
-			const start = performance.now();
-			let traceId = meta.__mapleTraceId ?? activeTraceId();
-			const url = meta.__mapleUrl ?? "";
-			const requestBody = typeof args[0] === "string" ? args[0] : void 0;
-			this.addEventListener("loadend", () => {
-				const extra = wantsBody(url) ? bodyAttrs(requestBody, xhrResponseText(this)) : void 0;
-				record(url, meta.__mapleMethod ?? "GET", this.status, start, traceId, void 0, extra);
-			});
-			const call = withStartedTraceId(() => origSend.apply(this, args));
-			traceId = call.traceId ?? traceId;
-			return call.result;
-		};
-	}
-	return () => {
-		if (origFetch) window.fetch = origFetch;
-		if (XHR && origOpen) XHR.prototype.open = origOpen;
-		if (XHR && origSend) XHR.prototype.send = origSend;
-	};
-}
-/**
-* Up to `maxLength` characters of a response body (one more, so `cut` marks it
-* cut), then the stream is cancelled: a large payload is never read in full.
-*/
-async function readPrefix(response, maxLength) {
-	const reader = response.body?.getReader();
-	if (!reader) return void 0;
-	const decoder = new TextDecoder();
-	let text = "";
-	const deadline = Date.now() + BODY_READ_TIMEOUT_MS;
-	while (text.length <= maxLength) {
-		const remaining = deadline - Date.now();
-		const chunk = remaining > 0 ? await readWithin(reader, remaining) : void 0;
-		if (!chunk) {
-			reader.cancel().catch(() => {});
-			return text || void 0;
-		}
-		if (chunk.done) return text + decoder.decode();
-		text += decoder.decode(chunk.value, { stream: true });
-	}
-	reader.cancel().catch(() => {});
-	return text;
-}
-/** One read, or `undefined` if nothing arrives within `ms`. */
-function readWithin(reader, ms) {
-	let timer;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(void 0), ms);
-	});
-	return Promise.race([reader.read(), timeout]).finally(() => clearTimeout(timer));
-}
-/** A text or JSON XHR response, as text; the browser already holds it, so this only slices. */
-function xhrResponseText(xhr) {
-	if (!isReadableText(xhr.getResponseHeader("content-type") ?? "")) return void 0;
-	if (xhr.responseType === "" || xhr.responseType === "text") return xhr.responseText;
-	if (xhr.responseType === "json") try {
-		return JSON.stringify(xhr.response);
-	} catch {
-		return;
-	}
-}
-function requestUrl(input) {
-	if (typeof input === "string") return input;
-	if (input instanceof URL) return input.href;
-	return input.url;
-}
-function requestMethod(input, init) {
-	return (init?.method ?? (typeof input === "object" && "method" in input ? input.method : void 0) ?? "GET").toUpperCase();
-}
-//#endregion
-//#region ../browser-session/src/replay/events.ts
-/**
-* Install the capture modules that turn console output and network requests
-* into distilled session events.
-*
-* Navigation, errors and interactions are deliberately absent: the sink
-* installs those itself (see `startBaselineCapture`), because page views, error
-* counts and click counts have to be counted even when replay is unsampled —
-* and a second listener here would double-count every one of them.
-*/
-function startEventCapture(config, sessionId) {
-	const sink = startEventSink(config, sessionId);
-	const emit = sink.emit;
-	const uninstall = [installConsoleCapture(emit), installNetworkCapture(emit, sink.ignoreUrl, config.maskAllText || !config.networkBodies ? void 0 : {
-		...config.networkBodies,
-		requestBodies: !config.maskAllInputs
-	})];
-	return {
-		stop: () => {
-			for (const off of uninstall) off();
-		},
-		flush: sink.flush
-	};
-}
-//#endregion
-//#region ../browser-session/src/replay/record.ts
-const FULL_SNAPSHOT = 2;
-const META = 4;
-const INCREMENTAL = 3;
-const SOURCE_MOUSE_INTERACTION = 2;
-const MOUSE_CLICK = 2;
-const FLUSH_INTERVAL_MS = 5e3;
-const FLUSH_BYTES = 102400;
-const CHECKOUT_EVERY_MS = 3e5;
-const MAX_BUFFER_BYTES = 4194304;
-function warnExhausted(sessionId) {
-	console.warn(`[maple] session replay ${sessionId} reached its maximum recorded size; recording stopped for this session (metadata and events continue)`);
-}
-let lastDropWarnAt = 0;
-function warnBufferDropped(bytes) {
-	const now = Date.now();
-	if (now - lastDropWarnAt < 3e4) return;
-	lastDropWarnAt = now;
-	console.warn(`[maple] session replay buffer exceeded ${MAX_BUFFER_BYTES} bytes (dropping ${bytes} buffered bytes; recording continues from the next full snapshot)`);
-}
-const MAX_PENDING_AGE_MS = 6e5;
-const PAGE_STARTED_AT = Date.now();
-/** How long a stored chunk that found the keepalive budget full waits before its one re-attempt. */
-const KEEPALIVE_RETRY_MS = 1e3;
-function isPendingChunk(value) {
-	return isJsonObject(value) && typeof value.sessionId === "string" && typeof value.chunkSeq === "number" && typeof value.isCheckpoint === "boolean" && typeof value.eventCount === "number" && typeof value.durationMs === "number" && typeof value.body === "string" && typeof value.createdAt === "number" && typeof value.target === "string";
-}
-/** Endpoint plus an FNV-1a hash of the key, so the key itself is not stored. */
-function targetOf(config) {
-	let hash = 2166136261;
-	for (const char of config.ingestKey ?? "") hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
-	return `${config.endpoint}|${hash >>> 0}`;
-}
-function readPending() {
-	if (!mayUseStorage()) return void 0;
-	try {
-		const parsed = JSON.parse(window.sessionStorage.getItem("maple.replay.pending") ?? "null");
-		return isPendingChunk(parsed) ? parsed : void 0;
-	} catch {
-		return;
-	}
-}
-/**
-* Keep `chunk` unless one is already waiting. False when it was not kept
-* (storage blocked or full): it is then only as durable as its upload.
-*/
-function storePending(chunk) {
-	if (!mayUseStorage()) return false;
-	try {
-		if (readPending()) return false;
-		window.sessionStorage.setItem(PENDING_CHUNK_KEY, JSON.stringify(chunk));
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Remove the stored chunk if it is `meta`'s, reporting whether it was. Whoever
-* removes it sends it, so a seq is posted once: ingest appends an index row per POST.
-*/
-function takePending(meta) {
-	const chunk = readPending();
-	return chunk?.sessionId === meta.sessionId && chunk.chunkSeq === meta.chunkSeq && clearPendingChunk();
-}
-/** Send the chunk an earlier flush left behind, if it is still this recorder's to send; otherwise drop it. */
-function sendPendingChunk(config, sessionId) {
-	const chunk = readPending();
-	if (!chunk) return;
-	if (chunk.target === targetOf(config) && chunk.createdAt > consentRevokedAt() && (chunk.createdAt >= PAGE_STARTED_AT || chunk.sessionId === sessionId && Date.now() - chunk.createdAt <= MAX_PENDING_AGE_MS)) compressAndPost(config, chunk, chunk.body, false, true);
-	else clearPendingChunk();
-}
-/**
-* Claim a seq and upload one chunk. The seq is monotonic across reloads
-* (persisted on the session record), so a refresh continues the sequence
-* instead of overwriting the previous load's blobs.
-*/
-function uploadChunk(config, sessionId, body, chunk, keepalive) {
-	const meta = {
-		sessionId,
-		chunkSeq: nextChunkSeq(),
-		...chunk
-	};
-	return compressAndPost(config, meta, body, keepalive, keepalive && storePending({
-		...meta,
-		body,
-		createdAt: Date.now(),
-		target: targetOf(config)
-	}));
-}
-async function compressAndPost(config, meta, body, keepalive, stored) {
-	let gzipped;
-	try {
-		gzipped = await gzip(new TextEncoder().encode(body));
-	} catch (error) {
-		warnDropped("chunk compression", error);
-		return;
-	}
-	if (stored) {
-		if (keepalive) {
-			const release = reserveKeepalive(true, gzipped.byteLength);
-			if (release) release();
-			else await new Promise((resolve) => setTimeout(resolve, KEEPALIVE_RETRY_MS));
-		}
-		if (!takePending(meta)) return void 0;
-	}
-	return postSessionBlob(config, meta, gzipped, keepalive);
-}
-function startRecording(config, sessionId) {
-	sendPendingChunk(config, sessionId);
-	let parts = [];
-	let bufferBytes = 0;
-	let bufferHasCheckpoint = false;
-	let firstTimestamp = 0;
-	let lastTimestamp = 0;
-	let droppedChunk = false;
-	let clickCount = 0;
-	let stopped = false;
-	let exhausted = false;
-	const resetBuffer = () => {
-		parts = [];
-		bufferBytes = 0;
-		bufferHasCheckpoint = false;
-		firstTimestamp = 0;
-		lastTimestamp = 0;
-	};
-	const flush = async (keepalive = false) => {
-		if (stopped || exhausted || parts.length === 0) return;
-		const body = `[${parts.join(",")}]`;
-		const isCheckpoint = bufferHasCheckpoint;
-		const eventCount = parts.length;
-		const durationMs = Math.max(0, lastTimestamp - firstTimestamp);
-		resetBuffer();
-		if (await uploadChunk(config, sessionId, body, {
-			isCheckpoint,
-			eventCount,
-			durationMs
-		}, keepalive) === "exhausted" && !exhausted) {
-			exhausted = true;
-			warnExhausted(sessionId);
-			haltCapture();
-		}
-	};
-	let haltCapture = () => {};
-	const stop = record({
-		emit: (event, isCheckpoint) => {
-			const active = markActivity();
-			if (active && active.id !== sessionId) return;
-			const e = event;
-			if (e.type === META && e.data && typeof e.data.href === "string") e.data.href = scrubUrl(e.data.href);
-			const isFullSnapshot = isCheckpoint === true || e.type === FULL_SNAPSHOT;
-			if (e.type === INCREMENTAL && e.data?.source === SOURCE_MOUSE_INTERACTION && e.data.type === MOUSE_CLICK) clickCount++;
-			let json;
-			try {
-				json = JSON.stringify(e);
-			} catch {
-				return;
-			}
-			if (droppedChunk && !isFullSnapshot) return;
-			droppedChunk = false;
-			if (bufferBytes + json.length > MAX_BUFFER_BYTES) {
-				warnBufferDropped(bufferBytes + json.length);
-				resetBuffer();
-				droppedChunk = true;
-				return;
-			}
-			if (isFullSnapshot) bufferHasCheckpoint = true;
-			if (parts.length === 0) firstTimestamp = e.timestamp;
-			lastTimestamp = e.timestamp;
-			parts.push(json);
-			bufferBytes += json.length;
-			if (bufferBytes >= FLUSH_BYTES) flush();
-		},
-		maskAllInputs: config.maskAllInputs,
-		blockSelector: BLOCK_SELECTOR,
-		...config.maskAllText ? { maskTextSelector: "*" } : void 0,
-		checkoutEveryNms: CHECKOUT_EVERY_MS,
-		...canvasOptions(config)
-	});
-	let idleHandle;
-	const scheduleFlush = () => {
-		if (typeof requestIdleCallback === "function") idleHandle = requestIdleCallback(() => {
-			idleHandle = void 0;
-			flush();
-		}, { timeout: 2e3 });
-		else flush();
-	};
-	const flushTimer = setInterval(scheduleFlush, FLUSH_INTERVAL_MS);
-	let halted = false;
-	haltCapture = () => {
-		if (halted) return;
-		halted = true;
-		clearInterval(flushTimer);
-		if (idleHandle !== void 0 && typeof cancelIdleCallback === "function") {
-			cancelIdleCallback(idleHandle);
-			idleHandle = void 0;
-		}
-		resetBuffer();
-		stop?.();
-	};
-	return {
-		stop: () => {
-			stopped = true;
-			haltCapture();
-		},
-		flush,
-		getClickCount: () => clickCount
-	};
-}
-/** rrweb options for `<canvas>` capture: sampled frames as WebP, off unless asked for. */
-function canvasOptions(config) {
-	if (config.maskAllText || !config.canvasFps || config.canvasFps <= 0) return void 0;
-	return {
-		recordCanvas: true,
-		sampling: { canvas: config.canvasFps },
-		dataURLOptions: {
-			type: "image/webp",
-			quality: .6
-		}
-	};
-}
-/**
-* Buffer mode checks out often, so the retained window stays near a minute. A
-* checkout is a full DOM snapshot, so it is skipped while hidden or when nothing changed.
-*/
-const BUFFER_CHECKOUT_MS = 3e4;
-/**
-* Record into memory only: the segments since the second-to-last checkout, so
-* 30-60s of replay, and nothing is uploaded until `drain()`. For sessions that
-* keep a replay only when an error happens.
-*/
-function startBufferedRecording(config, sessionId) {
-	let segments = [];
-	let bytes = 0;
-	let clickCount = 0;
-	let stopped = false;
-	/** Incremental events since the last snapshot: an idle page needs no new one. */
-	let changedSinceSnapshot = 0;
-	const stopRecord = record({
-		emit: (event) => {
-			const active = markActivity();
-			if (stopped || active && active.id !== sessionId) return;
-			const e = event;
-			if (e.type === META && e.data && typeof e.data.href === "string") e.data.href = scrubUrl(e.data.href);
-			if (e.type === INCREMENTAL && e.data?.source === SOURCE_MOUSE_INTERACTION && e.data.type === MOUSE_CLICK) clickCount++;
-			let json;
-			try {
-				json = JSON.stringify(e);
-			} catch {
-				return;
-			}
-			if (e.type === META) {
-				segments.push({
-					parts: [],
-					bytes: 0,
-					first: e.timestamp,
-					last: e.timestamp
-				});
-				while (segments.length > 2) bytes -= segments.shift()?.bytes ?? 0;
-				changedSinceSnapshot = 0;
-			} else if (e.type === INCREMENTAL) changedSinceSnapshot++;
-			const segment = segments.at(-1);
-			if (!segment) return;
-			segment.parts.push(json);
-			segment.bytes += json.length;
-			segment.last = e.timestamp;
-			bytes += json.length;
-			while (bytes > MAX_BUFFER_BYTES && segments.length > 0) bytes -= segments.shift()?.bytes ?? 0;
-		},
-		maskAllInputs: config.maskAllInputs,
-		blockSelector: BLOCK_SELECTOR,
-		...config.maskAllText ? { maskTextSelector: "*" } : void 0,
-		...canvasOptions(config)
-	});
-	const checkoutTimer = setInterval(() => {
-		if (stopped || changedSinceSnapshot === 0) return;
-		const current = segments.at(-1);
-		if (!(current === void 0 || current.bytes > MAX_BUFFER_BYTES / 2) && typeof document !== "undefined" && document.visibilityState === "hidden") return;
-		try {
-			record.takeFullSnapshot(true);
-		} catch {}
-	}, BUFFER_CHECKOUT_MS);
-	return {
-		drain: async (keepalive = false) => {
-			const pending = segments;
-			segments = [];
-			bytes = 0;
-			if (stopped) return;
-			await Promise.all(pending.map((segment) => uploadChunk(config, sessionId, `[${segment.parts.join(",")}]`, {
-				isCheckpoint: true,
-				eventCount: segment.parts.length,
-				durationMs: Math.max(0, segment.last - segment.first)
-			}, keepalive)));
-		},
-		stop: () => {
-			stopped = true;
-			clearInterval(checkoutTimer);
-			segments = [];
-			bytes = 0;
-			stopRecord?.();
-		},
-		getClickCount: () => clickCount
-	};
-}
-//#endregion
-//#region ../browser-session/src/session/replay-session.ts
-/**
-* Start recording the current browser session. Publishes the session sink,
-* posts an `active` metadata row, and installs visibility handlers:
-* hidden → flush + `ended` row (with observed trace ids) + stop capture;
-* visible → re-resolve the session (rotating if idle-expired), republish the
-* sink, restart capture, post a fresh `active` row. Metadata versions are
-* monotonic per session, so the latest row always wins on the backend.
-*
-* Returns undefined outside a browser. Sampling is the caller's decision.
-*/
-function startReplaySession(options) {
-	if (typeof window === "undefined") return void 0;
-	const engineConfig = {
-		endpoint: options.endpoint.replace(/\/$/, ""),
-		ingestKey: options.ingestKey,
-		sdk: options.sdk,
-		maskAllInputs: options.maskAllInputs,
-		maskAllText: options.maskAllText,
-		getIdentity: options.getIdentity,
-		canvasFps: options.canvasFps,
-		networkBodies: options.networkBodies
-	};
-	let recorder;
-	let buffered;
-	let events;
-	let publishedSessionId;
-	const buffering = options.mode === "buffer";
-	let triggered = !buffering;
-	/** Clicks the buffered recorder saw before a trigger replaced it. */
-	let clicksBeforeTrigger = 0;
-	const publish = (sessionId) => {
-		if (publishedSessionId === sessionId) return;
-		publishedSessionId = sessionId;
-		publishSessionSink(sessionId);
-	};
-	const startStreaming = (sessionId) => {
-		recorder = startRecording(engineConfig, sessionId);
-		events = startEventCapture(engineConfig, sessionId);
-	};
-	const lifecycle = startSessionLifecycle({
-		...options,
-		getTraceIds: getObservedTraceIds
-	}, {
-		recorded: () => triggered,
-		buffered: () => buffering,
-		post: (row, keepalive) => {
-			postSessionMeta(engineConfig, row, keepalive);
-		},
-		clicksSinceStart: () => clicksBeforeTrigger + (recorder?.getClickCount() ?? buffered?.getClickCount() ?? 0),
-		onStart: (record) => {
-			publish(record.id);
-			clicksBeforeTrigger = 0;
-			if (triggered) startStreaming(record.id);
-			else buffered = startBufferedRecording(engineConfig, record.id);
-		},
-		onSuspend: ({ flush, keepalive }) => {
-			const stoppingRecorder = recorder;
-			const stoppingEvents = events;
-			recorder = void 0;
-			events = void 0;
-			buffered?.stop();
-			buffered = void 0;
-			const flushed = flush ? Promise.all([stoppingRecorder?.flush(keepalive), stoppingEvents?.flush(keepalive)]).then(() => {}) : void 0;
-			stoppingRecorder?.stop();
-			stoppingEvents?.stop();
-			return flushed;
-		},
-		onSessionChange: (sessionId) => {
-			triggered = !buffering;
-			publish(sessionId);
-			options.onSessionChange?.(sessionId);
-		}
-	});
-	if (!lifecycle) return void 0;
-	return {
-		get sessionId() {
-			return lifecycle.sessionId;
-		},
-		announce: lifecycle.announce,
-		shutdown: lifecycle.shutdown,
-		trigger: async () => {
-			if (triggered) return;
-			triggered = true;
-			const sessionId = lifecycle.sessionId;
-			markReplayTriggered(sessionId);
-			const pending = buffered;
-			buffered = void 0;
-			if (!pending) return;
-			clicksBeforeTrigger = pending.getClickCount();
-			const drained = pending.drain();
-			pending.stop();
-			startStreaming(sessionId);
-			lifecycle.announce();
-			await drained;
-		}
-	};
-}
-//#endregion
-export { startReplaySession };