@faststats/web 0.1.9 → 0.2.1

package/src/replay.ts

@@ -33,570 +33,345 @@ export interface ReplayTrackerOptions {
 	recordConsole?: boolean;
 }
 
-interface PendingBatch {
-	batch: {
-		token: string;
-		sessionId: string | undefined;
-		sequence: number;
-		timestamp: number;
-		url: string;
-		events: eventWithTime[];
-	};
-	isCompressed: boolean;
-	retries: number;
-}
-
-class ReplayTracker {
+type ReplayBatch = {
+	token: string;
+	sessionId: string | undefined;
+	identifier?: string;
+	sequence: number;
+	timestamp: number;
+	url: string;
+	events: eventWithTime[];
+};
+
+const defaultSampling: recordOptions<eventWithTime>["sampling"] = {
+	mousemove: 50,
+	mouseInteraction: true,
+	scroll: 150,
+	media: 800,
+	input: "last",
+};
+
+const defaultSlimDOMOptions: SlimDOMOptions = {
+	script: true,
+	comment: true,
+	headFavicon: true,
+	headWhitespace: true,
+	headMetaDescKeywords: true,
+	headMetaSocial: true,
+	headMetaRobots: true,
+	headMetaHttpEquiv: true,
+	headMetaAuthorship: true,
+};
+
+export default class ReplayTracker {
 	private readonly endpoint: string;
-	private readonly siteKey: string;
-	private readonly debug: boolean;
-	private readonly flushInterval: number;
-	private readonly maxEvents: number;
-	private readonly sampling: recordOptions<eventWithTime>["sampling"];
-	private readonly slimDOMOptions: SlimDOMOptions;
-	private readonly maskAllInputs: boolean;
-	private readonly maskInputOptions?: recordOptions<eventWithTime>["maskInputOptions"];
-	private readonly blockClass?: string;
-	private readonly blockSelector?: string;
-	private readonly maskTextClass?: string;
-	private readonly maskTextSelector?: string;
-	private readonly checkoutEveryNms: number;
-	private readonly checkoutEveryNth?: number;
-	private readonly samplingPercentage: number;
-	private readonly recordConsole: boolean;
-
-	private events: eventWithTime[] = [];
-	private flushTimer: ReturnType<typeof setInterval> | null = null;
-	private stopRecording: listenerHandler | undefined = undefined;
+	private readonly compressionSupported =
+		typeof window !== "undefined" && "CompressionStream" in window;
+
+	private readonly sampled: boolean;
+	private readonly events: eventWithTime[] = [];
+	private readonly pending: ReplayBatch[] = [];
+
 	private started = false;
-	private startTime: number = 0;
-	private minLengthFlushScheduled = false;
-	private sequenceNumber = 0;
-	private pendingBatches: PendingBatch[] = [];
-	private isFlushing = false;
-	private compressionSupported = false;
-	private readonly sessionSamplingSeed: number;
-	private readonly minReplayLengthMs: number;
-	private readonly maxPendingBatches: number;
-	private flushScheduled = false;
-	private flushTimeout: ReturnType<typeof setTimeout> | null = null;
-	private idleFlushId: number | null = null;
-	private minLengthFlushTimer: ReturnType<typeof setTimeout> | null = null;
-	private pendingRetryTimer: ReturnType<typeof setTimeout> | null = null;
-	private isProcessingPending = false;
-
-	constructor(options: ReplayTrackerOptions) {
-		this.siteKey = options.siteKey;
+	private startTime = 0;
+	private sequence = 0;
+	private intervalId: ReturnType<typeof setInterval> | null = null;
+	private flushTask: ReturnType<typeof setTimeout> | null = null;
+	private retryTask: ReturnType<typeof setTimeout> | null = null;
+	private stopRecording?: listenerHandler;
+	private sending = false;
+
+	constructor(private readonly options: ReplayTrackerOptions) {
 		this.endpoint = replayEventsUrl(options.baseUrl);
-		this.debug = options.debug ?? false;
-		this.samplingPercentage = normalizeSamplingPercentage(
-			options.samplingPercentage,
-		);
-		this.flushInterval = options.flushInterval ?? 10_000;
-		this.maxEvents = options.maxEvents ?? 500;
-		this.sampling = options.sampling ?? {
-			mousemove: 50,
-			mouseInteraction: true,
-			scroll: 150,
-			media: 800,
-			input: "last",
-		};
-		this.slimDOMOptions = options.slimDOMOptions ?? {
-			script: true,
-			comment: true,
-			headFavicon: true,
-			headWhitespace: true,
-			headMetaDescKeywords: true,
-			headMetaSocial: true,
-			headMetaRobots: true,
-			headMetaHttpEquiv: true,
-			headMetaAuthorship: true,
-		};
-		this.maskAllInputs = options.maskAllInputs ?? true;
-		this.maskInputOptions = options.maskInputOptions ?? {
-			password: true,
-			email: true,
-			tel: true,
-		};
-		this.blockClass = options.blockClass;
-		this.blockSelector = options.blockSelector;
-		this.maskTextClass = options.maskTextClass;
-		this.maskTextSelector = options.maskTextSelector;
-		this.checkoutEveryNms = options.checkoutEveryNms ?? 60_000;
-		this.checkoutEveryNth = options.checkoutEveryNth;
-		this.recordConsole = options.recordConsole ?? true;
-		this.minReplayLengthMs = options.minReplayLengthMs ?? 3000;
-		this.maxPendingBatches = options.maxPendingBatches ?? 30;
-		this.sessionSamplingSeed = Math.random() * 100;
-
-		if (typeof window !== "undefined") {
-			this.compressionSupported = "CompressionStream" in window;
-		}
+		this.sampled =
+			Math.random() * 100 <
+			normalizeSamplingPercentage(options.samplingPercentage);
 	}
 
-	start(): void {
-		if (this.started || typeof window === "undefined") return;
+	private get debug(): boolean {
+		return this.options.debug ?? false;
+	}
 
-		if (this.samplingPercentage < 100) {
-			if (this.sessionSamplingSeed >= this.samplingPercentage) {
-				return;
-			}
-		}
+	private get flushInterval(): number {
+		return this.options.flushInterval ?? 10_000;
+	}
 
-		this.started = true;
-		this.startTime = Date.now();
+	private get maxEvents(): number {
+		return this.options.maxEvents ?? 500;
+	}
 
-		if (this.debug) {
-			console.log("[Replay] Recording started");
-		}
+	private get maxPendingBatches(): number {
+		return this.options.maxPendingBatches ?? 30;
+	}
 
-		const recordOptions: recordOptions<eventWithTime> = {
-			emit: (event, isCheckout) => this.handleEvent(event, isCheckout),
-			sampling: this.sampling,
-			slimDOMOptions: this.slimDOMOptions,
-			maskAllInputs: this.maskAllInputs,
-			checkoutEveryNms: this.checkoutEveryNms,
-		};
+	private get minReplayLengthMs(): number {
+		return this.options.minReplayLengthMs ?? 3000;
+	}
 
-		if (this.maskInputOptions) {
-			recordOptions.maskInputOptions = this.maskInputOptions;
-		}
-		if (this.blockClass) {
-			recordOptions.blockClass = this.blockClass;
-		}
-		if (this.blockSelector) {
-			recordOptions.blockSelector = this.blockSelector;
-		}
-		if (this.maskTextClass) {
-			recordOptions.maskTextClass = this.maskTextClass;
-		}
-		if (this.maskTextSelector) {
-			recordOptions.maskTextSelector = this.maskTextSelector;
-		}
-		if (this.checkoutEveryNth) {
-			recordOptions.checkoutEveryNth = this.checkoutEveryNth;
-		}
-		recordOptions.plugins = [
-			getRecordSequentialIdPlugin({
-				key: RRWEB_SEQUENTIAL_ID_KEY,
-			}),
-			...(this.recordConsole ? [getRecordConsolePlugin()] : []),
-		];
-
-		this.stopRecording = record(recordOptions);
-
-		this.flushTimer = setInterval(() => {
-			this.scheduleFlush();
-		}, this.flushInterval);
-
-		window.addEventListener("beforeunload", this.handleUnload);
-		window.addEventListener("pagehide", this.handleUnload);
-		document.addEventListener("visibilitychange", this.handleVisibilityChange);
-		this.scheduleMinLengthFlush();
+	private log(...args: unknown[]): void {
+		if (this.debug) console.log("[Replay]", ...args);
+	}
+
+	start(): void {
+		if (this.started || typeof window === "undefined" || !this.sampled) return;
+
+		this.started = true;
+		this.startTime = Date.now();
+
+		this.stopRecording = record({
+			emit: this.onEvent,
+			sampling: this.options.sampling ?? defaultSampling,
+			slimDOMOptions: this.options.slimDOMOptions ?? defaultSlimDOMOptions,
+			maskAllInputs: this.options.maskAllInputs ?? true,
+			maskInputOptions: this.options.maskInputOptions ?? {
+				password: true,
+				email: true,
+				tel: true,
+			},
+			blockClass: this.options.blockClass,
+			blockSelector: this.options.blockSelector,
+			maskTextClass: this.options.maskTextClass,
+			maskTextSelector: this.options.maskTextSelector,
+			checkoutEveryNms: this.options.checkoutEveryNms ?? 60_000,
+			checkoutEveryNth: this.options.checkoutEveryNth,
+			plugins: [
+				getRecordSequentialIdPlugin({ key: RRWEB_SEQUENTIAL_ID_KEY }),
+				...((this.options.recordConsole ?? true)
+					? [getRecordConsolePlugin()]
+					: []),
+			],
+		});
+
+		this.intervalId = setInterval(this.requestFlush, this.flushInterval);
+
+		window.addEventListener("beforeunload", this.onUnload);
+		window.addEventListener("pagehide", this.onUnload);
+		document.addEventListener("visibilitychange", this.onVisibilityChange);
+
+		this.log("Recording started");
 	}
 
 	stop(): void {
 		if (!this.started) return;
 		this.started = false;
 
-		if (this.debug) {
-			console.log("[Replay] Recording stopped");
-		}
-
 		this.stopRecording?.();
 		this.stopRecording = undefined;
-		this.clearScheduledFlush();
-		this.clearMinLengthFlushTimer();
-		this.clearPendingRetryTimer();
 
-		if (this.flushTimer) {
-			clearInterval(this.flushTimer);
-			this.flushTimer = null;
-		}
+		if (this.intervalId) clearInterval(this.intervalId);
+		if (this.flushTask) clearTimeout(this.flushTask);
+		if (this.retryTask) clearTimeout(this.retryTask);
 
-		window.removeEventListener("beforeunload", this.handleUnload);
-		window.removeEventListener("pagehide", this.handleUnload);
-		document.removeEventListener(
-			"visibilitychange",
-			this.handleVisibilityChange,
-		);
+		this.intervalId = null;
+		this.flushTask = null;
+		this.retryTask = null;
+
+		window.removeEventListener("beforeunload", this.onUnload);
+		window.removeEventListener("pagehide", this.onUnload);
+		document.removeEventListener("visibilitychange", this.onVisibilityChange);
 
 		if (!this.hasReachedMinLength()) {
-			this.events = [];
-			if (this.debug) {
-				console.log(
-					`[Replay] Session too short (${Date.now() - this.startTime}ms), discarding events`,
-				);
-			}
+			this.events.length = 0;
+			this.log(
+				`Session too short (${Date.now() - this.startTime}ms), discarding events`,
+			);
 			return;
 		}
 
-		void this.flush();
+		void this.flush(true);
+		this.log("Recording stopped");
 	}
 
-	private handleEvent(event: eventWithTime, isCheckout?: boolean): void {
-		this.events.push(event);
-
-		if (isCheckout) {
-			this.scheduleFlush();
-		} else if (this.events.length >= this.maxEvents) {
-			this.scheduleFlush();
-		} else if (
-			event.type === EventType.FullSnapshot &&
-			this.hasReachedMinLength()
-		) {
-			this.minLengthFlushScheduled = true;
-			this.scheduleFlush();
-		} else if (!this.minLengthFlushScheduled && this.hasReachedMinLength()) {
-			this.minLengthFlushScheduled = true;
-			this.scheduleFlush();
-		}
-	}
-
-	private hasReachedMinLength(): boolean {
-		if (this.minReplayLengthMs <= 0) return true;
-		return Date.now() - this.startTime >= this.minReplayLengthMs;
+	getSessionId(): string | undefined {
+		return getOrCreateSessionId();
 	}
 
-	private scheduleFlush(): void {
-		if (this.isFlushing || this.events.length === 0 || this.flushScheduled)
-			return;
-
-		this.flushScheduled = true;
-		const runFlush = () => {
-			this.flushScheduled = false;
-			this.flushTimeout = null;
-			this.idleFlushId = null;
-			void this.flush();
-		};
+	private onEvent = (event: eventWithTime, isCheckout?: boolean): void => {
+		this.events.push(event);
 
-		if (typeof window !== "undefined" && "requestIdleCallback" in window) {
-			this.idleFlushId = window.requestIdleCallback(runFlush, {
-				timeout: 2000,
-			});
-			return;
+		if (
+			isCheckout ||
+			this.events.length >= this.maxEvents ||
+			(event.type === EventType.FullSnapshot && this.hasReachedMinLength())
+		) {
+			this.requestFlush();
 		}
+	};
 
-		this.flushTimeout = setTimeout(runFlush, 0);
-	}
-
-	private handleUnload = (): void => {
-		this.clearScheduledFlush();
-		void this.flush({ lowLatency: true });
+	private onUnload = (): void => {
+		void this.flush(true);
 	};
 
-	private handleVisibilityChange = (): void => {
+	private onVisibilityChange = (): void => {
 		if (document.visibilityState === "hidden") {
-			if (this.flushTimer) {
-				clearInterval(this.flushTimer);
-				this.flushTimer = null;
-			}
-			this.clearScheduledFlush();
-			void this.flush({ lowLatency: true });
-		} else if (document.visibilityState === "visible" && this.started) {
-			if (!this.flushTimer) {
-				this.flushTimer = setInterval(() => {
-					this.scheduleFlush();
-				}, this.flushInterval);
-			}
+			void this.flush(true);
 		}
 	};
 
-	private clearScheduledFlush(): void {
-		if (
-			this.idleFlushId !== null &&
-			typeof window !== "undefined" &&
-			"cancelIdleCallback" in window
-		) {
-			window.cancelIdleCallback(this.idleFlushId);
-		}
-		this.idleFlushId = null;
-
-		if (this.flushTimeout) {
-			clearTimeout(this.flushTimeout);
-			this.flushTimeout = null;
-		}
-
-		this.flushScheduled = false;
-	}
-
-	private scheduleMinLengthFlush(): void {
-		if (this.minReplayLengthMs <= 0) return;
-
-		this.clearMinLengthFlushTimer();
-		this.minLengthFlushTimer = setTimeout(() => {
-			this.minLengthFlushTimer = null;
-			if (this.events.length === 0) return;
-
-			this.minLengthFlushScheduled = true;
-			this.scheduleFlush();
-		}, this.minReplayLengthMs);
-	}
-
-	private clearMinLengthFlushTimer(): void {
-		if (this.minLengthFlushTimer) {
-			clearTimeout(this.minLengthFlushTimer);
-			this.minLengthFlushTimer = null;
-		}
-	}
-
-	private clearPendingRetryTimer(): void {
-		if (this.pendingRetryTimer) {
-			clearTimeout(this.pendingRetryTimer);
-			this.pendingRetryTimer = null;
-		}
-	}
-
-	private queuePendingBatch(batch: PendingBatch): void {
-		if (this.pendingBatches.length >= this.maxPendingBatches) {
-			if (this.debug) {
-				console.warn(
-					`[Replay] Pending batch buffer full, dropping batch ${batch.batch.sequence}`,
-				);
-			}
-			return;
-		}
-		this.pendingBatches.push(batch);
-	}
-
-	private schedulePendingRetry(delayMs: number): void {
-		if (this.pendingRetryTimer) return;
-		this.pendingRetryTimer = setTimeout(() => {
-			this.pendingRetryTimer = null;
-			void this.processPendingBatches();
-		}, delayMs);
+	private hasReachedMinLength(): boolean {
+		return (
+			this.minReplayLengthMs <= 0 ||
+			Date.now() - this.startTime >= this.minReplayLengthMs
+		);
 	}
 
-	private async flush(options: { lowLatency?: boolean } = {}): Promise<void> {
-		if (this.events.length === 0) {
-			void this.processPendingBatches();
-			return;
-		}
+	private requestFlush = (): void => {
+		if (this.flushTask || this.sending || this.events.length === 0) return;
 
-		if (!this.hasReachedMinLength()) {
-			if (this.debug) {
-				console.log(
-					`[Replay] Too short (${Date.now() - this.startTime}ms), skipping`,
-				);
-			}
-			void this.processPendingBatches();
-			return;
-		}
-
-		if (this.isFlushing) return;
-		this.isFlushing = true;
+		this.flushTask = setTimeout(() => {
+			this.flushTask = null;
+			void this.flush(false);
+		}, 0);
+	};
 
-		const eventsToSend = this.events;
-		this.events = [];
+	private createBatch(events: eventWithTime[]): ReplayBatch {
+		const identifier = getAnonymousId();
 
-		const anonymousId = getAnonymousId();
-		const batch = {
-			token: this.siteKey,
+		return {
+			token: this.options.siteKey,
 			sessionId: getOrCreateSessionId(),
-			...(anonymousId ? { identifier: anonymousId } : {}),
-			sequence: this.sequenceNumber++,
+			...(identifier ? { identifier } : {}),
+			sequence: this.sequence++,
 			timestamp: Date.now(),
 			url: window.location.href,
-			events: eventsToSend,
+			events,
 		};
+	}
 
-		if (this.pendingBatches.length > 0 || this.isProcessingPending) {
-			this.queuePendingBatch({
-				batch,
-				isCompressed: this.compressionSupported && !options.lowLatency,
-				retries: 0,
-			});
-			this.isFlushing = false;
-			void this.processPendingBatches();
-			return;
-		}
+	private async encodeBatch(
+		batch: ReplayBatch,
+		lowLatency: boolean,
+	): Promise<{ data: Blob; isCompressed: boolean }> {
+		const json = JSON.stringify(batch);
 
-		if (this.debug) {
-			console.log(
-				`[Replay] Sending ${eventsToSend.length} events (seq: ${batch.sequence})`,
-			);
+		if (!this.compressionSupported || lowLatency) {
+			return {
+				data: new Blob([json], { type: "application/json" }),
+				isCompressed: false,
+			};
 		}
 
 		try {
-			let compressed: Blob;
-			let isCompressed = false;
-
-			if (this.compressionSupported && !options.lowLatency) {
-				try {
-					compressed = await this.compress(JSON.stringify(batch));
-					isCompressed = true;
-				} catch {
-					if (this.debug) {
-						console.warn("[Replay] Compression failed, using uncompressed");
-					}
-					compressed = new Blob([JSON.stringify(batch)], {
-						type: "application/json",
-					});
-				}
-			} else {
-				compressed = new Blob([JSON.stringify(batch)], {
-					type: "application/json",
-				});
-			}
-
-			const success = await this.send(compressed, isCompressed, {
-				useBeacon: options.lowLatency === true,
-			});
-			if (!success) {
-				this.queuePendingBatch({
-					batch,
-					isCompressed,
-					retries: 0,
-				});
-			}
-		} catch (error) {
-			if (this.debug) {
-				console.warn("[Replay] Flush error:", error);
-			}
-			this.queuePendingBatch({
-				batch,
+			return {
+				data: await this.compress(json),
+				isCompressed: true,
+			};
+		} catch {
+			this.log("Compression failed, using uncompressed");
+			return {
+				data: new Blob([json], { type: "application/json" }),
 				isCompressed: false,
-				retries: 0,
-			});
-		} finally {
-			this.isFlushing = false;
-			void this.processPendingBatches();
+			};
 		}
 	}
 
-	private async processPendingBatches(): Promise<void> {
-		if (this.isProcessingPending || this.pendingBatches.length === 0) return;
-		this.clearPendingRetryTimer();
-		this.isProcessingPending = true;
+	private async flush(lowLatency: boolean): Promise<void> {
+		if (this.sending) return;
 
-		try {
-			while (this.pendingBatches.length > 0) {
-				const batch = this.pendingBatches[0];
-				if (!batch) {
-					break;
-				}
+		if (this.events.length > 0) {
+			if (!this.hasReachedMinLength()) {
+				this.log(
+					`Too short (${Date.now() - this.startTime}ms), skipping flush`,
+				);
+			} else {
+				this.pending.push(this.createBatch(this.events.splice(0)));
+			}
+		}
 
-				if (batch.retries >= 3) {
-					if (this.debug) {
-						console.warn(
-							`[Replay] Max retries reached, restoring batch ${batch.batch.sequence} to buffer`,
-						);
-					}
-					this.pendingBatches.shift();
-					this.events = [...batch.batch.events, ...this.events];
-					this.scheduleFlush();
-					continue;
-				}
+		if (this.pending.length === 0) return;
+		this.sending = true;
 
-				batch.retries++;
-
-				let blob: Blob;
-				if (batch.isCompressed && this.compressionSupported) {
-					try {
-						blob = await this.compress(JSON.stringify(batch.batch));
-					} catch {
-						blob = new Blob([JSON.stringify(batch.batch)], {
-							type: "application/json",
-						});
-						batch.isCompressed = false;
-					}
-				} else {
-					blob = new Blob([JSON.stringify(batch.batch)], {
-						type: "application/json",
-					});
-				}
+		try {
+			while (this.pending.length > 0) {
+				const batch = this.pending[0];
+				if (!batch) break;
+
+				const encoded = await this.encodeBatch(batch, lowLatency);
+				const ok = await this.send(
+					encoded.data,
+					encoded.isCompressed,
+					lowLatency,
+				);
 
-				const success = await this.send(blob, batch.isCompressed, {
-					useBeacon: false,
-				});
-				if (success) {
-					this.pendingBatches.shift();
-					continue;
+				if (!ok) {
+					if (this.pending.length >= this.maxPendingBatches) {
+						this.log(`Pending buffer full, dropping batch ${batch.sequence}`);
+						this.pending.shift();
+					}
+					this.scheduleRetry();
+					break;
 				}
 
-				this.schedulePendingRetry(1000 * batch.retries);
-				break;
+				this.log(`Sent ${batch.events.length} events (seq: ${batch.sequence})`);
+				this.pending.shift();
+				lowLatency = false;
 			}
-		} catch {
-			const current = this.pendingBatches[0];
-			if (this.debug && current) {
-				console.warn(`[Replay] Retry ${current.retries} failed`);
-			}
-			this.schedulePendingRetry(current ? 1000 * current.retries : 1000);
 		} finally {
-			this.isProcessingPending = false;
+			this.sending = false;
 		}
 	}
 
-	private async compress(data: string): Promise<Blob> {
-		if (!this.compressionSupported) {
-			throw new Error("Compression not supported");
-		}
+	private scheduleRetry(): void {
+		if (this.retryTask) return;
 
-		const encoder = new TextEncoder();
-		const inputData = encoder.encode(data);
+		this.retryTask = setTimeout(() => {
+			this.retryTask = null;
+			void this.flush(false);
+		}, 1000);
+	}
 
+	private async compress(data: string): Promise<Blob> {
+		const input = new TextEncoder().encode(data);
 		const cs = new CompressionStream("gzip");
 		const writer = cs.writable.getWriter();
-		writer.write(inputData);
-		writer.close();
 
-		const compressedChunks: Uint8Array[] = [];
+		await writer.write(input);
+		await writer.close();
+
+		const chunks: Uint8Array[] = [];
 		const reader = cs.readable.getReader();
 
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
-			if (value) compressedChunks.push(value);
+			if (value) chunks.push(value);
 		}
 
-		const totalLength = compressedChunks.reduce(
-			(acc, chunk) => acc + chunk.length,
-			0,
-		);
-		const compressed = new Uint8Array(totalLength);
+		const size = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+		const output = new Uint8Array(size);
+
 		let offset = 0;
-		for (const chunk of compressedChunks) {
-			compressed.set(chunk, offset);
+		for (const chunk of chunks) {
+			output.set(chunk, offset);
 			offset += chunk.length;
 		}
 
-		if (this.debug) {
-			const ratio = ((compressed.length / inputData.length) * 100).toFixed(1);
-			console.log(
-				`[Replay] Compressed: ${inputData.length} → ${compressed.length} bytes (${ratio}%)`,
-			);
-		}
+		this.log(
+			`Compressed: ${input.length} → ${output.length} bytes (${(
+				(output.length / input.length) * 100
+			).toFixed(1)}%)`,
+		);
 
-		return new Blob([compressed], { type: "application/octet-stream" });
+		return new Blob([output], { type: "application/octet-stream" });
 	}
 
-	private async send(
+	private send(
 		data: Blob,
 		isCompressed: boolean,
-		options: { useBeacon?: boolean } = {},
+		lowLatency: boolean,
 	): Promise<boolean> {
-		const url = isCompressed ? `${this.endpoint}?encoding=gzip` : this.endpoint;
-		const sizeKB = (data.size / 1024).toFixed(1);
-
 		return (
 			sendData({
-				url,
+				url: isCompressed ? `${this.endpoint}?encoding=gzip` : this.endpoint,
 				data,
 				contentType: isCompressed
 					? "application/octet-stream"
 					: "application/json",
 				debug: this.debug,
-				debugPrefix: `[Replay] ${sizeKB}KB`,
-				useBeacon: options.useBeacon ?? false,
-				keepalive: options.useBeacon === true,
+				debugPrefix: `[Replay] ${(data.size / 1024).toFixed(1)}KB`,
+				useBeacon: lowLatency,
+				keepalive: lowLatency,
 			}) ?? Promise.resolve(false)
 		);
 	}
-
-	getSessionId(): string | undefined {
-		return getOrCreateSessionId();
-	}
 }
-
-export default ReplayTracker;