fix(sveltekit): Avoid double-wrapping load functions

packages/sveltekit/src/client/load.ts

@@ -14,8 +14,11 @@ import {
 } from '@sentry/utils';
 import type { LoadEvent } from '@sveltejs/kit';
 
+import type { SentryWrappedFlag } from '../common/utils';
 import { isRedirect } from '../common/utils';
 
+type PatchedLoadEvent = LoadEvent & Partial<SentryWrappedFlag>;
+
 function sendErrorToSentry(e: unknown): unknown {
   // In case we have a primitive, wrap it in the equivalent wrapper class (string -> String, etc.) so that we can
   // store a seen flag on it.
@@ -66,11 +69,17 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
   return new Proxy(origLoad, {
     apply: (wrappingTarget, thisArg, args: Parameters<T>) => {
       // Type casting here because `T` cannot extend `Load` (see comment above function signature)
-      const event = args[0] as LoadEvent;
+      const event = args[0] as PatchedLoadEvent;
+
+      // Check if already wrapped
+      if (event.__sentry_wrapped__) {
+        return wrappingTarget.apply(thisArg, args);
+      }
 
-      const patchedEvent = {
+      const patchedEvent: PatchedLoadEvent = {
         ...event,
         fetch: instrumentSvelteKitFetch(event.fetch),
+        __sentry_wrapped__: true,
       };
 
       const routeId = event.route.id;

packages/sveltekit/src/common/utils.ts

@@ -1,5 +1,13 @@
 import type { Redirect } from '@sveltejs/kit';
 
+export type SentryWrappedFlag = {
+  /**
+   * If this flag is set, we know that the load event was already wrapped once
+   * and we shouldn't wrap it again.
+   */
+  __sentry_wrapped__?: true;
+};
+
 /**
  * Determines if a thrown "error" is a Redirect object which SvelteKit users can throw to redirect to another route
  * see: https://kit.svelte.dev/docs/modules#sveltejs-kit-redirect

packages/sveltekit/src/server/load.ts

@@ -5,9 +5,13 @@ import type { TransactionContext } from '@sentry/types';
 import { addExceptionMechanism, objectify } from '@sentry/utils';
 import type { HttpError, LoadEvent, ServerLoadEvent } from '@sveltejs/kit';
 
+import type { SentryWrappedFlag } from '../common/utils';
 import { isRedirect } from '../common/utils';
 import { getTracePropagationData } from './utils';
 
+type PatchedLoadEvent = LoadEvent & SentryWrappedFlag;
+type PatchedServerLoadEvent = ServerLoadEvent & SentryWrappedFlag;
+
 function isHttpError(err: unknown): err is HttpError {
   return typeof err === 'object' && err !== null && 'status' in err && 'body' in err;
 }
@@ -59,7 +63,18 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
   return new Proxy(origLoad, {
     apply: (wrappingTarget, thisArg, args: Parameters<T>) => {
       // Type casting here because `T` cannot extend `Load` (see comment above function signature)
-      const event = args[0] as LoadEvent;
+      // Also, this event possibly already has a sentry wrapped flag attached
+      const event = args[0] as PatchedLoadEvent;
+
+      if (event.__sentry_wrapped__) {
+        return wrappingTarget.apply(thisArg, args);
+      }
+
+      const patchedEvent: PatchedLoadEvent = {
+        ...event,
+        __sentry_wrapped__: true,
+      };
+
       const routeId = event.route && event.route.id;
 
       const traceLoadContext: TransactionContext = {
@@ -71,7 +86,7 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
         },
       };
 
-      return trace(traceLoadContext, () => wrappingTarget.apply(thisArg, args), sendErrorToSentry);
+      return trace(traceLoadContext, () => wrappingTarget.apply(thisArg, [patchedEvent]), sendErrorToSentry);
     },
   });
 }
@@ -102,7 +117,18 @@ export function wrapServerLoadWithSentry<T extends (...args: any) => any>(origSe
   return new Proxy(origServerLoad, {
     apply: (wrappingTarget, thisArg, args: Parameters<T>) => {
       // Type casting here because `T` cannot extend `ServerLoad` (see comment above function signature)
-      const event = args[0] as ServerLoadEvent;
+      // Also, this event possibly already has a sentry wrapped flag attached
+      const event = args[0] as PatchedServerLoadEvent;
+
+      if (event.__sentry_wrapped__) {
+        return wrappingTarget.apply(thisArg, args);
+      }
+
+      const patchedEvent: PatchedServerLoadEvent = {
+        ...event,
+        __sentry_wrapped__: true,
+      };
+
       const routeId = event.route && event.route.id;
 
       const { dynamicSamplingContext, traceparentData } = getTracePropagationData(event);
@@ -121,7 +147,7 @@ export function wrapServerLoadWithSentry<T extends (...args: any) => any>(origSe
         ...traceparentData,
       };
 
-      return trace(traceLoadContext, () => wrappingTarget.apply(thisArg, args), sendErrorToSentry);
+      return trace(traceLoadContext, () => wrappingTarget.apply(thisArg, [patchedEvent]), sendErrorToSentry);
     },
   });
 }

packages/sveltekit/test/client/load.test.ts

@@ -450,4 +450,17 @@ describe('wrapLoadWithSentry', () => {
       { handled: false, type: 'sveltekit', data: { function: 'load' } },
     );
   });
+
+  it("doesn't wrap load more than once if the wrapper was applied multiple times", async () => {
+    async function load({ params }: Parameters<Load>[0]): Promise<ReturnType<Load>> {
+      return {
+        post: params.id,
+      };
+    }
+
+    const wrappedLoad = wrapLoadWithSentry(wrapLoadWithSentry(load));
+    await wrappedLoad(MOCK_LOAD_ARGS);
+
+    expect(mockTrace).toHaveBeenCalledTimes(1);
+  });
 });

packages/sveltekit/test/server/load.test.ts

@@ -249,6 +249,13 @@ describe('wrapLoadWithSentry calls trace', () => {
       expect.any(Function),
     );
   });
+
+  it("doesn't wrap load more than once if the wrapper was applied multiple times", async () => {
+    const wrappedLoad = wrapLoadWithSentry(wrapLoadWithSentry(wrapLoadWithSentry(load)));
+    await wrappedLoad(MOCK_LOAD_ARGS);
+
+    expect(mockTrace).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('wrapServerLoadWithSentry calls trace', () => {
@@ -375,4 +382,11 @@ describe('wrapServerLoadWithSentry calls trace', () => {
       expect.any(Function),
     );
   });
+
+  it("doesn't wrap server load more than once if the wrapper was applied multiple times", async () => {
+    const wrappedLoad = wrapServerLoadWithSentry(wrapServerLoadWithSentry(serverLoad));
+    await wrappedLoad(MOCK_SERVER_ONLY_LOAD_ARGS);
+
+    expect(mockTrace).toHaveBeenCalledTimes(1);
+  });
 });