@faststats/web 0.2.11 → 0.2.13

package/src/error.ts

@@ -1,5 +1,5 @@
 import { SDK_NAME, SDK_VERSION } from "./sdk";
-import { webEventsUrl } from "./utils/api-urls";
+import { normalizeAnalyticsBaseUrl, URLS } from "./utils/api-urls";
 import { getAnonymousId, getOrCreateSessionId } from "./utils/identifiers";
 import { sendData } from "./utils/send-data";
 
@@ -16,18 +16,6 @@ export type ErrorTracking = ErrorEntry & {
 	count: number;
 };
 
-type ErrorKind = "error" | "unhandledrejection";
-
-type NormalizedError = {
-	kind: ErrorKind;
-	message: string;
-	stack?: string;
-	filename?: string;
-	lineno?: number;
-	handled: boolean;
-	cause?: ErrorEntry;
-};
-
 export interface ErrorTrackingOptions {
 	siteKey: string;
 	baseUrl?: string;
@@ -38,214 +26,176 @@ export interface ErrorTrackingOptions {
 	sdkVersion?: string;
 }
 
-const EXTENSION_URL =
+type Kind = "error" | "unhandledrejection";
+
+const EXTENSION_RE =
 	/(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
 
 const parseStack = (stack?: string): string[] | undefined =>
 	stack
 		?.split("\n")
-		.map((line) => line.trim())
+		.map((l) => l.trim())
 		.filter(Boolean);
 
-function serializeCause(cause: unknown): ErrorEntry | undefined {
-	if (cause instanceof Error) {
+function serializeCause(value: unknown): ErrorEntry | undefined {
+	if (value instanceof Error) {
 		return {
-			error: cause.name?.trim() || "Error",
-			message: cause.message,
-			stack: parseStack(cause.stack),
-			cause: serializeCause(cause.cause),
+			error: value.name?.trim() || "Error",
+			message: value.message,
+			stack: parseStack(value.stack),
+			cause: serializeCause(value.cause),
 		};
 	}
-
-	if (typeof cause === "string") {
-		return { error: "Error", message: cause };
-	}
+	if (typeof value === "string") return { error: "Error", message: value };
 }
 
 function fingerprintCause(cause?: ErrorEntry): string {
-	return cause
-		? `${cause.error}\0${cause.message ?? ""}\0${fingerprintCause(cause.cause)}`
-		: "";
+	let s = "";
+	for (let c = cause; c; c = c.cause) {
+		s += `${c.error}\0${c.message ?? ""}\0`;
+	}
+	return s;
 }
 
-function hashError(data: NormalizedError): string {
-	const key = [
-		data.kind,
-		data.handled ? "handled" : "unhandled",
-		data.message,
-		data.filename ?? "",
-		data.lineno ?? "",
-		fingerprintCause(data.cause),
-	].join("\0");
-
+function hashKey(key: string): string {
 	let a = 2166136261;
 	let b = 3598710387;
-
 	for (let i = 0; i < key.length; i++) {
 		const c = key.charCodeAt(i);
 		a = Math.imul(a ^ c, 16777619);
 		b = Math.imul(b ^ c, 2246822519);
 	}
+	return `err_${(a >>> 0).toString(16).padStart(8, "0")}${(b >>> 0).toString(16).padStart(8, "0")}`;
+}
 
-	return `err_${(a >>> 0).toString(16).padStart(8, "0")}${(b >>> 0)
-		.toString(16)
-		.padStart(8, "0")}`;
+function readBuildId(): string | undefined {
+	const v = (globalThis as { __SOURCEMAPS_BUILD__?: { buildId?: unknown } })
+		.__SOURCEMAPS_BUILD__?.buildId;
+	return typeof v === "string" && v.trim() ? v : undefined;
 }
 
 export default class ErrorTracker {
 	private readonly endpoint: string;
-	private readonly handled = new WeakSet<Error>();
+	private readonly seen = new WeakSet<object>();
 	private readonly queue = new Map<string, ErrorTracking>();
 	private timer: ReturnType<typeof setInterval> | null = null;
 	private started = false;
 	private flushing = false;
 
 	constructor(private readonly options: ErrorTrackingOptions) {
-		this.endpoint = webEventsUrl(options.baseUrl);
-	}
-
-	private get debug(): boolean {
-		return this.options.debug ?? false;
-	}
-
-	private get flushInterval(): number {
-		return this.options.flushInterval ?? 5000;
-	}
-
-	private get maxQueueSize(): number {
-		return this.options.maxQueueSize ?? 50;
+		this.endpoint = `${normalizeAnalyticsBaseUrl(options.baseUrl)}${URLS.events}`;
 	}
 
 	private log(...args: unknown[]): void {
-		if (this.debug) console.log("[ErrorTracker]", ...args);
+		if (this.options.debug) console.log("[ErrorTracker]", ...args);
 	}
 
 	start(): void {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
-
 		window.addEventListener("error", this.onError);
 		window.addEventListener("unhandledrejection", this.onRejection);
-		document.addEventListener("visibilitychange", this.onVisibilityChange);
-		window.addEventListener("pagehide", this.requestFlush);
-
-		this.timer = setInterval(this.requestFlush, this.flushInterval);
-		this.log("Started listening for errors");
+		window.addEventListener("pagehide", this.scheduleFlush);
+		document.addEventListener("visibilitychange", this.onVisibility);
+		this.timer = setInterval(
+			this.scheduleFlush,
+			this.options.flushInterval ?? 5000,
+		);
+		this.log("Started");
 	}
 
 	stop(): void {
 		if (!this.started || typeof window === "undefined") return;
 		this.started = false;
-
 		window.removeEventListener("error", this.onError);
 		window.removeEventListener("unhandledrejection", this.onRejection);
-		document.removeEventListener("visibilitychange", this.onVisibilityChange);
-		window.removeEventListener("pagehide", this.requestFlush);
-
+		window.removeEventListener("pagehide", this.scheduleFlush);
+		document.removeEventListener("visibilitychange", this.onVisibility);
 		if (this.timer) clearInterval(this.timer);
 		this.timer = null;
-
-		this.requestFlush();
-		this.log("Stopped listening for errors");
+		this.scheduleFlush();
+		this.log("Stopped");
 	}
 
 	captureError(error: Error): void {
-		this.record(
-			{
-				kind: "error",
-				message: error.message,
-				stack: error.stack,
-				handled: true,
-				cause: serializeCause(error.cause),
-			},
-			error,
-		);
+		this.capture("error", error.message, true, error);
 	}
 
 	private onError = (event: ErrorEvent): void => {
-		const err = event.error;
-
-		this.record(
-			{
-				kind: "error",
-				message: event.message || "Unknown error",
-				filename: event.filename || undefined,
-				lineno: event.lineno || undefined,
-				stack: err instanceof Error ? err.stack : undefined,
-				handled: false,
-				cause: err instanceof Error ? serializeCause(err.cause) : undefined,
-			},
-			err,
+		this.capture(
+			"error",
+			event.message || "Unknown error",
+			false,
+			event.error,
+			event.filename || "",
+			event.lineno,
 		);
 	};
 
 	private onRejection = (event: PromiseRejectionEvent): void => {
 		const reason = event.reason;
-
-		this.record(
-			{
-				kind: "unhandledrejection",
-				message: reason.message || "Unhandled promise rejection",
-				stack: reason.stack || undefined,
-				handled: false,
-				cause: serializeCause(reason.cause),
-			},
-			reason,
-		);
+		const message =
+			reason instanceof Error
+				? reason.message
+				: typeof reason === "string"
+					? reason
+					: "Unhandled promise rejection";
+		this.capture("unhandledrejection", message, false, reason);
 	};
 
-	private onVisibilityChange = (): void => {
-		if (document.visibilityState === "hidden") this.requestFlush();
+	private onVisibility = (): void => {
+		if (document.visibilityState === "hidden") this.scheduleFlush();
 	};
 
-	private requestFlush = (): void => {
+	private scheduleFlush = (): void => {
 		void this.flush();
 	};
 
-	private restoreErrors(errors: ErrorTracking[]): void {
-		for (const error of errors) {
-			this.queue.set(error.hash, {
-				...error,
-				count: error.count + (this.queue.get(error.hash)?.count ?? 0),
-			});
-		}
-	}
-
-	private record(data: NormalizedError, original?: unknown): void {
-		if (original instanceof Error) {
-			if (this.handled.has(original)) {
-				this.log("Skipping duplicate:", original.message);
+	private capture(
+		kind: Kind,
+		message: string,
+		handled: boolean,
+		source: unknown,
+		filename = "",
+		lineno: number | "" = "",
+	): void {
+		const stackText = source instanceof Error ? (source.stack ?? "") : "";
+		if (EXTENSION_RE.test(`${filename}\n${stackText}`)) return;
+
+		if (typeof source === "object" && source !== null) {
+			if (this.seen.has(source)) {
+				this.log("Skipping duplicate:", message);
 				return;
 			}
-			this.handled.add(original);
+			this.seen.add(source);
 		}
 
-		if (EXTENSION_URL.test(`${data.filename ?? ""}\n${data.stack ?? ""}`)) {
-			return;
+		const entry: ErrorEntry = {
+			error: kind === "unhandledrejection" ? "UnhandledRejection" : "Error",
+			message,
+			handled,
+		};
+		if (source instanceof Error) {
+			entry.stack = parseStack(source.stack);
+			const cause = serializeCause(source.cause);
+			if (cause) entry.cause = cause;
 		}
 
-		const hash = hashError(data);
-		const existing = this.queue.get(hash);
+		const key = hashKey(
+			`${kind}\0${handled ? "handled" : "unhandled"}\0${message}\0${filename}\0${lineno}\0${fingerprintCause(entry.cause)}`,
+		);
 
+		const existing = this.queue.get(key);
 		if (existing) {
-			existing.count += 1;
+			existing.count++;
 		} else {
-			this.queue.set(hash, {
-				hash,
-				count: 1,
-				error:
-					data.kind === "unhandledrejection" ? "UnhandledRejection" : "Error",
-				message: data.message,
-				stack: parseStack(data.stack),
-				handled: data.handled,
-				...(data.cause ? { cause: data.cause } : {}),
-			});
+			this.queue.set(key, { hash: key, count: 1, ...entry });
 		}
 
-		this.log("Captured error:", data);
+		this.log("Captured:", entry);
 
-		if (this.queue.size >= this.maxQueueSize) {
-			this.requestFlush();
+		if (this.queue.size >= (this.options.maxQueueSize ?? 50)) {
+			this.scheduleFlush();
 		}
 	}
 
@@ -256,22 +206,12 @@ export default class ErrorTracker {
 		this.queue.clear();
 		this.flushing = true;
 
-		const identifier = getAnonymousId();
-		const sourcemapsBuild = (
-			globalThis as {
-				__SOURCEMAPS_BUILD__?: { buildId?: unknown };
-			}
-		).__SOURCEMAPS_BUILD__;
-
-		const buildId =
-			typeof sourcemapsBuild?.buildId === "string" &&
-			sourcemapsBuild.buildId.trim()
-				? sourcemapsBuild.buildId
-				: undefined;
+		const userId = getAnonymousId();
+		const buildId = readBuildId();
 
 		const payload = JSON.stringify({
 			token: this.options.siteKey,
-			...(identifier ? { userId: identifier } : {}),
+			...(userId ? { userId } : {}),
 			sessionId: getOrCreateSessionId(),
 			...(buildId ? { buildId } : {}),
 			sdkName: this.options.sdkName ?? SDK_NAME,
@@ -285,21 +225,28 @@ export default class ErrorTracker {
 			errors,
 		});
 
-		this.log("Flushing errors:", errors);
-		this.log("Payload:", payload);
+		this.log("Flushing:", errors);
 
 		try {
 			const sent = await sendData({
 				url: this.endpoint,
 				data: payload,
-				debug: this.debug,
+				debug: this.options.debug,
 				debugPrefix: "[ErrorTracker]",
 			});
-			if (!sent) this.restoreErrors(errors);
+			if (!sent) this.requeue(errors);
 		} catch {
-			this.restoreErrors(errors);
+			this.requeue(errors);
 		} finally {
 			this.flushing = false;
 		}
 	}
+
+	private requeue(errors: ErrorTracking[]): void {
+		for (const e of errors) {
+			const existing = this.queue.get(e.hash);
+			if (existing) existing.count += e.count;
+			else this.queue.set(e.hash, e);
+		}
+	}
 }

package/src/feature-flags.ts

@@ -1,4 +1,4 @@
-import { featureFlagsCheckUrl } from "./utils/api-urls";
+import { normalizeFeatureFlagsBaseUrl, URLS } from "./utils/api-urls";
 
 export type FeatureFlagEvaluation = {
 	value: string;
@@ -12,6 +12,7 @@ export type FeatureFlagCheckContext = {
 	projectId?: string;
 	identifier?: string;
 	externalId?: string;
+	sessionId?: string;
 	attributes?: Record<string, unknown>;
 	signal?: AbortSignal;
 };
@@ -28,6 +29,7 @@ export async function fetchFeatureFlagEvaluation(
 	const projectId = context.projectId;
 	const identifier = context.identifier;
 	const externalId = context.externalId;
+	const sessionId = context.sessionId;
 
 	if (!projectToken && !projectId) {
 		throw new Error("feature flag check requires projectToken or projectId");
@@ -41,6 +43,7 @@ export async function fetchFeatureFlagEvaluation(
 		...(projectId ? { projectId } : {}),
 		...(identifier ? { identifier } : {}),
 		...(externalId ? { externalId } : {}),
+		...(sessionId ? { sessionId } : {}),
 	};
 
 	if (context.attributes && Object.keys(context.attributes).length > 0) {
@@ -54,7 +57,7 @@ export async function fetchFeatureFlagEvaluation(
 		headers.Authorization = `Bearer ${projectToken}`;
 	}
 
-	const url = featureFlagsCheckUrl(context.baseUrl);
+	const url = `${normalizeFeatureFlagsBaseUrl(context.baseUrl)}${URLS.flags}`;
 	const res = await fetch(url, {
 		method: "POST",
 		headers,

package/src/replay.ts

@@ -6,7 +6,7 @@ import {
 import { record } from "rrweb";
 import type { recordOptions } from "rrweb/typings/types";
 import type { SlimDOMOptions } from "rrweb-snapshot";
-import { replayEventsUrl } from "./utils/api-urls";
+import { normalizeAnalyticsBaseUrl, URLS } from "./utils/api-urls";
 import {
 	getAnonymousId,
 	getOrCreateSessionId,
@@ -96,7 +96,7 @@ export default class ReplayTracker {
 	private sending = false;
 
 	constructor(private readonly options: ReplayTrackerOptions) {
-		this.endpoint = replayEventsUrl(options.baseUrl);
+		this.endpoint = `${normalizeAnalyticsBaseUrl(options.baseUrl)}${URLS.replay}`;
 		this.sampled =
 			Math.random() * 100 <
 			normalizeSamplingPercentage(options.samplingPercentage);

package/src/utils/api-urls.ts

@@ -10,28 +10,15 @@ export function normalizeAnalyticsBaseUrl(input?: string): string {
 	return stripTrailingSlashes(input) || DEFAULT_BASE;
 }
 
-export function webEventsUrl(baseUrl?: string): string {
-	return `${normalizeAnalyticsBaseUrl(baseUrl)}/v1/web`;
-}
-
-export function identifyEventsUrl(baseUrl?: string): string {
-	return `${normalizeAnalyticsBaseUrl(baseUrl)}/v1/identify`;
-}
-
-export function replayEventsUrl(baseUrl?: string): string {
-	return `${normalizeAnalyticsBaseUrl(baseUrl)}/v1/replay`;
-}
-
-export function webVitalsEventsUrl(baseUrl?: string): string {
-	return `${normalizeAnalyticsBaseUrl(baseUrl)}/v1/vitals`;
-}
+export const URLS = {
+	events: "/v1/web",
+	identify: "/v1/identify",
+	replay: "/v1/replay",
+	vitals: "/v1/vitals",
+	flags: "/v1/check",
+} as const;
 
 export function normalizeFeatureFlagsBaseUrl(input?: string): string {
 	if (input === undefined || input === "") return DEFAULT_FEATURE_FLAGS_BASE;
 	return stripTrailingSlashes(input) || DEFAULT_FEATURE_FLAGS_BASE;
 }
-
-export function featureFlagsCheckUrl(baseUrl?: string): string {
-	const base = normalizeFeatureFlagsBaseUrl(baseUrl);
-	return `${base}/v1/check`;
-}

package/src/utils/identifiers.ts

@@ -1,4 +1,8 @@
 const SESSION_TIMEOUT = 30 * 60 * 1000;
+const ANONYMOUS_ID_KEY = "faststats_anon_id";
+const SESSION_ID_KEY = "session_id";
+const SESSION_TIMESTAMP_KEY = "session_timestamp";
+const SESSION_START_KEY = "session_start";
 
 let cookielessMode = false;
 
@@ -13,65 +17,73 @@ export function getAnonymousId(cookieless?: boolean): string {
 }
 
 export function getOrCreateAnonymousId(): string {
-	if (typeof localStorage === "undefined") return "";
-	const existingId = localStorage.getItem("faststats_anon_id");
+	if (!localStorage) return "";
+	const existingId = localStorage.getItem(ANONYMOUS_ID_KEY);
 	if (existingId) return existingId;
 
 	const newId = crypto.randomUUID();
-	localStorage.setItem("faststats_anon_id", newId);
+	localStorage.setItem(ANONYMOUS_ID_KEY, newId);
 	return newId;
 }
 
 export function resetAnonymousId(cookieless?: boolean): string {
-	if (cookieless || typeof localStorage === "undefined") return "";
-	localStorage.removeItem("faststats_anon_id");
+	if (cookieless) return "";
+
+	if (!localStorage) return "";
+
+	localStorage.removeItem(ANONYMOUS_ID_KEY);
 	return getOrCreateAnonymousId();
 }
 
 export function getOrCreateSessionId(): string {
-	if (typeof sessionStorage === "undefined") return "";
-	const existingId = sessionStorage.getItem("session_id");
-	const sessionTimestamp = sessionStorage.getItem("session_timestamp");
+	if (!sessionStorage) return "";
+
+	const existingId = sessionStorage.getItem(SESSION_ID_KEY);
+	const sessionTimestamp = sessionStorage.getItem(SESSION_TIMESTAMP_KEY);
 
 	if (existingId && sessionTimestamp) {
 		const sessionAge = Date.now() - Number.parseInt(sessionTimestamp, 10);
 		if (sessionAge < SESSION_TIMEOUT) {
-			sessionStorage.setItem("session_timestamp", Date.now().toString());
+			sessionStorage.setItem(SESSION_TIMESTAMP_KEY, Date.now().toString());
 			return existingId;
 		}
-		sessionStorage.removeItem("session_id");
-		sessionStorage.removeItem("session_timestamp");
-		sessionStorage.removeItem("session_start");
+		clearSession(sessionStorage);
 	}
 
 	const now = Date.now().toString();
 	const newId = crypto.randomUUID();
-	sessionStorage.setItem("session_id", newId);
-	sessionStorage.setItem("session_timestamp", now);
-	sessionStorage.setItem("session_start", now);
+	sessionStorage.setItem(SESSION_ID_KEY, newId);
+	sessionStorage.setItem(SESSION_TIMESTAMP_KEY, now);
+	sessionStorage.setItem(SESSION_START_KEY, now);
 	return newId;
 }
 
 export function resetSessionId(): string {
-	if (typeof sessionStorage === "undefined") return "";
-	sessionStorage.removeItem("session_id");
-	sessionStorage.removeItem("session_timestamp");
-	sessionStorage.removeItem("session_start");
+	if (!sessionStorage) return "";
+
+	clearSession(sessionStorage);
 	return getOrCreateSessionId();
 }
 
 export function refreshSessionTimestamp(): void {
-	if (typeof sessionStorage === "undefined") return;
-	const existingId = sessionStorage.getItem("session_id");
-	if (existingId) {
-		sessionStorage.setItem("session_timestamp", Date.now().toString());
+	if (!sessionStorage) return;
+
+	if (sessionStorage.getItem(SESSION_ID_KEY)) {
+		sessionStorage.setItem(SESSION_TIMESTAMP_KEY, Date.now().toString());
 	}
 }
 
 export function getSessionStart(): number {
-	if (typeof sessionStorage === "undefined") return Date.now();
-	const start = sessionStorage.getItem("session_start");
+	if (!sessionStorage) return Date.now();
+
+	const start = sessionStorage.getItem(SESSION_START_KEY);
 	if (start) return Number.parseInt(start, 10);
-	const ts = sessionStorage.getItem("session_timestamp");
+	const ts = sessionStorage.getItem(SESSION_TIMESTAMP_KEY);
 	return ts ? Number.parseInt(ts, 10) : Date.now();
 }
+
+function clearSession(storage: Storage): void {
+	storage.removeItem(SESSION_ID_KEY);
+	storage.removeItem(SESSION_TIMESTAMP_KEY);
+	storage.removeItem(SESSION_START_KEY);
+}