@faststats/nitro 0.1.4

package/dist/report-error-Be0UMIs5.mjs

@@ -0,0 +1,341 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { version } from "node:os";
+//#region src/hash-error.ts
+const EXTENSION_URL = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
+function parseStack(stack) {
+	if (!stack) return void 0;
+	return stack.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !EXTENSION_URL.test(line));
+}
+function serializeCause(cause) {
+	if (cause instanceof Error) return {
+		error: cause.name?.trim() || "Error",
+		message: cause.message,
+		stack: parseStack(cause.stack),
+		cause: serializeCause(cause.cause)
+	};
+	if (typeof cause === "string") return {
+		error: "Error",
+		message: cause
+	};
+}
+function causeFingerprint(cause) {
+	if (!cause) return "";
+	return `${cause.error}\0${cause.message ?? ""}\0${causeFingerprint(cause.cause)}`;
+}
+function hashErrorData(data) {
+	const key = [
+		data.type,
+		data.message,
+		data.filename ?? "",
+		data.lineno ?? "",
+		causeFingerprint(data.cause)
+	].join("\0");
+	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")}`;
+}
+function hashServerError(error) {
+	const err = error instanceof Error ? error : new Error(String(error));
+	const hash = hashErrorData({
+		type: "error",
+		message: err.message,
+		stack: err.stack,
+		cause: serializeCause(err.cause)
+	});
+	const name = err.name?.trim() || "Error";
+	const cause = serializeCause(err.cause);
+	return {
+		hash,
+		entry: {
+			error: name,
+			message: err.message,
+			stack: parseStack(err.stack),
+			...cause ? { cause } : {}
+		}
+	};
+}
+//#endregion
+//#region src/runtime-context.ts
+function readPackageVersion(pkg) {
+	try {
+		const raw = readFileSync(createRequire(import.meta.url).resolve(`${pkg}/package.json`), "utf8");
+		const j = JSON.parse(raw);
+		return typeof j.version === "string" ? j.version : void 0;
+	} catch {
+		return;
+	}
+}
+function getNitroPackageVersion() {
+	return readPackageVersion("nitropack") ?? readPackageVersion("nitro");
+}
+function getRuntimeInfo() {
+	if (Bun.version !== void 0) return {
+		runtime: "bun",
+		runtimeVersion: Bun.version
+	};
+	if (Deno.version !== void 0) return {
+		runtime: "deno",
+		runtimeVersion: Deno.version
+	};
+	if (typeof process !== "undefined" && process.versions && typeof process.versions.node === "string") return {
+		runtime: "node",
+		runtimeVersion: process.versions.node
+	};
+	const edgeRt = EdgeRuntime;
+	if (edgeRt !== void 0) return {
+		runtime: "edge",
+		runtimeVersion: edgeRt
+	};
+	if (typeof globalThis !== "undefined" && "navigator" in globalThis && String(globalThis.navigator?.userAgent ?? "").includes("Cloudflare-Workers")) return { runtime: "workerd" };
+	return { runtime: "unknown" };
+}
+function getOsSlice() {
+	return {
+		os: globalThis.process?.release?.name || "unknown",
+		osVersion: version() || "unknown",
+		platform: globalThis.process?.platform || "unknown",
+		arch: globalThis.process?.arch || "unknown"
+	};
+}
+function buildServerReportContext(extra = {}) {
+	const { runtime, runtimeVersion } = getRuntimeInfo();
+	const osSlice = getOsSlice();
+	const nitroVersion = getNitroPackageVersion();
+	const nitroPreset = globalThis.process.env.NITRO_PRESET;
+	const cwd = globalThis.process?.cwd();
+	return {
+		source: "@faststats/nitro",
+		...extra,
+		nitroVersion,
+		nitroPreset,
+		runtime,
+		runtimeVersion,
+		...osSlice,
+		...cwd ? { cwd } : {}
+	};
+}
+//#endregion
+//#region src/error-reporter.ts
+function pruneUndefined(context) {
+	const result = {};
+	for (const [key, value] of Object.entries(context)) if (value !== void 0 && value !== "") result[key] = value;
+	return result;
+}
+function mergeBucketsInto(target, incoming) {
+	for (const [hash, incomingBucket] of incoming) {
+		const existing = target.get(hash);
+		if (!existing) {
+			target.set(hash, { ...incomingBucket });
+			continue;
+		}
+		existing.count += incomingBucket.count;
+		if (incomingBucket.path !== void 0) existing.path = incomingBucket.path;
+		if (incomingBucket.tags.length > 0) existing.tags = incomingBucket.tags;
+	}
+}
+function selectRoute(buckets) {
+	let route;
+	let count = -1;
+	for (const bucket of buckets.values()) if (bucket.path !== void 0 && bucket.count > count) {
+		count = bucket.count;
+		route = bucket.path;
+	}
+	return route;
+}
+function mergeCustomContext(buckets) {
+	const merged = {};
+	for (const bucket of buckets.values()) for (const [key, value] of Object.entries(bucket.custom)) if (!(key in merged)) merged[key] = value;
+	return merged;
+}
+function createPayload(snapshot, options, sessionId) {
+	const errors = [...snapshot.entries()].map(([hash, bucket]) => ({
+		...bucket.entry,
+		hash,
+		count: bucket.count
+	}));
+	const tags = [...new Set([...snapshot.values()].flatMap((bucket) => bucket.tags))];
+	const baseContext = buildServerReportContext({
+		route: selectRoute(snapshot),
+		plugin: options.pluginId,
+		tags: tags.length > 0 ? tags.join(",") : void 0
+	});
+	return {
+		errors,
+		sessionId,
+		...options.buildId ? { buildId: options.buildId } : {},
+		context: {
+			...pruneUndefined(baseContext),
+			...mergeCustomContext(snapshot)
+		}
+	};
+}
+async function resolveCustomContext(options, args) {
+	if (!options.getContext) return {};
+	try {
+		return await options.getContext(args) ?? {};
+	} catch {
+		return {};
+	}
+}
+function updateExistingBucket(bucket, args) {
+	bucket.count += 1;
+	if (args.path !== void 0) bucket.path = args.path;
+	if (args.tags.length > 0) bucket.tags = args.tags;
+}
+function createNitroErrorReporter(options, runtime) {
+	const state = {
+		buckets: /* @__PURE__ */ new Map(),
+		timer: null,
+		flushRunning: false,
+		consecutiveFailures: 0,
+		pausedUntil: 0
+	};
+	let sessionId = options.sessionId;
+	const getSessionId = () => {
+		sessionId ??= runtime.randomUUID();
+		return sessionId;
+	};
+	const clearFlushTimer = () => {
+		if (state.timer !== null) {
+			runtime.clearTimeout(state.timer);
+			state.timer = null;
+		}
+	};
+	const scheduleFlush = () => {
+		if (state.timer !== null) return;
+		state.timer = runtime.setTimeout(() => {
+			state.timer = null;
+			flushBatches();
+		}, options.flushIntervalMs);
+	};
+	const sendBatch = async (snapshot) => {
+		try {
+			const response = await runtime.fetch(options.errorEndpoint, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${options.token}`
+				},
+				body: JSON.stringify(createPayload(snapshot, options, getSessionId()))
+			});
+			if (response.ok) return true;
+			if (options.debug) runtime.warn("[faststats nitro] report failed", response.status, await response.text());
+			return false;
+		} catch (error) {
+			if (options.debug) runtime.warn("[faststats nitro] report error", error);
+			return false;
+		}
+	};
+	const flushBatches = async () => {
+		clearFlushTimer();
+		if (runtime.now() < state.pausedUntil) {
+			scheduleFlush();
+			return;
+		}
+		if (state.buckets.size === 0 || state.flushRunning) {
+			if (state.buckets.size > 0) scheduleFlush();
+			return;
+		}
+		state.flushRunning = true;
+		const snapshot = new Map(state.buckets);
+		state.buckets.clear();
+		const sendOk = await sendBatch(snapshot);
+		state.flushRunning = false;
+		if (sendOk) state.consecutiveFailures = 0;
+		else {
+			state.consecutiveFailures += 1;
+			mergeBucketsInto(state.buckets, snapshot);
+			if (state.consecutiveFailures >= options.circuitBreakerFailures) {
+				state.pausedUntil = runtime.now() + options.circuitBreakerPauseMs;
+				state.consecutiveFailures = 0;
+				if (options.debug) runtime.warn("[faststats nitro] circuit open; pausing error reports for", options.circuitBreakerPauseMs, "ms");
+			}
+		}
+		if (state.buckets.size > 0) scheduleFlush();
+	};
+	return { async report(error, args) {
+		if (!options.token) {
+			if (options.debug) runtime.warn("[faststats nitro] FASTSTATS_TOKEN not set; skipping error report");
+			return;
+		}
+		if (runtime.now() < state.pausedUntil) return;
+		const { hash, entry } = hashServerError(error);
+		const existing = state.buckets.get(hash);
+		if (existing) updateExistingBucket(existing, args);
+		else state.buckets.set(hash, {
+			entry,
+			count: 1,
+			path: args.path,
+			tags: args.tags,
+			custom: await resolveCustomContext(options, {
+				error,
+				path: args.path,
+				tags: args.tags
+			})
+		});
+		if (state.buckets.size >= options.maxBatchHashes) {
+			clearFlushTimer();
+			await flushBatches();
+			return;
+		}
+		scheduleFlush();
+	} };
+}
+//#endregion
+//#region src/report-error.ts
+const DEFAULT_ENDPOINT = "https://metrics.faststats.dev/v1/error";
+const reporters = /* @__PURE__ */ new WeakMap();
+const envInt = (key, fallback) => {
+	const value = Number.parseInt(process?.env?.[key] ?? "", 10);
+	return value > 0 ? value : fallback;
+};
+function resolveFaststatsNitroOptions(overrides = {}) {
+	return {
+		errorEndpoint: overrides.errorEndpoint ?? process?.env?.FASTSTATS_ERROR_ENDPOINT ?? DEFAULT_ENDPOINT,
+		debug: overrides.debug ?? process?.env?.FASTSTATS_DEBUG === "1",
+		token: overrides.token ?? process?.env?.FASTSTATS_TOKEN ?? process?.env?.FASTSTATS_API_TOKEN,
+		buildId: overrides.buildId ?? process?.env?.FASTSTATS_BUILD_ID,
+		sessionId: overrides.sessionId ?? process?.env?.FASTSTATS_SESSION_ID,
+		getContext: overrides.getContext,
+		pluginId: overrides.pluginId,
+		flushIntervalMs: overrides.flushIntervalMs ?? envInt("FASTSTATS_ERROR_FLUSH_MS", 5e3),
+		maxBatchHashes: overrides.maxBatchHashes ?? envInt("FASTSTATS_ERROR_MAX_HASHES", 50),
+		circuitBreakerFailures: overrides.circuitBreakerFailures ?? envInt("FASTSTATS_ERROR_CIRCUIT_FAILS", 5),
+		circuitBreakerPauseMs: overrides.circuitBreakerPauseMs ?? envInt("FASTSTATS_ERROR_CIRCUIT_PAUSE_MS", 6e4)
+	};
+}
+function createDefaultReporter(options) {
+	return createNitroErrorReporter(options, {
+		fetch: (input, init) => fetch(input, init),
+		setTimeout: (callback, delay) => setTimeout(callback, delay),
+		clearTimeout: (timer) => clearTimeout(timer),
+		now: () => Date.now(),
+		randomUUID: () => {
+			if (crypto.randomUUID !== void 0) return crypto.randomUUID();
+			return `sess-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+		},
+		warn: (...args) => console.warn(...args)
+	});
+}
+function getReporter(options) {
+	let reporter = reporters.get(options);
+	if (!reporter) {
+		reporter = createDefaultReporter(options);
+		reporters.set(options, reporter);
+	}
+	return reporter;
+}
+async function reportNitroErrorToFaststats(error, args) {
+	await getReporter(args.options).report(error, {
+		path: args.path,
+		tags: args.tags
+	});
+}
+//#endregion
+export { resolveFaststatsNitroOptions as n, reportNitroErrorToFaststats as t };

package/dist/report-error-CdwX_ZIm.d.mts

@@ -0,0 +1,20 @@
+//#region src/report-error.d.ts
+type FaststatsNitroOptions = {
+  token?: string;
+  errorEndpoint?: string;
+  buildId?: string;
+  sessionId?: string;
+  debug?: boolean;
+  pluginId?: string;
+  flushIntervalMs?: number;
+  maxBatchHashes?: number;
+  circuitBreakerFailures?: number;
+  circuitBreakerPauseMs?: number;
+  getContext?: (args: {
+    error: unknown;
+    path?: string;
+    tags: string[];
+  }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+};
+//#endregion
+export { FaststatsNitroOptions as t };

package/dist/v2.d.mts

@@ -0,0 +1,8 @@
+import { t as FaststatsNitroOptions } from "./report-error-CdwX_ZIm.mjs";
+import * as nitropack from "nitropack";
+
+//#region src/v2.d.ts
+declare function createFaststatsNitroPluginV2(options?: FaststatsNitroOptions): nitropack.NitroAppPlugin;
+declare const _default: nitropack.NitroAppPlugin;
+//#endregion
+export { createFaststatsNitroPluginV2, _default as default };

package/dist/v2.mjs

@@ -0,0 +1,23 @@
+import { n as resolveFaststatsNitroOptions, t as reportNitroErrorToFaststats } from "./report-error-Be0UMIs5.mjs";
+import { defineNitroPlugin } from "nitropack/runtime";
+//#region src/v2.ts
+function createFaststatsNitroPluginV2(options) {
+	const resolved = resolveFaststatsNitroOptions({
+		...options,
+		pluginId: options?.pluginId ?? "nitro-v2"
+	});
+	return defineNitroPlugin((nitroApp) => {
+		nitroApp.hooks.hook("error", async (error, context) => {
+			const event = context.event;
+			const tags = Array.isArray(context.tags) ? context.tags : [];
+			reportNitroErrorToFaststats(error, {
+				path: event?.path ?? (event?.node?.req?.url !== void 0 ? String(event.node.req.url) : void 0),
+				tags,
+				options: resolved
+			});
+		});
+	});
+}
+var v2_default = createFaststatsNitroPluginV2();
+//#endregion
+export { createFaststatsNitroPluginV2, v2_default as default };

package/dist/v3.d.mts

@@ -0,0 +1,8 @@
+import { t as FaststatsNitroOptions } from "./report-error-CdwX_ZIm.mjs";
+import * as nitro_types0 from "nitro/types";
+
+//#region src/v3.d.ts
+declare function createFaststatsNitroPluginV3(options?: FaststatsNitroOptions): nitro_types0.NitroAppPlugin;
+declare const _default: nitro_types0.NitroAppPlugin;
+//#endregion
+export { createFaststatsNitroPluginV3, _default as default };

package/dist/v3.mjs

@@ -0,0 +1,23 @@
+import { n as resolveFaststatsNitroOptions, t as reportNitroErrorToFaststats } from "./report-error-Be0UMIs5.mjs";
+import { definePlugin } from "nitro";
+//#region src/v3.ts
+function createFaststatsNitroPluginV3(options) {
+	const resolved = resolveFaststatsNitroOptions({
+		...options,
+		pluginId: options?.pluginId ?? "nitro-v3"
+	});
+	return definePlugin((nitroApp) => {
+		nitroApp.hooks.hook("error", async (error, ctx) => {
+			const event = ctx.event;
+			const tags = Array.isArray(ctx.tags) ? ctx.tags : [];
+			reportNitroErrorToFaststats(error, {
+				path: event?.path ?? (event?.node?.req?.url !== void 0 ? String(event.node.req.url) : void 0),
+				tags,
+				options: resolved
+			});
+		});
+	});
+}
+var v3_default = createFaststatsNitroPluginV3();
+//#endregion
+export { createFaststatsNitroPluginV3, v3_default as default };

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@faststats/nitro",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/faststats-dev/web-analytics.git"
+	},
+	"version": "0.1.4",
+	"type": "module",
+	"main": "./dist/v2.mjs",
+	"module": "./dist/v2.mjs",
+	"types": "./dist/v2.d.mts",
+	"exports": {
+		"./v2": {
+			"types": "./dist/v2.d.mts",
+			"import": "./dist/v2.mjs",
+			"default": "./dist/v2.mjs"
+		},
+		"./v3": {
+			"types": "./dist/v3.d.mts",
+			"import": "./dist/v3.mjs",
+			"default": "./dist/v3.mjs"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"nitropack": "^2.13.0",
+		"nitro": "3.0.260311-beta"
+	},
+	"devDependencies": {
+		"nitropack": "2.13.1",
+		"nitro": "3.0.260311-beta",
+		"tsdown": "^0.21.4",
+		"typescript": "^5.9.3"
+	},
+	"peerDependenciesMeta": {
+		"nitro": {
+			"optional": true
+		},
+		"nitropack": {
+			"optional": true
+		}
+	},
+	"scripts": {
+		"prepare": "tsdown",
+		"build": "tsdown",
+		"typecheck": "tsc --noEmit -p tsconfig.json",
+		"test": "bun test"
+	}
+}