silgi 0.1.0-beta.13 → 0.1.0-beta.15

package/dist/core/context-bridge.mjs

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/core/context-bridge.ts
+const ctxStorage = new AsyncLocalStorage();
+function runWithCtx(ctx, fn) {
+	return ctxStorage.run(ctx, fn);
+}
+function getCtx() {
+	return ctxStorage.getStore();
+}
+//#endregion
+export { getCtx, runWithCtx };

package/dist/core/handler.mjs

@@ -1,10 +1,11 @@
 import { routerCache } from "./router-utils.mjs";
 import { compileRouter, createContext, releaseContext } from "../compile.mjs";
 import { applyContext } from "./dispatch.mjs";
+import { iteratorToEventStream } from "./sse.mjs";
 import { analyticsTraceMap } from "../plugins/analytics.mjs";
 import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
+import { runWithCtx } from "./context-bridge.mjs";
 import { parseInput } from "./input.mjs";
-import { iteratorToEventStream } from "./sse.mjs";
 //#region src/core/handler.ts
 /**
 * Fetch API handler — single unified request handler.
@@ -128,7 +129,7 @@ function createFetchHandler(routerDef, contextFactory, hooks) {
 				path: pathname,
 				input: rawInput
 			});
-			const pipelineResult = route.handler(ctx, rawInput, request.signal);
+			const pipelineResult = runWithCtx(ctx, () => route.handler(ctx, rawInput, request.signal));
 			const output = pipelineResult instanceof Promise ? await pipelineResult : pipelineResult;
 			callHook("response", {
 				path: pathname,

package/dist/core/sse.mjs

@@ -95,4 +95,4 @@ function iteratorToEventStream(iterator, options = {}) {
 	}).pipeThrough(new TextEncoderStream());
 }
 //#endregion
-export { getEventMeta, iteratorToEventStream, withEventMeta };
+export { encodeEventMessage, getEventMeta, iteratorToEventStream, withEventMeta };

package/dist/core/storage.mjs

@@ -30,8 +30,9 @@ import memoryDriver from "unstorage/drivers/memory";
 function _initStorage(config) {
 	if (config && "getItem" in config) return config;
 	const storage = createStorage({});
-	storage.mount("data", memoryDriver());
-	storage.mount("cache", memoryDriver());
+	const configKeys = config ? new Set(Object.keys(config)) : null;
+	if (!configKeys?.has("data")) storage.mount("data", memoryDriver());
+	if (!configKeys?.has("cache")) storage.mount("cache", memoryDriver());
 	if (config) for (const [path, driver] of Object.entries(config)) storage.mount(path, driver);
 	return storage;
 }

package/dist/index.mjs

@@ -2,9 +2,9 @@ import { ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
 import { SilgiError, isDefinedError, toSilgiError } from "./core/error.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
-import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
 import { getEventMeta, withEventMeta } from "./core/sse.mjs";
+import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { silgi } from "./silgi.mjs";
 import { callable } from "./callable.mjs";
 import { lifecycleWrap } from "./lifecycle.mjs";

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

@@ -1,24 +1,4 @@
 //#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 { tracing } from 'silgi/better-auth'
- *
- * const auth = betterAuth({
- *   plugins: [
- *     tracing(),  // auto-traces all auth operations
- *   ],
- * })
- * ```
- */
 interface TracingConfig {
   /** Capture request body as span input (default: true) */
   captureInput?: boolean;

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

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "node:async_hooks";
+import { getCtx, runWithCtx } from "../../core/context-bridge.mjs";
 //#region src/integrations/better-auth/index.ts
 /**
 * Silgi + Better Auth tracing integration.
@@ -20,7 +20,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 * })
 * ```
 */
-const ctxStorage = new AsyncLocalStorage();
 function matchOperation(path) {
 	const normalized = path.replace(/^\/+/, "");
 	if (normalized.endsWith("/sign-up/email") || normalized === "sign-up/email") return {
@@ -281,11 +280,11 @@ function instrumentBetterAuth(auth) {
 * Run a function with silgi context available to instrumented Better Auth API calls.
 */
 function withCtx(ctx, fn) {
-	return ctxStorage.run(ctx, fn);
+	return runWithCtx(ctx, fn);
 }
 function wrapApiMethod(originalFn, operation, method) {
 	return async function instrumented(...args) {
-		const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+		const reqTrace = getCtx()?.__analyticsTrace;
 		if (!reqTrace) return originalFn.apply(this, args);
 		const spanName = `auth.api.${operation}`;
 		const start = performance.now();

package/dist/integrations/drizzle/index.mjs

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "node:async_hooks";
+import { getCtx, runWithCtx } from "../../core/context-bridge.mjs";
 //#region src/integrations/drizzle/index.ts
 /**
 * Silgi + Drizzle ORM tracing integration.
@@ -31,7 +31,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 * })
 * ```
 */
-const ctxStorage = new AsyncLocalStorage();
 const INSTRUMENTED = "__silgiDrizzleInstrumented";
 const DEFAULT_DB_SYSTEM = "postgresql";
 const DEFAULT_MAX_QUERY_LENGTH = 1e3;
@@ -59,7 +58,7 @@ function instrumentDrizzle(db, config) {
 * All Drizzle queries inside `fn` will be recorded as trace spans.
 */
 function withCtx(ctx, fn) {
-	return ctxStorage.run(ctx, fn);
+	return runWithCtx(ctx, fn);
 }
 function resolveConfig(config) {
 	return {
@@ -84,7 +83,7 @@ function patchSession(session, cfg, isTx) {
 		session.prepareQuery = function patchedPrepareQuery(...args) {
 			const prepared = originalPrepareQuery.apply(this, args);
 			if (!prepared || typeof prepared.execute !== "function") return prepared;
-			const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+			const reqTrace = getCtx()?.__analyticsTrace;
 			if (!reqTrace) return prepared;
 			const queryText = extractQueryText(args[0]) ?? prepared.rawQueryConfig?.text ?? prepared.queryConfig?.text ?? null;
 			const originalExecute = prepared.execute.bind(prepared);
@@ -98,7 +97,7 @@ function patchSession(session, cfg, isTx) {
 	if (typeof session.query === "function") {
 		const originalQuery = session.query.bind(session);
 		session.query = function patchedQuery(queryString, params) {
-			const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+			const reqTrace = getCtx()?.__analyticsTrace;
 			if (!reqTrace) return originalQuery.call(this, queryString, params);
 			return traceExecution(reqTrace, cfg, queryString ?? null, isTx, originalQuery, this, [queryString, params]);
 		};
@@ -127,7 +126,7 @@ function patchRawClient(client, cfg) {
 	if (!methodName) return false;
 	const originalMethod = client[methodName].bind(client);
 	client[methodName] = function patchedClientMethod(...args) {
-		const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+		const reqTrace = getCtx()?.__analyticsTrace;
 		if (!reqTrace) return originalMethod.apply(this, args);
 		return traceExecution(reqTrace, cfg, extractQueryText(args[0]) ?? null, false, originalMethod, this, args);
 	};
@@ -141,7 +140,7 @@ function patchSessionExecute(session, cfg) {
 	if (session[INSTRUMENTED]) return false;
 	const originalExecute = session.execute.bind(session);
 	session.execute = function patchedDeepExecute(...args) {
-		const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+		const reqTrace = getCtx()?.__analyticsTrace;
 		if (!reqTrace) return originalExecute.apply(this, args);
 		return traceExecution(reqTrace, cfg, extractQueryText(args[0]) ?? null, false, originalExecute, this, args);
 	};

package/dist/plugins/analytics-alerts.d.mts

@@ -0,0 +1,59 @@
+//#region src/plugins/analytics-alerts.d.ts
+/**
+ * Analytics Alerts — configurable alerting with sliding window evaluation.
+ */
+interface AlertRule {
+  /** Unique name for this alert. */
+  name: string;
+  /** Condition to evaluate. */
+  condition: 'error_rate' | 'latency_p95' | 'latency_avg' | 'error_count' | 'request_count' | 'no_requests';
+  /** Threshold value. For rates: percentage (0-100). For latency: milliseconds. For counts: absolute number. */
+  threshold: number;
+  /** Evaluation window in seconds (default: 300 = 5 minutes). */
+  windowSeconds?: number;
+  /** Cooldown between repeated alerts in seconds (default: 3600 = 1 hour). */
+  cooldownSeconds?: number;
+  /** Optional: only evaluate for a specific procedure. */
+  procedure?: string;
+  /** Actions to execute when alert fires. */
+  actions: AlertAction[];
+}
+type AlertAction = {
+  type: 'webhook';
+  url: string;
+  headers?: Record<string, string>;
+} | {
+  type: 'slack';
+  webhookUrl: string;
+  channel?: string;
+} | {
+  type: 'console';
+};
+interface AlertEvent {
+  rule: string;
+  condition: string;
+  value: number;
+  threshold: number;
+  procedure?: string;
+  timestamp: number;
+  message: string;
+}
+interface AlertState {
+  lastFired: number;
+  lastValue: number;
+}
+declare class AlertEngine {
+  #private;
+  constructor(rules: AlertRule[]);
+  /** Record a sample for window evaluation. */
+  record(durationMs: number, isError: boolean, procedure: string): void;
+  /** Evaluate all rules against current window data. */
+  evaluate(): void;
+  /** Get alert history. */
+  getHistory(): AlertEvent[];
+  /** Get current alert states. */
+  getStates(): Record<string, AlertState>;
+  dispose(): void;
+}
+//#endregion
+export { AlertEngine, AlertRule };

package/dist/plugins/analytics-alerts.mjs

@@ -0,0 +1,140 @@
+//#region src/plugins/analytics-alerts.ts
+var AlertEngine = class {
+	#rules;
+	#state = /* @__PURE__ */ new Map();
+	#samples = [];
+	#maxWindowMs;
+	#timer = null;
+	#history = [];
+	constructor(rules) {
+		this.#rules = rules;
+		this.#maxWindowMs = Math.max(...rules.map((r) => (r.windowSeconds ?? 300) * 1e3), 3e5);
+		this.#timer = setInterval(() => this.evaluate(), 3e4);
+		if (typeof this.#timer === "object" && "unref" in this.#timer) this.#timer.unref();
+	}
+	/** Record a sample for window evaluation. */
+	record(durationMs, isError, procedure) {
+		const now = Date.now();
+		this.#samples.push({
+			timestamp: now,
+			durationMs,
+			isError,
+			procedure
+		});
+		const cutoff = now - this.#maxWindowMs;
+		while (this.#samples.length > 0 && this.#samples[0].timestamp < cutoff) this.#samples.shift();
+	}
+	/** Evaluate all rules against current window data. */
+	evaluate() {
+		const now = Date.now();
+		for (const rule of this.#rules) {
+			const windowMs = (rule.windowSeconds ?? 300) * 1e3;
+			const cooldownMs = (rule.cooldownSeconds ?? 3600) * 1e3;
+			const cutoff = now - windowMs;
+			const state = this.#state.get(rule.name);
+			if (state && now - state.lastFired < cooldownMs) continue;
+			let samples = this.#samples.filter((s) => s.timestamp >= cutoff);
+			if (rule.procedure) samples = samples.filter((s) => s.procedure.includes(rule.procedure));
+			const value = this.#computeValue(rule.condition, samples);
+			if (value === null) continue;
+			if (!this.#checkThreshold(rule.condition, value, rule.threshold)) continue;
+			const event = {
+				rule: rule.name,
+				condition: rule.condition,
+				value,
+				threshold: rule.threshold,
+				procedure: rule.procedure,
+				timestamp: now,
+				message: `Alert "${rule.name}": ${rule.condition} is ${formatValue(rule.condition, value)} (threshold: ${formatValue(rule.condition, rule.threshold)})`
+			};
+			this.#state.set(rule.name, {
+				lastFired: now,
+				lastValue: value
+			});
+			this.#history.push(event);
+			if (this.#history.length > 1e3) this.#history.shift();
+			for (const action of rule.actions) this.#executeAction(action, event);
+		}
+	}
+	#computeValue(condition, samples) {
+		if (samples.length === 0) return condition === "no_requests" ? 0 : null;
+		switch (condition) {
+			case "error_rate": return samples.filter((s) => s.isError).length / samples.length * 100;
+			case "error_count": return samples.filter((s) => s.isError).length;
+			case "request_count": return samples.length;
+			case "no_requests": return samples.length;
+			case "latency_avg": return samples.reduce((sum, s) => sum + s.durationMs, 0) / samples.length;
+			case "latency_p95": {
+				const sorted = samples.map((s) => s.durationMs).sort((a, b) => a - b);
+				const idx = Math.ceil(sorted.length * .95) - 1;
+				return sorted[Math.max(0, idx)];
+			}
+		}
+	}
+	#checkThreshold(condition, value, threshold) {
+		if (condition === "no_requests") return value <= threshold;
+		return value >= threshold;
+	}
+	async #executeAction(action, event) {
+		try {
+			switch (action.type) {
+				case "console":
+					console.warn(`[silgi:alert] ${event.message}`);
+					break;
+				case "webhook":
+					await fetch(action.url, {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							...action.headers
+						},
+						body: JSON.stringify(event)
+					});
+					break;
+				case "slack":
+					await fetch(action.webhookUrl, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							channel: action.channel,
+							text: event.message,
+							blocks: [{
+								type: "section",
+								text: {
+									type: "mrkdwn",
+									text: `🚨 *${event.rule}*\n${event.message}`
+								}
+							}]
+						})
+					});
+					break;
+			}
+		} catch (err) {
+			console.error(`[silgi:alert] Failed to execute ${action.type} action: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+	/** Get alert history. */
+	getHistory() {
+		return this.#history;
+	}
+	/** Get current alert states. */
+	getStates() {
+		const result = {};
+		for (const [name, state] of this.#state) result[name] = state;
+		return result;
+	}
+	dispose() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = null;
+	}
+};
+function formatValue(condition, value) {
+	switch (condition) {
+		case "error_rate": return `${value.toFixed(1)}%`;
+		case "latency_avg":
+		case "latency_p95": return `${value.toFixed(1)}ms`;
+		default: return String(value);
+	}
+}
+//#endregion
+export { AlertEngine };

package/dist/plugins/analytics-cost.d.mts

@@ -0,0 +1,61 @@
+//#region src/plugins/analytics-cost.d.ts
+/**
+ * Analytics Cost Tracking — span cost metadata and budget monitoring.
+ */
+interface SpanCost {
+  /** Number of tokens/units consumed. */
+  units?: number;
+  /** Cost in dollars. */
+  amount: number;
+  /** Cost currency (default: USD). */
+  currency?: string;
+  /** Provider name (e.g., 'openai', 'anthropic', 'aws'). */
+  provider?: string;
+}
+interface CostBucket {
+  time: number;
+  totalAmount: number;
+  byProvider: Record<string, number>;
+  byProcedure: Record<string, number>;
+  byKind: Record<string, number>;
+}
+interface CostSummary {
+  totalAmount: number;
+  todayAmount: number;
+  byProvider: Record<string, number>;
+  byProcedure: Record<string, number>;
+  byKind: Record<string, number>;
+  dailyBuckets: CostBucket[];
+}
+interface BudgetRule {
+  /** Unique name. */
+  name: string;
+  /** Budget limit in dollars. */
+  limit: number;
+  /** Period: 'daily' | 'weekly' | 'monthly'. */
+  period: 'daily' | 'weekly' | 'monthly';
+  /** Optional: scope to a specific provider. */
+  provider?: string;
+  /** Optional: scope to a specific procedure. */
+  procedure?: string;
+}
+declare class CostTracker {
+  #private;
+  constructor(budgetRules?: BudgetRule[], onBudgetExceeded?: (rule: BudgetRule, current: number) => void);
+  /** Record a cost from a span. */
+  record(cost: SpanCost, procedure: string, kind: string): void;
+  /** Get cost summary. */
+  getSummary(): CostSummary;
+  /** Export for persistence. */
+  toJSON(): {
+    dailyBuckets: CostBucket[];
+    currentDay: CostBucket | null;
+  };
+  /** Restore from persistence. */
+  hydrate(data: {
+    dailyBuckets?: CostBucket[];
+    currentDay?: CostBucket | null;
+  }): void;
+}
+//#endregion
+export { BudgetRule, CostTracker, SpanCost };

package/dist/plugins/analytics-cost.mjs

@@ -0,0 +1,97 @@
+//#region src/plugins/analytics-cost.ts
+const DAY_MS = 864e5;
+const MAX_DAILY_BUCKETS = 30;
+var CostTracker = class {
+	#dailyBuckets = [];
+	#currentDay = null;
+	#budgetRules;
+	#onBudgetExceeded;
+	constructor(budgetRules = [], onBudgetExceeded) {
+		this.#budgetRules = budgetRules;
+		this.#onBudgetExceeded = onBudgetExceeded;
+	}
+	/** Record a cost from a span. */
+	record(cost, procedure, kind) {
+		const now = Date.now();
+		const dayStart = now - now % DAY_MS;
+		if (!this.#currentDay || this.#currentDay.time !== dayStart) {
+			if (this.#currentDay) {
+				this.#dailyBuckets.push(this.#currentDay);
+				if (this.#dailyBuckets.length > MAX_DAILY_BUCKETS) this.#dailyBuckets.shift();
+			}
+			this.#currentDay = {
+				time: dayStart,
+				totalAmount: 0,
+				byProvider: {},
+				byProcedure: {},
+				byKind: {}
+			};
+		}
+		this.#currentDay.totalAmount += cost.amount;
+		const provider = cost.provider ?? "unknown";
+		this.#currentDay.byProvider[provider] = (this.#currentDay.byProvider[provider] ?? 0) + cost.amount;
+		this.#currentDay.byProcedure[procedure] = (this.#currentDay.byProcedure[procedure] ?? 0) + cost.amount;
+		this.#currentDay.byKind[kind] = (this.#currentDay.byKind[kind] ?? 0) + cost.amount;
+		this.#checkBudgets();
+	}
+	/** Get cost summary. */
+	getSummary() {
+		const allBuckets = this.#currentDay ? [...this.#dailyBuckets, this.#currentDay] : [...this.#dailyBuckets];
+		const summary = {
+			totalAmount: 0,
+			todayAmount: this.#currentDay?.totalAmount ?? 0,
+			byProvider: {},
+			byProcedure: {},
+			byKind: {},
+			dailyBuckets: allBuckets
+		};
+		for (const bucket of allBuckets) {
+			summary.totalAmount += bucket.totalAmount;
+			for (const [k, v] of Object.entries(bucket.byProvider)) summary.byProvider[k] = (summary.byProvider[k] ?? 0) + v;
+			for (const [k, v] of Object.entries(bucket.byProcedure)) summary.byProcedure[k] = (summary.byProcedure[k] ?? 0) + v;
+			for (const [k, v] of Object.entries(bucket.byKind)) summary.byKind[k] = (summary.byKind[k] ?? 0) + v;
+		}
+		return summary;
+	}
+	/** Export for persistence. */
+	toJSON() {
+		return {
+			dailyBuckets: this.#dailyBuckets,
+			currentDay: this.#currentDay
+		};
+	}
+	/** Restore from persistence. */
+	hydrate(data) {
+		if (Array.isArray(data.dailyBuckets)) this.#dailyBuckets = data.dailyBuckets;
+		if (data.currentDay) this.#currentDay = data.currentDay;
+	}
+	#checkBudgets() {
+		if (!this.#onBudgetExceeded) return;
+		const now = Date.now();
+		for (const rule of this.#budgetRules) {
+			let amount = 0;
+			const buckets = this.#currentDay ? [...this.#dailyBuckets, this.#currentDay] : this.#dailyBuckets;
+			let cutoff;
+			switch (rule.period) {
+				case "daily":
+					cutoff = now - DAY_MS;
+					break;
+				case "weekly":
+					cutoff = now - 7 * DAY_MS;
+					break;
+				case "monthly":
+					cutoff = now - 30 * DAY_MS;
+					break;
+			}
+			for (const bucket of buckets) {
+				if (bucket.time < cutoff) continue;
+				if (rule.provider) amount += bucket.byProvider[rule.provider] ?? 0;
+				else if (rule.procedure) amount += bucket.byProcedure[rule.procedure] ?? 0;
+				else amount += bucket.totalAmount;
+			}
+			if (amount >= rule.limit) this.#onBudgetExceeded(rule, amount);
+		}
+	}
+};
+//#endregion
+export { CostTracker };