silgi 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/core/handler.mjs

@@ -232,7 +232,7 @@ location.reload();
 		});
 		const route = match.data;
 		const method = request.method;
-		if (ctxFactoryIsSync && (method === "GET" || !request.body || route.passthrough)) {
+		if (ctxFactoryIsSync && (method === "GET" || !request.body) && !route.passthrough) {
 			const usePool = !ctxFactoryIsEmpty || match.params || collector;
 			const ctx = usePool ? ctxPool.borrow() : emptyCtx;
 			let t0 = 0;
@@ -415,7 +415,28 @@ location.reload();
 			t0 = collector ? performance.now() : 0;
 			const pipelineResult = route.handler(ctx, rawInput, request.signal);
 			const output = pipelineResult instanceof Promise ? await pipelineResult : pipelineResult;
-			if (output instanceof Response) return output;
+			if (output instanceof Response) {
+				if (hasHooks || collector) {
+					const durationMs = collector ? round(performance.now() - t0) : 0;
+					if (hasHooks) hooks.callHook("response", {
+						path: pathname,
+						output: null,
+						durationMs
+					});
+					if (collector) {
+						collector.record(pathname, durationMs);
+						if (accumulator) accumulator.addProcedure({
+							procedure: pathname,
+							durationMs,
+							status: output.status,
+							input: rawInput ?? reqTrace?.procedureInput ?? null,
+							output: reqTrace?.procedureOutput ?? null,
+							spans: reqTrace?.spans ?? []
+						});
+					}
+				}
+				return output;
+			}
 			if (output instanceof ReadableStream) {
 				if (collector) {
 					const durationMs = round(performance.now() - t0);

package/dist/integrations/better-auth/index.d.mts

@@ -0,0 +1,61 @@
+//#region src/integrations/better-auth/index.d.ts
+/**
+ * Silgi + Better Auth tracing integration.
+ *
+ * Provides a Better Auth plugin factory that auto-traces all auth operations
+ * (sign-in, sign-up, OAuth, session management, etc.) into silgi analytics.
+ *
+ * The silgi request context is passed via `request.__silgiCtx`, set by
+ * the silgi auth handler before calling `auth.handler(request)`.
+ *
+ * @example
+ * ```ts
+ * import { silgiTracing } from 'silgi/better-auth'
+ *
+ * const auth = betterAuth({
+ *   plugins: [
+ *     silgiTracing(),  // auto-traces all auth operations
+ *   ],
+ * })
+ * ```
+ */
+interface SilgiTracingConfig {
+  /** Capture request body as span input (default: true) */
+  captureInput?: boolean;
+  /** Capture response data as span output (default: true) */
+  captureOutput?: boolean;
+  /** Pass `createAuthMiddleware` from `better-auth/api` to wrap hooks handler */
+  createAuthMiddleware?: (handler: any) => any;
+}
+/**
+ * Creates a Better Auth plugin that auto-traces all auth operations
+ * into silgi analytics spans.
+ *
+ * @param config - Optional configuration
+ * @returns A Better Auth plugin (typed as `any` to avoid requiring better-auth types at build time)
+ */
+declare function silgiTracing(config?: SilgiTracingConfig): any;
+/**
+ * Instrument a Better Auth instance to trace all `auth.api.*` method calls.
+ * Works with `withSilgiCtx` — programmatic calls from background jobs,
+ * server-side session fetches etc. are traced when context is available.
+ *
+ * @example
+ * ```ts
+ * import { instrumentBetterAuth, withSilgiCtx } from 'silgi/better-auth'
+ *
+ * const auth = instrumentBetterAuth(betterAuth({ ... }))
+ *
+ * // In a silgi procedure:
+ * const me = s.$resolve(async ({ ctx }) => {
+ *   return withSilgiCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
+ * })
+ * ```
+ */
+declare function instrumentBetterAuth<T extends Record<string, any>>(auth: T): T;
+/**
+ * Run a function with silgi context available to instrumented Better Auth API calls.
+ */
+declare function withSilgiCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
+//#endregion
+export { SilgiTracingConfig, instrumentBetterAuth, silgiTracing, withSilgiCtx };

package/dist/integrations/better-auth/index.mjs

@@ -0,0 +1,332 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/integrations/better-auth/index.ts
+/**
+* Silgi + Better Auth tracing integration.
+*
+* Provides a Better Auth plugin factory that auto-traces all auth operations
+* (sign-in, sign-up, OAuth, session management, etc.) into silgi analytics.
+*
+* The silgi request context is passed via `request.__silgiCtx`, set by
+* the silgi auth handler before calling `auth.handler(request)`.
+*
+* @example
+* ```ts
+* import { silgiTracing } from 'silgi/better-auth'
+*
+* const auth = betterAuth({
+*   plugins: [
+*     silgiTracing(),  // auto-traces all auth operations
+*   ],
+* })
+* ```
+*/
+const ctxStorage = new AsyncLocalStorage();
+function matchOperation(path) {
+	const normalized = path.replace(/^\/+/, "");
+	if (normalized.endsWith("/sign-up/email") || normalized === "sign-up/email") return {
+		spanName: "auth.signup.email",
+		operation: "signup",
+		method: "email"
+	};
+	if (normalized.endsWith("/sign-in/email") || normalized === "sign-in/email") return {
+		spanName: "auth.signin.email",
+		operation: "signin",
+		method: "email"
+	};
+	if (normalized.endsWith("/sign-out") || normalized === "sign-out") return {
+		spanName: "auth.signout",
+		operation: "signout"
+	};
+	if (normalized.endsWith("/get-session") || normalized === "get-session") return {
+		spanName: "auth.get_session",
+		operation: "get_session"
+	};
+	if (normalized.endsWith("/update-user") || normalized === "update-user") return {
+		spanName: "auth.update_user",
+		operation: "update_user"
+	};
+	if (normalized.endsWith("/delete-user") || normalized === "delete-user") return {
+		spanName: "auth.delete_user",
+		operation: "delete_user"
+	};
+	if (normalized.endsWith("/change-password") || normalized === "change-password") return {
+		spanName: "auth.change_password",
+		operation: "change_password"
+	};
+	if (normalized.endsWith("/change-email") || normalized === "change-email") return {
+		spanName: "auth.change_email",
+		operation: "change_email"
+	};
+	if (normalized.endsWith("/verify-email") || normalized === "verify-email") return {
+		spanName: "auth.verify_email",
+		operation: "verify_email"
+	};
+	if (normalized.endsWith("/forget-password") || normalized === "forget-password") return {
+		spanName: "auth.forgot_password",
+		operation: "forgot_password"
+	};
+	if (normalized.endsWith("/reset-password") || normalized === "reset-password") return {
+		spanName: "auth.reset_password",
+		operation: "reset_password"
+	};
+	if (normalized.endsWith("/list-sessions") || normalized === "list-sessions") return {
+		spanName: "auth.list_sessions",
+		operation: "list_sessions"
+	};
+	if (normalized.endsWith("/revoke-session") || normalized === "revoke-session") return {
+		spanName: "auth.revoke_session",
+		operation: "revoke_session"
+	};
+	const callbackMatch = normalized.match(/\/callback\/([^/?]+)/);
+	if (callbackMatch) {
+		const provider = callbackMatch[1];
+		return {
+			spanName: `auth.oauth.callback.${provider}`,
+			operation: "oauth_callback",
+			method: "oauth",
+			provider
+		};
+	}
+	const signinMatch = normalized.match(/\/sign-in\/([^/?]+)$/);
+	if (signinMatch && signinMatch[1] !== "email") {
+		const provider = signinMatch[1];
+		return {
+			spanName: `auth.oauth.initiate.${provider}`,
+			operation: "oauth_initiate",
+			method: "oauth",
+			provider
+		};
+	}
+	const segments = normalized.split("/");
+	return {
+		spanName: `auth.${(segments[segments.length - 1] || "unknown").replace(/-/g, "_")}`,
+		operation: "unknown"
+	};
+}
+function round(n) {
+	return Math.round(n * 100) / 100;
+}
+function extractUserData(returned) {
+	const result = {};
+	if (!returned || typeof returned !== "object") return result;
+	const data = returned.data ?? returned;
+	if (data.user?.id) result.userId = String(data.user.id);
+	if (data.user?.email) result.userEmail = String(data.user.email);
+	if (data.session?.id) result.sessionId = String(data.session.id);
+	if (!result.userId && returned.id && returned.email) {
+		result.userId = String(returned.id);
+		result.userEmail = String(returned.email);
+	}
+	return result;
+}
+const requestMetas = /* @__PURE__ */ new WeakMap();
+/**
+* Creates a Better Auth plugin that auto-traces all auth operations
+* into silgi analytics spans.
+*
+* @param config - Optional configuration
+* @returns A Better Auth plugin (typed as `any` to avoid requiring better-auth types at build time)
+*/
+function silgiTracing(config) {
+	const captureInput = config?.captureInput ?? true;
+	const captureOutput = config?.captureOutput ?? true;
+	return {
+		id: "silgi-tracing",
+		onRequest: async (request, _ctx) => {
+			try {
+				const path = new URL(request.url).pathname;
+				const match = matchOperation(path);
+				requestMetas.set(request, {
+					startTime: performance.now(),
+					path,
+					operation: match.operation,
+					method: match.method,
+					provider: match.provider,
+					spanName: match.spanName
+				});
+			} catch {}
+		},
+		hooks: { after: [{
+			matcher: () => true,
+			handler: (config?.createAuthMiddleware ?? ((fn) => fn))(async (ctx) => {
+				try {
+					const request = ctx.request;
+					if (!request) return;
+					const silgiCtx = request.__silgiCtx;
+					if (!silgiCtx) return;
+					const reqTrace = silgiCtx.__analyticsTrace;
+					if (!reqTrace) return;
+					const meta = requestMetas.get(request);
+					requestMetas.delete(request);
+					const path = ctx.path || "";
+					const match = meta ? {
+						spanName: meta.spanName,
+						operation: meta.operation,
+						method: meta.method,
+						provider: meta.provider
+					} : matchOperation(path);
+					const startTime = meta?.startTime ?? performance.now();
+					const durationMs = round(performance.now() - startTime);
+					const returned = ctx.context?.returned;
+					const newSession = ctx.context?.newSession;
+					const userData = extractUserData(returned);
+					if (!userData.userId && newSession?.user?.id) userData.userId = String(newSession.user.id);
+					if (!userData.userEmail && newSession?.user?.email) userData.userEmail = String(newSession.user.email);
+					if (!userData.sessionId && newSession?.session?.id) userData.sessionId = String(newSession.session.id);
+					const success = !returned?.error && !ctx.context?.error;
+					const attributes = {
+						"auth.operation": match.operation,
+						"auth.success": success
+					};
+					if (match.method) attributes["auth.method"] = match.method;
+					if (match.provider) attributes["auth.provider"] = match.provider;
+					if (userData.userId) attributes["user.id"] = userData.userId;
+					if (userData.userEmail) attributes["user.email"] = userData.userEmail;
+					if (userData.sessionId) attributes["session.id"] = userData.sessionId;
+					const span = {
+						name: match.spanName,
+						kind: "http",
+						durationMs,
+						startOffsetMs: round(startTime - reqTrace.t0),
+						attributes
+					};
+					if (captureInput && ctx.body) span.input = ctx.body;
+					if (captureOutput && returned && typeof returned === "object") span.output = returned;
+					if (!success && returned?.error) span.error = typeof returned.error === "string" ? returned.error : returned.error?.message ?? "error";
+					reqTrace.spans.push(span);
+					if (captureInput && ctx.body) reqTrace.procedureInput = ctx.body;
+					if (captureOutput && returned && typeof returned === "object") reqTrace.procedureOutput = returned;
+				} catch {}
+			})
+		}] }
+	};
+}
+const API_METHOD_METADATA = {
+	getSession: { operation: "get_session" },
+	signOut: { operation: "signout" },
+	signInEmail: {
+		operation: "signin",
+		method: "email"
+	},
+	signUpEmail: {
+		operation: "signup",
+		method: "email"
+	},
+	signInSocial: {
+		operation: "signin",
+		method: "oauth"
+	},
+	callbackOAuth: {
+		operation: "oauth_callback",
+		method: "oauth"
+	},
+	linkSocialAccount: {
+		operation: "link_social_account",
+		method: "oauth"
+	},
+	unlinkAccount: { operation: "unlink_account" },
+	listUserAccounts: { operation: "list_user_accounts" },
+	updateUser: { operation: "update_user" },
+	deleteUser: { operation: "delete_user" },
+	changePassword: { operation: "change_password" },
+	setPassword: { operation: "set_password" },
+	changeEmail: { operation: "change_email" },
+	verifyEmail: { operation: "verify_email" },
+	sendVerificationEmail: { operation: "send_verification_email" },
+	forgetPassword: { operation: "forget_password" },
+	resetPassword: { operation: "reset_password" },
+	listSessions: { operation: "list_sessions" },
+	revokeSession: { operation: "revoke_session" },
+	revokeSessions: { operation: "revoke_sessions" },
+	revokeOtherSessions: { operation: "revoke_other_sessions" },
+	refreshToken: { operation: "refresh_token" },
+	getAccessToken: { operation: "get_access_token" }
+};
+const AUTH_INSTRUMENTED = "__silgiBetterAuthInstrumented";
+/**
+* Instrument a Better Auth instance to trace all `auth.api.*` method calls.
+* Works with `withSilgiCtx` — programmatic calls from background jobs,
+* server-side session fetches etc. are traced when context is available.
+*
+* @example
+* ```ts
+* import { instrumentBetterAuth, withSilgiCtx } from 'silgi/better-auth'
+*
+* const auth = instrumentBetterAuth(betterAuth({ ... }))
+*
+* // In a silgi procedure:
+* const me = s.$resolve(async ({ ctx }) => {
+*   return withSilgiCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
+* })
+* ```
+*/
+function instrumentBetterAuth(auth) {
+	if (!auth || auth[AUTH_INSTRUMENTED]) return auth;
+	const api = auth.api;
+	if (!api || typeof api !== "object") return auth;
+	const instrumented = /* @__PURE__ */ new Set();
+	for (const [methodName, metadata] of Object.entries(API_METHOD_METADATA)) if (typeof api[methodName] === "function") {
+		api[methodName] = wrapApiMethod(api[methodName], metadata.operation, metadata.method);
+		instrumented.add(methodName);
+	}
+	for (const key of Object.keys(api)) if (typeof api[key] === "function" && !instrumented.has(key) && !key.startsWith("$") && !key.startsWith("_")) {
+		const operation = key.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+		api[key] = wrapApiMethod(api[key], operation);
+		instrumented.add(key);
+	}
+	auth[AUTH_INSTRUMENTED] = true;
+	return auth;
+}
+/**
+* Run a function with silgi context available to instrumented Better Auth API calls.
+*/
+function withSilgiCtx(ctx, fn) {
+	return ctxStorage.run(ctx, fn);
+}
+function wrapApiMethod(originalFn, operation, method) {
+	return async function instrumented(...args) {
+		const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+		if (!reqTrace) return originalFn.apply(this, args);
+		const spanName = `auth.api.${operation}`;
+		const start = performance.now();
+		const attributes = {
+			"auth.operation": operation,
+			"auth.success": true
+		};
+		if (method) attributes["auth.method"] = method;
+		try {
+			const result = await originalFn.apply(this, args);
+			const data = result?.data ?? result;
+			if (data?.user?.id) attributes["user.id"] = String(data.user.id);
+			if (data?.user?.email) attributes["user.email"] = String(data.user.email);
+			if (data?.session?.id) attributes["session.id"] = String(data.session.id);
+			if (result?.error) {
+				attributes["auth.success"] = false;
+				attributes["auth.error"] = typeof result.error === "string" ? result.error : result.error?.message ?? "unknown";
+			}
+			reqTrace.spans.push({
+				name: spanName,
+				kind: "http",
+				durationMs: round(performance.now() - start),
+				startOffsetMs: round(start - reqTrace.t0),
+				attributes,
+				output: result && typeof result === "object" ? result : void 0
+			});
+			return result;
+		} catch (error) {
+			attributes["auth.success"] = false;
+			attributes["auth.error"] = error instanceof Error ? error.message : String(error);
+			reqTrace.spans.push({
+				name: spanName,
+				kind: "http",
+				durationMs: round(performance.now() - start),
+				startOffsetMs: round(start - reqTrace.t0),
+				attributes,
+				error: error instanceof Error ? error.stack ?? error.message : String(error)
+			});
+			throw error;
+		}
+	};
+}
+//#endregion
+export { instrumentBetterAuth, silgiTracing, withSilgiCtx };

package/dist/integrations/drizzle/index.d.mts

@@ -0,0 +1,27 @@
+//#region src/integrations/drizzle/index.d.ts
+interface InstrumentDrizzleConfig {
+  /** Logical database name (e.g. 'auth', 'ecommerce') */
+  dbName?: string;
+  /** Database system identifier. Default: 'postgresql' */
+  dbSystem?: string;
+  /** Capture SQL query text in spans. Default: true */
+  captureQueryText?: boolean;
+  /** Max query text length before truncation. Default: 1000 */
+  maxQueryTextLength?: number;
+  /** Database host */
+  peerName?: string;
+  /** Database port */
+  peerPort?: number;
+}
+/**
+ * Instrument a Drizzle db instance to record query spans in silgi analytics.
+ * Returns the same db instance (mutated). Safe to call multiple times.
+ */
+declare function instrumentDrizzle<T extends Record<string, any>>(db: T, config?: InstrumentDrizzleConfig): T;
+/**
+ * Run a function with silgi context available to instrumented Drizzle instances.
+ * All Drizzle queries inside `fn` will be recorded as trace spans.
+ */
+declare function withSilgiCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
+//#endregion
+export { InstrumentDrizzleConfig, instrumentDrizzle, withSilgiCtx };