Merge branch 'master' into kmclb-next-js-performance

Author: lobsterkatie

.github/workflows/build.yml

@@ -76,6 +76,14 @@ jobs:
         # this file) to a constant and skip rebuilding all of the packages each time CI runs.
         if: steps.cache_built_packages.outputs.cache-hit == ''
         run: yarn build
+        # We are performing a `prepublishOnly` step manually because build workflow is not responsible for publishing
+        # the actual release. It only creates artifacts which then are uploaded and used by another workflow.
+        # Because of that, any `prepublishOnly` script is skipped and files it produces are not included in the tarball.
+        # We also cannot use `prepare` script which would be more suited, because it's run only before `pack` is called,
+        # and it's done from a `release` workflow and not here.
+      - name: Run prepublishOnly script
+        if: startsWith(github.ref, 'refs/heads/release/')
+        run: yarn prepublishOnly
     outputs:
       # this needs to be passed on, because the `needs` context only looks at direct ancestors (so steps which depend on
       # `job_build` can't see `job_install_deps` and what it returned)

packages/browser/src/loader.js

@@ -58,7 +58,7 @@
     // come out in the wrong order. Because of that we don't need async=1 as GA does.
     // it was probably(?) a legacy behavior that they left to not modify few years old snippet
     // https://www.html5rocks.com/en/tutorials/speed/script-loading/
-    var _currentScriptTag = _document.getElementsByTagName(_script)[0];
+    var _currentScriptTag = _document.scripts[0];
     var _newScriptTag = _document.createElement(_script);
     _newScriptTag.src = _sdkBundleUrl;
     _newScriptTag.setAttribute('crossorigin', 'anonymous');

packages/nextjs/src/index.server.ts

@@ -1,9 +1,10 @@
+import { RewriteFrames } from '@sentry/integrations';
 import { configureScope, init as nodeInit } from '@sentry/node';
 
 import { instrumentServer } from './utils/instrumentServer';
 import { MetadataBuilder } from './utils/metadataBuilder';
 import { NextjsOptions } from './utils/nextjsOptions';
-import { defaultRewriteFrames, getFinalServerIntegrations } from './utils/serverIntegrations';
+import { addIntegration } from './utils/userIntegrations';
 
 export * from '@sentry/node';
 
@@ -16,12 +17,7 @@ export function init(options: NextjsOptions): void {
   const metadataBuilder = new MetadataBuilder(options, ['nextjs', 'node']);
   metadataBuilder.addSdkMetadata();
   options.environment = options.environment || process.env.NODE_ENV;
-  if (options.integrations) {
-    options.integrations = getFinalServerIntegrations(options.integrations);
-  } else {
-    options.integrations = [defaultRewriteFrames];
-  }
-
+  addServerIntegrations(options);
   // Right now we only capture frontend sessions for Next.js
   options.autoSessionTracking = false;
 
@@ -31,6 +27,23 @@ export function init(options: NextjsOptions): void {
   });
 }
 
+const SOURCEMAP_FILENAME_REGEX = /^.*\/\.next\//;
+
+const defaultRewriteFramesIntegration = new RewriteFrames({
+  iteratee: frame => {
+    frame.filename = frame.filename?.replace(SOURCEMAP_FILENAME_REGEX, 'app:///_next/');
+    return frame;
+  },
+});
+
+function addServerIntegrations(options: NextjsOptions): void {
+  if (options.integrations) {
+    options.integrations = addIntegration(defaultRewriteFramesIntegration, options.integrations);
+  } else {
+    options.integrations = [defaultRewriteFramesIntegration];
+  }
+}
+
 export { withSentryConfig } from './utils/config';
 export { withSentry } from './utils/handlers';
 

packages/nextjs/src/utils/serverIntegrations.ts

@@ -0,0 +1,41 @@
+import { Integration } from '@sentry/types';
+
+export type UserFunctionIntegrations = (integrations: Integration[]) => Integration[];
+type UserIntegrations = Integration[] | UserFunctionIntegrations;
+
+/**
+ * Retrieves the patched integrations with the provided integration.
+ *
+ * The integration must be present in the final user integrations, and they are compared
+ * by integration name. If the user has defined one, there's nothing to patch; if not,
+ * the provided integration is added.
+ *
+ * @param integration The integration to patch, if necessary.
+ * @param userIntegrations Integrations defined by the user.
+ * @returns Final integrations, patched if necessary.
+ */
+export function addIntegration(integration: Integration, userIntegrations: UserIntegrations): UserIntegrations {
+  if (Array.isArray(userIntegrations)) {
+    return addIntegrationToArray(integration, userIntegrations);
+  } else {
+    return addIntegrationToFunction(integration, userIntegrations);
+  }
+}
+
+function addIntegrationToArray(integration: Integration, userIntegrations: Integration[]): Integration[] {
+  if (userIntegrations.map(int => int.name).includes(integration.name)) {
+    return userIntegrations;
+  }
+  return [...userIntegrations, integration];
+}
+
+function addIntegrationToFunction(
+  integration: Integration,
+  userIntegrationsFunc: UserFunctionIntegrations,
+): UserFunctionIntegrations {
+  const wrapper: UserFunctionIntegrations = defaultIntegrations => {
+    const userFinalIntegrations = userIntegrationsFunc(defaultIntegrations);
+    return addIntegrationToArray(integration, userFinalIntegrations);
+  };
+  return wrapper;
+}

packages/nextjs/src/utils/userIntegrations.ts

@@ -0,0 +1,50 @@
+import { RewriteFrames } from '@sentry/integrations';
+import { Integration } from '@sentry/types';
+
+import { addIntegration, UserFunctionIntegrations } from '../src/utils/userIntegrations';
+
+const testIntegration = new RewriteFrames();
+
+describe('user integrations without any integrations', () => {
+  test('as an array', () => {
+    const userIntegrations: Integration[] = [];
+    // Should get a single integration
+    let finalIntegrations = addIntegration(testIntegration, userIntegrations);
+    expect(finalIntegrations).toBeInstanceOf(Array);
+    finalIntegrations = finalIntegrations as Integration[];
+    expect(finalIntegrations).toHaveLength(1);
+    expect(finalIntegrations[0]).toMatchObject(testIntegration);
+  });
+
+  test('as a function', () => {
+    const userIntegrationFnc: UserFunctionIntegrations = (): Integration[] => [];
+    // Should get a single integration
+    const integrationWrapper = addIntegration(testIntegration, userIntegrationFnc);
+    expect(integrationWrapper).toBeInstanceOf(Function);
+    const finalIntegrations = (integrationWrapper as UserFunctionIntegrations)([]);
+    expect(finalIntegrations).toHaveLength(1);
+    expect(finalIntegrations[0]).toMatchObject(testIntegration);
+  });
+});
+
+describe('user integrations with integrations', () => {
+  test('as an array', () => {
+    const userIntegrations = [new RewriteFrames()];
+    // Should get the same array (with no patches)
+    const finalIntegrations = addIntegration(testIntegration, userIntegrations);
+    expect(finalIntegrations).toMatchObject(userIntegrations);
+  });
+
+  test('as a function', () => {
+    const userIntegrations = [new RewriteFrames()];
+    const integrationsFnc: UserFunctionIntegrations = (_integrations: Integration[]): Integration[] => {
+      return userIntegrations;
+    };
+    // Should get a function that returns the test integration
+    let finalIntegrations = addIntegration(testIntegration, integrationsFnc);
+    expect(typeof finalIntegrations === 'function').toBe(true);
+    expect(finalIntegrations).toBeInstanceOf(Function);
+    finalIntegrations = finalIntegrations as UserFunctionIntegrations;
+    expect(finalIntegrations([])).toMatchObject(userIntegrations);
+  });
+});