fix(sveltekit): Termporarily disable serverside load tracing

packages/sveltekit/src/index.types.ts

@@ -9,7 +9,7 @@ export * from './server';
 
 import type { Integration, Options, StackParser } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
-import type { HandleClientError, HandleServerError, ServerLoad } from '@sveltejs/kit';
+import type { HandleClientError, HandleServerError, Load, ServerLoad } from '@sveltejs/kit';
 
 import type * as clientSdk from './client';
 import type * as serverSdk from './server';
@@ -21,7 +21,7 @@ export declare function handleErrorWithSentry<T extends HandleClientError | Hand
   handleError?: T,
 ): ReturnType<T>;
 
-export declare function wrapLoadWithSentry<S extends ServerLoad>(origLoad: S): S;
+export declare function wrapLoadWithSentry<S extends ServerLoad | Load>(origLoad: S): S;
 
 // We export a merged Integrations object so that users can (at least typing-wise) use all integrations everywhere.
 export declare const Integrations: typeof clientSdk.Integrations & typeof serverSdk.Integrations;

packages/sveltekit/src/server/load.ts

@@ -1,13 +1,7 @@
 /* eslint-disable @sentry-internal/sdk/no-optional-chaining */
-import { trace } from '@sentry/core';
 import { captureException } from '@sentry/node';
-import {
-  addExceptionMechanism,
-  baggageHeaderToDynamicSamplingContext,
-  extractTraceparentData,
-  objectify,
-} from '@sentry/utils';
-import type { HttpError, ServerLoad } from '@sveltejs/kit';
+import { addExceptionMechanism, isThenable, objectify } from '@sentry/utils';
+import type { HttpError, Load, ServerLoad } from '@sveltejs/kit';
 import * as domain from 'domain';
 
 function isHttpError(err: unknown): err is HttpError {
@@ -49,32 +43,26 @@ function sendErrorToSentry(e: unknown): unknown {
  *
  * @param origLoad SvelteKit user defined load function
  */
-export function wrapLoadWithSentry(origLoad: ServerLoad): ServerLoad {
+export function wrapLoadWithSentry<T extends ServerLoad | Load>(origLoad: T): T {
   return new Proxy(origLoad, {
     apply: (wrappingTarget, thisArg, args: Parameters<ServerLoad>) => {
       return domain.create().bind(() => {
-        const [event] = args;
+        let maybePromiseResult: ReturnType<T>;
 
-        const sentryTraceHeader = event.request.headers.get('sentry-trace');
-        const baggageHeader = event.request.headers.get('baggage');
-        const traceparentData = sentryTraceHeader ? extractTraceparentData(sentryTraceHeader) : undefined;
-        const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggageHeader);
+        try {
+          maybePromiseResult = wrappingTarget.apply(thisArg, args);
+        } catch (e) {
+          sendErrorToSentry(e);
+          throw e;
+        }
 
-        const routeId = event.route.id;
-        return trace(
-          {
-            op: 'function.sveltekit.load',
-            name: routeId ? routeId : event.url.pathname,
-            status: 'ok',
-            ...traceparentData,
-            metadata: {
-              source: routeId ? 'route' : 'url',
-              dynamicSamplingContext: traceparentData && !dynamicSamplingContext ? {} : dynamicSamplingContext,
-            },
-          },
-          () => wrappingTarget.apply(thisArg, args),
-          sendErrorToSentry,
-        );
+        if (isThenable(maybePromiseResult)) {
+          Promise.resolve(maybePromiseResult).then(null, e => {
+            sendErrorToSentry(e);
+          });
+        }
+
+        return maybePromiseResult;
       })();
     },
   });

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

@@ -101,7 +101,8 @@ describe('wrapLoadWithSentry', () => {
     expect(mockCaptureException).toHaveBeenCalledTimes(1);
   });
 
-  it('calls trace function', async () => {
+  // TODO: enable this once we figured out how tracing the load function doesn't result in creating a new transaction
+  it.skip('calls trace function', async () => {
     async function load({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
       return {
         post: params.id,