feat(sveltekit): Add wrapper for server load function

Author: AbhiPrasad

packages/sveltekit/src/client/handleError.ts

@@ -16,7 +16,7 @@ export function handleErrorWithSentry(handleError?: HandleClientError): HandleCl
     captureException(input.error, scope => {
       scope.addEventProcessor(event => {
         addExceptionMechanism(event, {
-          type: 'sveltekit',
+          type: 'instrument',
           handled: false,
         });
         return event;

packages/sveltekit/src/server/handleError.ts

@@ -16,7 +16,7 @@ export function handleErrorWithSentry(handleError?: HandleServerError): HandleSe
     captureException(input.error, scope => {
       scope.addEventProcessor(event => {
         addExceptionMechanism(event, {
-          type: 'sveltekit',
+          type: 'instrument',
           handled: false,
         });
         return event;

packages/sveltekit/src/server/index.ts

@@ -2,3 +2,4 @@ export * from '@sentry/node';
 
 export { init } from './sdk';
 export { handleErrorWithSentry } from './handleError';
+export { wrapLoadWithSentry } from './load';

packages/sveltekit/src/server/load.ts

@@ -0,0 +1,40 @@
+import { captureException } from '@sentry/node';
+import { addExceptionMechanism, objectify } from '@sentry/utils';
+// eslint-disable-next-line import/no-unresolved
+import type { ServerLoad } from '@sveltejs/kit';
+
+/**
+ * Wrap load function with Sentry
+ *
+ * @param origLoad SvelteKit user defined load function
+ */
+export function wrapLoadWithSentry(origLoad: ServerLoad): ServerLoad {
+  return new Proxy(origLoad, {
+    apply: async (wrappingTarget, thisArg, args: Parameters<ServerLoad>) => {
+      try {
+        return await wrappingTarget.apply(thisArg, args);
+      } catch (e) {
+        // 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.
+        const objectifiedErr = objectify(e);
+
+        captureException(objectifiedErr, scope => {
+          scope.addEventProcessor(event => {
+            addExceptionMechanism(event, {
+              type: 'instrument',
+              handled: false,
+              data: {
+                function: 'load',
+              },
+            });
+            return event;
+          });
+
+          return scope;
+        });
+
+        throw objectifiedErr;
+      }
+    },
+  });
+}

packages/sveltekit/test/server/handleError.test.ts

@@ -11,7 +11,7 @@ const mockCaptureException = jest.fn();
 let mockScope = new Scope();
 
 jest.mock('@sentry/node', () => {
-  const original = jest.requireActual('@sentry/core');
+  const original = jest.requireActual('@sentry/node');
   return {
     ...original,
     captureException: (err: unknown, cb: (arg0: unknown) => unknown) => {

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

@@ -0,0 +1,74 @@
+import { Scope } from '@sentry/node';
+// eslint-disable-next-line import/no-unresolved
+import type { ServerLoad } from '@sveltejs/kit';
+
+import { wrapLoadWithSentry } from '../../src/server/load';
+
+const mockCaptureException = jest.fn();
+let mockScope = new Scope();
+
+jest.mock('@sentry/node', () => {
+  const original = jest.requireActual('@sentry/node');
+  return {
+    ...original,
+    captureException: (err: unknown, cb: (arg0: unknown) => unknown) => {
+      cb(mockScope);
+      mockCaptureException(err, cb);
+      return original.captureException(err, cb);
+    },
+  };
+});
+
+const mockAddExceptionMechanism = jest.fn();
+
+jest.mock('@sentry/utils', () => {
+  const original = jest.requireActual('@sentry/utils');
+  return {
+    ...original,
+    addExceptionMechanism: (...args: unknown[]) => mockAddExceptionMechanism(...args),
+  };
+});
+
+function getById(_id?: string) {
+  throw new Error('error');
+}
+
+async function erroringLoad({ params }: Parameters<ServerLoad>[0]): Promise<ReturnType<ServerLoad>> {
+  return {
+    post: getById(params.id),
+  };
+}
+
+describe('wrapLoadWithSentry', () => {
+  beforeEach(() => {
+    mockCaptureException.mockClear();
+    mockAddExceptionMechanism.mockClear();
+    mockScope = new Scope();
+  });
+
+  it('calls captureException', async () => {
+    const wrappedLoad = wrapLoadWithSentry(erroringLoad);
+    const res = wrappedLoad({ params: { id: '1' } } as any);
+    await expect(res).rejects.toThrow();
+
+    expect(mockCaptureException).toHaveBeenCalledTimes(1);
+  });
+
+  it('adds an exception mechanism', async () => {
+    const addEventProcessorSpy = jest.spyOn(mockScope, 'addEventProcessor').mockImplementationOnce(callback => {
+      void callback({}, { event_id: 'fake-event-id' });
+      return mockScope;
+    });
+
+    const wrappedLoad = wrapLoadWithSentry(erroringLoad);
+    const res = wrappedLoad({ params: { id: '1' } } as any);
+    await expect(res).rejects.toThrow();
+
+    expect(addEventProcessorSpy).toBeCalledTimes(1);
+    expect(mockAddExceptionMechanism).toBeCalledTimes(1);
+    expect(mockAddExceptionMechanism).toBeCalledWith(
+      {},
+      { handled: false, type: 'instrument', data: { function: 'load' } },
+    );
+  });
+});