autotel-tanstack 1.13.30 → 1.13.31

package/dist/middleware.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"middleware.js"}
+{"version":3,"file":"middleware.js","names":[],"sources":["../src/middleware.ts"],"sourcesContent":["import { context, SpanStatusCode, type Attributes } from '@opentelemetry/api';\nimport { trace, type TraceContext } from 'autotel';\nimport { extractContextFromRequest } from './context';\nimport { isServerSide } from './env';\nimport { isExcludedPath } from './route-filter';\nimport {\n  type TracingMiddlewareConfig,\n  DEFAULT_CONFIG,\n  SPAN_ATTRIBUTES,\n} from './types';\n\n/**\n * Build span attributes for HTTP requests\n */\nfunction buildRequestAttributes(\n  request: Request,\n  config: Required<\n    Omit<TracingMiddlewareConfig, 'customAttributes' | 'service' | 'type'>\n  >,\n): Attributes {\n  const url = new URL(request.url);\n  const attrs: Attributes = {\n    [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,\n    [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,\n    [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',\n  };\n\n  if (url.search) {\n    attrs[SPAN_ATTRIBUTES.URL_QUERY] = url.search;\n  }\n\n  // Capture configured headers\n  if (config.captureHeaders) {\n    for (const header of config.captureHeaders) {\n      const value = request.headers.get(header);\n      if (value) {\n        attrs[`http.request.header.${header.toLowerCase()}`] = value;\n      }\n    }\n  }\n\n  return attrs;\n}\n\n/**\n * Build span attributes for server functions\n */\nfunction buildServerFnAttributes(\n  functionName: string,\n  method: string,\n  args: unknown,\n  config: Required<\n    Omit<TracingMiddlewareConfig, 'customAttributes' | 'service' | 'type'>\n  >,\n): Attributes {\n  const attrs: Attributes = {\n    [SPAN_ATTRIBUTES.RPC_SYSTEM]: 'tanstack-start',\n    [SPAN_ATTRIBUTES.RPC_METHOD]: functionName,\n    [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'serverFn',\n    [SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_NAME]: functionName,\n    [SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_METHOD]: method,\n  };\n\n  if (config.captureArgs && args !== undefined) {\n    try {\n      attrs[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS] = JSON.stringify(args);\n    } catch {\n      attrs[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS] = '[non-serializable]';\n    }\n  }\n\n  return attrs;\n}\n\n/**\n * Generic middleware handler type (compatible with TanStack's middleware pattern)\n *\n * This type represents the shape of TanStack middleware handlers.\n * We use a generic type to avoid direct dependency on TanStack packages.\n */\nexport interface MiddlewareHandler<TContext = unknown> {\n  (opts: {\n    next: (ctx?: Partial<TContext>) => Promise<TContext>;\n    context: TContext;\n    request?: Request;\n    pathname?: string;\n    data?: unknown;\n    method?: string;\n    filename?: string;\n    functionId?: string;\n    signal?: AbortSignal;\n  }): Promise<TContext>;\n}\n\n/**\n * Create a TanStack-compatible tracing middleware\n *\n * This creates middleware that automatically traces all requests/server functions\n * with OpenTelemetry spans. Use with TanStack Start's middleware system.\n *\n * @param config - Configuration options\n * @returns Middleware handler compatible with TanStack Start\n *\n * @example\n * ```typescript\n * // Global request middleware in app/start.ts\n * import { createStart } from '@tanstack/react-start';\n * import { createTracingMiddleware } from 'autotel-tanstack/middleware';\n *\n * export const startInstance = createStart(() => ({\n *   requestMiddleware: [\n *     createTracingMiddleware({\n *       captureHeaders: ['x-request-id', 'user-agent'],\n *       excludePaths: ['/health', '/metrics'],\n *     }),\n *   ],\n * }));\n * ```\n *\n * @example\n * ```typescript\n * // Server function middleware\n * import { createServerFn } from '@tanstack/react-start';\n * import { createTracingMiddleware } from 'autotel-tanstack/middleware';\n *\n * export const getUser = createServerFn({ method: 'GET' })\n *   .middleware([createTracingMiddleware({ type: 'function' })])\n *   .handler(async ({ data: id }) => {\n *     return await db.users.findUnique({ where: { id } });\n *   });\n * ```\n */\nexport function createTracingMiddleware<TContext = unknown>(\n  config?: TracingMiddlewareConfig,\n): MiddlewareHandler<TContext> {\n  const mergedConfig = {\n    ...DEFAULT_CONFIG,\n    ...config,\n    type: config?.type ?? 'request',\n  };\n\n  return async function tracingMiddleware(opts) {\n    // If we're in the browser, return a no-op middleware\n    // This prevents autotel (which uses Node.js APIs) from being bundled/executed in the browser\n    if (!isServerSide()) {\n      return opts.next();\n    }\n    const { next, request, pathname, data, functionId } = opts;\n\n    // For function middleware\n    if (mergedConfig.type === 'function') {\n      const fnName = functionId || 'unknown';\n      const method = (opts as { method?: string }).method || 'POST';\n\n      return trace(`tanstack.serverFn.${fnName}`, async (ctx: TraceContext) => {\n        const attrs = buildServerFnAttributes(\n          fnName,\n          method,\n          data,\n          mergedConfig,\n        );\n        ctx.setAttributes(attrs as Record<string, string | number | boolean>);\n\n        // Add custom attributes if provided\n        if (config?.customAttributes) {\n          const customAttrs = config.customAttributes({\n            type: 'serverFn',\n            name: fnName,\n            args: data,\n          });\n          ctx.setAttributes(\n            customAttrs as Record<string, string | number | boolean>,\n          );\n        }\n\n        try {\n          const result = await next();\n\n          // Capture result if configured\n          if (mergedConfig.captureResults && result !== undefined) {\n            try {\n              ctx.setAttribute(\n                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT,\n                JSON.stringify(result),\n              );\n            } catch {\n              ctx.setAttribute(\n                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT,\n                '[non-serializable]',\n              );\n            }\n          }\n\n          ctx.setStatus({ code: SpanStatusCode.OK });\n          return result;\n        } catch (error) {\n          if (mergedConfig.captureErrors) {\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            // Report error to error store\n            try {\n              const { reportError } = await import('./error-reporting');\n              reportError(error as Error, {\n                type: 'serverFn',\n                name: fnName,\n                method,\n              });\n            } catch {\n              // Error reporting not available, skip\n            }\n          }\n          throw error;\n        }\n      }) as Promise<TContext>;\n    }\n\n    // For request middleware\n    if (!request) {\n      // No request available, just pass through\n      return next();\n    }\n\n    const url = new URL(request.url);\n\n    // Check if path should be excluded\n    if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {\n      return next();\n    }\n\n    // Extract parent context from request headers\n    const parentContext = extractContextFromRequest(request);\n\n    // Run within parent context for distributed tracing\n    return context.with(parentContext, async () => {\n      const spanName = `${request.method} ${pathname || url.pathname}`;\n\n      return trace(spanName, async (ctx: TraceContext) => {\n        const attrs = buildRequestAttributes(request, mergedConfig);\n        ctx.setAttributes(attrs as Record<string, string | number | boolean>);\n\n        // Add custom attributes if provided\n        if (config?.customAttributes) {\n          const customAttrs = config.customAttributes({\n            type: 'request',\n            name: spanName,\n            request,\n          });\n          ctx.setAttributes(\n            customAttrs as Record<string, string | number | boolean>,\n          );\n        }\n\n        const startTime = Date.now();\n\n        try {\n          const result = await next();\n\n          const duration = Date.now() - startTime;\n          ctx.setAttribute(\n            SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n            duration,\n          );\n\n          // Record timing in metrics collector\n          try {\n            const { metricsCollector } = await import('./metrics');\n            metricsCollector.recordTiming(spanName, duration);\n          } catch {\n            // Metrics not available, skip\n          }\n\n          // Try to get response status from result if it's a Response\n          if (result && typeof result === 'object' && 'status' in result) {\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,\n              (result as { status: number }).status,\n            );\n          }\n\n          ctx.setStatus({ code: SpanStatusCode.OK });\n          return result;\n        } catch (error) {\n          const duration = Date.now() - startTime;\n          ctx.setAttribute(\n            SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n            duration,\n          );\n\n          if (mergedConfig.captureErrors) {\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            // Report error to error store\n            try {\n              const { reportError } = await import('./error-reporting');\n              reportError(error as Error, {\n                type: 'request',\n                method: request.method,\n                pathname: url.pathname,\n              });\n            } catch {\n              // Error reporting not available, skip\n            }\n          }\n          throw error;\n        }\n      }) as Promise<TContext>;\n    });\n  };\n}\n\n/**\n * Pre-configured tracing middleware with sensible defaults\n *\n * Convenience export for quick setup. Uses adaptive sampling,\n * captures x-request-id header, and excludes common health check paths.\n *\n * @param config - Optional configuration overrides\n * @returns Middleware handler\n *\n * @example\n * ```typescript\n * import { createStart } from '@tanstack/react-start';\n * import { tracingMiddleware } from 'autotel-tanstack/middleware';\n *\n * export const startInstance = createStart(() => ({\n *   requestMiddleware: [tracingMiddleware()],\n * }));\n * ```\n */\nexport function tracingMiddleware<TContext = unknown>(\n  config?: TracingMiddlewareConfig,\n): MiddlewareHandler<TContext> {\n  return createTracingMiddleware({\n    sampling: 'adaptive',\n    captureHeaders: ['x-request-id', 'user-agent'],\n    excludePaths: ['/health', '/healthz', '/ready', '/metrics', '/_ping'],\n    ...config,\n  });\n}\n\n/**\n * Create function-specific tracing middleware\n *\n * Convenience wrapper for server function middleware.\n *\n * @param config - Optional configuration\n * @returns Middleware handler for server functions\n *\n * @example\n * ```typescript\n * import { createServerFn } from '@tanstack/react-start';\n * import { functionTracingMiddleware } from 'autotel-tanstack/middleware';\n *\n * export const getUser = createServerFn({ method: 'GET' })\n *   .middleware([functionTracingMiddleware()])\n *   .handler(async ({ data: id }) => {\n *     return await db.users.findUnique({ where: { id } });\n *   });\n * ```\n */\nexport function functionTracingMiddleware<TContext = unknown>(\n  config?: Omit<TracingMiddlewareConfig, 'type'>,\n): MiddlewareHandler<TContext> {\n  return createTracingMiddleware({\n    ...config,\n    type: 'function',\n  });\n}\n\n/**\n * Create a tracing handler for use with TanStack's native createMiddleware()\n *\n * This provides the raw tracing logic that you can pass to createMiddleware().server().\n * Use this when you want full control over the middleware builder pattern.\n *\n * The handler accepts TanStack's middleware signature `{ next, context, request }`\n * and internally adapts it to our more flexible MiddlewareHandler interface.\n *\n * @param config - Configuration options\n * @returns Server handler function compatible with createMiddleware().server()\n *\n * @example\n * ```typescript\n * import { createStart, createMiddleware } from '@tanstack/react-start';\n * import { createTracingServerHandler } from 'autotel-tanstack/middleware';\n *\n * // TanStack-native middleware creation\n * const requestTracingMiddleware = createMiddleware().server(\n *   createTracingServerHandler({ captureHeaders: ['x-request-id'] })\n * );\n *\n * export const start = createStart(() => ({\n *   requestMiddleware: [requestTracingMiddleware],\n * }));\n * ```\n *\n * @example\n * ```typescript\n * // For server functions - use createMiddleware({ type: 'function' })\n * import { createStart, createMiddleware } from '@tanstack/react-start';\n * import { createTracingServerHandler } from 'autotel-tanstack/middleware';\n *\n * const functionTracingMiddleware = createMiddleware({ type: 'function' }).server(\n *   createTracingServerHandler({ type: 'function', captureArgs: true })\n * );\n *\n * export const start = createStart(() => ({\n *   functionMiddleware: [functionTracingMiddleware],\n * }));\n * ```\n */\nexport function createTracingServerHandler<TContext = unknown>(\n  config?: TracingMiddlewareConfig,\n): (opts: any) => any {\n  const handler = createTracingMiddleware<TContext>(config);\n\n  // Adapt TanStack's signature to our handler\n  return async (opts: any) => {\n    return handler(opts);\n  };\n}\n"],"mappings":"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"}

package/dist/route-filter-dLg-j3jR.js

@@ -0,0 +1,33 @@
+import { shouldInstrumentPath } from "autotel-edge";
+
+//#region src/route-filter.ts
+/**
+* TanStack historically supported:
+* - glob strings (`/api/internal/*`)
+* - regex values
+* - plain-string prefix matching (`/health` matches `/healthz`)
+*
+* This helper keeps those semantics while delegating glob matching to
+* autotel-edge's shared middleware toolkit.
+*/
+function isExcludedPath(pathname, excludePaths) {
+	for (const pattern of excludePaths) {
+		if (pattern instanceof RegExp) {
+			if (pattern.test(pathname)) return true;
+			continue;
+		}
+		if (pattern.includes("*") || pattern.includes("?")) {
+			if (!shouldInstrumentPath(pathname, {
+				include: void 0,
+				exclude: [pattern]
+			})) return true;
+			continue;
+		}
+		if (pathname === pattern || pathname.startsWith(pattern)) return true;
+	}
+	return false;
+}
+
+//#endregion
+export { isExcludedPath as t };
+//# sourceMappingURL=route-filter-dLg-j3jR.js.map

package/dist/route-filter-dLg-j3jR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-filter-dLg-j3jR.js","names":[],"sources":["../src/route-filter.ts"],"sourcesContent":["import { shouldInstrumentPath } from 'autotel-edge';\n\n/**\n * TanStack historically supported:\n * - glob strings (`/api/internal/*`)\n * - regex values\n * - plain-string prefix matching (`/health` matches `/healthz`)\n *\n * This helper keeps those semantics while delegating glob matching to\n * autotel-edge's shared middleware toolkit.\n */\nexport function isExcludedPath(\n  pathname: string,\n  excludePaths: Array<string | RegExp>,\n): boolean {\n  for (const pattern of excludePaths) {\n    if (pattern instanceof RegExp) {\n      if (pattern.test(pathname)) return true;\n      continue;\n    }\n\n    if (pattern.includes('*') || pattern.includes('?')) {\n      if (\n        !shouldInstrumentPath(pathname, {\n          include: undefined,\n          exclude: [pattern],\n        })\n      ) {\n        return true;\n      }\n      continue;\n    }\n\n    if (pathname === pattern || pathname.startsWith(pattern)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,eACd,UACA,cACS;CACT,KAAK,MAAM,WAAW,cAAc;EAClC,IAAI,mBAAmB,QAAQ;GAC7B,IAAI,QAAQ,KAAK,QAAQ,GAAG,OAAO;GACnC;EACF;EAEA,IAAI,QAAQ,SAAS,GAAG,KAAK,QAAQ,SAAS,GAAG,GAAG;GAClD,IACE,CAAC,qBAAqB,UAAU;IAC9B,SAAS;IACT,SAAS,CAAC,OAAO;GACnB,CAAC,GAED,OAAO;GAET;EACF;EAEA,IAAI,aAAa,WAAW,SAAS,WAAW,OAAO,GACrD,OAAO;CAEX;CAEA,OAAO;AACT"}

package/dist/server-functions.d.ts

@@ -1,6 +1,6 @@
-import { b as TraceServerFnConfig } from './types-m5OjZJ-4.js';
-import '@opentelemetry/api';
+import { a as TraceServerFnConfig } from "./types-pQgmQa4j.js";
 
+//#region src/server-functions.d.ts
 /**
  * Wrap a TanStack server function with OpenTelemetry tracing
  *
@@ -67,5 +67,6 @@ declare function traceServerFn<T extends (...args: any[]) => any>(serverFn: T, c
  * ```
  */
 declare function createTracedServerFnFactory<TCreateServerFn extends (...args: any[]) => any>(createServerFnOriginal: TCreateServerFn, defaultConfig?: Omit<TraceServerFnConfig, 'name'>): TCreateServerFn;
-
+//#endregion
 export { createTracedServerFnFactory, traceServerFn };
+//# sourceMappingURL=server-functions.d.ts.map

package/dist/server-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-functions.d.ts","names":[],"sources":["../src/server-functions.ts"],"mappings":";;;;;AA6CA;;;;;;;;;;;;;;;;AAGI;AAwGJ;;;;;;;;;;;;;;;;;;AAKkB;;;iBAhHF,aAAA,eAA4B,IAAA,iBAC1C,QAAA,EAAU,CAAA,EACV,MAAA,GAAQ,mBAAA,GACP,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;iBAwGa,2BAAA,6BACc,IAAA,iBAE5B,sBAAA,EAAwB,eAAA,EACxB,aAAA,GAAe,IAAA,CAAK,mBAAA,YACnB,eAAA"}

package/dist/server-functions.js

@@ -1,6 +1,134 @@
-export { createTracedServerFnFactory, traceServerFn } from './chunk-ESU66L3L.js';
-import './chunk-EUYFVNYE.js';
-import './chunk-I4LX3LOG.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=server-functions.js.map
+import { n as SPAN_ATTRIBUTES } from "./types-BrccP0yX.js";
+import { r as isServerSide } from "./env-BpFWNnpL.js";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { trace } from "autotel";
+
+//#region src/server-functions.ts
+/**
+* Wrap a TanStack server function with OpenTelemetry tracing
+*
+* This function wraps a server function to automatically create spans
+* for each invocation. It captures function name, arguments (optionally),
+* results (optionally), and errors.
+*
+* @param serverFn - The server function to wrap
+* @param config - Configuration options
+* @returns Wrapped server function with tracing
+*
+* @example
+* ```typescript
+* import { createServerFn } from '@tanstack/react-start';
+* import { traceServerFn } from 'autotel-tanstack/server-functions';
+*
+* const getUserBase = createServerFn({ method: 'GET' })
+*   .handler(async ({ data: id }) => {
+*     return await db.users.findUnique({ where: { id } });
+*   });
+*
+* export const getUser = traceServerFn(getUserBase, { name: 'getUser' });
+* ```
+*
+* @example
+* ```typescript
+* // With argument and result capture (careful with PII!)
+* export const createUser = traceServerFn(
+*   createServerFn({ method: 'POST' })
+*     .handler(async ({ data }) => {
+*       return await db.users.create({ data });
+*     }),
+*   {
+*     name: 'createUser',
+*     captureArgs: true,
+*     captureResults: false, // Don't capture for PII reasons
+*   }
+* );
+* ```
+*/
+function traceServerFn(serverFn, config = {}) {
+	const fnName = config.name || serverFn.name || "serverFn";
+	const captureArgs = config.captureArgs ?? true;
+	const captureResults = config.captureResults ?? false;
+	return new Proxy(serverFn, {
+		apply(target, thisArg, argArray) {
+			if (!isServerSide()) return target.apply(thisArg, argArray);
+			return trace(`tanstack.serverFn.${fnName}`, async (ctx) => {
+				ctx.setAttributes({
+					[SPAN_ATTRIBUTES.RPC_SYSTEM]: "tanstack-start",
+					[SPAN_ATTRIBUTES.RPC_METHOD]: fnName,
+					[SPAN_ATTRIBUTES.TANSTACK_TYPE]: "serverFn",
+					[SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_NAME]: fnName
+				});
+				if (captureArgs && argArray.length > 0) {
+					const args = argArray[0];
+					if (args !== void 0) try {
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS, JSON.stringify(args));
+					} catch {
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS, "[non-serializable]");
+					}
+				}
+				try {
+					const result = await Reflect.apply(target, thisArg, argArray);
+					if (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 ("recordError" in ctx && typeof ctx.recordError === "function") ctx.recordError(error);
+					else if ("recordException" in ctx && typeof ctx.recordException === "function") ctx.recordException(error);
+					throw error;
+				}
+			});
+		},
+		get(target, prop, receiver) {
+			return Reflect.get(target, prop, receiver);
+		}
+	});
+}
+/**
+* Create a traced version of createServerFn
+*
+* This higher-order function wraps TanStack's createServerFn to automatically
+* add tracing to all created server functions.
+*
+* @param createServerFnOriginal - The original createServerFn from TanStack
+* @param defaultConfig - Default configuration for all server functions
+* @returns Wrapped createServerFn that produces traced server functions
+*
+* @example
+* ```typescript
+* import { createServerFn as originalCreateServerFn } from '@tanstack/react-start';
+* import { createTracedServerFnFactory } from 'autotel-tanstack/server-functions';
+*
+* export const createServerFn = createTracedServerFnFactory(originalCreateServerFn);
+*
+* // Now all server functions created with createServerFn are automatically traced
+* export const getUser = createServerFn({ method: 'GET' })
+*   .handler(async ({ data: id }) => {
+*     return await db.users.findUnique({ where: { id } });
+*   });
+* ```
+*/
+function createTracedServerFnFactory(createServerFnOriginal, defaultConfig = {}) {
+	return new Proxy(createServerFnOriginal, { apply(target, thisArg, argArray) {
+		const result = Reflect.apply(target, thisArg, argArray);
+		if (result && typeof result === "object" && "handler" in result && typeof result.handler === "function") {
+			const originalHandler = result.handler.bind(result);
+			result.handler = function tracedHandler(handlerFn) {
+				const wrappedHandler = originalHandler(handlerFn);
+				const fnName = handlerFn?.name || "serverFn";
+				return traceServerFn(wrappedHandler, {
+					...defaultConfig,
+					name: fnName
+				});
+			};
+		}
+		return result;
+	} });
+}
+
+//#endregion
+export { createTracedServerFnFactory, traceServerFn };
 //# sourceMappingURL=server-functions.js.map

package/dist/server-functions.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"server-functions.js"}
+{"version":3,"file":"server-functions.js","names":[],"sources":["../src/server-functions.ts"],"sourcesContent":["import { SpanStatusCode } from '@opentelemetry/api';\nimport { trace, type TraceContext } from 'autotel';\nimport { isServerSide } from './env';\nimport { type TraceServerFnConfig, SPAN_ATTRIBUTES } from './types';\n\n/**\n * Wrap a TanStack server function with OpenTelemetry tracing\n *\n * This function wraps a server function to automatically create spans\n * for each invocation. It captures function name, arguments (optionally),\n * results (optionally), and errors.\n *\n * @param serverFn - The server function to wrap\n * @param config - Configuration options\n * @returns Wrapped server function with tracing\n *\n * @example\n * ```typescript\n * import { createServerFn } from '@tanstack/react-start';\n * import { traceServerFn } from 'autotel-tanstack/server-functions';\n *\n * const getUserBase = createServerFn({ method: 'GET' })\n *   .handler(async ({ data: id }) => {\n *     return await db.users.findUnique({ where: { id } });\n *   });\n *\n * export const getUser = traceServerFn(getUserBase, { name: 'getUser' });\n * ```\n *\n * @example\n * ```typescript\n * // With argument and result capture (careful with PII!)\n * export const createUser = traceServerFn(\n *   createServerFn({ method: 'POST' })\n *     .handler(async ({ data }) => {\n *       return await db.users.create({ data });\n *     }),\n *   {\n *     name: 'createUser',\n *     captureArgs: true,\n *     captureResults: false, // Don't capture for PII reasons\n *   }\n * );\n * ```\n */\nexport function traceServerFn<T extends (...args: any[]) => any>(\n  serverFn: T,\n  config: TraceServerFnConfig = {},\n): T {\n  const fnName = config.name || serverFn.name || 'serverFn';\n  const captureArgs = config.captureArgs ?? true;\n  const captureResults = config.captureResults ?? false;\n\n  return new Proxy(serverFn, {\n    apply(target, thisArg, argArray) {\n      // If we're in the browser, just call the function without tracing\n      // Server functions should never run in the browser, but this prevents\n      // autotel (which uses Node.js APIs) from being executed if it somehow does\n      if (!isServerSide()) {\n        return target.apply(thisArg, argArray);\n      }\n\n      return trace(`tanstack.serverFn.${fnName}`, async (ctx: TraceContext) => {\n        ctx.setAttributes({\n          [SPAN_ATTRIBUTES.RPC_SYSTEM]: 'tanstack-start',\n          [SPAN_ATTRIBUTES.RPC_METHOD]: fnName,\n          [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'serverFn',\n          [SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_NAME]: fnName,\n        });\n\n        // Capture arguments if configured\n        if (captureArgs && argArray.length > 0) {\n          const args = argArray[0];\n          if (args !== undefined) {\n            try {\n              ctx.setAttribute(\n                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS,\n                JSON.stringify(args),\n              );\n            } catch {\n              ctx.setAttribute(\n                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS,\n                '[non-serializable]',\n              );\n            }\n          }\n        }\n\n        try {\n          const result = await Reflect.apply(target, thisArg, argArray);\n\n          // Capture result if configured\n          if (captureResults && result !== undefined) {\n            try {\n              ctx.setAttribute(\n                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT,\n                JSON.stringify(result),\n              );\n            } catch {\n              ctx.setAttribute(\n                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT,\n                '[non-serializable]',\n              );\n            }\n          }\n\n          ctx.setStatus({ code: SpanStatusCode.OK });\n          return result;\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    get(target, prop, receiver) {\n      return Reflect.get(target, prop, receiver);\n    },\n  }) as T;\n}\n\n/**\n * Create a traced version of createServerFn\n *\n * This higher-order function wraps TanStack's createServerFn to automatically\n * add tracing to all created server functions.\n *\n * @param createServerFnOriginal - The original createServerFn from TanStack\n * @param defaultConfig - Default configuration for all server functions\n * @returns Wrapped createServerFn that produces traced server functions\n *\n * @example\n * ```typescript\n * import { createServerFn as originalCreateServerFn } from '@tanstack/react-start';\n * import { createTracedServerFnFactory } from 'autotel-tanstack/server-functions';\n *\n * export const createServerFn = createTracedServerFnFactory(originalCreateServerFn);\n *\n * // Now all server functions created with createServerFn are automatically traced\n * export const getUser = createServerFn({ method: 'GET' })\n *   .handler(async ({ data: id }) => {\n *     return await db.users.findUnique({ where: { id } });\n *   });\n * ```\n */\nexport function createTracedServerFnFactory<\n  TCreateServerFn extends (...args: any[]) => any,\n>(\n  createServerFnOriginal: TCreateServerFn,\n  defaultConfig: Omit<TraceServerFnConfig, 'name'> = {},\n): TCreateServerFn {\n  return new Proxy(createServerFnOriginal, {\n    apply(target, thisArg, argArray) {\n      const result = Reflect.apply(target, thisArg, argArray);\n\n      // If the result has a .handler method, wrap it\n      if (\n        result &&\n        typeof result === 'object' &&\n        'handler' in result &&\n        typeof result.handler === 'function'\n      ) {\n        const originalHandler = result.handler.bind(result);\n\n        result.handler = function tracedHandler(handlerFn: unknown) {\n          const wrappedHandler = originalHandler(handlerFn as never);\n\n          // Try to infer function name from the handler\n          const fnName = (handlerFn as { name?: string })?.name || 'serverFn';\n\n          return traceServerFn(wrappedHandler, {\n            ...defaultConfig,\n            name: fnName,\n          });\n        };\n      }\n\n      return result;\n    },\n  }) as TCreateServerFn;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,cACd,UACA,SAA8B,CAAC,GAC5B;CACH,MAAM,SAAS,OAAO,QAAQ,SAAS,QAAQ;CAC/C,MAAM,cAAc,OAAO,eAAe;CAC1C,MAAM,iBAAiB,OAAO,kBAAkB;CAEhD,OAAO,IAAI,MAAM,UAAU;EACzB,MAAM,QAAQ,SAAS,UAAU;GAI/B,IAAI,CAAC,aAAa,GAChB,OAAO,OAAO,MAAM,SAAS,QAAQ;GAGvC,OAAO,MAAM,qBAAqB,UAAU,OAAO,QAAsB;IACvE,IAAI,cAAc;MACf,gBAAgB,aAAa;MAC7B,gBAAgB,aAAa;MAC7B,gBAAgB,gBAAgB;MAChC,gBAAgB,0BAA0B;IAC7C,CAAC;IAGD,IAAI,eAAe,SAAS,SAAS,GAAG;KACtC,MAAM,OAAO,SAAS;KACtB,IAAI,SAAS,QACX,IAAI;MACF,IAAI,aACF,gBAAgB,yBAChB,KAAK,UAAU,IAAI,CACrB;KACF,QAAQ;MACN,IAAI,aACF,gBAAgB,yBAChB,oBACF;KACF;IAEJ;IAEA,IAAI;KACF,MAAM,SAAS,MAAM,QAAQ,MAAM,QAAQ,SAAS,QAAQ;KAG5D,IAAI,kBAAkB,WAAW,QAC/B,IAAI;MACF,IAAI,aACF,gBAAgB,2BAChB,KAAK,UAAU,MAAM,CACvB;KACF,QAAQ;MACN,IAAI,aACF,gBAAgB,2BAChB,oBACF;KACF;KAGF,IAAI,UAAU,EAAE,MAAM,eAAe,GAAG,CAAC;KACzC,OAAO;IACT,SAAS,OAAO;KACd,IAAI,iBAAiB,OAAO,OAAO,IAAI,gBAAgB,YACrD,IAAI,YAAY,KAAK;UAChB,IACL,qBAAqB,OACrB,OAAO,IAAI,oBAAoB,YAE/B,IAAI,gBAAgB,KAAK;KAE3B,MAAM;IACR;GACF,CAAC;EACH;EAEA,IAAI,QAAQ,MAAM,UAAU;GAC1B,OAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;EAC3C;CACF,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,4BAGd,wBACA,gBAAmD,CAAC,GACnC;CACjB,OAAO,IAAI,MAAM,wBAAwB,EACvC,MAAM,QAAQ,SAAS,UAAU;EAC/B,MAAM,SAAS,QAAQ,MAAM,QAAQ,SAAS,QAAQ;EAGtD,IACE,UACA,OAAO,WAAW,YAClB,aAAa,UACb,OAAO,OAAO,YAAY,YAC1B;GACA,MAAM,kBAAkB,OAAO,QAAQ,KAAK,MAAM;GAElD,OAAO,UAAU,SAAS,cAAc,WAAoB;IAC1D,MAAM,iBAAiB,gBAAgB,SAAkB;IAGzD,MAAM,SAAU,WAAiC,QAAQ;IAEzD,OAAO,cAAc,gBAAgB;KACnC,GAAG;KACH,MAAM;IACR,CAAC;GACH;EACF;EAEA,OAAO;CACT,EACF,CAAC;AACH"}

package/dist/testing.d.ts

@@ -1,5 +1,103 @@
-import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { AttributeValue, Attributes, Context, HrTime, Link, SpanContext, SpanKind, SpanStatus } from "@opentelemetry/api";
 
+//#region ../../node_modules/.pnpm/@opentelemetry+resources@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type RawResourceAttribute = [string, MaybePromise<AttributeValue | undefined>];
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+resources@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/Resource.d.ts
+/**
+ * An interface that represents a resource. A Resource describes the entity for which signals (metrics or trace) are
+ * collected.
+ *
+ * This interface is NOT user-implementable. Valid ways to obtain a {@link Resource} are by using either of these functions
+ *  - {@link resourceFromAttributes}
+ *  - {@link emptyResource}
+ *  - {@link defaultResource}
+ *  - {@link detectResources}
+ */
+interface Resource {
+  /**
+   * Check if async attributes have resolved. This is useful to avoid awaiting
+   * waitForAsyncAttributes (which will introduce asynchronous behavior) when not necessary.
+   *
+   * @returns true if the resource "attributes" property is not yet settled to its final value
+   */
+  readonly asyncAttributesPending?: boolean;
+  /**
+   * @returns the Resource's attributes.
+   */
+  readonly attributes: Attributes;
+  /**
+   * @returns the Resource's schema URL or undefined if not set.
+   */
+  readonly schemaUrl?: string;
+  /**
+   * Returns a promise that will never be rejected. Resolves when all async attributes have finished being added to
+   * this Resource's attributes. This is useful in exporters to block until resource detection
+   * has finished.
+   */
+  waitForAsyncAttributes?(): Promise<void>;
+  /**
+   * Returns a new, merged {@link Resource} by merging the current Resource
+   * with the other Resource. In case of a collision, other Resource takes
+   * precedence.
+   *
+   * @param other the Resource that will be merged with this.
+   * @returns the newly merged Resource.
+   */
+  merge(other: Resource | null): Resource;
+  getRawAttributes(): RawResourceAttribute[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/types.d.ts
+/**
+ * An instrumentation scope consists of the name and optional version
+ * used to obtain a tracer or meter from a provider. This metadata is made
+ * available on ReadableSpan and MetricRecord for use by the export pipeline.
+ */
+interface InstrumentationScope {
+  readonly name: string;
+  readonly version?: string;
+  readonly schemaUrl?: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/src/TimedEvent.d.ts
+/**
+ * Represents a timed event.
+ * A timed event is an event with a timestamp.
+ */
+interface TimedEvent {
+  time: HrTime;
+  /** The name of the event. */
+  name: string;
+  /** The attributes of the event. */
+  attributes?: Attributes;
+  /** Count of attributes of the event that were dropped due to collection limits */
+  droppedAttributesCount?: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/src/export/ReadableSpan.d.ts
+interface ReadableSpan {
+  readonly name: string;
+  readonly kind: SpanKind;
+  readonly spanContext: () => SpanContext;
+  readonly parentSpanContext?: SpanContext;
+  readonly startTime: HrTime;
+  readonly endTime: HrTime;
+  readonly status: SpanStatus;
+  readonly attributes: Attributes;
+  readonly links: Link[];
+  readonly events: TimedEvent[];
+  readonly duration: HrTime;
+  readonly ended: boolean;
+  readonly resource: Resource;
+  readonly instrumentationScope: InstrumentationScope;
+  readonly droppedAttributesCount: number;
+  readonly droppedEventsCount: number;
+  readonly droppedLinksCount: number;
+}
+//#endregion
+//#region src/testing.d.ts
 /**
  * Test harness for TanStack instrumentation testing
  *
@@ -7,53 +105,53 @@ import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
  * with autotel-tanstack instrumentation.
  */
 interface TestHarness {
-    /**
-     * The in-memory span exporter
-     */
-    exporter: {
-        getFinishedSpans(): ReadableSpan[];
-        reset(): void;
-    };
-    /**
-     * Get all finished spans
-     */
-    getSpans(): ReadableSpan[];
-    /**
-     * Get spans by name (exact match or regex)
-     */
-    getSpansByName(name: string | RegExp): ReadableSpan[];
-    /**
-     * Get spans by TanStack type
-     */
-    getSpansByType(type: 'request' | 'serverFn' | 'loader' | 'beforeLoad'): ReadableSpan[];
-    /**
-     * Reset collected spans
-     */
+  /**
+   * The in-memory span exporter
+   */
+  exporter: {
+    getFinishedSpans(): ReadableSpan[];
     reset(): void;
-    /**
-     * Assert a span exists
-     */
-    assertSpanExists(name: string | RegExp): void;
-    /**
-     * Assert a span has a specific attribute
-     */
-    assertSpanHasAttribute(name: string | RegExp, attr: string, value?: unknown): void;
-    /**
-     * Assert a server function was traced
-     */
-    assertServerFnTraced(name: string): void;
-    /**
-     * Assert a loader was traced
-     */
-    assertLoaderTraced(routeId: string): void;
-    /**
-     * Assert a beforeLoad was traced
-     */
-    assertBeforeLoadTraced(routeId: string): void;
-    /**
-     * Assert an HTTP request was traced
-     */
-    assertRequestTraced(method: string, path: string): void;
+  };
+  /**
+   * Get all finished spans
+   */
+  getSpans(): ReadableSpan[];
+  /**
+   * Get spans by name (exact match or regex)
+   */
+  getSpansByName(name: string | RegExp): ReadableSpan[];
+  /**
+   * Get spans by TanStack type
+   */
+  getSpansByType(type: 'request' | 'serverFn' | 'loader' | 'beforeLoad'): ReadableSpan[];
+  /**
+   * Reset collected spans
+   */
+  reset(): void;
+  /**
+   * Assert a span exists
+   */
+  assertSpanExists(name: string | RegExp): void;
+  /**
+   * Assert a span has a specific attribute
+   */
+  assertSpanHasAttribute(name: string | RegExp, attr: string, value?: unknown): void;
+  /**
+   * Assert a server function was traced
+   */
+  assertServerFnTraced(name: string): void;
+  /**
+   * Assert a loader was traced
+   */
+  assertLoaderTraced(routeId: string): void;
+  /**
+   * Assert a beforeLoad was traced
+   */
+  assertBeforeLoadTraced(routeId: string): void;
+  /**
+   * Assert an HTTP request was traced
+   */
+  assertRequestTraced(method: string, path: string): void;
 }
 /**
  * Create a test harness for TanStack instrumentation testing
@@ -106,9 +204,9 @@ declare function createTestHarness(): TestHarness;
  * ```
  */
 declare function createMockRequest(method: string, path: string, options?: {
-    headers?: Record<string, string>;
-    body?: string;
-    traceparent?: string;
+  headers?: Record<string, string>;
+  body?: string;
+  traceparent?: string;
 }): Request;
 /**
  * Generate a valid W3C traceparent header for testing
@@ -132,23 +230,23 @@ declare function generateTraceparent(traceId?: string, spanId?: string): string;
  * `Record<string, unknown>` in TypeScript 6+ strict mode.
  */
 type SerializedSpan = {
-    name: string;
-    spanId: string;
-    traceId: string;
-    parentSpanId?: string;
-    attributes?: Record<string, unknown>;
-    status: {
-        code: number;
-        message?: string;
-    };
-    durationMs: number;
+  name: string;
+  spanId: string;
+  traceId: string;
+  parentSpanId?: string;
+  attributes?: Record<string, unknown>;
+  status: {
+    code: number;
+    message?: string;
+  };
+  durationMs: number;
 };
 /**
  * Accepts either a raw `Request` (legacy) or a TanStack Router context
  * object containing `{ request: Request }` (Router 1.168+).
  */
 type HandlerInput = Request | {
-    request: Request;
+  request: Request;
 };
 type CreateFileRoute = (path: string) => (options: any) => any;
 /**
@@ -192,8 +290,9 @@ type CreateFileRoute = (path: string) => (options: any) => any;
  */
 declare function createTestSpansRoute(createFileRoute: CreateFileRoute, path?: string): any;
 declare function createTestSpansHandlers(): {
-    GET: (input: HandlerInput) => Response;
-    DELETE: (input: HandlerInput) => Response;
+  GET: (input: HandlerInput) => Response;
+  DELETE: (input: HandlerInput) => Response;
 };
-
-export { type SerializedSpan, type TestHarness, createMockRequest, createTestHarness, createTestSpansHandlers, createTestSpansRoute, generateTraceparent };
+//#endregion
+export { SerializedSpan, TestHarness, createMockRequest, createTestHarness, createTestSpansHandlers, createTestSpansRoute, generateTraceparent };
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","names":["detect","ResourceDetectionConfig","config","DetectedResource","attributes","DetectedResourceAttributes","MaybePromise","AttributeValue","Record","DetectedResourceAttributeValue","T","Promise","schemaUrl","asyncAttributesPending","attributes","Attributes","schemaUrl","waitForAsyncAttributes","Promise","merge","Resource","other","getRawAttributes","RawResourceAttribute","Function","__wrapped","__unwrap","__original","name","version","schemaUrl","Exception","ex","time","HrTime","name","attributes","Attributes","droppedAttributesCount","name","kind","SpanKind","spanContext","SpanContext","parentSpanContext","startTime","HrTime","endTime","status","SpanStatus","attributes","Attributes","links","Link","events","TimedEvent","duration","ended","resource","Resource","instrumentationScope","InstrumentationScope","droppedAttributesCount","droppedEventsCount","droppedLinksCount"],"sources":["../../../node_modules/.pnpm/@opentelemetry+resources@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/types.d.ts","../../../node_modules/.pnpm/@opentelemetry+resources@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/Resource.d.ts","../../../node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/types.d.ts","../../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/src/TimedEvent.d.ts","../../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/src/export/ReadableSpan.d.ts","../src/testing.ts"],"x_google_ignoreList":[0,1,2,3,4],"mappings":"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"}