@faststats/web 0.2.12 → 0.2.14

package/src/web-vitals.ts

@@ -1,6 +1,6 @@
 import type { Metric, MetricWithAttribution } from "web-vitals";
-import { webVitalsEventsUrl } from "./utils/api-urls";
-import { getOrCreateSessionId } from "./utils/identifiers";
+import { normalizeAnalyticsBaseUrl, URLS } from "./utils/api-urls";
+import { getOrCreateSessionId } from "./utils/session-manager";
 import { normalizeSamplingPercentage } from "./utils/types";
 
 export interface WebVitalsOptions {
@@ -12,64 +12,23 @@ export interface WebVitalsOptions {
 }
 
 type MetricName = "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
+type AnyMetric = Metric | MetricWithAttribution;
 
-type MetricState = {
+type MetricPayload = {
+	metric: MetricName;
 	value: number;
 	attributes: Record<string, unknown>;
 };
 
-type AnyMetric = Metric | MetricWithAttribution;
-type ObserverOptions = {
-	reportAllChanges?: boolean;
-};
-type Observer = (
-	cb: (metric: AnyMetric) => void,
-	opts?: ObserverOptions,
-) => void;
-type ObserverTuple = [Observer, Observer, Observer, Observer, Observer];
-type ObserverConfig = {
-	observe: Observer;
-	options?: ObserverOptions;
-};
-
-async function loadObservers(attribution: boolean): Promise<ObserverConfig[]> {
-	const { onCLS, onFCP, onINP, onLCP, onTTFB } = attribution
-		? await import("web-vitals/attribution")
-		: await import("web-vitals");
-	return createObserverConfigs([onCLS, onFCP, onINP, onLCP, onTTFB]);
-}
-
-function createObserverConfigs([
-	onCLS,
-	onFCP,
-	onINP,
-	onLCP,
-	onTTFB,
-]: ObserverTuple): ObserverConfig[] {
-	return [
-		{ observe: onCLS, options: { reportAllChanges: true } },
-		{ observe: onFCP },
-		{ observe: onINP, options: { reportAllChanges: true } },
-		{ observe: onLCP, options: { reportAllChanges: true } },
-		{ observe: onTTFB },
-	];
-}
-
 export default class WebVitalsTracker {
 	private readonly endpoint: string;
-	private readonly metricsByUrl = new Map<
-		string,
-		Map<MetricName, MetricState>
-	>();
-	private readonly pendingFlushUrls = new Set<string>();
 	private readonly sampled: boolean;
+	private readonly metrics = new Map<MetricName, MetricPayload>();
 	private started = false;
-	private flushing = false;
-	private finalFlushRequested = false;
-	private currentUrl = "";
+	private url = "";
 
 	constructor(private readonly options: WebVitalsOptions) {
-		this.endpoint = webVitalsEventsUrl(options.baseUrl);
+		this.endpoint = `${normalizeAnalyticsBaseUrl(options.baseUrl)}${URLS.vitals}`;
 		this.sampled =
 			Math.random() * 100 <
 			normalizeSamplingPercentage(options.samplingPercentage);
@@ -83,77 +42,68 @@ export default class WebVitalsTracker {
 		if (this.debug) console.log("[WebVitals]", ...args);
 	}
 
-	start(): void {
+	async start(): Promise<void> {
 		if (this.started || typeof window === "undefined") return;
 
 		this.started = true;
-		this.currentUrl = window.location.href;
+		this.url = window.location.href;
 
-		document.addEventListener("visibilitychange", this.onVisibilityChange, {
+		document.addEventListener("visibilitychange", this.onHidden, {
 			passive: true,
 		});
 		window.addEventListener("pagehide", this.onPageHide, { passive: true });
 
+		const mod = this.options.attribution
+			? await import("web-vitals/attribution")
+			: await import("web-vitals");
+
+		if (!this.started) return;
+
+		mod.onCLS(this.capture, { reportAllChanges: true });
+		mod.onINP(this.capture, { reportAllChanges: true });
+		mod.onLCP(this.capture, { reportAllChanges: true });
+		mod.onFCP(this.capture);
+		mod.onTTFB(this.capture);
+
 		this.log("Tracking started");
-		void this.observe();
 	}
 
 	stop(): void {
 		if (!this.started || typeof window === "undefined") return;
 
 		this.started = false;
-		this.cleanupListeners();
-		this.queueFlush(this.currentUrl, true);
+		this.removeListeners();
+		void this.flush();
 	}
 
 	trackPageChange(url?: string): void {
 		if (!this.started || typeof window === "undefined") return;
-		const nextUrl = url ?? window.location.href;
-		if (nextUrl === this.currentUrl) return;
 
-		const previousUrl = this.currentUrl;
-		this.currentUrl = nextUrl;
-		this.queueFlush(previousUrl);
-	}
+		const nextUrl = url ?? window.location.href;
+		if (nextUrl === this.url) return;
 
-	private cleanupListeners(): void {
-		document.removeEventListener("visibilitychange", this.onVisibilityChange);
-		window.removeEventListener("pagehide", this.onPageHide);
+		void this.flush();
+		this.url = nextUrl;
 	}
 
-	private async observe(): Promise<void> {
-		try {
-			const observers = await loadObservers(this.options.attribution ?? false);
-
-			if (!this.started) return;
-
-			for (const { observe, options } of observers) {
-				observe(this.captureMetric, options);
-			}
-		} catch (error) {
-			this.log("Failed to load web-vitals", error);
-		}
-	}
-
-	private onVisibilityChange = (): void => {
+	private onHidden = (): void => {
 		if (document.visibilityState === "hidden") {
-			this.queueFlush(this.currentUrl, true);
+			void this.flush();
 		}
 	};
 
 	private onPageHide = (): void => {
-		this.queueFlush(this.currentUrl, true);
+		void this.flush();
 	};
 
-	private captureMetric = (metric: AnyMetric): void => {
+	private capture = (metric: AnyMetric): void => {
 		if (!this.started || !this.sampled) return;
 
 		const name = metric.name as MetricName;
-		const attribution =
-			(metric as MetricWithAttribution).attribution ?? undefined;
-		const metrics = this.metricsForUrl(this.currentUrl);
+		const attribution = (metric as MetricWithAttribution).attribution;
 
-		metrics.set(name, {
+		this.metrics.set(name, {
+			metric: name,
 			value: metric.value,
 			attributes: {
 				id: metric.id,
@@ -163,99 +113,47 @@ export default class WebVitalsTracker {
 				...(attribution ?? {}),
 			},
 		});
-
-		this.log(`${name} captured: ${metric.value}`);
 	};
 
-	private metricsForUrl(url: string): Map<MetricName, MetricState> {
-		let metrics = this.metricsByUrl.get(url);
-		if (!metrics) {
-			metrics = new Map();
-			this.metricsByUrl.set(url, metrics);
-		}
-		return metrics;
-	}
-
-	private queueFlush(url: string, final = false): void {
-		this.finalFlushRequested ||= final;
-		this.pendingFlushUrls.add(url);
-		void this.flushPending();
-	}
-
-	private async flushPending(): Promise<void> {
-		if (this.flushing) return;
-		if (typeof window === "undefined" || typeof fetch !== "function") {
-			this.finishFinalFlushIfNeeded();
-			return;
-		}
-
-		this.flushing = true;
-
-		try {
-			const urls = [...this.pendingFlushUrls];
-			this.pendingFlushUrls.clear();
-			for (const url of urls) {
-				if (!(await this.sendMetricsForUrl(url)))
-					this.pendingFlushUrls.add(url);
-			}
-		} finally {
-			this.flushing = false;
-			this.finishFinalFlushIfNeeded();
-		}
-	}
-
-	private async sendMetricsForUrl(url: string): Promise<boolean> {
-		const metrics = this.metricsByUrl.get(url);
-		if (!metrics || metrics.size === 0) return true;
-
-		const vitals = [...metrics.entries()].map(([metric, data]) => ({
-			metric,
-			value: data.value,
-			attributes: data.attributes,
-		}));
-		const body = JSON.stringify({
-			sessionId: getOrCreateSessionId(),
-			vitals,
-			metadata: { url },
-		});
+	private async flush(): Promise<void> {
+		if (typeof window === "undefined" || typeof fetch !== "function") return;
+		if (!this.metrics.size) return;
 
-		this.log(`Sending metrics for ${url} (${vitals.length})`);
+		const vitals = Array.from(this.metrics.values());
+		const url = this.url;
+		this.metrics.clear();
 
 		try {
 			const controller = new AbortController();
-			const timeout = window.setTimeout(() => controller.abort(), 3000);
-
-			try {
-				const response = await fetch(this.endpoint, {
-					method: "POST",
-					body,
-					headers: {
-						"Content-Type": "application/json",
-						Authorization: `Bearer ${this.options.siteKey}`,
-					},
-					keepalive: true,
-					signal: controller.signal,
-				});
-
-				if (!response.ok) {
-					throw new Error(`HTTP ${response.status}`);
-				}
-
-				this.metricsByUrl.delete(url);
-			} finally {
-				clearTimeout(timeout);
+			const timeoutId = window.setTimeout(() => controller.abort(), 3000);
+
+			const response = await fetch(this.endpoint, {
+				method: "POST",
+				body: JSON.stringify({
+					sessionId: getOrCreateSessionId(),
+					vitals,
+					metadata: { url },
+				}),
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.options.siteKey}`,
+				},
+				keepalive: true,
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeoutId);
+
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}`);
 			}
-			return true;
 		} catch (error) {
 			this.log("Failed to send metrics", error);
-			return false;
 		}
 	}
 
-	private finishFinalFlushIfNeeded(): void {
-		if (!this.finalFlushRequested) return;
-		this.finalFlushRequested = false;
-		this.started = false;
-		this.cleanupListeners();
+	private removeListeners(): void {
+		document.removeEventListener("visibilitychange", this.onHidden);
+		window.removeEventListener("pagehide", this.onPageHide);
 	}
 }

package/tests/analytics.test.ts

@@ -362,6 +362,7 @@ describe("WebAnalytics lifecycle", () => {
 		expect(checkCall?.body).toContain('"key":"beta"');
 		expect(checkCall?.body).toContain('"externalId":"user_1"');
 		expect(checkCall?.body).toContain('"identifier":');
+		expect(checkCall?.body).toContain('"sessionId":');
 	});
 
 	test("navigation sends page leave and navigation pageview", async () => {
@@ -398,10 +399,13 @@ describe("WebAnalytics lifecycle", () => {
 		});
 
 		await analytics.start();
-		const storage = globalThis.sessionStorage as unknown as MockStorage;
-		const sessionId = storage.getItem("session_id");
+		const storage = globalThis.localStorage as unknown as MockStorage;
+		const sessionId = storage.getItem("faststats_session_id");
 		expect(sessionId).toBeTruthy();
-		storage.setItem("session_timestamp", "0");
+		storage.setItem(
+			"faststats_session_activity",
+			(Date.now() - 31 * 60 * 1000).toString(),
+		);
 		harness.fetchCalls.length = 0;
 
 		Object.defineProperty(globalThis.document, "visibilityState", {
@@ -419,7 +423,7 @@ describe("WebAnalytics lifecycle", () => {
 		}
 		await wait(0);
 
-		expect(storage.getItem("session_id")).toBe(sessionId);
+		expect(storage.getItem("faststats_session_id")).toBe(sessionId);
 		const pageLeaveCall = harness.fetchCalls.find((call) =>
 			call.body?.includes('"event":"page_leave"'),
 		);

package/tests/identifiers.test.ts

@@ -1,10 +1,10 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
+	getAnonymousId,
 	getOrCreateAnonymousId,
-	getOrCreateSessionId,
-	getSessionStart,
-	resetSessionId,
+	resetAnonymousId,
 } from "../src/utils/identifiers";
+import { setCookielessMode } from "../src/utils/session-manager";
 
 class MockStorage {
 	private readonly data = new Map<string, string>();
@@ -32,17 +32,16 @@ function setGlobal(name: keyof typeof globalThis, value: unknown): void {
 
 const original = {
 	localStorage: globalThis.localStorage,
-	sessionStorage: globalThis.sessionStorage,
 };
 
 beforeEach(() => {
 	setGlobal("localStorage", new MockStorage());
-	setGlobal("sessionStorage", new MockStorage());
+	setCookielessMode(false);
 });
 
 afterEach(() => {
 	setGlobal("localStorage", original.localStorage);
-	setGlobal("sessionStorage", original.sessionStorage);
+	setCookielessMode(false);
 });
 
 describe("identifiers", () => {
@@ -53,43 +52,27 @@ describe("identifiers", () => {
 		expect(second).toBe(id);
 	});
 
-	test("session id is recreated when timestamp is invalid", () => {
-		const storage = globalThis.sessionStorage as unknown as MockStorage;
-		storage.setItem("session_id", "old-session");
-		storage.setItem("session_timestamp", "NaN");
-		const id = getOrCreateSessionId();
-		expect(id).not.toBe("old-session");
-	});
-
-	test("session start falls back when stored value is invalid", () => {
-		const storage = globalThis.sessionStorage as unknown as MockStorage;
-		storage.setItem("session_start", "NaN");
-		const start = getSessionStart();
-		expect(Number.isNaN(start)).toBe(true);
-	});
-
-	test("resetSessionId creates a new session id", () => {
-		const first = getOrCreateSessionId();
-		const second = resetSessionId();
+	test("resetAnonymousId creates a new anonymous id", () => {
+		const first = getOrCreateAnonymousId();
+		const second = resetAnonymousId();
 		expect(second.length).toBeGreaterThan(0);
 		expect(second).not.toBe(first);
 	});
 
-	test("storage access failures disable persisted identifiers", () => {
+	test("cookieless mode skips anonymous id persistence", () => {
+		setCookielessMode(true);
+		expect(getAnonymousId()).toBe("");
+	});
+
+	test("storage access failures disable persisted anonymous id", () => {
 		Object.defineProperty(globalThis, "localStorage", {
 			configurable: true,
 			get() {
 				throw new Error("storage blocked");
 			},
 		});
-		Object.defineProperty(globalThis, "sessionStorage", {
-			configurable: true,
-			get() {
-				throw new Error("storage blocked");
-			},
-		});
 
 		expect(getOrCreateAnonymousId()).toBe("");
-		expect(getOrCreateSessionId()).toBe("");
+		expect(resetAnonymousId()).toBe("");
 	});
 });

package/tests/replay.test.ts

@@ -1,7 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { gunzipSync } from "node:zlib";
 import ReplayTracker from "../src/replay";
-import { getOrCreateSessionId } from "../src/utils/identifiers";
+import {
+	getOrCreateSessionId,
+	type SessionContext,
+	setDefaultSiteKey,
+} from "../src/utils/session-manager";
 
 function decodeBody(data: string | Uint8Array): string {
 	if (typeof data === "string") return data;
@@ -32,12 +36,16 @@ type ReplayEvent = {
 
 type ReplayBatch = {
 	token: string;
-	sessionId?: string;
+	sessionId: string;
+	windowId: string;
+	viewId: string;
+	sessionStart: number;
 	identifier?: string;
 	batchId: string;
 	sequence: number;
 	timestamp: number;
 	url: string;
+	isFinal?: boolean;
 	events: ReplayEvent[];
 };
 
@@ -49,7 +57,12 @@ type ReplayTrackerInternals = {
 	retryTask: ReturnType<typeof setTimeout> | null;
 	startTime: number;
 	onEvent: (event: ReplayEvent, isCheckout?: boolean) => void;
-	flush: (lowLatency: boolean) => Promise<void>;
+	trackPageChange: (url?: string) => void;
+	flush: (
+		lowLatency: boolean,
+		contextOverride?: SessionContext,
+		isFinal?: boolean,
+	) => Promise<void>;
 	send: (
 		data: string | Uint8Array,
 		isCompressed: boolean,
@@ -89,6 +102,7 @@ beforeEach(() => {
 	setGlobal("location", { href: "https://example.com/" } as Location);
 	setGlobal("localStorage", new MockStorage());
 	setGlobal("sessionStorage", new MockStorage());
+	setDefaultSiteKey("site_test");
 	setGlobal("navigator", { sendBeacon: () => false });
 	setGlobal(
 		"fetch",
@@ -111,10 +125,25 @@ function createTracker(
 ): ReplayTrackerInternals {
 	return new ReplayTracker({
 		siteKey: "site_test",
+		samplingPercentage: 100,
 		...options,
 	}) as unknown as ReplayTrackerInternals;
 }
 
+async function captureReplayBatch(
+	tracker: ReplayTrackerInternals,
+): Promise<ReplayBatch> {
+	const payloads: ReplayBatch[] = [];
+	tracker.send = async (data) => {
+		payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
+		return true;
+	};
+	tracker.startTime = Date.now() - 1000;
+	tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
+	await tracker.flush(false);
+	return payloads[0] as ReplayBatch;
+}
+
 describe("ReplayTracker", () => {
 	test("buffers replay events", () => {
 		const tracker = createTracker({
@@ -192,6 +221,9 @@ describe("ReplayTracker", () => {
 		expect(captured.payload).not.toBeNull();
 		expect(captured.payload?.token).toBe("site_test");
 		expect(captured.payload?.sessionId).toBeTruthy();
+		expect(captured.payload?.windowId).toBeTruthy();
+		expect(captured.payload?.viewId).toBeTruthy();
+		expect(captured.payload?.sessionStart).toBeGreaterThan(0);
 		expect(captured.payload?.batchId).toBeTruthy();
 		expect(captured.payload?.events).toHaveLength(1);
 		expect(captured.lowLatency).toBe(true);
@@ -232,15 +264,10 @@ describe("ReplayTracker", () => {
 			return true;
 		};
 
-		(tracker as unknown as { sessionId?: string }).sessionId =
-			getOrCreateSessionId();
+		getOrCreateSessionId();
 		tracker.startTime = Date.now() - 1000;
 		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
 		await tracker.flush(false);
-
-		const storage = globalThis.sessionStorage as unknown as MockStorage;
-		storage.setItem("session_timestamp", "0");
-
 		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
 		await tracker.flush(false);
 
@@ -249,6 +276,149 @@ describe("ReplayTracker", () => {
 		expect(payloads[1]?.sessionId).toBe(payloads[0]?.sessionId);
 	});
 
+	test("uses a new session id after idle timeout", async () => {
+		const tracker = createTracker({
+			minReplayLengthMs: 0,
+		});
+
+		const payloads: ReplayBatch[] = [];
+		tracker.send = async (data) => {
+			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
+			return true;
+		};
+
+		getOrCreateSessionId();
+		tracker.startTime = Date.now() - 1000;
+		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
+		await tracker.flush(false);
+
+		const local = globalThis.localStorage as unknown as MockStorage;
+		local.setItem(
+			"faststats_session_activity",
+			(Date.now() - 31 * 60 * 1000).toString(),
+		);
+
+		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
+		await tracker.flush(false);
+
+		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
+		await tracker.flush(false);
+
+		expect(payloads).toHaveLength(3);
+		expect(payloads[1]?.sessionId).toBe(payloads[0]?.sessionId);
+		expect(payloads[1]?.isFinal).toBe(true);
+		expect(payloads[2]?.sessionId).not.toBe(payloads[0]?.sessionId);
+	});
+
+	test("finalizes queued events under previous session after idle timeout", async () => {
+		const tracker = createTracker({
+			minReplayLengthMs: 0,
+		});
+
+		const payloads: ReplayBatch[] = [];
+		tracker.send = async (data) => {
+			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
+			return true;
+		};
+
+		const previousSessionId = getOrCreateSessionId();
+		const local = globalThis.localStorage as unknown as MockStorage;
+		local.setItem(
+			"faststats_session_activity",
+			(Date.now() - 31 * 60 * 1000).toString(),
+		);
+
+		tracker.startTime = Date.now() - 1000;
+		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
+		await tracker.flush(false);
+
+		expect(payloads).toHaveLength(1);
+		expect(payloads[0]?.sessionId).toBe(previousSessionId);
+		expect(payloads[0]?.isFinal).toBe(true);
+	});
+
+	test("keeps the same window and view ids across replay batches", async () => {
+		const tracker = createTracker({
+			minReplayLengthMs: 0,
+		});
+
+		const payloads: ReplayBatch[] = [];
+		tracker.send = async (data) => {
+			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
+			return true;
+		};
+		getOrCreateSessionId();
+		tracker.startTime = Date.now() - 1000;
+
+		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
+		await tracker.flush(false);
+		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
+		await tracker.flush(false);
+
+		expect(payloads).toHaveLength(2);
+		expect(payloads[1]?.windowId).toBe(payloads[0]?.windowId);
+		expect(payloads[1]?.viewId).toBe(payloads[0]?.viewId);
+		expect(payloads[1]?.sequence).toBe((payloads[0]?.sequence ?? 0) + 1);
+	});
+
+	test("window id is stable across replay tracker remounts", async () => {
+		const sharedSession = new MockStorage();
+		sharedSession.setItem("faststats_window_id_site_test", "stable-window");
+
+		setGlobal("sessionStorage", sharedSession);
+
+		const first = createTracker({ minReplayLengthMs: 0 });
+		const second = createTracker({ minReplayLengthMs: 0 });
+
+		const firstBatch = await captureReplayBatch(first);
+		const secondBatch = await captureReplayBatch(second);
+
+		expect(firstBatch.windowId).toBe("stable-window");
+		expect(secondBatch.windowId).toBe("stable-window");
+	});
+
+	test("same session across tabs with different window ids", async () => {
+		const sharedLocal = new MockStorage();
+		sharedLocal.setItem("faststats_session_id", "shared-session");
+		sharedLocal.setItem("faststats_session_activity", Date.now().toString());
+		sharedLocal.setItem("faststats_session_start", Date.now().toString());
+
+		setGlobal("localStorage", sharedLocal);
+		setGlobal("sessionStorage", new MockStorage());
+
+		const first = createTracker({ minReplayLengthMs: 0 });
+		const firstBatch = await captureReplayBatch(first);
+
+		setGlobal("sessionStorage", new MockStorage());
+		const second = createTracker({ minReplayLengthMs: 0 });
+		const secondBatch = await captureReplayBatch(second);
+
+		expect(firstBatch.sessionId).toBe("shared-session");
+		expect(secondBatch.sessionId).toBe("shared-session");
+		expect(firstBatch.windowId).not.toBe(secondBatch.windowId);
+	});
+
+	test("trackPageChange rotates viewId and emits meta event", () => {
+		const tracker = createTracker();
+		(tracker as unknown as { started: boolean }).started = true;
+		const firstViewId = (tracker as unknown as { viewId: string }).viewId;
+
+		tracker.trackPageChange("https://example.com/about");
+
+		const viewEvent = tracker.events.find(
+			(e) =>
+				(e.data as Record<string, unknown> | undefined)?.tag ===
+				"faststats:view",
+		);
+		expect(viewEvent).toBeDefined();
+		const payload = (viewEvent?.data as Record<string, unknown> | undefined)
+			?.payload as Record<string, unknown> | undefined;
+		expect(payload?.href).toBe("https://example.com/about");
+		expect((tracker as unknown as { viewId: string }).viewId).not.toBe(
+			firstViewId,
+		);
+	});
+
 	test("sends replay as plain JSON when CompressionStream is unavailable", async () => {
 		const tracker = createTracker({
 			minReplayLengthMs: 0,
@@ -332,7 +502,7 @@ describe("ReplayTracker", () => {
 		tracker.startTime = Date.now() - 1000;
 		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
 
-		await tracker.flush(true);
+		await tracker.flush(true, undefined, true);
 
 		expect(compressedFlag).toBe(true);
 		expect(lowLatencyFlag).toBe(true);