fix(nextjs): Always initialize SDK with global hub (#4086)

In a nextjs app using `@sentry/nextjs`, the code which initializes the SDK is kicked off by the first incoming request[1]. Because we use domains to prevent scope bleed between requests, at the time when `Sentry.init()` is called, we're already in a domain, and as a result, @sentry/node's `init` function sets the domain's hub as the global hub, the hub from which all subsequent hubs will inherit. This means that - currently - all future hubs inherit data from that first request, which they shouldn't.

This PR fixes that by essentially deactivating the domain while the SDK is initialized, so that all initialization code will act on the global hub. Then, because ideally the domain hub would have inherited from the global hub, the work done to the global hub is copied over to the domain hub (to mimic the effects of the inheritance) before the domain is made active again.

[1] It's the request handler's loading of either `_app` or the API route handler (both of which we've prefaced with the user's `sentry.server.config.js`) which triggers the user's `Sentry.init` to run.

Author: lobsterkatie

packages/nextjs/package.json

@@ -18,6 +18,7 @@
   },
   "dependencies": {
     "@sentry/core": "6.13.3",
+    "@sentry/hub": "6.13.3",
     "@sentry/integrations": "6.13.3",
     "@sentry/node": "6.13.3",
     "@sentry/react": "6.13.3",

packages/nextjs/src/index.server.ts

@@ -1,6 +1,8 @@
+import { Carrier, getHubFromCarrier, getMainCarrier } from '@sentry/hub';
 import { RewriteFrames } from '@sentry/integrations';
 import { configureScope, getCurrentHub, init as nodeInit, Integrations } from '@sentry/node';
 import { escapeStringForRegex, logger } from '@sentry/utils';
+import * as domainModule from 'domain';
 import * as path from 'path';
 
 import { instrumentServer } from './utils/instrumentServer';
@@ -15,6 +17,7 @@ export * from '@sentry/node';
 export { ErrorBoundary, withErrorBoundary } from '@sentry/react';
 
 type GlobalWithDistDir = typeof global & { __rewriteFramesDistDir__: string };
+const domain = domainModule as typeof domainModule & { active: (domainModule.Domain & Carrier) | null };
 
 /** Inits the Sentry NextJS SDK on node. */
 export function init(options: NextjsOptions): void {
@@ -36,11 +39,34 @@ export function init(options: NextjsOptions): void {
   // Right now we only capture frontend sessions for Next.js
   options.autoSessionTracking = false;
 
+  // In an ideal world, this init function would be called before any requests are handled. That way, every domain we
+  // use to wrap a request would inherit its scope and client from the global hub. In practice, however, handling the
+  // first request is what causes us to initialize the SDK, as the init code is injected into `_app` and all API route
+  // handlers, and those are only accessed in the course of handling a request. As a result, we're already in a domain
+  // when `init` is called. In order to compensate for this and mimic the ideal world scenario, we stash the active
+  // domain, run `init` as normal, and then restore the domain afterwards, copying over data from the main hub as if we
+  // really were inheriting.
+  const activeDomain = domain.active;
+  domain.active = null;
+
   nodeInit(options);
+
   configureScope(scope => {
     scope.setTag('runtime', 'node');
   });
 
+  if (activeDomain) {
+    const globalHub = getHubFromCarrier(getMainCarrier());
+    const domainHub = getHubFromCarrier(activeDomain);
+
+    // apply the changes made by `nodeInit` to the domain's hub also
+    domainHub.bindClient(globalHub.getClient());
+    domainHub.getScope()?.update(globalHub.getScope());
+
+    // restore the domain hub as the current one
+    domain.active = activeDomain;
+  }
+
   logger.log('SDK successfully initialized');
 }
 

packages/nextjs/test/index.server.test.ts

@@ -1,9 +1,11 @@
 import { RewriteFrames } from '@sentry/integrations';
 import * as SentryNode from '@sentry/node';
+import { getCurrentHub, NodeClient } from '@sentry/node';
 import { Integration } from '@sentry/types';
 import { getGlobalObject } from '@sentry/utils';
+import * as domain from 'domain';
 
-import { init, Scope } from '../src/index.server';
+import { init } from '../src/index.server';
 import { NextjsOptions } from '../src/utils/nextjsOptions';
 
 const { Integrations } = SentryNode;
@@ -13,14 +15,11 @@ const global = getGlobalObject();
 // normally this is set as part of the build process, so mock it here
 (global as typeof global & { __rewriteFramesDistDir__: string }).__rewriteFramesDistDir__ = '.next';
 
-let configureScopeCallback: (scope: Scope) => void = () => undefined;
-jest.spyOn(SentryNode, 'configureScope').mockImplementation(callback => (configureScopeCallback = callback));
 const nodeInit = jest.spyOn(SentryNode, 'init');
 
 describe('Server init()', () => {
   afterEach(() => {
     nodeInit.mockClear();
-    configureScopeCallback = () => undefined;
     global.__SENTRY__.hub = undefined;
   });
 
@@ -53,11 +52,40 @@ describe('Server init()', () => {
   });
 
   it('sets runtime on scope', () => {
-    const mockScope = new Scope();
+    const currentScope = getCurrentHub().getScope();
+
+    // @ts-ignore need access to protected _tags attribute
+    expect(currentScope._tags).toEqual({});
+
     init({});
-    configureScopeCallback(mockScope);
+
     // @ts-ignore need access to protected _tags attribute
-    expect(mockScope._tags).toEqual({ runtime: 'node' });
+    expect(currentScope._tags).toEqual({ runtime: 'node' });
+  });
+
+  it("initializes both global hub and domain hub when there's an active domain", () => {
+    const globalHub = getCurrentHub();
+    const local = domain.create();
+    local.run(() => {
+      const domainHub = getCurrentHub();
+
+      // they are in fact two different hubs, and neither one yet has a client
+      expect(domainHub).not.toBe(globalHub);
+      expect(globalHub.getClient()).toBeUndefined();
+      expect(domainHub.getClient()).toBeUndefined();
+
+      // this tag should end up only in the domain hub
+      domainHub.setTag('dogs', 'areGreat');
+
+      init({});
+
+      expect(globalHub.getClient()).toEqual(expect.any(NodeClient));
+      expect(domainHub.getClient()).toBe(globalHub.getClient());
+      // @ts-ignore need access to protected _tags attribute
+      expect(globalHub.getScope()._tags).toEqual({ runtime: 'node' });
+      // @ts-ignore need access to protected _tags attribute
+      expect(domainHub.getScope()._tags).toEqual({ runtime: 'node', dogs: 'areGreat' });
+    });
   });
 
   describe('integrations', () => {