@hammadj/better-auth-telemetry 1.5.0-beta.9

package/src/detectors/detect-auth-config.ts

@@ -0,0 +1,203 @@
+import type { BetterAuthOptions } from "@better-auth/core";
+import type { TelemetryContext } from "../types";
+
+export function getTelemetryAuthConfig(
+	options: BetterAuthOptions,
+	context?: TelemetryContext | undefined,
+) {
+	return {
+		database: context?.database,
+		adapter: context?.adapter,
+		emailVerification: {
+			sendVerificationEmail: !!options.emailVerification?.sendVerificationEmail,
+			sendOnSignUp: !!options.emailVerification?.sendOnSignUp,
+			sendOnSignIn: !!options.emailVerification?.sendOnSignIn,
+			autoSignInAfterVerification:
+				!!options.emailVerification?.autoSignInAfterVerification,
+			expiresIn: options.emailVerification?.expiresIn,
+			onEmailVerification: !!options.emailVerification?.onEmailVerification,
+			afterEmailVerification:
+				!!options.emailVerification?.afterEmailVerification,
+		},
+		emailAndPassword: {
+			enabled: !!options.emailAndPassword?.enabled,
+			disableSignUp: !!options.emailAndPassword?.disableSignUp,
+			requireEmailVerification:
+				!!options.emailAndPassword?.requireEmailVerification,
+			maxPasswordLength: options.emailAndPassword?.maxPasswordLength,
+			minPasswordLength: options.emailAndPassword?.minPasswordLength,
+			sendResetPassword: !!options.emailAndPassword?.sendResetPassword,
+			resetPasswordTokenExpiresIn:
+				options.emailAndPassword?.resetPasswordTokenExpiresIn,
+			onPasswordReset: !!options.emailAndPassword?.onPasswordReset,
+			password: {
+				hash: !!options.emailAndPassword?.password?.hash,
+				verify: !!options.emailAndPassword?.password?.verify,
+			},
+			autoSignIn: !!options.emailAndPassword?.autoSignIn,
+			revokeSessionsOnPasswordReset:
+				!!options.emailAndPassword?.revokeSessionsOnPasswordReset,
+		},
+		socialProviders: Object.keys(options.socialProviders || {}).map((p) => {
+			const provider =
+				options.socialProviders?.[p as keyof typeof options.socialProviders];
+			if (!provider) return {};
+			return {
+				id: p,
+				mapProfileToUser: !!provider.mapProfileToUser,
+				disableDefaultScope: !!provider.disableDefaultScope,
+				disableIdTokenSignIn: !!provider.disableIdTokenSignIn,
+				disableImplicitSignUp: provider.disableImplicitSignUp,
+				disableSignUp: provider.disableSignUp,
+				getUserInfo: !!provider.getUserInfo,
+				overrideUserInfoOnSignIn: !!provider.overrideUserInfoOnSignIn,
+				prompt: provider.prompt,
+				verifyIdToken: !!provider.verifyIdToken,
+				scope: provider.scope,
+				refreshAccessToken: !!provider.refreshAccessToken,
+			};
+		}),
+		plugins: options.plugins?.map((p) => p.id.toString()),
+		user: {
+			modelName: options.user?.modelName,
+			fields: options.user?.fields,
+			additionalFields: options.user?.additionalFields,
+			changeEmail: {
+				enabled: options.user?.changeEmail?.enabled,
+				sendChangeEmailVerification:
+					!!options.user?.changeEmail?.sendChangeEmailVerification,
+			},
+		},
+		verification: {
+			modelName: options.verification?.modelName,
+			disableCleanup: options.verification?.disableCleanup,
+			fields: options.verification?.fields,
+		},
+		session: {
+			modelName: options.session?.modelName,
+			additionalFields: options.session?.additionalFields,
+			cookieCache: {
+				enabled: options.session?.cookieCache?.enabled,
+				maxAge: options.session?.cookieCache?.maxAge,
+				strategy: options.session?.cookieCache?.strategy,
+			},
+			disableSessionRefresh: options.session?.disableSessionRefresh,
+			expiresIn: options.session?.expiresIn,
+			fields: options.session?.fields,
+			freshAge: options.session?.freshAge,
+			preserveSessionInDatabase: options.session?.preserveSessionInDatabase,
+			storeSessionInDatabase: options.session?.storeSessionInDatabase,
+			updateAge: options.session?.updateAge,
+		},
+		account: {
+			modelName: options.account?.modelName,
+			fields: options.account?.fields,
+			encryptOAuthTokens: options.account?.encryptOAuthTokens,
+			updateAccountOnSignIn: options.account?.updateAccountOnSignIn,
+			accountLinking: {
+				enabled: options.account?.accountLinking?.enabled,
+				trustedProviders: options.account?.accountLinking?.trustedProviders,
+				updateUserInfoOnLink:
+					options.account?.accountLinking?.updateUserInfoOnLink,
+				allowUnlinkingAll: options.account?.accountLinking?.allowUnlinkingAll,
+			},
+		},
+		hooks: {
+			after: !!options.hooks?.after,
+			before: !!options.hooks?.before,
+		},
+		secondaryStorage: !!options.secondaryStorage,
+		advanced: {
+			cookiePrefix: !!options.advanced?.cookiePrefix, //this shouldn't be tracked
+			cookies: !!options.advanced?.cookies,
+			crossSubDomainCookies: {
+				domain: !!options.advanced?.crossSubDomainCookies?.domain,
+				enabled: options.advanced?.crossSubDomainCookies?.enabled,
+				additionalCookies:
+					options.advanced?.crossSubDomainCookies?.additionalCookies,
+			},
+			database: {
+				useNumberId:
+					!!options.advanced?.database?.useNumberId ||
+					options.advanced?.database?.generateId === "serial",
+				generateId: options.advanced?.database?.generateId,
+				defaultFindManyLimit: options.advanced?.database?.defaultFindManyLimit,
+			},
+			useSecureCookies: options.advanced?.useSecureCookies,
+			ipAddress: {
+				disableIpTracking: options.advanced?.ipAddress?.disableIpTracking,
+				ipAddressHeaders: options.advanced?.ipAddress?.ipAddressHeaders,
+			},
+			disableCSRFCheck: options.advanced?.disableCSRFCheck,
+			cookieAttributes: {
+				expires: options.advanced?.defaultCookieAttributes?.expires,
+				secure: options.advanced?.defaultCookieAttributes?.secure,
+				sameSite: options.advanced?.defaultCookieAttributes?.sameSite,
+				domain: !!options.advanced?.defaultCookieAttributes?.domain,
+				path: options.advanced?.defaultCookieAttributes?.path,
+				httpOnly: options.advanced?.defaultCookieAttributes?.httpOnly,
+			},
+		},
+		trustedOrigins: options.trustedOrigins?.length,
+		rateLimit: {
+			storage: options.rateLimit?.storage,
+			modelName: options.rateLimit?.modelName,
+			window: options.rateLimit?.window,
+			customStorage: !!options.rateLimit?.customStorage,
+			enabled: options.rateLimit?.enabled,
+			max: options.rateLimit?.max,
+		},
+		onAPIError: {
+			errorURL: options.onAPIError?.errorURL,
+			onError: !!options.onAPIError?.onError,
+			throw: options.onAPIError?.throw,
+		},
+		logger: {
+			disabled: options.logger?.disabled,
+			level: options.logger?.level,
+			log: !!options.logger?.log,
+		},
+		databaseHooks: {
+			user: {
+				create: {
+					after: !!options.databaseHooks?.user?.create?.after,
+					before: !!options.databaseHooks?.user?.create?.before,
+				},
+				update: {
+					after: !!options.databaseHooks?.user?.update?.after,
+					before: !!options.databaseHooks?.user?.update?.before,
+				},
+			},
+			session: {
+				create: {
+					after: !!options.databaseHooks?.session?.create?.after,
+					before: !!options.databaseHooks?.session?.create?.before,
+				},
+				update: {
+					after: !!options.databaseHooks?.session?.update?.after,
+					before: !!options.databaseHooks?.session?.update?.before,
+				},
+			},
+			account: {
+				create: {
+					after: !!options.databaseHooks?.account?.create?.after,
+					before: !!options.databaseHooks?.account?.create?.before,
+				},
+				update: {
+					after: !!options.databaseHooks?.account?.update?.after,
+					before: !!options.databaseHooks?.account?.update?.before,
+				},
+			},
+			verification: {
+				create: {
+					after: !!options.databaseHooks?.verification?.create?.after,
+					before: !!options.databaseHooks?.verification?.create?.before,
+				},
+				update: {
+					after: !!options.databaseHooks?.verification?.update?.after,
+					before: !!options.databaseHooks?.verification?.update?.before,
+				},
+			},
+		},
+	};
+}

package/src/detectors/detect-database.ts

@@ -0,0 +1,22 @@
+import type { DetectionInfo } from "../types";
+import { getPackageVersion } from "../utils/package-json";
+
+const DATABASES: Record<string, string> = {
+	pg: "postgresql",
+	mysql: "mysql",
+	mariadb: "mariadb",
+	sqlite3: "sqlite",
+	"better-sqlite3": "sqlite",
+	"@prisma/client": "prisma",
+	mongoose: "mongodb",
+	mongodb: "mongodb",
+	"drizzle-orm": "drizzle",
+};
+
+export async function detectDatabase(): Promise<DetectionInfo | undefined> {
+	for (const [pkg, name] of Object.entries(DATABASES)) {
+		const version = await getPackageVersion(pkg);
+		if (version) return { name, version };
+	}
+	return undefined;
+}

package/src/detectors/detect-framework.ts

@@ -0,0 +1,23 @@
+import { getPackageVersion } from "../utils/package-json";
+
+const FRAMEWORKS: Record<string, string> = {
+	next: "next",
+	nuxt: "nuxt",
+	"@remix-run/server-runtime": "remix",
+	astro: "astro",
+	"@sveltejs/kit": "sveltekit",
+	"solid-start": "solid-start",
+	"tanstack-start": "tanstack-start",
+	hono: "hono",
+	express: "express",
+	elysia: "elysia",
+	expo: "expo",
+};
+
+export async function detectFramework() {
+	for (const [pkg, name] of Object.entries(FRAMEWORKS)) {
+		const version = await getPackageVersion(pkg);
+		if (version) return { name, version };
+	}
+	return undefined;
+}

package/src/detectors/detect-project-info.ts

@@ -0,0 +1,18 @@
+// https://github.com/zkochan/packages/blob/main/which-pm-runs/index.js
+import { env } from "@better-auth/core/env";
+
+export function detectPackageManager() {
+	const userAgent = env.npm_config_user_agent;
+	if (!userAgent) {
+		return undefined;
+	}
+
+	const pmSpec = userAgent.split(" ")[0]!;
+	const separatorPos = pmSpec.lastIndexOf("/");
+	const name = pmSpec.substring(0, separatorPos);
+
+	return {
+		name: name === "npminstall" ? "cnpm" : name,
+		version: pmSpec.substring(separatorPos + 1),
+	};
+}

package/src/detectors/detect-runtime.ts

@@ -0,0 +1,31 @@
+import { getEnvVar, isTest } from "@better-auth/core/env";
+import { isCI } from "./detect-system-info";
+
+export function detectRuntime() {
+	// @ts-expect-error: TS doesn't know about Deno global
+	if (typeof Deno !== "undefined") {
+		// @ts-expect-error: TS doesn't know about Deno global
+		const denoVersion = Deno?.version?.deno ?? null;
+		return { name: "deno", version: denoVersion };
+	}
+
+	if (typeof Bun !== "undefined") {
+		const bunVersion = Bun?.version ?? null;
+		return { name: "bun", version: bunVersion };
+	}
+
+	if (typeof process !== "undefined" && process?.versions?.node) {
+		return { name: "node", version: process.versions.node ?? null };
+	}
+	return { name: "edge", version: null };
+}
+
+export function detectEnvironment() {
+	return getEnvVar("NODE_ENV") === "production"
+		? "production"
+		: isCI()
+			? "ci"
+			: isTest()
+				? "test"
+				: "development";
+}

package/src/detectors/detect-system-info.ts

@@ -0,0 +1,209 @@
+import { env } from "@better-auth/core/env";
+import { importRuntime } from "../utils/import-util";
+
+function getVendor() {
+	const hasAny = (...keys: string[]) =>
+		keys.some((k) => Boolean((env as any)[k]));
+
+	if (
+		hasAny("CF_PAGES", "CF_PAGES_URL", "CF_ACCOUNT_ID") ||
+		(typeof navigator !== "undefined" &&
+			navigator.userAgent === "Cloudflare-Workers")
+	) {
+		return "cloudflare";
+	}
+
+	if (hasAny("VERCEL", "VERCEL_URL", "VERCEL_ENV")) return "vercel";
+
+	if (hasAny("NETLIFY", "NETLIFY_URL")) return "netlify";
+
+	if (
+		hasAny(
+			"RENDER",
+			"RENDER_URL",
+			"RENDER_INTERNAL_HOSTNAME",
+			"RENDER_SERVICE_ID",
+		)
+	) {
+		return "render";
+	}
+
+	if (
+		hasAny("AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV", "LAMBDA_TASK_ROOT")
+	) {
+		return "aws";
+	}
+
+	if (
+		hasAny(
+			"GOOGLE_CLOUD_FUNCTION_NAME",
+			"GOOGLE_CLOUD_PROJECT",
+			"GCP_PROJECT",
+			"K_SERVICE",
+		)
+	) {
+		return "gcp";
+	}
+
+	if (
+		hasAny(
+			"AZURE_FUNCTION_NAME",
+			"FUNCTIONS_WORKER_RUNTIME",
+			"WEBSITE_INSTANCE_ID",
+			"WEBSITE_SITE_NAME",
+		)
+	) {
+		return "azure";
+	}
+
+	if (hasAny("DENO_DEPLOYMENT_ID", "DENO_REGION")) return "deno-deploy";
+
+	if (hasAny("FLY_APP_NAME", "FLY_REGION", "FLY_ALLOC_ID")) return "fly-io";
+
+	if (hasAny("RAILWAY_STATIC_URL", "RAILWAY_ENVIRONMENT_NAME"))
+		return "railway";
+
+	if (hasAny("DYNO", "HEROKU_APP_NAME")) return "heroku";
+
+	if (hasAny("DO_DEPLOYMENT_ID", "DO_APP_NAME", "DIGITALOCEAN"))
+		return "digitalocean";
+
+	if (hasAny("KOYEB", "KOYEB_DEPLOYMENT_ID", "KOYEB_APP_NAME")) return "koyeb";
+
+	return null;
+}
+
+export async function detectSystemInfo() {
+	try {
+		//check if it's cloudflare
+		if (getVendor() === "cloudflare") return "cloudflare";
+		const os = await importRuntime<typeof import("os")>("os");
+		const cpus = os.cpus();
+		return {
+			deploymentVendor: getVendor(),
+			systemPlatform: os.platform(),
+			systemRelease: os.release(),
+			systemArchitecture: os.arch(),
+			cpuCount: cpus.length,
+			cpuModel: cpus.length ? cpus[0]!.model : null,
+			cpuSpeed: cpus.length ? cpus[0]!.speed : null,
+			memory: os.totalmem(),
+			isWSL: await isWsl(),
+			isDocker: await isDocker(),
+			isTTY:
+				typeof process !== "undefined" && (process as any).stdout
+					? (process as any).stdout.isTTY
+					: null,
+		};
+	} catch {
+		return {
+			systemPlatform: null,
+			systemRelease: null,
+			systemArchitecture: null,
+			cpuCount: null,
+			cpuModel: null,
+			cpuSpeed: null,
+			memory: null,
+			isWSL: null,
+			isDocker: null,
+			isTTY: null,
+		};
+	}
+}
+
+let isDockerCached: boolean | undefined;
+
+async function hasDockerEnv() {
+	if (getVendor() === "cloudflare") return false;
+
+	try {
+		const fs = await importRuntime<typeof import("fs")>("fs");
+		fs.statSync("/.dockerenv");
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function hasDockerCGroup() {
+	if (getVendor() === "cloudflare") return false;
+	try {
+		const fs = await importRuntime<typeof import("fs")>("fs");
+		return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+	} catch {
+		return false;
+	}
+}
+
+async function isDocker() {
+	if (getVendor() === "cloudflare") return false;
+
+	if (isDockerCached === undefined) {
+		isDockerCached = (await hasDockerEnv()) || (await hasDockerCGroup());
+	}
+
+	return isDockerCached;
+}
+
+async function isWsl() {
+	try {
+		if (getVendor() === "cloudflare") return false;
+		if (typeof process === "undefined" || process?.platform !== "linux") {
+			return false;
+		}
+		const fs = await importRuntime<typeof import("fs")>("fs");
+		const os = await importRuntime<typeof import("os")>("os");
+		if (os.release().toLowerCase().includes("microsoft")) {
+			if (await isInsideContainer()) {
+				return false;
+			}
+
+			return true;
+		}
+
+		return fs
+			.readFileSync("/proc/version", "utf8")
+			.toLowerCase()
+			.includes("microsoft")
+			? !(await isInsideContainer())
+			: false;
+	} catch {
+		return false;
+	}
+}
+
+let isInsideContainerCached: boolean | undefined;
+
+const hasContainerEnv = async () => {
+	if (getVendor() === "cloudflare") return false;
+	try {
+		const fs = await importRuntime<typeof import("fs")>("fs");
+		fs.statSync("/run/.containerenv");
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+async function isInsideContainer() {
+	if (isInsideContainerCached === undefined) {
+		isInsideContainerCached = (await hasContainerEnv()) || (await isDocker());
+	}
+
+	return isInsideContainerCached;
+}
+
+export function isCI() {
+	return (
+		env.CI !== "false" &&
+		("BUILD_ID" in env || // Jenkins, Cloudbees
+			"BUILD_NUMBER" in env || // Jenkins, TeamCity (fixed typo: extra space removed)
+			"CI" in env || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari, Cloudflare
+			"CI_APP_ID" in env || // Appflow
+			"CI_BUILD_ID" in env || // Appflow
+			"CI_BUILD_NUMBER" in env || // Appflow
+			"CI_NAME" in env || // Codeship and others
+			"CONTINUOUS_INTEGRATION" in env || // Travis CI, Cirrus CI
+			"RUN_ID" in env) // TaskCluster, dsari
+	);
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+import type { BetterAuthOptions } from "@better-auth/core";
+import { ENV, getBooleanEnvVar, isTest, logger } from "@better-auth/core/env";
+import { betterFetch } from "@better-fetch/fetch";
+import { getTelemetryAuthConfig } from "./detectors/detect-auth-config";
+import { detectDatabase } from "./detectors/detect-database";
+import { detectFramework } from "./detectors/detect-framework";
+import { detectPackageManager } from "./detectors/detect-project-info";
+import { detectEnvironment, detectRuntime } from "./detectors/detect-runtime";
+import { detectSystemInfo } from "./detectors/detect-system-info";
+import { getProjectId } from "./project-id";
+import type { TelemetryContext, TelemetryEvent } from "./types";
+export { getTelemetryAuthConfig };
+export type { TelemetryEvent } from "./types";
+
+const noop: (event: TelemetryEvent) => Promise<void> = async function noop() {};
+
+export async function createTelemetry(
+	options: BetterAuthOptions,
+	context?: TelemetryContext | undefined,
+) {
+	const debugEnabled =
+		options.telemetry?.debug ||
+		getBooleanEnvVar("BETTER_AUTH_TELEMETRY_DEBUG", false);
+
+	const telemetryEndpoint = ENV.BETTER_AUTH_TELEMETRY_ENDPOINT;
+	// Return noop if no endpoint and no custom track function
+	if (!telemetryEndpoint && !context?.customTrack) {
+		return {
+			publish: noop,
+		};
+	}
+	const track = async (event: TelemetryEvent) => {
+		if (context?.customTrack) {
+			await context.customTrack(event).catch(logger.error);
+		} else if (telemetryEndpoint) {
+			if (debugEnabled) {
+				logger.info("telemetry event", JSON.stringify(event, null, 2));
+			} else {
+				await betterFetch(telemetryEndpoint, {
+					method: "POST",
+					body: event,
+				}).catch(logger.error);
+			}
+		}
+	};
+
+	const isEnabled = async () => {
+		const telemetryEnabled =
+			options.telemetry?.enabled !== undefined
+				? options.telemetry.enabled
+				: false;
+		const envEnabled = getBooleanEnvVar("BETTER_AUTH_TELEMETRY", false);
+		return (
+			(envEnabled || telemetryEnabled) && (context?.skipTestCheck || !isTest())
+		);
+	};
+
+	const enabled = await isEnabled();
+	let anonymousId: string | undefined;
+
+	if (enabled) {
+		anonymousId = await getProjectId(options.baseURL);
+
+		const payload = {
+			config: getTelemetryAuthConfig(options, context),
+			runtime: detectRuntime(),
+			database: await detectDatabase(),
+			framework: await detectFramework(),
+			environment: detectEnvironment(),
+			systemInfo: await detectSystemInfo(),
+			packageManager: detectPackageManager(),
+		};
+
+		void track({ type: "init", payload, anonymousId });
+	}
+
+	return {
+		publish: async (event: TelemetryEvent) => {
+			if (!enabled) return;
+			if (!anonymousId) {
+				anonymousId = await getProjectId(options.baseURL);
+			}
+			await track({
+				type: event.type,
+				payload: event.payload,
+				anonymousId,
+			});
+		},
+	};
+}

package/src/project-id.ts

@@ -0,0 +1,27 @@
+import { hashToBase64 } from "./utils/hash";
+import { generateId } from "./utils/id";
+import { getNameFromLocalPackageJson } from "./utils/package-json";
+
+let projectIdCached: string | null = null;
+
+export async function getProjectId(
+	baseUrl: string | undefined,
+): Promise<string> {
+	if (projectIdCached) return projectIdCached;
+
+	const projectName = await getNameFromLocalPackageJson();
+	if (projectName) {
+		projectIdCached = await hashToBase64(
+			baseUrl ? baseUrl + projectName : projectName,
+		);
+		return projectIdCached;
+	}
+
+	if (baseUrl) {
+		projectIdCached = await hashToBase64(baseUrl);
+		return projectIdCached;
+	}
+
+	projectIdCached = generateId(32);
+	return projectIdCached;
+}