remove domain usage from load

Author: Lms24

packages/core/src/tracing/trace.ts

@@ -31,6 +31,7 @@ export function trace<T>(
   const scope = hub.getScope();
 
   const parentSpan = scope.getSpan();
+
   const activeSpan = parentSpan ? parentSpan.startChild(ctx) : hub.startTransaction(ctx);
   scope.setSpan(activeSpan);
 

packages/sveltekit/src/server/load.ts

@@ -1,15 +1,14 @@
 /* eslint-disable @sentry-internal/sdk/no-optional-chaining */
 import { trace } from '@sentry/core';
 import { captureException } from '@sentry/node';
-import type { TransactionContext } from '@sentry/types';
+import type { DynamicSamplingContext, TraceparentData, TransactionContext } from '@sentry/types';
 import {
   addExceptionMechanism,
   baggageHeaderToDynamicSamplingContext,
   extractTraceparentData,
   objectify,
 } from '@sentry/utils';
 import type { HttpError, Load, LoadEvent, ServerLoad, ServerLoadEvent } from '@sveltejs/kit';
-import * as domain from 'domain';
 
 function isHttpError(err: unknown): err is HttpError {
   return typeof err === 'object' && err !== null && 'status' in err && 'body' in err;
@@ -53,42 +52,41 @@ function sendErrorToSentry(e: unknown): unknown {
 export function wrapLoadWithSentry<T extends Load | ServerLoad>(origLoad: T): T {
   return new Proxy(origLoad, {
     apply: (wrappingTarget, thisArg, args: Parameters<ServerLoad | Load>) => {
-      return domain.create().bind(() => {
-        const [event] = args;
-        const routeId = event.route && event.route.id;
+      const [event] = args;
+      const routeId = event.route && event.route.id;
 
-        const traceSharedLoadContext: TransactionContext = {
-          op: 'function.sveltekit.load',
-          name: routeId ? routeId : event.url.pathname,
-          status: 'ok',
-          metadata: {
-            source: routeId ? 'route' : 'url',
-          },
-        };
+      const { traceparentData, dynamicSamplingContext } = getTracePropagationData(event);
 
-        let finalTraceLoadContext = { ...traceSharedLoadContext };
+      const traceLoadContext: TransactionContext = {
+        op: 'function.sveltekit.load',
+        name: routeId ? routeId : event.url.pathname,
+        status: 'ok',
+        metadata: {
+          source: routeId ? 'route' : 'url',
+          dynamicSamplingContext: traceparentData && !dynamicSamplingContext ? {} : dynamicSamplingContext,
+        },
+        ...traceparentData,
+      };
 
-        if (isServerOnlyLoad(event)) {
-          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);
+      return trace(traceLoadContext, () => wrappingTarget.apply(thisArg, args), sendErrorToSentry);
+    },
+  });
+}
 
-          const traceSeverOnlyLoadContext = {
-            ...traceparentData,
-            metadata: {
-              ...traceSharedLoadContext.metadata,
-              dynamicSamplingContext: traceparentData && !dynamicSamplingContext ? {} : dynamicSamplingContext,
-            },
-          };
+function getTracePropagationData(event: ServerLoadEvent | LoadEvent): {
+  traceparentData?: TraceparentData;
+  dynamicSamplingContext?: Partial<DynamicSamplingContext>;
+} {
+  if (!isServerOnlyLoad(event)) {
+    return {};
+  }
 
-          finalTraceLoadContext = { ...traceSharedLoadContext, ...traceSeverOnlyLoadContext };
-        }
+  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);
 
-        return trace(finalTraceLoadContext, () => wrappingTarget.apply(thisArg, args), sendErrorToSentry);
-      })();
-    },
-  });
+  return { traceparentData, dynamicSamplingContext };
 }
 
 /**

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

@@ -136,6 +136,57 @@ describe('wrapLoadWithSentry', () => {
     expect(mockCaptureException).toHaveBeenCalledTimes(1);
   });
 
+  describe('with error() helper', () => {
+    it.each([
+      // [statusCode, timesCalled]
+      [400, 0],
+      [401, 0],
+      [403, 0],
+      [404, 0],
+      [409, 0],
+      [429, 0],
+      [499, 0],
+      [500, 1],
+      [501, 1],
+      [503, 1],
+      [504, 1],
+    ])('error with status code %s calls captureException %s times', async (code, times) => {
+      async function load({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
+        throw error(code, params.id);
+      }
+
+      const wrappedLoad = wrapLoadWithSentry(load);
+      const res = wrappedLoad(MOCK_LOAD_ARGS);
+      await expect(res).rejects.toThrow();
+
+      expect(mockCaptureException).toHaveBeenCalledTimes(times);
+    });
+  });
+
+  it('adds an exception mechanism', async () => {
+    const addEventProcessorSpy = vi.spyOn(mockScope, 'addEventProcessor').mockImplementationOnce(callback => {
+      void callback({}, { event_id: 'fake-event-id' });
+      return mockScope;
+    });
+
+    async function load({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
+      return {
+        post: getById(params.id),
+      };
+    }
+
+    const wrappedLoad = wrapLoadWithSentry(load);
+    const res = wrappedLoad(MOCK_LOAD_ARGS);
+    await expect(res).rejects.toThrow();
+
+    expect(addEventProcessorSpy).toBeCalledTimes(1);
+    expect(mockAddExceptionMechanism).toBeCalledTimes(1);
+    expect(mockAddExceptionMechanism).toBeCalledWith(
+      {},
+      { handled: false, type: 'sveltekit', data: { function: 'load' } },
+    );
+  });
+
   describe('calls trace', () => {
     async function load({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
       return {
@@ -256,55 +307,4 @@ describe('wrapLoadWithSentry', () => {
       );
     });
   });
-
-  describe('with error() helper', () => {
-    it.each([
-      // [statusCode, timesCalled]
-      [400, 0],
-      [401, 0],
-      [403, 0],
-      [404, 0],
-      [409, 0],
-      [429, 0],
-      [499, 0],
-      [500, 1],
-      [501, 1],
-      [503, 1],
-      [504, 1],
-    ])('error with status code %s calls captureException %s times', async (code, times) => {
-      async function load({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
-        throw error(code, params.id);
-      }
-
-      const wrappedLoad = wrapLoadWithSentry(load);
-      const res = wrappedLoad(MOCK_LOAD_ARGS);
-      await expect(res).rejects.toThrow();
-
-      expect(mockCaptureException).toHaveBeenCalledTimes(times);
-    });
-  });
-
-  it('adds an exception mechanism', async () => {
-    const addEventProcessorSpy = vi.spyOn(mockScope, 'addEventProcessor').mockImplementationOnce(callback => {
-      void callback({}, { event_id: 'fake-event-id' });
-      return mockScope;
-    });
-
-    async function load({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
-      return {
-        post: getById(params.id),
-      };
-    }
-
-    const wrappedLoad = wrapLoadWithSentry(load);
-    const res = wrappedLoad(MOCK_LOAD_ARGS);
-    await expect(res).rejects.toThrow();
-
-    expect(addEventProcessorSpy).toBeCalledTimes(1);
-    expect(mockAddExceptionMechanism).toBeCalledTimes(1);
-    expect(mockAddExceptionMechanism).toBeCalledWith(
-      {},
-      { handled: false, type: 'sveltekit', data: { function: 'load' } },
-    );
-  });
 });