silgi 0.43.28 → 0.50.0

package/dist/plugins/analytics/sse.mjs

@@ -0,0 +1,74 @@
+import { encodeEventMessage } from "../../core/sse.mjs";
+//#region src/plugins/analytics/sse.ts
+/**
+* Analytics SSE — real-time event streaming for the analytics dashboard.
+*/
+var AnalyticsSSEHub = class {
+	#clients = /* @__PURE__ */ new Set();
+	#statsInterval = null;
+	#getStats = null;
+	constructor() {}
+	/** Start periodic stats broadcast. */
+	startStatsBroadcast(getStats, intervalMs = 5e3) {
+		this.#getStats = getStats;
+		this.#statsInterval = setInterval(() => {
+			if (this.#clients.size > 0 && this.#getStats) this.broadcast({
+				type: "stats",
+				data: this.#getStats()
+			});
+		}, intervalMs);
+		if (typeof this.#statsInterval === "object" && "unref" in this.#statsInterval) this.#statsInterval.unref();
+	}
+	/** Broadcast an event to all connected clients. */
+	broadcast(event) {
+		if (this.#clients.size === 0) return;
+		const message = encodeEventMessage({
+			event: event.type,
+			data: JSON.stringify(event.data)
+		});
+		for (const controller of this.#clients) try {
+			controller.enqueue(message);
+		} catch {
+			this.#clients.delete(controller);
+		}
+	}
+	/** Create an SSE ReadableStream for a new client connection. */
+	createStream() {
+		let controller;
+		let keepAliveTimer;
+		return new ReadableStream({
+			start: (ctrl) => {
+				controller = ctrl;
+				this.#clients.add(controller);
+				controller.enqueue(encodeEventMessage({ comment: "connected" }));
+				keepAliveTimer = setInterval(() => {
+					try {
+						controller.enqueue(encodeEventMessage({ comment: "keepalive" }));
+					} catch {
+						clearInterval(keepAliveTimer);
+						this.#clients.delete(controller);
+					}
+				}, 15e3);
+				if (typeof keepAliveTimer === "object" && "unref" in keepAliveTimer) keepAliveTimer.unref();
+			},
+			cancel: () => {
+				clearInterval(keepAliveTimer);
+				this.#clients.delete(controller);
+			}
+		}).pipeThrough(new TextEncoderStream());
+	}
+	/** Number of connected clients. */
+	get clientCount() {
+		return this.#clients.size;
+	}
+	dispose() {
+		if (this.#statsInterval) clearInterval(this.#statsInterval);
+		this.#statsInterval = null;
+		for (const controller of this.#clients) try {
+			controller.close();
+		} catch {}
+		this.#clients.clear();
+	}
+};
+//#endregion
+export { AnalyticsSSEHub };

package/dist/plugins/analytics/store.mjs

@@ -0,0 +1,103 @@
+import { useStorage } from "../../core/storage.mjs";
+import { isTrackedRequestPath } from "./utils.mjs";
+import { normalizeErrorEntries, normalizeRequestEntries } from "./normalize.mjs";
+//#region src/plugins/analytics/store.ts
+/**
+* Persistent analytics storage — flush/hydrate to unstorage.
+*/
+var AnalyticsStore = class {
+	#storage;
+	#pendingRequests = [];
+	#pendingErrors = [];
+	#retentionMs;
+	#timer = null;
+	#flushing = false;
+	constructor(flushInterval, retentionDays) {
+		this.#storage = useStorage("data");
+		this.#retentionMs = retentionDays * 864e5;
+		this.#timer = setInterval(() => this.flush(), flushInterval);
+		if (typeof this.#timer === "object" && "unref" in this.#timer) this.#timer.unref();
+	}
+	enqueueRequest(entry) {
+		this.#pendingRequests.push(entry);
+	}
+	enqueueError(entry) {
+		this.#pendingErrors.push(entry);
+	}
+	async flush() {
+		if (this.#flushing) return;
+		const requests = this.#pendingRequests.splice(0);
+		const errors = this.#pendingErrors.splice(0);
+		if (requests.length === 0 && errors.length === 0) return;
+		this.#flushing = true;
+		try {
+			const cutoff = Date.now() - this.#retentionMs;
+			if (requests.length > 0) {
+				const merged = [...normalizeRequestEntries(await this.#storage.getItem("analytics:requests")).filter((entry) => isTrackedRequestPath(entry.path)), ...requests].filter((e) => e.timestamp >= cutoff);
+				await this.#storage.setItem("analytics:requests", merged);
+			}
+			if (errors.length > 0) {
+				const merged = [...normalizeErrorEntries(await this.#storage.getItem("analytics:errors")).filter((entry) => isTrackedRequestPath(entry.procedure)), ...errors].filter((e) => e.timestamp >= cutoff);
+				await this.#storage.setItem("analytics:errors", merged);
+			}
+		} catch {
+			this.#pendingRequests.unshift(...requests);
+			this.#pendingErrors.unshift(...errors);
+		} finally {
+			this.#flushing = false;
+		}
+	}
+	async getRequests() {
+		const cutoff = Date.now() - this.#retentionMs;
+		const stored = normalizeRequestEntries(await this.#storage.getItem("analytics:requests")).filter((entry) => isTrackedRequestPath(entry.path) && entry.timestamp >= cutoff);
+		const pending = this.#pendingRequests.filter((entry) => isTrackedRequestPath(entry.path) && entry.timestamp >= cutoff);
+		if (pending.length === 0) return stored;
+		return [...stored, ...pending];
+	}
+	async getErrors() {
+		const cutoff = Date.now() - this.#retentionMs;
+		const stored = normalizeErrorEntries(await this.#storage.getItem("analytics:errors")).filter((entry) => isTrackedRequestPath(entry.procedure) && entry.timestamp >= cutoff);
+		const pending = this.#pendingErrors.filter((entry) => isTrackedRequestPath(entry.procedure) && entry.timestamp >= cutoff);
+		if (pending.length === 0) return stored;
+		return [...stored, ...pending];
+	}
+	async hydrate() {
+		try {
+			return await this.#storage.getItem("analytics:counters") ?? {
+				totalRequests: 0,
+				totalErrors: 0
+			};
+		} catch {
+			return {
+				totalRequests: 0,
+				totalErrors: 0
+			};
+		}
+	}
+	async saveCounters(totalRequests, totalErrors) {
+		try {
+			await this.#storage.setItem("analytics:counters", {
+				totalRequests,
+				totalErrors
+			});
+		} catch {}
+	}
+	async loadHiddenPaths() {
+		try {
+			const paths = await this.#storage.getItem("analytics:hiddenPaths");
+			return Array.isArray(paths) ? paths : [];
+		} catch {
+			return [];
+		}
+	}
+	saveHiddenPaths(paths) {
+		this.#storage.setItem("analytics:hiddenPaths", paths).catch(() => {});
+	}
+	async dispose() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = null;
+		await this.flush();
+	}
+};
+//#endregion
+export { AnalyticsStore };

package/dist/plugins/analytics/timeseries.d.mts

@@ -0,0 +1,50 @@
+//#region src/plugins/analytics/timeseries.d.ts
+/**
+ * Analytics Time-Series — multi-tier bucketed aggregation with automatic downsampling.
+ *
+ * Three tiers:
+ * - minute: 1-minute buckets, last 60 minutes
+ * - hour: 1-hour buckets, last 24 hours
+ * - day: 1-day buckets, last 30 days
+ */
+interface TimeSeriesBucket {
+  time: number;
+  count: number;
+  errors: number;
+  totalLatency: number;
+  minLatency: number;
+  maxLatency: number;
+}
+interface TimeSeriesSnapshot {
+  time: number;
+  count: number;
+  errors: number;
+  errorRate: number;
+  avgLatency: number;
+  minLatency: number;
+  maxLatency: number;
+}
+type TimeRange = '1h' | '6h' | '24h' | '7d' | '30d';
+declare class TimeSeriesAggregator {
+  #private;
+  constructor();
+  /** Record a request. */
+  record(durationMs: number, isError: boolean): void;
+  /** Get time-series for a given range. */
+  query(range: TimeRange): TimeSeriesSnapshot[];
+  /** Export state for persistence. */
+  toJSON(): {
+    minutes: TimeSeriesBucket[];
+    hours: TimeSeriesBucket[];
+    days: TimeSeriesBucket[];
+  };
+  /** Restore from persisted state. */
+  hydrate(data: {
+    minutes?: TimeSeriesBucket[];
+    hours?: TimeSeriesBucket[];
+    days?: TimeSeriesBucket[];
+  }): void;
+  dispose(): void;
+}
+//#endregion
+export { TimeSeriesAggregator };

package/dist/plugins/analytics/timeseries.mjs

@@ -0,0 +1,169 @@
+//#region src/plugins/analytics/timeseries.ts
+const MINUTE_MS = 6e4;
+const HOUR_MS = 36e5;
+const DAY_MS = 864e5;
+const MAX_MINUTE_BUCKETS = 60;
+const MAX_HOUR_BUCKETS = 24;
+const MAX_DAY_BUCKETS = 30;
+var TimeSeriesAggregator = class {
+	#minutes = [];
+	#hours = [];
+	#days = [];
+	#currentMinute = null;
+	#rollupTimer = null;
+	constructor() {
+		this.#rollupTimer = setInterval(() => this.#rollup(), MINUTE_MS);
+		if (typeof this.#rollupTimer === "object" && "unref" in this.#rollupTimer) this.#rollupTimer.unref();
+	}
+	/** Record a request. */
+	record(durationMs, isError) {
+		const now = Date.now();
+		const minuteStart = now - now % MINUTE_MS;
+		if (!this.#currentMinute || this.#currentMinute.time !== minuteStart) {
+			if (this.#currentMinute) {
+				this.#minutes.push(this.#currentMinute);
+				if (this.#minutes.length > MAX_MINUTE_BUCKETS) this.#minutes.shift();
+			}
+			this.#currentMinute = createBucket(minuteStart);
+		}
+		this.#currentMinute.count++;
+		if (isError) this.#currentMinute.errors++;
+		this.#currentMinute.totalLatency += durationMs;
+		if (durationMs < this.#currentMinute.minLatency) this.#currentMinute.minLatency = durationMs;
+		if (durationMs > this.#currentMinute.maxLatency) this.#currentMinute.maxLatency = durationMs;
+	}
+	/** Get time-series for a given range. */
+	query(range) {
+		this.#flushCurrentMinute();
+		switch (range) {
+			case "1h": return this.#minutes.map(toSnapshot);
+			case "6h": {
+				const cutoff = Date.now() - 6 * HOUR_MS;
+				const hourData = this.#hours.filter((b) => b.time >= cutoff).map(toSnapshot);
+				const minuteData = this.#minutes.map(toSnapshot);
+				return [...hourData, ...minuteData];
+			}
+			case "24h": return this.#hours.map(toSnapshot);
+			case "7d": {
+				const cutoff = Date.now() - 7 * DAY_MS;
+				return this.#days.filter((b) => b.time >= cutoff).map(toSnapshot);
+			}
+			case "30d": return this.#days.map(toSnapshot);
+		}
+	}
+	/** Export state for persistence. */
+	toJSON() {
+		this.#flushCurrentMinute();
+		return {
+			minutes: this.#minutes,
+			hours: this.#hours,
+			days: this.#days
+		};
+	}
+	/** Restore from persisted state. */
+	hydrate(data) {
+		if (Array.isArray(data.minutes)) this.#minutes = data.minutes;
+		if (Array.isArray(data.hours)) this.#hours = data.hours;
+		if (Array.isArray(data.days)) this.#days = data.days;
+	}
+	#flushCurrentMinute() {
+		if (this.#currentMinute && this.#currentMinute.count > 0) {
+			const minuteStart = Date.now() - Date.now() % MINUTE_MS;
+			if (this.#currentMinute.time !== minuteStart) {
+				this.#minutes.push(this.#currentMinute);
+				if (this.#minutes.length > MAX_MINUTE_BUCKETS) this.#minutes.shift();
+				this.#currentMinute = null;
+			}
+		}
+	}
+	#rollup() {
+		const now = Date.now();
+		const hourStart = now - now % HOUR_MS;
+		const completedMinutes = this.#minutes.filter((b) => b.time < hourStart);
+		if (completedMinutes.length > 0) {
+			const byHour = /* @__PURE__ */ new Map();
+			for (const b of completedMinutes) {
+				const hStart = b.time - b.time % HOUR_MS;
+				const arr = byHour.get(hStart);
+				if (arr) arr.push(b);
+				else byHour.set(hStart, [b]);
+			}
+			for (const [hStart, buckets] of byHour) {
+				const existing = this.#hours.find((h) => h.time === hStart);
+				if (existing) mergeBucketInto(existing, buckets);
+				else {
+					this.#hours.push(mergeBuckets(hStart, buckets));
+					if (this.#hours.length > MAX_HOUR_BUCKETS) this.#hours.shift();
+				}
+			}
+			this.#minutes = this.#minutes.filter((b) => b.time >= hourStart);
+		}
+		const dayStart = now - now % DAY_MS;
+		const completedHours = this.#hours.filter((b) => b.time < dayStart);
+		if (completedHours.length > 0) {
+			const byDay = /* @__PURE__ */ new Map();
+			for (const b of completedHours) {
+				const dStart = b.time - b.time % DAY_MS;
+				const arr = byDay.get(dStart);
+				if (arr) arr.push(b);
+				else byDay.set(dStart, [b]);
+			}
+			for (const [dStart, buckets] of byDay) {
+				const existing = this.#days.find((d) => d.time === dStart);
+				if (existing) mergeBucketInto(existing, buckets);
+				else {
+					this.#days.push(mergeBuckets(dStart, buckets));
+					if (this.#days.length > MAX_DAY_BUCKETS) this.#days.shift();
+				}
+			}
+			this.#hours = this.#hours.filter((b) => b.time >= dayStart);
+		}
+	}
+	dispose() {
+		if (this.#rollupTimer) clearInterval(this.#rollupTimer);
+		this.#rollupTimer = null;
+	}
+};
+function createBucket(time) {
+	return {
+		time,
+		count: 0,
+		errors: 0,
+		totalLatency: 0,
+		minLatency: Infinity,
+		maxLatency: 0
+	};
+}
+function mergeBuckets(time, buckets) {
+	const merged = createBucket(time);
+	for (const b of buckets) {
+		merged.count += b.count;
+		merged.errors += b.errors;
+		merged.totalLatency += b.totalLatency;
+		if (b.minLatency < merged.minLatency) merged.minLatency = b.minLatency;
+		if (b.maxLatency > merged.maxLatency) merged.maxLatency = b.maxLatency;
+	}
+	return merged;
+}
+function mergeBucketInto(target, buckets) {
+	for (const b of buckets) {
+		target.count += b.count;
+		target.errors += b.errors;
+		target.totalLatency += b.totalLatency;
+		if (b.minLatency < target.minLatency) target.minLatency = b.minLatency;
+		if (b.maxLatency > target.maxLatency) target.maxLatency = b.maxLatency;
+	}
+}
+function toSnapshot(b) {
+	return {
+		time: b.time,
+		count: b.count,
+		errors: b.errors,
+		errorRate: b.count > 0 ? b.errors / b.count * 100 : 0,
+		avgLatency: b.count > 0 ? b.totalLatency / b.count : 0,
+		minLatency: b.minLatency === Infinity ? 0 : b.minLatency,
+		maxLatency: b.maxLatency
+	};
+}
+//#endregion
+export { TimeSeriesAggregator };

package/dist/plugins/analytics/trace.d.mts

@@ -0,0 +1,48 @@
+import { SpanKind, TraceSpan } from "./types.mjs";
+
+//#region src/plugins/analytics/trace.d.ts
+declare class RequestTrace {
+  spans: TraceSpan[];
+  /** Procedure-level input — set via `setProcedureInput()` or `trace(..., { procedure: { input } })` */
+  procedureInput: unknown;
+  /** Procedure-level output — set via `setProcedureOutput()` or `trace(..., { procedure: { output } })` */
+  procedureOutput: unknown;
+  /** @internal Start time — used by integrations (drizzle etc.) for span offset calculation */
+  readonly t0: number;
+  trace<T>(name: string, fn: () => T | Promise<T>, opts?: {
+    kind?: SpanKind;
+    detail?: string;
+    input?: unknown;
+    output?: unknown | ((result: T) => unknown);
+    procedure?: {
+      input?: unknown;
+      output?: unknown | ((result: T) => unknown);
+    };
+  }): Promise<T>;
+  totalByKind(kind: SpanKind): number;
+}
+/**
+ * Standalone trace function — works with or without analytics.
+ *
+ * ```ts
+ * import { trace } from 'silgi/analytics'
+ *
+ * const listUsers = s.$resolve(async ({ ctx }) => {
+ *   return await trace(ctx, 'db.users.findMany', () => db.users.findMany())
+ *   // or with explicit kind:
+ *   return await trace(ctx, 'findUsers', () => db.users.findMany(), { kind: 'db', detail: 'SELECT * FROM users' })
+ * })
+ * ```
+ */
+declare function trace<T>(ctx: Record<string, unknown>, name: string, fn: () => T | Promise<T>, opts?: {
+  kind?: SpanKind;
+  detail?: string;
+  input?: unknown;
+  output?: unknown | ((result: T) => unknown);
+  procedure?: {
+    input?: unknown;
+    output?: unknown | ((result: T) => unknown);
+  };
+}): Promise<T>;
+//#endregion
+export { RequestTrace, trace };

package/dist/plugins/analytics/trace.mjs

@@ -0,0 +1,83 @@
+import { round } from "./utils.mjs";
+//#region src/plugins/analytics/trace.ts
+/**
+* Request-level tracing — span collection and standalone trace() helper.
+*/
+var RequestTrace = class {
+	spans = [];
+	/** Procedure-level input — set via `setProcedureInput()` or `trace(..., { procedure: { input } })` */
+	procedureInput = void 0;
+	/** Procedure-level output — set via `setProcedureOutput()` or `trace(..., { procedure: { output } })` */
+	procedureOutput = void 0;
+	/** @internal Start time — used by integrations (drizzle etc.) for span offset calculation */
+	t0 = performance.now();
+	async trace(name, fn, opts) {
+		const start = performance.now();
+		const kind = opts?.kind ?? guessKind(name);
+		try {
+			const result = await fn();
+			this.spans.push({
+				name,
+				kind,
+				durationMs: round(performance.now() - start),
+				startOffsetMs: round(start - this.t0),
+				detail: opts?.detail,
+				input: opts?.input,
+				output: typeof opts?.output === "function" ? opts.output(result) : opts?.output
+			});
+			if (opts?.procedure) {
+				if (opts.procedure.input !== void 0) this.procedureInput = opts.procedure.input;
+				const po = opts.procedure.output;
+				if (po !== void 0) this.procedureOutput = typeof po === "function" ? po(result) : po;
+			}
+			return result;
+		} catch (err) {
+			this.spans.push({
+				name,
+				kind,
+				durationMs: round(performance.now() - start),
+				startOffsetMs: round(start - this.t0),
+				detail: opts?.detail,
+				input: opts?.input,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			if (opts?.procedure?.input !== void 0) this.procedureInput = opts.procedure.input;
+			throw err;
+		}
+	}
+	totalByKind(kind) {
+		let total = 0;
+		for (const s of this.spans) if (s.kind === kind) total += s.durationMs;
+		return round(total);
+	}
+};
+function guessKind(name) {
+	const lower = name.toLowerCase();
+	if (lower.startsWith("db.") || lower.includes("sql") || lower.includes("prisma") || lower.includes("drizzle") || lower.includes("query") || lower.includes("mongo")) return "db";
+	if (lower.startsWith("http.") || lower.includes("fetch") || lower.includes("api.")) return "http";
+	if (lower.startsWith("cache.") || lower.includes("redis") || lower.includes("memcache")) return "cache";
+	if (lower.includes("queue") || lower.includes("publish") || lower.includes("nats") || lower.includes("kafka")) return "queue";
+	if (lower.includes("email") || lower.includes("smtp") || lower.includes("ses")) return "email";
+	if (lower.includes("ai") || lower.includes("llm") || lower.includes("openai") || lower.includes("gemini")) return "ai";
+	return "custom";
+}
+/**
+* Standalone trace function — works with or without analytics.
+*
+* ```ts
+* import { trace } from 'silgi/analytics'
+*
+* const listUsers = s.$resolve(async ({ ctx }) => {
+*   return await trace(ctx, 'db.users.findMany', () => db.users.findMany())
+*   // or with explicit kind:
+*   return await trace(ctx, 'findUsers', () => db.users.findMany(), { kind: 'db', detail: 'SELECT * FROM users' })
+* })
+* ```
+*/
+async function trace(ctx, name, fn, opts) {
+	const reqTrace = ctx.__analyticsTrace;
+	if (reqTrace) return reqTrace.trace(name, fn, opts);
+	return fn();
+}
+//#endregion
+export { RequestTrace, trace };

package/dist/plugins/analytics/types.d.mts

@@ -0,0 +1,145 @@
+import { BudgetRule, SpanCost } from "./cost.mjs";
+import { AlertRule } from "./alerts.mjs";
+
+//#region src/plugins/analytics/types.d.ts
+interface TimeWindow {
+  time: number;
+  count: number;
+  errors: number;
+}
+type SpanKind = 'db' | 'http' | 'cache' | 'queue' | 'email' | 'ai' | 'custom';
+interface TraceSpan {
+  name: string;
+  kind: SpanKind;
+  durationMs: number;
+  startOffsetMs?: number;
+  detail?: string;
+  input?: unknown;
+  output?: unknown;
+  error?: string;
+  /** Structured key-value attributes (db.name, auth.operation, user.id, etc.) */
+  attributes?: Record<string, string | number | boolean>;
+  /** Cost metadata for this span (tokens, price, provider). */
+  cost?: SpanCost;
+}
+interface ErrorEntry {
+  id: number;
+  /** Links back to the RequestEntry that produced this error. */
+  requestId: string;
+  timestamp: number;
+  procedure: string;
+  error: string;
+  code: string;
+  status: number;
+  stack: string;
+  input: unknown;
+  headers: Record<string, string>;
+  durationMs: number;
+  spans: TraceSpan[];
+}
+/** A single procedure call within an HTTP request. */
+interface ProcedureCall {
+  procedure: string;
+  durationMs: number;
+  status: number;
+  input: unknown;
+  output: unknown;
+  spans: TraceSpan[];
+  error?: string;
+}
+/** An HTTP request containing one or more procedure calls. */
+interface RequestEntry {
+  id: number;
+  /** Unique request ID (returned in x-request-id response header). */
+  requestId: string;
+  /** Persistent session ID (from cookie — survives browser restart). */
+  sessionId: string;
+  timestamp: number;
+  durationMs: number;
+  method: string;
+  url: string;
+  path: string;
+  ip: string;
+  headers: Record<string, string>;
+  responseHeaders: Record<string, string>;
+  userAgent: string;
+  status: number;
+  procedures: ProcedureCall[];
+  isBatch: boolean;
+  /** Trace ID for correlating related requests across services. */
+  traceId?: string;
+  /** Parent request ID — links child requests to the originating request. */
+  parentRequestId?: string;
+}
+/** A background task execution record. */
+interface TaskExecution {
+  id: number;
+  taskName: string;
+  trigger: 'dispatch' | 'cron' | 'http';
+  timestamp: number;
+  durationMs: number;
+  status: 'success' | 'error';
+  error?: string;
+  input?: unknown;
+  output?: unknown;
+  spans: TraceSpan[];
+}
+interface AnalyticsOptions {
+  /** Latency samples to keep per procedure (default: 1024) */
+  bufferSize?: number;
+  /** Time-series history in seconds (default: 120) */
+  historySeconds?: number;
+  /**
+   * Protect dashboard access.
+   * - `string` — secret token checked against `Authorization: Bearer <token>` header or `?token=` query param
+   * - `(req: Request) => boolean | Promise<boolean>` — custom auth function
+   * - `undefined` — no auth (open access, NOT recommended in production)
+   */
+  auth?: string | ((req: Request) => boolean | Promise<boolean>);
+  /** Interval in ms between storage flushes (default: 5000) */
+  flushInterval?: number;
+  /** Days to retain entries in storage (default: 30). Entries older than this are pruned on flush. */
+  retentionDays?: number;
+  /** Path prefixes to exclude from tracking. Can also be managed at runtime via the dashboard or API. */
+  ignorePaths?: string[];
+  /** Alert rules — fire actions when conditions are met within a sliding window. */
+  alerts?: AlertRule[];
+  /** Budget rules for cost tracking. */
+  budgets?: BudgetRule[];
+}
+interface ProcedureSnapshot {
+  count: number;
+  errors: number;
+  errorRate: number;
+  latency: {
+    avg: number;
+    p50: number;
+    p95: number;
+    p99: number;
+  };
+  lastError: string | null;
+  lastErrorTime: number | null;
+}
+interface TaskSnapshot {
+  totalRuns: number;
+  totalErrors: number;
+  tasks: Record<string, {
+    runs: number;
+    errors: number;
+    avgDurationMs: number;
+    lastRun: number | null;
+  }>;
+}
+interface AnalyticsSnapshot {
+  uptime: number;
+  totalRequests: number;
+  totalErrors: number;
+  errorRate: number;
+  requestsPerSecond: number;
+  avgLatency: number;
+  procedures: Record<string, ProcedureSnapshot>;
+  timeSeries: TimeWindow[];
+  tasks: TaskSnapshot;
+}
+//#endregion
+export { AnalyticsOptions, AnalyticsSnapshot, ErrorEntry, ProcedureCall, ProcedureSnapshot, RequestEntry, SpanKind, TaskExecution, TaskSnapshot, TraceSpan };