Reinstate scope tests

Author: andreiborza

packages/node-core/rollup.anr-worker.config.mjs

@@ -7,7 +7,7 @@ export function createWorkerCodeBuilder(entry, outDir) {
     makeBaseBundleConfig({
       bundleType: 'node-worker',
       entrypoints: [entry],
-      licenseTitle: '@sentry/node',
+      licenseTitle: '@sentry/node-core',
       outputFileBase: () => 'worker-script.js',
       packageSpecificConfig: {
         output: {

packages/node-core/src/init.ts

@@ -1,7 +1,7 @@
 import { init } from './sdk';
 
 /**
- * The @sentry/node/init export can be used with the node --import and --require args to initialize the SDK entirely via
+ * The @sentry/node-core/init export can be used with the node --import and --require args to initialize the SDK entirely via
  * environment variables.
  *
  * > SENTRY_DSN=https://examplePublicKey@o0.ingest.sentry.io/0 SENTRY_TRACES_SAMPLE_RATE=1.0 node --import=@sentry/node/init app.mjs

packages/node-core/test/integration/scope.test.ts

@@ -16,9 +16,7 @@ describe('Integration | Scope', () => {
       const beforeSend = vi.fn(() => null);
       const beforeSendTransaction = vi.fn(() => null);
 
-      const client = tracingEnabled
-        ? mockSdkInit({ tracesSampleRate: 1, beforeSend, beforeSendTransaction })
-        : mockSdkInit({ beforeSend, beforeSendTransaction });
+      const client = mockSdkInit({ tracesSampleRate: tracingEnabled ? 1 : 0, beforeSend, beforeSendTransaction });
 
       const rootScope = getCurrentScope();
 
@@ -38,29 +36,24 @@ describe('Integration | Scope', () => {
         Sentry.withScope(scope2 => {
           scope2.setTag('tag3', 'val3');
 
-          if (tracingEnabled) {
-            Sentry.startSpan({ name: 'outer' }, span => {
-              expect(getCapturedScopesOnSpan(span).scope).toBe(scope2);
-
-              spanId = span.spanContext().spanId;
-              traceId = span.spanContext().traceId;
+          Sentry.startSpan({ name: 'outer' }, span => {
+            expect(getCapturedScopesOnSpan(span).scope).toBe(tracingEnabled ? scope2 : undefined);
 
-              Sentry.setTag('tag4', 'val4');
+            spanId = span.spanContext().spanId;
+            traceId = span.spanContext().traceId;
 
-              Sentry.captureException(error);
-            });
-          } else {
             Sentry.setTag('tag4', 'val4');
+
             Sentry.captureException(error);
-          }
+          });
         });
       });
 
       await client?.flush();
 
       expect(beforeSend).toHaveBeenCalledTimes(1);
 
-      if (spanId && tracingEnabled) {
+      if (spanId) {
         expect(beforeSend).toHaveBeenCalledWith(
           expect.objectContaining({
             contexts: expect.objectContaining({
@@ -135,9 +128,7 @@ describe('Integration | Scope', () => {
       const beforeSend = vi.fn(() => null);
       const beforeSendTransaction = vi.fn(() => null);
 
-      const client = tracingEnabled
-        ? mockSdkInit({ tracesSampleRate: 1, beforeSend, beforeSendTransaction })
-        : mockSdkInit({ beforeSend, beforeSendTransaction });
+      const client = mockSdkInit({ tracesSampleRate: tracingEnabled ? 1 : 0, beforeSend, beforeSendTransaction });
 
       const rootScope = getCurrentScope();
 
@@ -235,17 +226,124 @@ describe('Integration | Scope', () => {
       );
 
       if (tracingEnabled) {
-        expect(traceId1).not.toEqual(traceId2);
         expect(beforeSendTransaction).toHaveBeenCalledTimes(2);
       }
     });
   });
 
+  describe('global scope', () => {
+    beforeEach(() => {
+      resetGlobals();
+    });
+
+    it('works before calling init', () => {
+      const globalScope = Sentry.getGlobalScope();
+      expect(globalScope).toBeDefined();
+      // No client attached
+      expect(globalScope.getClient()).toBeUndefined();
+      // Repeatedly returns the same instance
+      expect(Sentry.getGlobalScope()).toBe(globalScope);
+
+      globalScope.setTag('tag1', 'val1');
+      globalScope.setTag('tag2', 'val2');
+
+      expect(globalScope.getScopeData().tags).toEqual({ tag1: 'val1', tag2: 'val2' });
+
+      // Now when we call init, the global scope remains intact
+      Sentry.init({ dsn: 'https://username@domain/123', defaultIntegrations: false });
+
+      expect(globalScope.getClient()).toBeUndefined();
+      expect(Sentry.getGlobalScope()).toBe(globalScope);
+      expect(globalScope.getScopeData().tags).toEqual({ tag1: 'val1', tag2: 'val2' });
+    });
+
+    it('is applied to events', async () => {
+      const beforeSend = vi.fn();
+      const client = mockSdkInit({ beforeSend });
+
+      const globalScope = Sentry.getGlobalScope();
+      globalScope.setTag('tag1', 'val1');
+      globalScope.setTag('tag2', 'val2');
+
+      const error = new Error('test error');
+      Sentry.captureException(error);
+
+      await client?.flush();
+
+      expect(beforeSend).toHaveBeenCalledTimes(1);
+      expect(beforeSend).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: {
+            tag1: 'val1',
+            tag2: 'val2',
+          },
+        }),
+        {
+          event_id: expect.any(String),
+          originalException: error,
+          syntheticException: expect.any(Error),
+        },
+      );
+    });
+  });
+
   describe('isolation scope', () => {
     beforeEach(() => {
       resetGlobals();
     });
 
+    it('works before calling init', () => {
+      const isolationScope = Sentry.getIsolationScope();
+      expect(isolationScope).toBeDefined();
+      // No client attached
+      expect(isolationScope.getClient()).toBeUndefined();
+      // Repeatedly returns the same instance
+      expect(Sentry.getIsolationScope()).toBe(isolationScope);
+
+      isolationScope.setTag('tag1', 'val1');
+      isolationScope.setTag('tag2', 'val2');
+
+      expect(isolationScope.getScopeData().tags).toEqual({ tag1: 'val1', tag2: 'val2' });
+
+      // Now when we call init, the isolation scope remains intact
+      Sentry.init({ dsn: 'https://username@domain/123', defaultIntegrations: false });
+
+      // client is only attached to global scope by default
+      expect(isolationScope.getClient()).toBeUndefined();
+      expect(Sentry.getIsolationScope()).toBe(isolationScope);
+      expect(isolationScope.getScopeData().tags).toEqual({ tag1: 'val1', tag2: 'val2' });
+    });
+
+    it('is applied to events', async () => {
+      const beforeSend = vi.fn();
+      mockSdkInit({ beforeSend });
+      const client = Sentry.getClient();
+
+      const isolationScope = Sentry.getIsolationScope();
+      isolationScope.setTag('tag1', 'val1');
+      isolationScope.setTag('tag2', 'val2');
+
+      const error = new Error('test error');
+      Sentry.captureException(error);
+
+      await client?.flush();
+
+      expect(beforeSend).toHaveBeenCalledTimes(1);
+      expect(beforeSend).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: {
+            tag1: 'val1',
+            tag2: 'val2',
+          },
+        }),
+        {
+          event_id: expect.any(String),
+          originalException: error,
+          syntheticException: expect.any(Error),
+        },
+      );
+    });
+
     it('withIsolationScope works', async () => {
       const beforeSend = vi.fn();
       mockSdkInit({ beforeSend });
@@ -494,8 +592,8 @@ describe('Integration | Scope', () => {
     });
 
     it('automatically forks with OTEL context', async () => {
-      const beforeSend = vi.fn(() => null);
-      mockSdkInit({ tracesSampleRate: 1, beforeSend });
+      const beforeSend = vi.fn();
+      mockSdkInit({ beforeSend });
       const client = Sentry.getClient();
 
       const initialCurrentScope = Sentry.getCurrentScope();