autotel-tanstack 1.13.30 → 1.13.32

package/dist/loaders.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"loaders.js"}
+{"version":3,"file":"loaders.js","names":[],"sources":["../src/loaders.ts"],"sourcesContent":["import { SpanStatusCode } from '@opentelemetry/api';\nimport { trace, type TraceContext } from 'autotel';\nimport { isServerSide } from './env';\nimport { type TraceLoaderConfig, SPAN_ATTRIBUTES } from './types';\n\n// Re-export types from @tanstack/react-router for consumers who need them\nexport type { LoaderFnContext } from '@tanstack/react-router';\n\n/**\n * Internal type for extracting route info from TanStack context.\n * This is a minimal interface used only for instrumentation - the actual\n * TanStack types flow through the generic parameter.\n */\ninterface TanStackContextInternal {\n  route?: { id?: string };\n  params?: Record<string, string>;\n}\n\n/**\n * Wrap a TanStack route loader with OpenTelemetry tracing\n *\n * This function wraps a loader function to automatically create spans\n * for each invocation. It captures route ID, params (optionally),\n * and errors.\n *\n * The generic type TLoaderFn preserves the full TanStack Router type inference,\n * including typed params, context, and return types.\n *\n * @param loaderFn - The loader function to wrap\n * @param config - Configuration options\n * @returns Wrapped loader function with tracing (preserves original types)\n *\n * @example\n * ```typescript\n * import { createFileRoute } from '@tanstack/react-router';\n * import { traceLoader } from 'autotel-tanstack/loaders';\n *\n * export const Route = createFileRoute('/users/$userId')({\n *   // Types are fully preserved - params.userId is typed as string\n *   loader: traceLoader(async ({ params }) => {\n *     return await db.users.findUnique({ where: { id: params.userId } });\n *   }),\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Sync loaders are also supported\n * export const Route = createFileRoute('/static')({\n *   loader: traceLoader(({ context }) => ({\n *     message: `Welcome, ${context.userId}!`,\n *   })),\n * });\n * ```\n */\nexport function traceLoader<TLoaderFn extends (ctx: any) => any>(\n  loaderFn: TLoaderFn,\n  config: TraceLoaderConfig = {},\n): TLoaderFn {\n  const captureParams = config.captureParams ?? true;\n  const captureResult = config.captureResult ?? false;\n\n  const wrapped = (context: TanStackContextInternal) => {\n    // If we're in the browser, just call the loader without tracing\n    // This prevents autotel (which uses Node.js APIs) from being executed in the browser\n    if (!isServerSide()) {\n      return loaderFn(context);\n    }\n\n    const routeId = context?.route?.id || 'unknown';\n    const spanName = config.name || `tanstack.loader.${routeId}`;\n\n    // Handle both sync and async loaders\n    const result = loaderFn(context);\n    const isPromise = result instanceof Promise;\n\n    if (!isPromise) {\n      // Sync loader - wrap in trace synchronously\n      return trace(spanName, (ctx: TraceContext) => {\n        ctx.setAttributes({\n          [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'loader',\n          [SPAN_ATTRIBUTES.TANSTACK_LOADER_ROUTE_ID]: routeId,\n          [SPAN_ATTRIBUTES.TANSTACK_LOADER_TYPE]: 'loader',\n        });\n\n        if (captureParams && context?.params) {\n          try {\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n              JSON.stringify(context.params),\n            );\n          } catch {\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n              '[non-serializable]',\n            );\n          }\n        }\n\n        if (captureResult && result !== undefined) {\n          try {\n            ctx.setAttribute('tanstack.loader.result', JSON.stringify(result));\n          } catch {\n            ctx.setAttribute('tanstack.loader.result', '[non-serializable]');\n          }\n        }\n\n        ctx.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      });\n    }\n\n    // Async loader\n    return trace(spanName, async (ctx: TraceContext) => {\n      ctx.setAttributes({\n        [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'loader',\n        [SPAN_ATTRIBUTES.TANSTACK_LOADER_ROUTE_ID]: routeId,\n        [SPAN_ATTRIBUTES.TANSTACK_LOADER_TYPE]: 'loader',\n      });\n\n      if (captureParams && context?.params) {\n        try {\n          ctx.setAttribute(\n            SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n            JSON.stringify(context.params),\n          );\n        } catch {\n          ctx.setAttribute(\n            SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n            '[non-serializable]',\n          );\n        }\n      }\n\n      try {\n        const asyncResult = await result;\n\n        if (captureResult && asyncResult !== undefined) {\n          try {\n            ctx.setAttribute(\n              'tanstack.loader.result',\n              JSON.stringify(asyncResult),\n            );\n          } catch {\n            ctx.setAttribute('tanstack.loader.result', '[non-serializable]');\n          }\n        }\n\n        ctx.setStatus({ code: SpanStatusCode.OK });\n        return asyncResult;\n      } catch (error) {\n        if ('recordError' in ctx && typeof ctx.recordError === 'function') {\n          ctx.recordError(error);\n        } else if (\n          'recordException' in ctx &&\n          typeof ctx.recordException === 'function'\n        ) {\n          ctx.recordException(error);\n        }\n        throw error;\n      }\n    });\n  };\n\n  return wrapped as TLoaderFn;\n}\n\n/**\n * Wrap a TanStack route beforeLoad function with OpenTelemetry tracing\n *\n * This function wraps a beforeLoad function to automatically create spans.\n * beforeLoad runs before the route component renders and is typically\n * used for auth checks, redirects, or data prefetching.\n *\n * The generic type TBeforeLoadFn preserves the full TanStack Router type inference,\n * including typed params, context, search, and return types.\n *\n * @param beforeLoadFn - The beforeLoad function to wrap\n * @param config - Configuration options\n * @returns Wrapped beforeLoad function with tracing (preserves original types)\n *\n * @example\n * ```typescript\n * import { createFileRoute, redirect } from '@tanstack/react-router';\n * import { traceBeforeLoad } from 'autotel-tanstack/loaders';\n *\n * export const Route = createFileRoute('/dashboard')({\n *   // Types are fully preserved - context, params, search are all typed\n *   beforeLoad: traceBeforeLoad(async ({ context, params }) => {\n *     if (!context.auth.isAuthenticated) {\n *       throw redirect({ to: '/login' });\n *     }\n *     return { userId: params.userId }; // Return type flows to loader context\n *   }),\n *   loader: ({ context }) => {\n *     // context.userId is typed from beforeLoad return\n *     return { user: context.userId };\n *   },\n * });\n * ```\n */\nexport function traceBeforeLoad<TBeforeLoadFn extends (opts: any) => any>(\n  beforeLoadFn: TBeforeLoadFn,\n  config: TraceLoaderConfig = {},\n): TBeforeLoadFn {\n  const captureParams = config.captureParams ?? true;\n\n  const wrapped = (input: TanStackContextInternal) => {\n    // Skip tracing in browser\n    if (!isServerSide()) {\n      return beforeLoadFn(input);\n    }\n\n    const routeId = input?.route?.id || 'unknown';\n    const spanName = config.name || `tanstack.beforeLoad.${routeId}`;\n\n    // Handle both sync and async beforeLoad\n    const result = beforeLoadFn(input);\n    const isPromise = result instanceof Promise;\n\n    if (!isPromise) {\n      // Sync beforeLoad\n      return trace(spanName, (ctx: TraceContext) => {\n        ctx.setAttributes({\n          [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'beforeLoad',\n          [SPAN_ATTRIBUTES.TANSTACK_LOADER_ROUTE_ID]: routeId,\n          [SPAN_ATTRIBUTES.TANSTACK_LOADER_TYPE]: 'beforeLoad',\n        });\n\n        if (captureParams && input?.params) {\n          try {\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n              JSON.stringify(input.params),\n            );\n          } catch {\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n              '[non-serializable]',\n            );\n          }\n        }\n\n        ctx.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      });\n    }\n\n    // Async beforeLoad\n    return trace(spanName, async (ctx: TraceContext) => {\n      ctx.setAttributes({\n        [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'beforeLoad',\n        [SPAN_ATTRIBUTES.TANSTACK_LOADER_ROUTE_ID]: routeId,\n        [SPAN_ATTRIBUTES.TANSTACK_LOADER_TYPE]: 'beforeLoad',\n      });\n\n      if (captureParams && input?.params) {\n        try {\n          ctx.setAttribute(\n            SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n            JSON.stringify(input.params),\n          );\n        } catch {\n          ctx.setAttribute(\n            SPAN_ATTRIBUTES.TANSTACK_LOADER_PARAMS,\n            '[non-serializable]',\n          );\n        }\n      }\n\n      try {\n        const asyncResult = await result;\n        ctx.setStatus({ code: SpanStatusCode.OK });\n        return asyncResult;\n      } catch (error) {\n        // Check if this is a redirect or notFound (expected control flow)\n        const errorName = (error as Error).name;\n        if (errorName === 'RedirectError' || errorName === 'NotFoundError') {\n          // Mark as OK since these are expected control flow\n          ctx.setAttribute('tanstack.beforeLoad.redirect', true);\n          ctx.setStatus({ code: SpanStatusCode.OK });\n        } else {\n          if ('recordError' in ctx && typeof ctx.recordError === 'function') {\n            ctx.recordError(error);\n          } else if (\n            'recordException' in ctx &&\n            typeof ctx.recordException === 'function'\n          ) {\n            ctx.recordException(error);\n          }\n        }\n        throw error;\n      }\n    });\n  };\n\n  return wrapped as TBeforeLoadFn;\n}\n\n/**\n * Create a traced route configuration helper\n *\n * This higher-order function helps create route configurations\n * with automatic tracing for both loader and beforeLoad.\n *\n * @param routeId - The route identifier\n * @param config - Tracing configuration\n * @returns Object with traced loader and beforeLoad wrappers\n *\n * @example\n * ```typescript\n * import { createFileRoute } from '@tanstack/react-router';\n * import { createTracedRoute } from 'autotel-tanstack/loaders';\n *\n * const traced = createTracedRoute('/users/$userId');\n *\n * export const Route = createFileRoute('/users/$userId')({\n *   beforeLoad: traced.beforeLoad(async ({ context }) => {\n *     // Auth check\n *   }),\n *   loader: traced.loader(async ({ params }) => {\n *     return await getUser(params.userId);\n *   }),\n * });\n * ```\n */\nexport function createTracedRoute(\n  routeId: string,\n  config: Omit<TraceLoaderConfig, 'name'> = {},\n) {\n  return {\n    /**\n     * Wrap a loader function with tracing\n     */\n    loader<TLoaderFn extends (ctx: any) => any>(\n      loaderFn: TLoaderFn,\n    ): TLoaderFn {\n      return traceLoader(loaderFn, {\n        ...config,\n        name: `tanstack.loader.${routeId}`,\n      });\n    },\n\n    /**\n     * Wrap a beforeLoad function with tracing\n     */\n    beforeLoad<TBeforeLoadFn extends (opts: any) => any>(\n      beforeLoadFn: TBeforeLoadFn,\n    ): TBeforeLoadFn {\n      return traceBeforeLoad(beforeLoadFn, {\n        ...config,\n        name: `tanstack.beforeLoad.${routeId}`,\n      });\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/metrics.d.ts

@@ -1,5 +1,4 @@
-import * as _tanstack_react_start from '@tanstack/react-start';
-
+//#region src/metrics.d.ts
 /**
  * Performance metrics collection for TanStack Start
  *
@@ -10,12 +9,12 @@ import * as _tanstack_react_start from '@tanstack/react-start';
  * Performance timing data
  */
 interface TimingStats {
-    count: number;
-    avg: number;
-    p50: number;
-    p95: number;
-    min: number;
-    max: number;
+  count: number;
+  avg: number;
+  p50: number;
+  p95: number;
+  min: number;
+  max: number;
 }
 /**
  * Metrics collector for performance data
@@ -36,28 +35,28 @@ interface TimingStats {
  * ```
  */
 declare class MetricsCollector {
-    private metrics;
-    private readonly maxSamples;
-    /**
-     * Record a timing measurement
-     */
-    recordTiming(name: string, duration: number): void;
-    /**
-     * Get statistics for a metric
-     */
-    getStats(name: string): TimingStats | null;
-    /**
-     * Get all collected metrics
-     */
-    getAllStats(): Record<string, TimingStats>;
-    /**
-     * Reset all metrics
-     */
-    reset(): void;
-    /**
-     * Reset a specific metric
-     */
-    resetMetric(name: string): void;
+  private metrics;
+  private readonly maxSamples;
+  /**
+   * Record a timing measurement
+   */
+  recordTiming(name: string, duration: number): void;
+  /**
+   * Get statistics for a metric
+   */
+  getStats(name: string): TimingStats | null;
+  /**
+   * Get all collected metrics
+   */
+  getAllStats(): Record<string, TimingStats>;
+  /**
+   * Reset all metrics
+   */
+  reset(): void;
+  /**
+   * Reset a specific metric
+   */
+  resetMetric(name: string): void;
 }
 /**
  * Global metrics collector instance
@@ -85,13 +84,13 @@ declare const metricsCollector: MetricsCollector;
  * });
  * ```
  */
-declare function createMetricsHandler(): () => Promise<_tanstack_react_start.JsonResponse<{
-    system: {
-        uptime: number;
-        memory: NodeJS.MemoryUsage;
-        timestamp: string;
-    };
-    application: Record<string, TimingStats>;
+declare function createMetricsHandler(): () => Promise<import("@tanstack/react-start").JsonResponse<{
+  system: {
+    uptime: number;
+    memory: NodeJS.MemoryUsage;
+    timestamp: string;
+  };
+  application: Record<string, TimingStats>;
 }>>;
 /**
  * Auto-record timing from a function execution
@@ -109,5 +108,6 @@ declare function createMetricsHandler(): () => Promise<_tanstack_react_start.Jso
  * ```
  */
 declare function recordTiming<T extends (...args: any[]) => any>(metricName: string, fn: T): T;
-
-export { type TimingStats, createMetricsHandler, metricsCollector, recordTiming };
+//#endregion
+export { TimingStats, createMetricsHandler, metricsCollector, recordTiming };
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","names":[],"sources":["../src/metrics.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,WAAA;EACf,KAAA;EACA,GAAA;EACA,GAAA;EACA,GAAA;EACA,GAAA;EACA,GAAA;AAAA;;;;;;;;;;;;;;;;;;;cAqBI,gBAAA;EAAA,QACI,OAAA;EAAA,iBACS,UAAA;EAyEmC;;;EApEpD,YAAA,CAAa,IAAA,UAAc,QAAA;EA4Fb;;;EA3Ed,QAAA,CAAS,IAAA,WAAe,WAAA;;;;EAsBxB,WAAA,IAAe,MAAA,SAAe,WAAA;EAqDI;;;EAvClC,KAAA;;;;EAOA,WAAA,CAAY,IAAA;AAAA;;;;cAQD,gBAAA,EAAgB,gBAAyB;;AAsDtD;;;;;;;;;;;AAGI;;;;;;;;;;iBAjCY,oBAAA,UAAoB,OAAA,iCAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;iBA8BpB,YAAA,eAA2B,IAAA,iBACzC,UAAA,UACA,EAAA,EAAI,CAAA,GACH,CAAC"}

package/dist/metrics.js

@@ -1,4 +1,145 @@
-export { createMetricsHandler, metricsCollector, recordTiming } from './chunk-G526TOMY.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=metrics.js.map
+//#region src/metrics.ts
+/**
+* Metrics collector for performance data
+*
+* Collects timing metrics and provides statistical analysis.
+* Thread-safe for concurrent access.
+*
+* @example
+* ```typescript
+* import { metricsCollector } from 'autotel-tanstack/metrics';
+*
+* // Record a timing
+* metricsCollector.recordTiming('serverFn.getUser', 150);
+*
+* // Get stats
+* const stats = metricsCollector.getStats('serverFn.getUser');
+* console.log(`Average: ${stats.avg}ms, P95: ${stats.p95}ms`);
+* ```
+*/
+var MetricsCollector = class {
+	metrics = /* @__PURE__ */ new Map();
+	maxSamples = 1e3;
+	/**
+	* Record a timing measurement
+	*/
+	recordTiming(name, duration) {
+		if (!this.metrics.has(name)) this.metrics.set(name, []);
+		const timings = this.metrics.get(name);
+		timings.push(duration);
+		if (timings.length > this.maxSamples) timings.shift();
+	}
+	/**
+	* Get statistics for a metric
+	*/
+	getStats(name) {
+		const timings = this.metrics.get(name);
+		if (!timings || timings.length === 0) return null;
+		const sorted = [...timings].toSorted((a, b) => a - b);
+		const sum = timings.reduce((a, b) => a + b, 0);
+		return {
+			count: timings.length,
+			avg: sum / timings.length,
+			p50: sorted.at(Math.floor(sorted.length * .5)) ?? 0,
+			p95: sorted.at(Math.floor(sorted.length * .95)) ?? 0,
+			min: sorted[0] ?? 0,
+			max: sorted.at(-1) ?? 0
+		};
+	}
+	/**
+	* Get all collected metrics
+	*/
+	getAllStats() {
+		const stats = {};
+		for (const [name] of this.metrics) {
+			const stat = this.getStats(name);
+			if (stat) stats[name] = stat;
+		}
+		return stats;
+	}
+	/**
+	* Reset all metrics
+	*/
+	reset() {
+		this.metrics.clear();
+	}
+	/**
+	* Reset a specific metric
+	*/
+	resetMetric(name) {
+		this.metrics.delete(name);
+	}
+};
+/**
+* Global metrics collector instance
+*/
+const metricsCollector = new MetricsCollector();
+/**
+* Helper to create a metrics endpoint handler
+*
+* Returns a handler that exposes metrics in JSON format.
+* Use this to create a `/metrics` endpoint.
+*
+* @example
+* ```typescript
+* // routes/metrics.ts
+* import { createFileRoute } from '@tanstack/react-router';
+* import { json } from '@tanstack/react-start';
+* import { createMetricsHandler } from 'autotel-tanstack/metrics';
+*
+* export const Route = createFileRoute('/metrics')({
+*   server: {
+*     handlers: {
+*       GET: createMetricsHandler(),
+*     },
+*   },
+* });
+* ```
+*/
+function createMetricsHandler() {
+	return async () => {
+		const { json } = await import("@tanstack/react-start");
+		return json({
+			system: {
+				uptime: process.uptime(),
+				memory: process.memoryUsage(),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			application: metricsCollector.getAllStats()
+		});
+	};
+}
+/**
+* Auto-record timing from a function execution
+*
+* Wraps a function to automatically record its execution time.
+*
+* @example
+* ```typescript
+* import { recordTiming } from 'autotel-tanstack/metrics';
+*
+* const getUser = createServerFn({ method: 'GET' })
+*   .handler(recordTiming('serverFn.getUser', async ({ data: id }) => {
+*     return await db.users.findUnique({ where: { id } });
+*   }));
+* ```
+*/
+function recordTiming(metricName, fn) {
+	return (async (...args) => {
+		const startTime = Date.now();
+		try {
+			const result = await fn(...args);
+			const duration = Date.now() - startTime;
+			metricsCollector.recordTiming(metricName, duration);
+			return result;
+		} catch (error) {
+			const duration = Date.now() - startTime;
+			metricsCollector.recordTiming(`${metricName}.error`, duration);
+			throw error;
+		}
+	});
+}
+
+//#endregion
+export { createMetricsHandler, metricsCollector, recordTiming };
 //# sourceMappingURL=metrics.js.map

package/dist/metrics.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"metrics.js"}
+{"version":3,"file":"metrics.js","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["/**\n * Performance metrics collection for TanStack Start\n *\n * Provides utilities to collect and expose performance metrics\n * following the patterns from TanStack Start observability guide.\n */\n\n/**\n * Performance timing data\n */\nexport interface TimingStats {\n  count: number;\n  avg: number;\n  p50: number;\n  p95: number;\n  min: number;\n  max: number;\n}\n\n/**\n * Metrics collector for performance data\n *\n * Collects timing metrics and provides statistical analysis.\n * Thread-safe for concurrent access.\n *\n * @example\n * ```typescript\n * import { metricsCollector } from 'autotel-tanstack/metrics';\n *\n * // Record a timing\n * metricsCollector.recordTiming('serverFn.getUser', 150);\n *\n * // Get stats\n * const stats = metricsCollector.getStats('serverFn.getUser');\n * console.log(`Average: ${stats.avg}ms, P95: ${stats.p95}ms`);\n * ```\n */\nclass MetricsCollector {\n  private metrics = new Map<string, number[]>();\n  private readonly maxSamples = 1000; // Limit memory usage\n\n  /**\n   * Record a timing measurement\n   */\n  recordTiming(name: string, duration: number): void {\n    if (!this.metrics.has(name)) {\n      this.metrics.set(name, []);\n    }\n\n    const timings = this.metrics.get(name)!;\n    timings.push(duration);\n\n    // Limit samples to prevent memory issues\n    if (timings.length > this.maxSamples) {\n      timings.shift(); // Remove oldest\n    }\n  }\n\n  /**\n   * Get statistics for a metric\n   */\n  getStats(name: string): TimingStats | null {\n    const timings = this.metrics.get(name);\n    if (!timings || timings.length === 0) {\n      return null;\n    }\n\n    const sorted = [...timings].toSorted((a, b) => a - b);\n    const sum = timings.reduce((a, b) => a + b, 0);\n\n    return {\n      count: timings.length,\n      avg: sum / timings.length,\n      p50: sorted.at(Math.floor(sorted.length * 0.5)) ?? 0,\n      p95: sorted.at(Math.floor(sorted.length * 0.95)) ?? 0,\n      min: sorted[0] ?? 0,\n      max: sorted.at(-1) ?? 0,\n    };\n  }\n\n  /**\n   * Get all collected metrics\n   */\n  getAllStats(): Record<string, TimingStats> {\n    const stats: Record<string, TimingStats> = {};\n    for (const [name] of this.metrics) {\n      const stat = this.getStats(name);\n      if (stat) {\n        stats[name] = stat;\n      }\n    }\n    return stats;\n  }\n\n  /**\n   * Reset all metrics\n   */\n  reset(): void {\n    this.metrics.clear();\n  }\n\n  /**\n   * Reset a specific metric\n   */\n  resetMetric(name: string): void {\n    this.metrics.delete(name);\n  }\n}\n\n/**\n * Global metrics collector instance\n */\nexport const metricsCollector = new MetricsCollector();\n\n/**\n * Helper to create a metrics endpoint handler\n *\n * Returns a handler that exposes metrics in JSON format.\n * Use this to create a `/metrics` endpoint.\n *\n * @example\n * ```typescript\n * // routes/metrics.ts\n * import { createFileRoute } from '@tanstack/react-router';\n * import { json } from '@tanstack/react-start';\n * import { createMetricsHandler } from 'autotel-tanstack/metrics';\n *\n * export const Route = createFileRoute('/metrics')({\n *   server: {\n *     handlers: {\n *       GET: createMetricsHandler(),\n *     },\n *   },\n * });\n * ```\n */\nexport function createMetricsHandler() {\n  return async () => {\n    const { json } = await import('@tanstack/react-start');\n\n    return json({\n      system: {\n        uptime: process.uptime(),\n        memory: process.memoryUsage(),\n        timestamp: new Date().toISOString(),\n      },\n      application: metricsCollector.getAllStats(),\n    });\n  };\n}\n\n/**\n * Auto-record timing from a function execution\n *\n * Wraps a function to automatically record its execution time.\n *\n * @example\n * ```typescript\n * import { recordTiming } from 'autotel-tanstack/metrics';\n *\n * const getUser = createServerFn({ method: 'GET' })\n *   .handler(recordTiming('serverFn.getUser', async ({ data: id }) => {\n *     return await db.users.findUnique({ where: { id } });\n *   }));\n * ```\n */\nexport function recordTiming<T extends (...args: any[]) => any>(\n  metricName: string,\n  fn: T,\n): T {\n  return (async (...args: Parameters<T>) => {\n    const startTime = Date.now();\n    try {\n      const result = await fn(...args);\n      const duration = Date.now() - startTime;\n      metricsCollector.recordTiming(metricName, duration);\n      return result as ReturnType<T>;\n    } catch (error) {\n      const duration = Date.now() - startTime;\n      metricsCollector.recordTiming(`${metricName}.error`, duration);\n      throw error;\n    }\n  }) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqCA,IAAM,mBAAN,MAAuB;CACrB,AAAQ,0BAAU,IAAI,IAAsB;CAC5C,AAAiB,aAAa;;;;CAK9B,aAAa,MAAc,UAAwB;EACjD,IAAI,CAAC,KAAK,QAAQ,IAAI,IAAI,GACxB,KAAK,QAAQ,IAAI,MAAM,CAAC,CAAC;EAG3B,MAAM,UAAU,KAAK,QAAQ,IAAI,IAAI;EACrC,QAAQ,KAAK,QAAQ;EAGrB,IAAI,QAAQ,SAAS,KAAK,YACxB,QAAQ,MAAM;CAElB;;;;CAKA,SAAS,MAAkC;EACzC,MAAM,UAAU,KAAK,QAAQ,IAAI,IAAI;EACrC,IAAI,CAAC,WAAW,QAAQ,WAAW,GACjC,OAAO;EAGT,MAAM,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,UAAU,GAAG,MAAM,IAAI,CAAC;EACpD,MAAM,MAAM,QAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC;EAE7C,OAAO;GACL,OAAO,QAAQ;GACf,KAAK,MAAM,QAAQ;GACnB,KAAK,OAAO,GAAG,KAAK,MAAM,OAAO,SAAS,EAAG,CAAC,KAAK;GACnD,KAAK,OAAO,GAAG,KAAK,MAAM,OAAO,SAAS,GAAI,CAAC,KAAK;GACpD,KAAK,OAAO,MAAM;GAClB,KAAK,OAAO,GAAG,EAAE,KAAK;EACxB;CACF;;;;CAKA,cAA2C;EACzC,MAAM,QAAqC,CAAC;EAC5C,KAAK,MAAM,CAAC,SAAS,KAAK,SAAS;GACjC,MAAM,OAAO,KAAK,SAAS,IAAI;GAC/B,IAAI,MACF,MAAM,QAAQ;EAElB;EACA,OAAO;CACT;;;;CAKA,QAAc;EACZ,KAAK,QAAQ,MAAM;CACrB;;;;CAKA,YAAY,MAAoB;EAC9B,KAAK,QAAQ,OAAO,IAAI;CAC1B;AACF;;;;AAKA,MAAa,mBAAmB,IAAI,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;AAwBrD,SAAgB,uBAAuB;CACrC,OAAO,YAAY;EACjB,MAAM,EAAE,SAAS,MAAM,OAAO;EAE9B,OAAO,KAAK;GACV,QAAQ;IACN,QAAQ,QAAQ,OAAO;IACvB,QAAQ,QAAQ,YAAY;IAC5B,4BAAW,IAAI,KAAK,EAAC,CAAC,YAAY;GACpC;GACA,aAAa,iBAAiB,YAAY;EAC5C,CAAC;CACH;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,aACd,YACA,IACG;CACH,QAAQ,OAAO,GAAG,SAAwB;EACxC,MAAM,YAAY,KAAK,IAAI;EAC3B,IAAI;GACF,MAAM,SAAS,MAAM,GAAG,GAAG,IAAI;GAC/B,MAAM,WAAW,KAAK,IAAI,IAAI;GAC9B,iBAAiB,aAAa,YAAY,QAAQ;GAClD,OAAO;EACT,SAAS,OAAO;GACd,MAAM,WAAW,KAAK,IAAI,IAAI;GAC9B,iBAAiB,aAAa,GAAG,WAAW,SAAS,QAAQ;GAC7D,MAAM;EACR;CACF;AACF"}

package/dist/middleware.d.ts

@@ -1,6 +1,6 @@
-import { c as TracingMiddlewareConfig } from './types-m5OjZJ-4.js';
-import '@opentelemetry/api';
+import { o as TracingMiddlewareConfig } from "./types-pQgmQa4j.js";
 
+//#region src/middleware.d.ts
 /**
  * Generic middleware handler type (compatible with TanStack's middleware pattern)
  *
@@ -8,17 +8,17 @@ import '@opentelemetry/api';
  * We use a generic type to avoid direct dependency on TanStack packages.
  */
 interface MiddlewareHandler<TContext = unknown> {
-    (opts: {
-        next: (ctx?: Partial<TContext>) => Promise<TContext>;
-        context: TContext;
-        request?: Request;
-        pathname?: string;
-        data?: unknown;
-        method?: string;
-        filename?: string;
-        functionId?: string;
-        signal?: AbortSignal;
-    }): Promise<TContext>;
+  (opts: {
+    next: (ctx?: Partial<TContext>) => Promise<TContext>;
+    context: TContext;
+    request?: Request;
+    pathname?: string;
+    data?: unknown;
+    method?: string;
+    filename?: string;
+    functionId?: string;
+    signal?: AbortSignal;
+  }): Promise<TContext>;
 }
 /**
  * Create a TanStack-compatible tracing middleware
@@ -143,5 +143,6 @@ declare function functionTracingMiddleware<TContext = unknown>(config?: Omit<Tra
  * ```
  */
 declare function createTracingServerHandler<TContext = unknown>(config?: TracingMiddlewareConfig): (opts: any) => any;
-
-export { type MiddlewareHandler, createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware };
+//#endregion
+export { MiddlewareHandler, createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware };
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../src/middleware.ts"],"mappings":";;;;;AAgFA;;;;UAAiB,iBAAA;EAAA,CACd,IAAA;IACC,IAAA,GAAO,GAAA,GAAM,OAAA,CAAQ,QAAA,MAAc,OAAA,CAAQ,QAAA;IAC3C,OAAA,EAAS,QAAA;IACT,OAAA,GAAU,OAAA;IACV,QAAA;IACA,IAAA;IACA,MAAA;IACA,QAAA;IACA,UAAA;IACA,MAAA,GAAS,WAAA;EAAA,IACP,OAAA,CAAQ,QAAA;AAAA;;;;;;;;;;;;;;;;;;;;AAAQ;AAyCtB;;;;;;;;;;;;;;AAE6B;AAiN7B;;;iBAnNgB,uBAAA,qBACd,MAAA,GAAS,uBAAA,GACR,iBAAA,CAAkB,QAAA;;;;;;;;;;;AAmNQ;AA6B7B;;;;;;;;iBA/BgB,iBAAA,qBACd,MAAA,GAAS,uBAAA,GACR,iBAAA,CAAkB,QAAA;;;;;;;;AA+BQ;AAiD7B;;;;;;;;;AAEa;;;iBArDG,yBAAA,qBACd,MAAA,GAAS,IAAA,CAAK,uBAAA,YACb,iBAAA,CAAkB,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDL,0BAAA,qBACd,MAAA,GAAS,uBAAuB,IAC9B,IAAA"}

package/dist/middleware.js

@@ -1,8 +1,291 @@
-export { createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware } from './chunk-LRA2UVVS.js';
-import './chunk-EUYFVNYE.js';
-import './chunk-CCME55EK.js';
-import './chunk-I4LX3LOG.js';
-import './chunk-NTY64BKS.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=middleware.js.map
+import { n as SPAN_ATTRIBUTES, t as DEFAULT_CONFIG } from "./types-BrccP0yX.js";
+import { extractContextFromRequest } from "./context.js";
+import { r as isServerSide } from "./env-BpFWNnpL.js";
+import { t as isExcludedPath } from "./route-filter-dLg-j3jR.js";
+import { SpanStatusCode, context } from "@opentelemetry/api";
+import { trace } from "autotel";
+
+//#region src/middleware.ts
+/**
+* Build span attributes for HTTP requests
+*/
+function buildRequestAttributes(request, config) {
+	const url = new URL(request.url);
+	const attrs = {
+		[SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
+		[SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
+		[SPAN_ATTRIBUTES.TANSTACK_TYPE]: "request"
+	};
+	if (url.search) attrs[SPAN_ATTRIBUTES.URL_QUERY] = url.search;
+	if (config.captureHeaders) for (const header of config.captureHeaders) {
+		const value = request.headers.get(header);
+		if (value) attrs[`http.request.header.${header.toLowerCase()}`] = value;
+	}
+	return attrs;
+}
+/**
+* Build span attributes for server functions
+*/
+function buildServerFnAttributes(functionName, method, args, config) {
+	const attrs = {
+		[SPAN_ATTRIBUTES.RPC_SYSTEM]: "tanstack-start",
+		[SPAN_ATTRIBUTES.RPC_METHOD]: functionName,
+		[SPAN_ATTRIBUTES.TANSTACK_TYPE]: "serverFn",
+		[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_NAME]: functionName,
+		[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_METHOD]: method
+	};
+	if (config.captureArgs && args !== void 0) try {
+		attrs[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS] = JSON.stringify(args);
+	} catch {
+		attrs[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS] = "[non-serializable]";
+	}
+	return attrs;
+}
+/**
+* Create a TanStack-compatible tracing middleware
+*
+* This creates middleware that automatically traces all requests/server functions
+* with OpenTelemetry spans. Use with TanStack Start's middleware system.
+*
+* @param config - Configuration options
+* @returns Middleware handler compatible with TanStack Start
+*
+* @example
+* ```typescript
+* // Global request middleware in app/start.ts
+* import { createStart } from '@tanstack/react-start';
+* import { createTracingMiddleware } from 'autotel-tanstack/middleware';
+*
+* export const startInstance = createStart(() => ({
+*   requestMiddleware: [
+*     createTracingMiddleware({
+*       captureHeaders: ['x-request-id', 'user-agent'],
+*       excludePaths: ['/health', '/metrics'],
+*     }),
+*   ],
+* }));
+* ```
+*
+* @example
+* ```typescript
+* // Server function middleware
+* import { createServerFn } from '@tanstack/react-start';
+* import { createTracingMiddleware } from 'autotel-tanstack/middleware';
+*
+* export const getUser = createServerFn({ method: 'GET' })
+*   .middleware([createTracingMiddleware({ type: 'function' })])
+*   .handler(async ({ data: id }) => {
+*     return await db.users.findUnique({ where: { id } });
+*   });
+* ```
+*/
+function createTracingMiddleware(config) {
+	const mergedConfig = {
+		...DEFAULT_CONFIG,
+		...config,
+		type: config?.type ?? "request"
+	};
+	return async function tracingMiddleware(opts) {
+		if (!isServerSide()) return opts.next();
+		const { next, request, pathname, data, functionId } = opts;
+		if (mergedConfig.type === "function") {
+			const fnName = functionId || "unknown";
+			const method = opts.method || "POST";
+			return trace(`tanstack.serverFn.${fnName}`, async (ctx) => {
+				const attrs = buildServerFnAttributes(fnName, method, data, mergedConfig);
+				ctx.setAttributes(attrs);
+				if (config?.customAttributes) {
+					const customAttrs = config.customAttributes({
+						type: "serverFn",
+						name: fnName,
+						args: data
+					});
+					ctx.setAttributes(customAttrs);
+				}
+				try {
+					const result = await next();
+					if (mergedConfig.captureResults && result !== void 0) try {
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT, JSON.stringify(result));
+					} catch {
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT, "[non-serializable]");
+					}
+					ctx.setStatus({ code: SpanStatusCode.OK });
+					return result;
+				} catch (error) {
+					if (mergedConfig.captureErrors) {
+						if ("recordError" in ctx && typeof ctx.recordError === "function") ctx.recordError(error);
+						else if ("recordException" in ctx && typeof ctx.recordException === "function") ctx.recordException(error);
+						try {
+							const { reportError } = await import("./error-reporting.js");
+							reportError(error, {
+								type: "serverFn",
+								name: fnName,
+								method
+							});
+						} catch {}
+					}
+					throw error;
+				}
+			});
+		}
+		if (!request) return next();
+		const url = new URL(request.url);
+		if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) return next();
+		const parentContext = extractContextFromRequest(request);
+		return context.with(parentContext, async () => {
+			const spanName = `${request.method} ${pathname || url.pathname}`;
+			return trace(spanName, async (ctx) => {
+				const attrs = buildRequestAttributes(request, mergedConfig);
+				ctx.setAttributes(attrs);
+				if (config?.customAttributes) {
+					const customAttrs = config.customAttributes({
+						type: "request",
+						name: spanName,
+						request
+					});
+					ctx.setAttributes(customAttrs);
+				}
+				const startTime = Date.now();
+				try {
+					const result = await next();
+					const duration = Date.now() - startTime;
+					ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+					try {
+						const { metricsCollector } = await import("./metrics.js");
+						metricsCollector.recordTiming(spanName, duration);
+					} catch {}
+					if (result && typeof result === "object" && "status" in result) ctx.setAttribute(SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE, result.status);
+					ctx.setStatus({ code: SpanStatusCode.OK });
+					return result;
+				} catch (error) {
+					const duration = Date.now() - startTime;
+					ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+					if (mergedConfig.captureErrors) {
+						if ("recordError" in ctx && typeof ctx.recordError === "function") ctx.recordError(error);
+						else if ("recordException" in ctx && typeof ctx.recordException === "function") ctx.recordException(error);
+						try {
+							const { reportError } = await import("./error-reporting.js");
+							reportError(error, {
+								type: "request",
+								method: request.method,
+								pathname: url.pathname
+							});
+						} catch {}
+					}
+					throw error;
+				}
+			});
+		});
+	};
+}
+/**
+* Pre-configured tracing middleware with sensible defaults
+*
+* Convenience export for quick setup. Uses adaptive sampling,
+* captures x-request-id header, and excludes common health check paths.
+*
+* @param config - Optional configuration overrides
+* @returns Middleware handler
+*
+* @example
+* ```typescript
+* import { createStart } from '@tanstack/react-start';
+* import { tracingMiddleware } from 'autotel-tanstack/middleware';
+*
+* export const startInstance = createStart(() => ({
+*   requestMiddleware: [tracingMiddleware()],
+* }));
+* ```
+*/
+function tracingMiddleware(config) {
+	return createTracingMiddleware({
+		sampling: "adaptive",
+		captureHeaders: ["x-request-id", "user-agent"],
+		excludePaths: [
+			"/health",
+			"/healthz",
+			"/ready",
+			"/metrics",
+			"/_ping"
+		],
+		...config
+	});
+}
+/**
+* Create function-specific tracing middleware
+*
+* Convenience wrapper for server function middleware.
+*
+* @param config - Optional configuration
+* @returns Middleware handler for server functions
+*
+* @example
+* ```typescript
+* import { createServerFn } from '@tanstack/react-start';
+* import { functionTracingMiddleware } from 'autotel-tanstack/middleware';
+*
+* export const getUser = createServerFn({ method: 'GET' })
+*   .middleware([functionTracingMiddleware()])
+*   .handler(async ({ data: id }) => {
+*     return await db.users.findUnique({ where: { id } });
+*   });
+* ```
+*/
+function functionTracingMiddleware(config) {
+	return createTracingMiddleware({
+		...config,
+		type: "function"
+	});
+}
+/**
+* Create a tracing handler for use with TanStack's native createMiddleware()
+*
+* This provides the raw tracing logic that you can pass to createMiddleware().server().
+* Use this when you want full control over the middleware builder pattern.
+*
+* The handler accepts TanStack's middleware signature `{ next, context, request }`
+* and internally adapts it to our more flexible MiddlewareHandler interface.
+*
+* @param config - Configuration options
+* @returns Server handler function compatible with createMiddleware().server()
+*
+* @example
+* ```typescript
+* import { createStart, createMiddleware } from '@tanstack/react-start';
+* import { createTracingServerHandler } from 'autotel-tanstack/middleware';
+*
+* // TanStack-native middleware creation
+* const requestTracingMiddleware = createMiddleware().server(
+*   createTracingServerHandler({ captureHeaders: ['x-request-id'] })
+* );
+*
+* export const start = createStart(() => ({
+*   requestMiddleware: [requestTracingMiddleware],
+* }));
+* ```
+*
+* @example
+* ```typescript
+* // For server functions - use createMiddleware({ type: 'function' })
+* import { createStart, createMiddleware } from '@tanstack/react-start';
+* import { createTracingServerHandler } from 'autotel-tanstack/middleware';
+*
+* const functionTracingMiddleware = createMiddleware({ type: 'function' }).server(
+*   createTracingServerHandler({ type: 'function', captureArgs: true })
+* );
+*
+* export const start = createStart(() => ({
+*   functionMiddleware: [functionTracingMiddleware],
+* }));
+* ```
+*/
+function createTracingServerHandler(config) {
+	const handler = createTracingMiddleware(config);
+	return async (opts) => {
+		return handler(opts);
+	};
+}
+
+//#endregion
+export { createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware };
 //# sourceMappingURL=middleware.js.map