autotel-tanstack 1.13.34 → 1.13.36

package/src/instrument.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Hoisted so the values exist when the (also-hoisted) vi.mock factories run,
-// since instrument is imported statically below.
-const {
-  mockInit,
-  mockIsInitialized,
-  mockExporter,
-  MockInMemorySpanExporter,
-  MockSimpleSpanProcessor,
-} = vi.hoisted(() => {
-  const exporter = { reset: vi.fn(), getFinishedSpans: vi.fn(() => []) };
-  return {
-    mockInit: vi.fn(),
-    mockIsInitialized: vi.fn(() => false),
-    mockExporter: exporter,
-    MockInMemorySpanExporter: vi.fn(function () {
-      return exporter;
-    }),
-    MockSimpleSpanProcessor: vi.fn(function (exp: unknown) {
-      return { exporter: exp };
-    }),
-  };
-});
-
-vi.mock('autotel', () => ({
-  init: mockInit,
-  isInitialized: mockIsInitialized,
-}));
-vi.mock('autotel/exporters', () => ({
-  InMemorySpanExporter: MockInMemorySpanExporter,
-}));
-vi.mock('autotel/processors', () => ({
-  SimpleSpanProcessor: MockSimpleSpanProcessor,
-}));
-
-import { instrument } from './instrument';
-
-type InitCall = {
-  service?: string;
-  endpoint?: string;
-  debug?: boolean | 'pretty';
-  logs?: unknown;
-  subscribers?: unknown;
-  spanProcessors?: unknown[];
-};
-const lastInit = () => mockInit.mock.calls[0][0] as InitCall;
-
-describe('instrument()', () => {
-  const originalEnv = { ...process.env };
-
-  beforeEach(() => {
-    mockInit.mockReset();
-    mockIsInitialized.mockReturnValue(false);
-    MockInMemorySpanExporter.mockClear();
-    MockSimpleSpanProcessor.mockClear();
-    delete (globalThis as Record<string, unknown>).__testSpanExporter;
-    delete process.env.E2E;
-    delete process.env.AUTOTEL_DEBUG;
-    delete process.env.OTEL_SERVICE_NAME;
-    delete process.env.NODE_ENV;
-  });
-  afterEach(() => {
-    process.env = { ...originalEnv };
-  });
-
-  it('is idempotent — does nothing when already initialized', () => {
-    mockIsInitialized.mockReturnValue(true);
-    instrument({ service: 'x' });
-    expect(mockInit).not.toHaveBeenCalled();
-  });
-
-  it('defaults the service name to tanstack-start', () => {
-    instrument();
-    expect(lastInit().service).toBe('tanstack-start');
-  });
-
-  it('prefers an explicit service over OTEL_SERVICE_NAME', () => {
-    process.env.OTEL_SERVICE_NAME = 'from-env';
-    instrument({ service: 'explicit' });
-    expect(lastInit().service).toBe('explicit');
-  });
-
-  it('falls back to OTEL_SERVICE_NAME', () => {
-    process.env.OTEL_SERVICE_NAME = 'from-env';
-    instrument();
-    expect(lastInit().service).toBe('from-env');
-  });
-
-  it('passes options straight through to init in normal mode', () => {
-    const subscribers = [{ name: 'sub' } as never];
-    instrument({
-      endpoint: 'http://collector:4318',
-      subscribers,
-      logs: true,
-    });
-    const call = lastInit();
-    expect(call.endpoint).toBe('http://collector:4318');
-    expect(call.subscribers).toBe(subscribers);
-    expect(call.logs).toBe(true);
-    expect(call.spanProcessors).toBeUndefined();
-  });
-
-  it('resolves debug from AUTOTEL_DEBUG', () => {
-    process.env.AUTOTEL_DEBUG = 'pretty';
-    instrument({ endpoint: 'http://c:4318' });
-    expect(lastInit().debug).toBe('pretty');
-  });
-
-  it('pretty-prints in dev when no endpoint is set', () => {
-    process.env.NODE_ENV = 'development';
-    instrument();
-    expect(lastInit().debug).toBe('pretty');
-  });
-
-  it('captures spans in memory under E2E=1 and skips OTLP + logs', () => {
-    process.env.E2E = '1';
-    const subscribers = [{ name: 'sub' } as never];
-    instrument({ endpoint: 'http://c:4318', subscribers, logs: true });
-
-    expect(MockInMemorySpanExporter).toHaveBeenCalledOnce();
-    const call = lastInit();
-    expect(call.spanProcessors).toHaveLength(1);
-    expect(call.endpoint).toBeUndefined(); // no OTLP shipping in tests
-    expect(call.logs).toBeUndefined(); // logs off in E2E
-    expect(call.subscribers).toBe(subscribers); // subscribers still flow
-    expect((globalThis as Record<string, unknown>).__testSpanExporter).toBe(
-      mockExporter,
-    );
-  });
-});

package/src/instrument.ts

@@ -1,97 +0,0 @@
-/**
- * Configurable tracing setup for TanStack Start.
- *
- * `instrument(options)` is a thin wrapper over autotel's `init` that adds the
- * TanStack defaults so apps don't hand-roll them:
- *
- * - service name defaults to `OTEL_SERVICE_NAME` or `'tanstack-start'`;
- * - `debug` resolves from `AUTOTEL_DEBUG` (`pretty` in dev when no endpoint set);
- * - when `E2E=1`, spans are captured by an `InMemorySpanExporter` exposed as
- *   `globalThis.__testSpanExporter` (for span assertions) instead of shipping
- *   over OTLP;
- * - it's idempotent — a second call is a no-op.
- *
- * Everything else — `endpoint`, `headers`, `subscribers`, `logs`,
- * `canonicalLogLines`, extra `spanProcessors`, … — passes straight through to
- * `init`, and the standard `OTEL_*` env vars are resolved by autotel core, so
- * apps never re-parse them.
- *
- * The zero-config `autotel-tanstack/auto` side-effect module is just
- * `instrument()` with no options.
- *
- * @example
- * ```ts
- * import { instrument } from 'autotel-tanstack';
- * import { PostHogSubscriber } from 'autotel-subscribers';
- *
- * instrument({
- *   subscribers: process.env.POSTHOG_KEY
- *     ? [new PostHogSubscriber({ apiKey: process.env.POSTHOG_KEY })]
- *     : [],
- *   logs: true,
- *   canonicalLogLines: { enabled: true, rootSpansOnly: true },
- * });
- * ```
- *
- * @module
- */
-
-import { init, isInitialized, type AutotelConfig } from 'autotel';
-import { InMemorySpanExporter } from 'autotel/exporters';
-import { SimpleSpanProcessor } from 'autotel/processors';
-
-// `service` is optional here — instrument() defaults it to OTEL_SERVICE_NAME or
-// 'tanstack-start'. Everything else matches autotel's init config.
-export type InstrumentOptions = Omit<AutotelConfig, 'service'> & {
-  service?: string;
-};
-
-const DEFAULT_SERVICE = 'tanstack-start';
-
-/**
- * Resolve span-debug output: an explicit option wins; otherwise `AUTOTEL_DEBUG`
- * (`pretty` | `true`/`1` | `false`/`0`); otherwise pretty-print in development
- * when there's no OTLP endpoint, so spans are visible immediately.
- */
-function resolveDebug(
-  explicit: AutotelConfig['debug'],
-  endpoint: string | undefined,
-): boolean | 'pretty' {
-  if (explicit !== undefined) return explicit;
-  const env = process.env.AUTOTEL_DEBUG;
-  if (env === 'pretty') return 'pretty';
-  if (env === 'true' || env === '1') return true;
-  if (env === 'false' || env === '0') return false;
-  if (!endpoint && process.env.NODE_ENV === 'development') return 'pretty';
-  return false;
-}
-
-export function instrument(options: InstrumentOptions = {}): void {
-  // Idempotent: tolerate the instrumentation module being evaluated more than
-  // once (HMR, multiple entry points) without re-initializing.
-  if (isInitialized()) return;
-
-  const service =
-    options.service ?? process.env.OTEL_SERVICE_NAME ?? DEFAULT_SERVICE;
-
-  if (process.env.E2E === '1') {
-    // Capture spans in memory for test assertions; skip OTLP/logs entirely.
-    const exporter = new InMemorySpanExporter();
-    (globalThis as Record<string, unknown>).__testSpanExporter = exporter;
-    init({
-      service,
-      subscribers: options.subscribers,
-      spanProcessors: [
-        new SimpleSpanProcessor(exporter),
-        ...(options.spanProcessors ?? []),
-      ],
-    });
-    return;
-  }
-
-  init({
-    ...options,
-    service,
-    debug: resolveDebug(options.debug, options.endpoint),
-  });
-}

package/src/loaders.test.ts

@@ -1,123 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { traceLoader, traceBeforeLoad, createTracedRoute } from './loaders';
-
-// Mock autotel
-vi.mock('autotel', () => ({
-  trace: vi.fn((name, fn) =>
-    fn({
-      setAttributes: vi.fn(),
-      setAttribute: vi.fn(),
-      setStatus: vi.fn(),
-      recordException: vi.fn(),
-    }),
-  ),
-}));
-
-describe('loaders', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('traceLoader', () => {
-    it('should wrap a loader function', async () => {
-      const loaderFn = vi.fn().mockResolvedValue({ data: 'test' });
-      const tracedLoader = traceLoader(loaderFn);
-
-      const context = {
-        params: { userId: '123' },
-        route: { id: '/users/$userId' },
-      };
-
-      const result = await tracedLoader(context);
-
-      expect(loaderFn).toHaveBeenCalledWith(context);
-      expect(result).toEqual({ data: 'test' });
-    });
-
-    it('should use custom name if provided', async () => {
-      const loaderFn = vi.fn().mockResolvedValue({ data: 'test' });
-      const tracedLoader = traceLoader(loaderFn, { name: 'customLoader' });
-
-      await tracedLoader({ route: { id: '/test' } });
-      expect(loaderFn).toHaveBeenCalled();
-    });
-
-    it('should propagate errors', async () => {
-      const error = new Error('Loader error');
-      const loaderFn = vi.fn().mockRejectedValue(error);
-      const tracedLoader = traceLoader(loaderFn);
-
-      await expect(tracedLoader({})).rejects.toThrow('Loader error');
-    });
-
-    it('should handle missing route id', async () => {
-      const loaderFn = vi.fn().mockResolvedValue({ data: 'test' });
-      const tracedLoader = traceLoader(loaderFn);
-
-      const result = await tracedLoader({});
-      expect(result).toEqual({ data: 'test' });
-    });
-  });
-
-  describe('traceBeforeLoad', () => {
-    it('should wrap a beforeLoad function', async () => {
-      const beforeLoadFn = vi.fn().mockResolvedValue({ auth: true });
-      const tracedBeforeLoad = traceBeforeLoad(beforeLoadFn);
-
-      const context = {
-        params: { userId: '123' },
-        route: { id: '/users/$userId' },
-      };
-
-      const result = await tracedBeforeLoad(context);
-
-      expect(beforeLoadFn).toHaveBeenCalledWith(context);
-      expect(result).toEqual({ auth: true });
-    });
-
-    it('should handle redirect errors gracefully', async () => {
-      const redirectError = new Error('Redirect');
-      redirectError.name = 'RedirectError';
-      const beforeLoadFn = vi.fn().mockRejectedValue(redirectError);
-      const tracedBeforeLoad = traceBeforeLoad(beforeLoadFn);
-
-      await expect(tracedBeforeLoad({})).rejects.toThrow('Redirect');
-    });
-
-    it('should handle notFound errors gracefully', async () => {
-      const notFoundError = new Error('Not Found');
-      notFoundError.name = 'NotFoundError';
-      const beforeLoadFn = vi.fn().mockRejectedValue(notFoundError);
-      const tracedBeforeLoad = traceBeforeLoad(beforeLoadFn);
-
-      await expect(tracedBeforeLoad({})).rejects.toThrow('Not Found');
-    });
-  });
-
-  describe('createTracedRoute', () => {
-    it('should create loader and beforeLoad wrappers', () => {
-      const traced = createTracedRoute('/users/$userId');
-
-      expect(traced.loader).toBeDefined();
-      expect(traced.beforeLoad).toBeDefined();
-    });
-
-    it('should wrap loader with route id in span name', async () => {
-      const traced = createTracedRoute('/users/$userId');
-      const loaderFn = vi.fn().mockResolvedValue({ user: {} });
-      const tracedLoader = traced.loader(loaderFn);
-
-      await tracedLoader({ params: { userId: '123' } });
-      expect(loaderFn).toHaveBeenCalled();
-    });
-
-    it('should wrap beforeLoad with route id in span name', async () => {
-      const traced = createTracedRoute('/dashboard');
-      const beforeLoadFn = vi.fn().mockResolvedValue({});
-      const tracedBeforeLoad = traced.beforeLoad(beforeLoadFn);
-
-      await tracedBeforeLoad({});
-      expect(beforeLoadFn).toHaveBeenCalled();
-    });
-  });
-});

package/src/loaders.ts

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