From ab23658916a68b75f2a5416239af5065652d9fca Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Mon, 8 Apr 2024 12:00:49 +0200
Subject: [PATCH 01/64] test(e2e): Disable faulty Next.js assertion (#11429)

---
 .../tests/request-instrumentation.test.ts     | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts
index c0a24f747d56..7dbe20e2efb6 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts
@@ -19,14 +19,16 @@ test('Should send a transaction with a fetch span', async ({ page }) => {
     }),
   );
 
-  expect((await transactionPromise).spans).toContainEqual(
-    expect.objectContaining({
-      data: expect.objectContaining({
-        'http.method': 'GET',
-        'sentry.op': 'http.client',
-        'sentry.origin': 'auto.http.otel.http',
-      }),
-      description: 'GET http://example.com/',
-    }),
-  );
+  // TODO: Uncomment the below when fixed. For whatever reason that we now have accepted, spans created with Node.js' http.get() will not attach themselves to transactions.
+  // More info: https://github.com/getsentry/sentry-javascript/pull/11016/files#diff-10fa195789425786c6e5e769380be18790768f0b76319ee41bbb488d9fe50405R4
+  // expect((await transactionPromise).spans).toContainEqual(
+  //   expect.objectContaining({
+  //     data: expect.objectContaining({
+  //       'http.method': 'GET',
+  //       'sentry.op': 'http.client',
+  //       'sentry.origin': 'auto.http.otel.http',
+  //     }),
+  //     description: 'GET http://example.com/',
+  //   }),
+  // );
 });

From f2841167fc9fdead93cb5192d94aa0a2609ac13c Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 8 Apr 2024 11:37:21 +0100
Subject: [PATCH 02/64] fix(opentelemetry): Avoid weakmap for storing data
 (#11470)

It may happen that we have different modules, different versions etc. so
the weakmaps may not be in sync. Just storing a non-enumerable property
should be the safer choice here.

Partially required for next.js 13.4.19 to work....
---
 packages/opentelemetry/src/utils/contextData.ts |  7 ++++---
 packages/opentelemetry/src/utils/spanData.ts    | 16 ++++------------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/packages/opentelemetry/src/utils/contextData.ts b/packages/opentelemetry/src/utils/contextData.ts
index e6e4ab0548d3..8cf0833b0150 100644
--- a/packages/opentelemetry/src/utils/contextData.ts
+++ b/packages/opentelemetry/src/utils/contextData.ts
@@ -1,10 +1,11 @@
 import type { Context } from '@opentelemetry/api';
 import type { Scope } from '@sentry/types';
+import { addNonEnumerableProperty } from '@sentry/utils';
 
 import { SENTRY_SCOPES_CONTEXT_KEY } from '../constants';
 import type { CurrentScopes } from '../types';
 
-const SCOPE_CONTEXT_MAP = new WeakMap<Scope, Context>();
+const SCOPE_CONTEXT_FIELD = '_scopeContext';
 
 /**
  * Try to get the current scopes from the given OTEL context.
@@ -27,7 +28,7 @@ export function setScopesOnContext(context: Context, scopes: CurrentScopes): Con
  * We need this to get the context from the scope in the `trace` functions.
  */
 export function setContextOnScope(scope: Scope, context: Context): void {
-  SCOPE_CONTEXT_MAP.set(scope, context);
+  addNonEnumerableProperty(scope, SCOPE_CONTEXT_FIELD, context);
 }
 
 /**
@@ -35,5 +36,5 @@ export function setContextOnScope(scope: Scope, context: Context): void {
  * TODO v8: Use this for the `trace` functions.
  * */
 export function getContextFromScope(scope: Scope): Context | undefined {
-  return SCOPE_CONTEXT_MAP.get(scope);
+  return (scope as { [SCOPE_CONTEXT_FIELD]?: Context })[SCOPE_CONTEXT_FIELD];
 }
diff --git a/packages/opentelemetry/src/utils/spanData.ts b/packages/opentelemetry/src/utils/spanData.ts
index 8b0ea37bdcd5..3dc00f043f8a 100644
--- a/packages/opentelemetry/src/utils/spanData.ts
+++ b/packages/opentelemetry/src/utils/spanData.ts
@@ -1,17 +1,9 @@
 import type { Scope } from '@sentry/types';
+import { addNonEnumerableProperty } from '@sentry/utils';
 
 import type { AbstractSpan } from '../types';
 
-// We store the parent span, scopes & metadata in separate weakmaps, so we can access them for a given span
-// This way we can enhance the data that an OTEL Span natively gives us
-// and since we are using weakmaps, we do not need to clean up after ourselves
-const SpanScopes = new WeakMap<
-  AbstractSpan,
-  {
-    scope: Scope;
-    isolationScope: Scope;
-  }
->();
+const SPAN_SCOPES_FIELD = '_spanScopes';
 
 /**
  * Set the Sentry scope to be used for finishing a given OTEL span.
@@ -25,7 +17,7 @@ export function setSpanScopes(
     isolationScope: Scope;
   },
 ): void {
-  SpanScopes.set(span, scopes);
+  addNonEnumerableProperty(span, SPAN_SCOPES_FIELD, scopes);
 }
 
 /** Get the Sentry scopes to use for finishing an OTEL span. */
@@ -35,5 +27,5 @@ export function getSpanScopes(span: AbstractSpan):
       isolationScope: Scope;
     }
   | undefined {
-  return SpanScopes.get(span);
+  return (span as { [SPAN_SCOPES_FIELD]?: { scope: Scope; isolationScope: Scope } })[SPAN_SCOPES_FIELD];
 }

From 9c8f0d343a597fcb4602afd2ce87bb6d1a632b55 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 8 Apr 2024 12:10:53 +0100
Subject: [PATCH 03/64] feat(browser): Add `lazyLoadIntegration` utility
 (#11339)

This can be used to lazy load a pluggable integration.

Usage:

```js
async function getOrLazyLoadFeedback() {
  const existing = Sentry.getFeedback(); // check if it has already been installed
  if (existing) {
    return existing;
  }
  try {
    const feedbackIntegration = await Sentry.lazyLoadIntegration('feedbackIntegration');
    client.addIntegration(feedbackIntegration());
  } catch(error) {
    // this can error, we need to handle this!
  }
}
```

Closes https://github.com/getsentry/sentry-javascript/issues/10905
---
 .../lazyLoad/existingIntegration/init.js      | 13 +++
 .../lazyLoad/existingIntegration/subject.js   |  7 ++
 .../lazyLoad/existingIntegration/test.ts      | 24 ++++++
 .../lazyLoad/validIntegration/init.js         | 12 +++
 .../lazyLoad/validIntegration/subject.js      |  7 ++
 .../lazyLoad/validIntegration/test.ts         | 24 ++++++
 packages/browser/src/client.ts                |  5 +-
 packages/browser/src/exports.ts               |  2 +
 .../browser/src/utils/lazyLoadIntegration.ts  | 77 +++++++++++++++++
 .../unit/utils/lazyLoadIntegration.test.ts    | 83 +++++++++++++++++++
 10 files changed, 253 insertions(+), 1 deletion(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/test.ts
 create mode 100644 packages/browser/src/utils/lazyLoadIntegration.ts
 create mode 100644 packages/browser/test/unit/utils/lazyLoadIntegration.test.ts

diff --git a/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/init.js b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/init.js
new file mode 100644
index 000000000000..85b9d1a0fb2e
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/init.js
@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/browser';
+import { httpClientIntegration } from '@sentry/browser';
+
+window.Sentry = {
+  ...Sentry,
+  // This would be done by the CDN bundle otherwise
+  httpClientIntegration: httpClientIntegration,
+};
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [],
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/subject.js b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/subject.js
new file mode 100644
index 000000000000..6ce3c00ab277
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/subject.js
@@ -0,0 +1,7 @@
+window._testLazyLoadIntegration = async function run() {
+  const integration = await window.Sentry.lazyLoadIntegration('httpClientIntegration');
+
+  window.Sentry.getClient()?.addIntegration(integration());
+
+  window._integrationLoaded = true;
+};
diff --git a/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/test.ts b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/test.ts
new file mode 100644
index 000000000000..7faba50a3864
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/existingIntegration/test.ts
@@ -0,0 +1,24 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+
+sentryTest('it bails if the integration is already loaded', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+
+  const hasIntegration = await page.evaluate('!!window.Sentry.getClient()?.getIntegrationByName("HttpClient")');
+  expect(hasIntegration).toBe(false);
+
+  const scriptTagsBefore = await page.evaluate('document.querySelectorAll("script").length');
+
+  await page.evaluate('window._testLazyLoadIntegration()');
+  await page.waitForFunction('window._integrationLoaded');
+
+  const scriptTagsAfter = await page.evaluate('document.querySelectorAll("script").length');
+
+  const hasIntegration2 = await page.evaluate('!!window.Sentry.getClient()?.getIntegrationByName("HttpClient")');
+  expect(hasIntegration2).toBe(true);
+
+  expect(scriptTagsAfter).toBe(scriptTagsBefore);
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/init.js b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/init.js
new file mode 100644
index 000000000000..eb75d30bf760
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/init.js
@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = {
+  ...Sentry,
+  // Ensure this is _not_ set
+  httpClientIntegration: undefined,
+};
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [],
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/subject.js b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/subject.js
new file mode 100644
index 000000000000..6ce3c00ab277
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/subject.js
@@ -0,0 +1,7 @@
+window._testLazyLoadIntegration = async function run() {
+  const integration = await window.Sentry.lazyLoadIntegration('httpClientIntegration');
+
+  window.Sentry.getClient()?.addIntegration(integration());
+
+  window._integrationLoaded = true;
+};
diff --git a/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/test.ts b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/test.ts
new file mode 100644
index 000000000000..d407445c0e84
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/lazyLoad/validIntegration/test.ts
@@ -0,0 +1,24 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+
+sentryTest('it allows to lazy load an integration', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+
+  const hasIntegration = await page.evaluate('!!window.Sentry.getClient()?.getIntegrationByName("HttpClient")');
+  expect(hasIntegration).toBe(false);
+
+  const scriptTagsBefore = await page.evaluate<number>('document.querySelectorAll("script").length');
+
+  await page.evaluate('window._testLazyLoadIntegration()');
+  await page.waitForFunction('window._integrationLoaded');
+
+  const scriptTagsAfter = await page.evaluate<number>('document.querySelectorAll("script").length');
+
+  const hasIntegration2 = await page.evaluate('!!window.Sentry.getClient()?.getIntegrationByName("HttpClient")');
+  expect(hasIntegration2).toBe(true);
+
+  expect(scriptTagsAfter).toBe(scriptTagsBefore + 1);
+});
diff --git a/packages/browser/src/client.ts b/packages/browser/src/client.ts
index 869d28c16c50..882a27cf3881 100644
--- a/packages/browser/src/client.ts
+++ b/packages/browser/src/client.ts
@@ -34,7 +34,10 @@ export type BrowserOptions = Options<BrowserTransportOptions> &
  */
 export type BrowserClientOptions = ClientOptions<BrowserTransportOptions> &
   BrowserClientReplayOptions &
-  BrowserClientProfilingOptions;
+  BrowserClientProfilingOptions & {
+    /** If configured, this URL will be used as base URL for lazy loading integration. */
+    cdnBaseUrl?: string;
+  };
 
 /**
  * The Sentry Browser SDK Client.
diff --git a/packages/browser/src/exports.ts b/packages/browser/src/exports.ts
index a83b1e549eba..2efa7f8ec6d6 100644
--- a/packages/browser/src/exports.ts
+++ b/packages/browser/src/exports.ts
@@ -95,3 +95,5 @@ export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { httpContextIntegration } from './integrations/httpcontext';
 export { linkedErrorsIntegration } from './integrations/linkederrors';
 export { browserApiErrorsIntegration } from './integrations/browserapierrors';
+
+export { lazyLoadIntegration } from './utils/lazyLoadIntegration';
diff --git a/packages/browser/src/utils/lazyLoadIntegration.ts b/packages/browser/src/utils/lazyLoadIntegration.ts
new file mode 100644
index 000000000000..19cf28f1af52
--- /dev/null
+++ b/packages/browser/src/utils/lazyLoadIntegration.ts
@@ -0,0 +1,77 @@
+import { SDK_VERSION, getClient } from '@sentry/core';
+import type { IntegrationFn } from '@sentry/types';
+import type { BrowserClient } from '../client';
+import { WINDOW } from '../helpers';
+
+// This is a map of integration function method to bundle file name.
+const LazyLoadableIntegrations = {
+  replayIntegration: 'replay',
+  replayCanvasIntegration: 'replay-canvas',
+  feedbackIntegration: 'feedback',
+  captureConsoleIntegration: 'captureconsole',
+  contextLinesIntegration: 'contextlines',
+  linkedErrorsIntegration: 'linkederrors',
+  debugIntegration: 'debug',
+  dedupeIntegration: 'dedupe',
+  extraErrorDataIntegration: 'extraerrordata',
+  httpClientIntegration: 'httpclient',
+  reportingObserverIntegration: 'reportingobserver',
+  rewriteFramesIntegration: 'rewriteframes',
+  sessionTimingIntegration: 'sessiontiming',
+} as const;
+
+const WindowWithMaybeIntegration = WINDOW as {
+  Sentry?: Partial<Record<keyof typeof LazyLoadableIntegrations, IntegrationFn>>;
+};
+
+/**
+ * Lazy load an integration from the CDN.
+ * Rejects if the integration cannot be loaded.
+ */
+export async function lazyLoadIntegration(name: keyof typeof LazyLoadableIntegrations): Promise<IntegrationFn> {
+  const bundle = LazyLoadableIntegrations[name];
+
+  if (!bundle || !WindowWithMaybeIntegration.Sentry) {
+    throw new Error(`Cannot lazy load integration: ${name}`);
+  }
+
+  // Bail if the integration already exists
+  const existing = WindowWithMaybeIntegration.Sentry[name];
+  if (typeof existing === 'function') {
+    return existing;
+  }
+
+  const url = getScriptURL(bundle);
+  const script = WINDOW.document.createElement('script');
+  script.src = url;
+  script.crossOrigin = 'anonymous';
+
+  const waitForLoad = new Promise<void>((resolve, reject) => {
+    script.addEventListener('load', () => resolve());
+    script.addEventListener('error', reject);
+  });
+
+  WINDOW.document.body.appendChild(script);
+
+  try {
+    await waitForLoad;
+  } catch {
+    throw new Error(`Error when loading integration: ${name}`);
+  }
+
+  const integrationFn = WindowWithMaybeIntegration.Sentry[name];
+
+  if (typeof integrationFn !== 'function') {
+    throw new Error(`Could not load integration: ${name}`);
+  }
+
+  return integrationFn;
+}
+
+function getScriptURL(bundle: string): string {
+  const client = getClient<BrowserClient>();
+  const options = client && client.getOptions();
+  const baseURL = (options && options.cdnBaseUrl) || 'https://browser.sentry-cdn.com';
+
+  return new URL(`/${SDK_VERSION}/${bundle}.min.js`, baseURL).toString();
+}
diff --git a/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts b/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts
new file mode 100644
index 000000000000..a9a86cbf4374
--- /dev/null
+++ b/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts
@@ -0,0 +1,83 @@
+import { TextDecoder, TextEncoder } from 'util';
+import { SDK_VERSION, lazyLoadIntegration } from '../../../src';
+import * as Sentry from '../../../src';
+const patchedEncoder = (!global.window.TextEncoder && (global.window.TextEncoder = TextEncoder)) || true;
+// @ts-expect-error patch the encoder on the window, else importing JSDOM fails (deleted in afterAll)
+const patchedDecoder = (!global.window.TextDecoder && (global.window.TextDecoder = TextDecoder)) || true;
+
+import { JSDOM } from 'jsdom';
+
+const globalDocument = global.document;
+const globalWindow = global.window;
+const globalLocation = global.location;
+
+describe('lazyLoadIntegration', () => {
+  beforeEach(() => {
+    const dom = new JSDOM('<body></body>', {
+      runScripts: 'dangerously',
+      resources: 'usable',
+    });
+
+    global.document = dom.window.document;
+    // @ts-expect-error need to override global document
+    global.window = dom.window;
+    global.location = dom.window.location;
+    // @ts-expect-error For testing sake
+    global.Sentry = undefined;
+  });
+
+  // Reset back to previous values
+  afterEach(() => {
+    global.document = globalDocument;
+    global.window = globalWindow;
+    global.location = globalLocation;
+  });
+
+  afterAll(() => {
+    // @ts-expect-error patch the encoder on the window, else importing JSDOM fails
+    patchedEncoder && delete global.window.TextEncoder;
+    // @ts-expect-error patch the encoder on the window, else importing JSDOM fails
+    patchedDecoder && delete global.window.TextDecoder;
+  });
+
+  test('it rejects invalid name', async () => {
+    // @ts-expect-error For testing sake - otherwise this bails out anyhow
+    global.Sentry = Sentry;
+
+    // @ts-expect-error we want to test this
+    await expect(() => lazyLoadIntegration('invalid!!!')).rejects.toThrow('Cannot lazy load integration: invalid!!!');
+  });
+
+  test('it rejects without global Sentry variable', async () => {
+    await expect(() => lazyLoadIntegration('httpClientIntegration')).rejects.toThrow(
+      'Cannot lazy load integration: httpClientIntegration',
+    );
+  });
+
+  test('it does not inject a script tag if integration already exists', async () => {
+    // @ts-expect-error For testing sake
+    global.Sentry = Sentry;
+
+    const integration = await lazyLoadIntegration('httpClientIntegration');
+
+    expect(integration).toBe(Sentry.httpClientIntegration);
+    expect(global.document.querySelectorAll('script')).toHaveLength(0);
+  });
+
+  test('it injects a script tag if integration is not yet loaded xxx', async () => {
+    // @ts-expect-error For testing sake
+    global.Sentry = {
+      ...Sentry,
+      httpClientIntegration: undefined,
+    };
+
+    // We do not await here, as this this does not seem to work with JSDOM :(
+    // We have browser integration tests to check that this actually works
+    void lazyLoadIntegration('httpClientIntegration');
+
+    expect(global.document.querySelectorAll('script')).toHaveLength(1);
+    expect(global.document.querySelector('script')?.src).toEqual(
+      `https://browser.sentry-cdn.com/${SDK_VERSION}/httpclient.min.js`,
+    );
+  });
+});

From 83f7ccec7298d77c862b83fce4ef6c1439c31a7e Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 8 Apr 2024 13:11:58 +0200
Subject: [PATCH 04/64] feat(node): Update scope `transactionName` in http and
 express instrumentations (#11434)

Concrete changes:
1. `addRequestDataToEvent` no longer applies its transaction name to
_non-transaction_ events
2. Http instrumentation sets the isolation scope's `transactionName` in
the Otel `requestHook` to the unparameterized request URL path (w/o
query params or fragments).
3. Express instrumentation sets the isolation scope's `transactionName`
in the Otel `spanName` hook to a parameterized route, once a request
handler span (e.g. `app.get(...)`) is created.
4. As a consequence of the above, non-transaction events now get
assigned `event.transaction` correctly from the scopes.
---
 .../express/tracing/withError/server.js       | 29 +++++++
 .../suites/express/tracing/withError/test.ts  | 28 +++++++
 packages/node/src/integrations/http.ts        | 44 +++++++----
 .../node/src/integrations/tracing/express.ts  |  9 +++
 packages/utils/src/requestdata.ts             |  2 +-
 packages/utils/test/requestdata.test.ts       | 77 +++++++++++--------
 6 files changed, 139 insertions(+), 50 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/express/tracing/withError/server.js
 create mode 100644 dev-packages/node-integration-tests/suites/express/tracing/withError/test.ts

diff --git a/dev-packages/node-integration-tests/suites/express/tracing/withError/server.js b/dev-packages/node-integration-tests/suites/express/tracing/withError/server.js
new file mode 100644
index 000000000000..3b45591ec4df
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/tracing/withError/server.js
@@ -0,0 +1,29 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  // disable attaching headers to /test/* endpoints
+  tracePropagationTargets: [/^(?!.*test).*$/],
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+// express must be required after Sentry is initialized
+const express = require('express');
+const cors = require('cors');
+const { startExpressServerAndSendPortToRunner } = require('@sentry-internal/node-integration-tests');
+
+const app = express();
+
+app.use(cors());
+
+app.get('/test/:id1/:id2', (_req, res) => {
+  Sentry.captureMessage(new Error('error_1'));
+  res.send('Success');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/withError/test.ts b/dev-packages/node-integration-tests/suites/express/tracing/withError/test.ts
new file mode 100644
index 000000000000..f164bdd0caab
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/tracing/withError/test.ts
@@ -0,0 +1,28 @@
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+describe('express tracing experimental', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  describe('CJS', () => {
+    test('should apply the scope transactionName to error events', done => {
+      createRunner(__dirname, 'server.js')
+        .ignore('session', 'sessions', 'transaction')
+        .expect({
+          event: {
+            exception: {
+              values: [
+                {
+                  value: 'error_1',
+                },
+              ],
+            },
+            transaction: 'GET /test/:id1/:id2',
+          },
+        })
+        .start(done)
+        .makeRequest('get', '/test/123/abc?q=1');
+    });
+  });
+});
diff --git a/packages/node/src/integrations/http.ts b/packages/node/src/integrations/http.ts
index ed93ebacdaa5..c01b6dcf871b 100644
--- a/packages/node/src/integrations/http.ts
+++ b/packages/node/src/integrations/http.ts
@@ -4,10 +4,11 @@ import { SpanKind } from '@opentelemetry/api';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
 
-import { addBreadcrumb, defineIntegration, getIsolationScope, isSentryRequestUrl } from '@sentry/core';
+import { addBreadcrumb, defineIntegration, getIsolationScope, isSentryRequestUrl, spanToJSON } from '@sentry/core';
 import { _INTERNAL, getClient, getSpanKind } from '@sentry/opentelemetry';
 import type { IntegrationFn } from '@sentry/types';
 
+import { stripUrlQueryAndFragment } from '@sentry/utils';
 import type { NodeClient } from '../sdk/client';
 import { setIsolationScope } from '../sdk/scope';
 import type { HTTPModuleRequestIncomingMessage } from '../transports/http-module';
@@ -81,19 +82,35 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
           requireParentforOutgoingSpans: true,
           requireParentforIncomingSpans: false,
           requestHook: (span, req) => {
-            _updateSpan(span);
+            addOriginToSpan(span, 'auto.http.otel.http');
+
+            if (getSpanKind(span) !== SpanKind.SERVER) {
+              return;
+            }
 
             // Update the isolation scope, isolate this request
-            if (getSpanKind(span) === SpanKind.SERVER) {
-              const isolationScope = getIsolationScope().clone();
-              isolationScope.setSDKProcessingMetadata({ request: req });
-
-              const client = getClient<NodeClient>();
-              if (client && client.getOptions().autoSessionTracking) {
-                isolationScope.setRequestSession({ status: 'ok' });
-              }
-              setIsolationScope(isolationScope);
+            const isolationScope = getIsolationScope().clone();
+            isolationScope.setSDKProcessingMetadata({ request: req });
+
+            const client = getClient<NodeClient>();
+            if (client && client.getOptions().autoSessionTracking) {
+              isolationScope.setRequestSession({ status: 'ok' });
             }
+            setIsolationScope(isolationScope);
+
+            // attempt to update the scope's `transactionName` based on the request URL
+            // Ideally, framework instrumentations coming after the HttpInstrumentation
+            // update the transactionName once we get a parameterized route.
+            const attributes = spanToJSON(span).data;
+            if (!attributes) {
+              return;
+            }
+
+            const httpMethod = String(attributes['http.method']).toUpperCase() || 'GET';
+            const httpTarget = stripUrlQueryAndFragment(String(attributes['http.target'])) || '/';
+            const bestEffortTransactionName = `${httpMethod} ${httpTarget}`;
+
+            isolationScope.setTransactionName(bestEffortTransactionName);
           },
           responseHook: (span, res) => {
             if (_breadcrumbs) {
@@ -123,11 +140,6 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
  */
 export const httpIntegration = defineIntegration(_httpIntegration);
 
-/** Update the span with data we need. */
-function _updateSpan(span: Span): void {
-  addOriginToSpan(span, 'auto.http.otel.http');
-}
-
 /** Add a breadcrumb for outgoing requests. */
 function _addRequestBreadcrumb(span: Span, response: HTTPModuleRequestIncomingMessage | ServerResponse): void {
   if (getSpanKind(span) !== SpanKind.CLIENT) {
diff --git a/packages/node/src/integrations/tracing/express.ts b/packages/node/src/integrations/tracing/express.ts
index 12e44199e16d..57ea1cb75ac0 100644
--- a/packages/node/src/integrations/tracing/express.ts
+++ b/packages/node/src/integrations/tracing/express.ts
@@ -18,6 +18,15 @@ const _expressIntegration = (() => {
             requestHook(span) {
               addOriginToSpan(span, 'auto.http.otel.express');
             },
+            spanNameHook(info, defaultName) {
+              if (info.layerType === 'request_handler') {
+                // type cast b/c Otel unfortunately types info.request as any :(
+                const req = info.request as { method?: string };
+                const method = req.method ? req.method.toUpperCase() : 'GET';
+                getIsolationScope().setTransactionName(`${method} ${info.route}`);
+              }
+              return defaultName;
+            },
           }),
         ],
       });
diff --git a/packages/utils/src/requestdata.ts b/packages/utils/src/requestdata.ts
index 807bc0541c2c..85133521ef76 100644
--- a/packages/utils/src/requestdata.ts
+++ b/packages/utils/src/requestdata.ts
@@ -298,7 +298,7 @@ export function addRequestDataToEvent(
     }
   }
 
-  if (include.transaction && !event.transaction) {
+  if (include.transaction && !event.transaction && event.type === 'transaction') {
     // TODO do we even need this anymore?
     // TODO make this work for nextjs
     event.transaction = extractTransaction(req, include.transaction);
diff --git a/packages/utils/test/requestdata.test.ts b/packages/utils/test/requestdata.test.ts
index 3bd5ac507268..7e44f703c62a 100644
--- a/packages/utils/test/requestdata.test.ts
+++ b/packages/utils/test/requestdata.test.ts
@@ -149,52 +149,63 @@ describe('addRequestDataToEvent', () => {
   });
 
   describe('transaction property', () => {
-    test('extracts method and full route path by default`', () => {
-      const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
+    describe('for transaction events', () => {
+      beforeEach(() => {
+        mockEvent.type = 'transaction';
+      });
 
-      expect(parsedRequest.transaction).toEqual('POST /routerMountPath/subpath/:parameterName');
-    });
+      test('extracts method and full route path by default`', () => {
+        const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
 
-    test('extracts method and full path by default when mountpoint is `/`', () => {
-      mockReq.originalUrl = mockReq.originalUrl.replace('/routerMountpath', '');
-      mockReq.baseUrl = '';
+        expect(parsedRequest.transaction).toEqual('POST /routerMountPath/subpath/:parameterName');
+      });
 
-      const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
+      test('extracts method and full path by default when mountpoint is `/`', () => {
+        mockReq.originalUrl = mockReq.originalUrl.replace('/routerMountpath', '');
+        mockReq.baseUrl = '';
 
-      // `subpath/` is the full path here, because there's no router mount path
-      expect(parsedRequest.transaction).toEqual('POST /subpath/:parameterName');
-    });
+        const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
 
-    test('fallback to method and `originalUrl` if route is missing', () => {
-      delete mockReq.route;
+        // `subpath/` is the full path here, because there's no router mount path
+        expect(parsedRequest.transaction).toEqual('POST /subpath/:parameterName');
+      });
 
-      const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
+      test('fallback to method and `originalUrl` if route is missing', () => {
+        delete mockReq.route;
 
-      expect(parsedRequest.transaction).toEqual('POST /routerMountPath/subpath/specificValue');
-    });
+        const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
 
-    test('can extract path only instead if configured', () => {
-      const optionsWithPathTransaction = {
-        include: {
-          transaction: 'path',
-        },
-      } as const;
+        expect(parsedRequest.transaction).toEqual('POST /routerMountPath/subpath/specificValue');
+      });
 
-      const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq, optionsWithPathTransaction);
+      test('can extract path only instead if configured', () => {
+        const optionsWithPathTransaction = {
+          include: {
+            transaction: 'path',
+          },
+        } as const;
 
-      expect(parsedRequest.transaction).toEqual('/routerMountPath/subpath/:parameterName');
-    });
+        const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq, optionsWithPathTransaction);
 
-    test('can extract handler name instead if configured', () => {
-      const optionsWithHandlerTransaction = {
-        include: {
-          transaction: 'handler',
-        },
-      } as const;
+        expect(parsedRequest.transaction).toEqual('/routerMountPath/subpath/:parameterName');
+      });
 
-      const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq, optionsWithHandlerTransaction);
+      test('can extract handler name instead if configured', () => {
+        const optionsWithHandlerTransaction = {
+          include: {
+            transaction: 'handler',
+          },
+        } as const;
+
+        const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq, optionsWithHandlerTransaction);
+
+        expect(parsedRequest.transaction).toEqual('parameterNameRouteHandler');
+      });
+    });
+    it('transaction is not applied to non-transaction events', () => {
+      const parsedRequest: Event = addRequestDataToEvent(mockEvent, mockReq);
 
-      expect(parsedRequest.transaction).toEqual('parameterNameRouteHandler');
+      expect(parsedRequest.transaction).toBeUndefined();
     });
   });
 });

From a1e4efe98af16077123dfde6c28ed2eed7c8f060 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 8 Apr 2024 14:00:21 +0100
Subject: [PATCH 05/64] fix(opentelemetry): Use scope span capturing from core
 (#11475)

To ensure we can use this in an isomorphic way.

This means we do not rely on this being a mutable object anymore, but we
need to ensure to update it (in http integration) on both the span _and_
for the current context.
---
 packages/core/src/tracing/index.ts            |  1 +
 packages/node/src/integrations/http.ts        | 18 +++++++++--
 packages/node/test/integration/scope.test.ts  |  6 ++--
 packages/opentelemetry/src/index.ts           |  1 -
 packages/opentelemetry/src/spanExporter.ts    | 14 ++++++---
 packages/opentelemetry/src/spanProcessor.ts   |  4 +--
 packages/opentelemetry/src/utils/spanData.ts  | 31 -------------------
 .../test/integration/scope.test.ts            |  4 +--
 8 files changed, 33 insertions(+), 46 deletions(-)
 delete mode 100644 packages/opentelemetry/src/utils/spanData.ts

diff --git a/packages/core/src/tracing/index.ts b/packages/core/src/tracing/index.ts
index cd9ca5ea6351..7cc86ae76531 100644
--- a/packages/core/src/tracing/index.ts
+++ b/packages/core/src/tracing/index.ts
@@ -1,3 +1,4 @@
+export { setCapturedScopesOnSpan, getCapturedScopesOnSpan } from './utils';
 export { addTracingExtensions } from './hubextensions';
 export { startIdleSpan, TRACING_DEFAULTS } from './idleSpan';
 export { SentrySpan } from './sentrySpan';
diff --git a/packages/node/src/integrations/http.ts b/packages/node/src/integrations/http.ts
index c01b6dcf871b..1c7c9bc8842e 100644
--- a/packages/node/src/integrations/http.ts
+++ b/packages/node/src/integrations/http.ts
@@ -4,7 +4,16 @@ import { SpanKind } from '@opentelemetry/api';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
 
-import { addBreadcrumb, defineIntegration, getIsolationScope, isSentryRequestUrl, spanToJSON } from '@sentry/core';
+import {
+  addBreadcrumb,
+  defineIntegration,
+  getCapturedScopesOnSpan,
+  getCurrentScope,
+  getIsolationScope,
+  isSentryRequestUrl,
+  setCapturedScopesOnSpan,
+  spanToJSON,
+} from '@sentry/core';
 import { _INTERNAL, getClient, getSpanKind } from '@sentry/opentelemetry';
 import type { IntegrationFn } from '@sentry/types';
 
@@ -88,8 +97,12 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
               return;
             }
 
+            const scopes = getCapturedScopesOnSpan(span);
+
             // Update the isolation scope, isolate this request
-            const isolationScope = getIsolationScope().clone();
+            const isolationScope = (scopes.isolationScope || getIsolationScope()).clone();
+            const scope = scopes.scope || getCurrentScope();
+
             isolationScope.setSDKProcessingMetadata({ request: req });
 
             const client = getClient<NodeClient>();
@@ -97,6 +110,7 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
               isolationScope.setRequestSession({ status: 'ok' });
             }
             setIsolationScope(isolationScope);
+            setCapturedScopesOnSpan(span, scope, isolationScope);
 
             // attempt to update the scope's `transactionName` based on the request URL
             // Ideally, framework instrumentations coming after the HttpInstrumentation
diff --git a/packages/node/test/integration/scope.test.ts b/packages/node/test/integration/scope.test.ts
index db3f61d251ba..ed9f20cf2b6c 100644
--- a/packages/node/test/integration/scope.test.ts
+++ b/packages/node/test/integration/scope.test.ts
@@ -1,5 +1,5 @@
-import { getCurrentScope } from '@sentry/core';
-import { getClient, getSpanScopes } from '@sentry/opentelemetry';
+import { getCapturedScopesOnSpan, getCurrentScope } from '@sentry/core';
+import { getClient } from '@sentry/opentelemetry';
 import { clearGlobalScope } from '../../../core/test/lib/clear-global-scope';
 
 import * as Sentry from '../../src/';
@@ -42,7 +42,7 @@ describe('Integration | Scope', () => {
           scope2.setTag('tag3', 'val3');
 
           Sentry.startSpan({ name: 'outer' }, span => {
-            expect(getSpanScopes(span)?.scope).toBe(enableTracing ? scope2 : undefined);
+            expect(getCapturedScopesOnSpan(span)?.scope).toBe(enableTracing ? scope2 : undefined);
 
             spanId = span.spanContext().spanId;
             traceId = span.spanContext().traceId;
diff --git a/packages/opentelemetry/src/index.ts b/packages/opentelemetry/src/index.ts
index 8cae9b317837..776dd8c50d0c 100644
--- a/packages/opentelemetry/src/index.ts
+++ b/packages/opentelemetry/src/index.ts
@@ -4,7 +4,6 @@ export type { OpenTelemetryClient } from './types';
 export { wrapClientClass } from './custom/client';
 
 export { getSpanKind } from './utils/getSpanKind';
-export { getSpanScopes } from './utils/spanData';
 
 export { getScopesFromContext } from './utils/contextData';
 
diff --git a/packages/opentelemetry/src/spanExporter.ts b/packages/opentelemetry/src/spanExporter.ts
index a2603fe91718..bdebb8e2f6e0 100644
--- a/packages/opentelemetry/src/spanExporter.ts
+++ b/packages/opentelemetry/src/spanExporter.ts
@@ -2,7 +2,12 @@ import type { Span } from '@opentelemetry/api';
 import { SpanKind } from '@opentelemetry/api';
 import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
-import { captureEvent, getMetricSummaryJsonForSpan, timedEventsToMeasurements } from '@sentry/core';
+import {
+  captureEvent,
+  getCapturedScopesOnSpan,
+  getMetricSummaryJsonForSpan,
+  timedEventsToMeasurements,
+} from '@sentry/core';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
@@ -23,7 +28,6 @@ import { getLocalParentId } from './utils/groupSpansWithParents';
 import { groupSpansWithParents } from './utils/groupSpansWithParents';
 import { mapStatus } from './utils/mapStatus';
 import { parseSpanDescription } from './utils/parseSpanDescription';
-import { getSpanScopes } from './utils/spanData';
 
 type SpanNodeCompleted = SpanNode & { span: ReadableSpan };
 
@@ -176,7 +180,7 @@ function parseSpan(span: ReadableSpan): { op?: string; origin?: SpanOrigin; sour
 
 function createTransactionForOtelSpan(span: ReadableSpan): TransactionEvent {
   const { op, description, data, origin = 'manual', source } = getSpanData(span);
-  const capturedSpanScopes = getSpanScopes(span);
+  const capturedSpanScopes = getCapturedScopesOnSpan(span as unknown as Span);
 
   const sampleRate = span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE] as number | undefined;
 
@@ -220,8 +224,8 @@ function createTransactionForOtelSpan(span: ReadableSpan): TransactionEvent {
     type: 'transaction',
     sdkProcessingMetadata: {
       ...dropUndefinedKeys({
-        capturedSpanScope: capturedSpanScopes?.scope,
-        capturedSpanIsolationScope: capturedSpanScopes?.isolationScope,
+        capturedSpanScope: capturedSpanScopes.scope,
+        capturedSpanIsolationScope: capturedSpanScopes.isolationScope,
         sampleRate,
         dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),
       }),
diff --git a/packages/opentelemetry/src/spanProcessor.ts b/packages/opentelemetry/src/spanProcessor.ts
index 740afc2cc6fa..e3f604cab64b 100644
--- a/packages/opentelemetry/src/spanProcessor.ts
+++ b/packages/opentelemetry/src/spanProcessor.ts
@@ -8,12 +8,12 @@ import {
   getDefaultIsolationScope,
   logSpanEnd,
   logSpanStart,
+  setCapturedScopesOnSpan,
 } from '@sentry/core';
 import { SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE } from './semanticAttributes';
 import { SentrySpanExporter } from './spanExporter';
 import { getScopesFromContext } from './utils/contextData';
 import { setIsSetup } from './utils/setupCheck';
-import { setSpanScopes } from './utils/spanData';
 
 function onSpanStart(span: Span, parentContext: Context): void {
   // This is a reliable way to get the parent span - because this is exactly how the parent is identified in the OTEL SDK
@@ -42,7 +42,7 @@ function onSpanStart(span: Span, parentContext: Context): void {
 
   // We need the scope at time of span creation in order to apply it to the event when the span is finished
   if (scopes) {
-    setSpanScopes(span, scopes);
+    setCapturedScopesOnSpan(span, scopes.scope, scopes.isolationScope);
   }
 
   logSpanStart(span);
diff --git a/packages/opentelemetry/src/utils/spanData.ts b/packages/opentelemetry/src/utils/spanData.ts
deleted file mode 100644
index 3dc00f043f8a..000000000000
--- a/packages/opentelemetry/src/utils/spanData.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import type { Scope } from '@sentry/types';
-import { addNonEnumerableProperty } from '@sentry/utils';
-
-import type { AbstractSpan } from '../types';
-
-const SPAN_SCOPES_FIELD = '_spanScopes';
-
-/**
- * Set the Sentry scope to be used for finishing a given OTEL span.
- * This is different from `setCapturedScopesOnSpan`, as that works on _sentry_ spans,
- * while here we are basically "caching" this on the otel spans.
- */
-export function setSpanScopes(
-  span: AbstractSpan,
-  scopes: {
-    scope: Scope;
-    isolationScope: Scope;
-  },
-): void {
-  addNonEnumerableProperty(span, SPAN_SCOPES_FIELD, scopes);
-}
-
-/** Get the Sentry scopes to use for finishing an OTEL span. */
-export function getSpanScopes(span: AbstractSpan):
-  | {
-      scope: Scope;
-      isolationScope: Scope;
-    }
-  | undefined {
-  return (span as { [SPAN_SCOPES_FIELD]?: { scope: Scope; isolationScope: Scope } })[SPAN_SCOPES_FIELD];
-}
diff --git a/packages/opentelemetry/test/integration/scope.test.ts b/packages/opentelemetry/test/integration/scope.test.ts
index 7742fcf06767..e17516a9d7bf 100644
--- a/packages/opentelemetry/test/integration/scope.test.ts
+++ b/packages/opentelemetry/test/integration/scope.test.ts
@@ -1,5 +1,6 @@
 import {
   captureException,
+  getCapturedScopesOnSpan,
   getClient,
   getCurrentScope,
   getIsolationScope,
@@ -9,7 +10,6 @@ import {
 } from '@sentry/core';
 
 import { startSpan } from '../../src/trace';
-import { getSpanScopes } from '../../src/utils/spanData';
 import type { TestClientInterface } from '../helpers/TestClient';
 import { cleanupOtel, mockSdkInit } from '../helpers/mockSdkInit';
 
@@ -49,7 +49,7 @@ describe('Integration | Scope', () => {
           scope2.setTag('tag3', 'val3');
 
           startSpan({ name: 'outer' }, span => {
-            expect(getSpanScopes(span)?.scope).toBe(enableTracing ? scope2 : undefined);
+            expect(getCapturedScopesOnSpan(span)?.scope).toBe(enableTracing ? scope2 : undefined);
 
             spanId = span.spanContext().spanId;
             traceId = span.spanContext().traceId;

From 8aca02debd9272b5d5f4b6540f990883baf32f11 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Mon, 8 Apr 2024 09:26:20 -0400
Subject: [PATCH 06/64] ref(browser): Move utils to
 @sentry-internal/browser-utils (#11451)

ref https://github.com/getsentry/sentry-javascript/issues/9832

Building off https://github.com/getsentry/sentry-javascript/pull/11381,
this moves browser related utils into the browser utils package.

Next step is to move `browserTracingIntegration` into browser!
---
 packages/browser-utils/.eslintrc.js           |  3 +++
 .../src/browser/backgroundtab.ts              |  2 +-
 .../src/browser/browserTracingIntegration.ts  | 13 +++------
 .../browser-utils/src/browser/instrument.ts   |  2 +-
 .../src/browser/metrics/index.ts              |  2 +-
 packages/browser-utils/src/browser/request.ts |  3 +--
 .../src/{common => }/debug-build.ts           |  0
 packages/browser-utils/src/index.ts           |  9 +++++++
 .../src/instrument/dom.ts                     | 15 +++--------
 .../src/instrument/history.ts                 | 17 +++---------
 .../src/instrument/xhr.ts                     | 27 +++++++------------
 .../test/browser/request.test.ts              |  7 ++---
 .../test/instrument/dom.test.ts               |  4 +--
 .../test/instrument/xhr.test.ts               |  5 ++--
 .../browser/src/integrations/breadcrumbs.ts   | 20 +++++++-------
 .../browser/src/integrations/httpclient.ts    |  3 +--
 packages/browser/src/profiling/integration.ts |  3 +--
 packages/browser/src/profiling/utils.ts       | 13 +++++++--
 packages/browser/src/sdk.ts                   |  9 ++-----
 packages/deno/src/integrations/breadcrumbs.ts | 11 ++++++--
 .../src/coreHandlers/util/xhrUtils.ts         |  3 ++-
 .../src/util/addGlobalListeners.ts            |  5 +++-
 .../beforeAddRecordingEvent.test.ts           |  4 +--
 .../test/integration/flush.test.ts            |  3 ++-
 .../test/integration/sendReplayEvent.test.ts  |  4 +--
 .../test/integration/stop.test.ts             |  4 +--
 .../test/mocks/resetSdkMock.ts                |  4 +--
 .../handleNetworkBreadcrumbs.test.ts          |  2 +-
 packages/utils/src/instrument/console.ts      |  2 +-
 packages/utils/src/instrument/fetch.ts        |  2 +-
 packages/utils/src/instrument/globalError.ts  |  2 +-
 .../instrument/globalUnhandledRejection.ts    |  2 +-
 .../instrument/{_handlers.ts => handlers.ts}  |  0
 packages/utils/src/instrument/index.ts        | 14 +++-------
 34 files changed, 105 insertions(+), 114 deletions(-)
 rename packages/browser-utils/src/{common => }/debug-build.ts (100%)
 rename packages/{utils => browser-utils}/src/instrument/dom.ts (94%)
 rename packages/{utils => browser-utils}/src/instrument/history.ts (78%)
 rename packages/{utils => browser-utils}/src/instrument/xhr.ts (86%)
 rename packages/{utils => browser-utils}/test/instrument/dom.test.ts (75%)
 rename packages/{utils => browser-utils}/test/instrument/xhr.test.ts (75%)
 rename packages/utils/src/instrument/{_handlers.ts => handlers.ts} (100%)

diff --git a/packages/browser-utils/.eslintrc.js b/packages/browser-utils/.eslintrc.js
index 50f4342a74c6..7346008450be 100644
--- a/packages/browser-utils/.eslintrc.js
+++ b/packages/browser-utils/.eslintrc.js
@@ -1,5 +1,8 @@
 module.exports = {
   extends: ['../../.eslintrc.js'],
+  env: {
+    browser: true,
+  },
   overrides: [
     {
       files: ['src/**'],
diff --git a/packages/browser-utils/src/browser/backgroundtab.ts b/packages/browser-utils/src/browser/backgroundtab.ts
index 928503ba6869..a3ed7d88bd3e 100644
--- a/packages/browser-utils/src/browser/backgroundtab.ts
+++ b/packages/browser-utils/src/browser/backgroundtab.ts
@@ -2,7 +2,7 @@ import { SPAN_STATUS_ERROR, getActiveSpan, getRootSpan } from '@sentry/core';
 import { spanToJSON } from '@sentry/core';
 import { logger } from '@sentry/utils';
 
-import { DEBUG_BUILD } from '../common/debug-build';
+import { DEBUG_BUILD } from '../debug-build';
 import { WINDOW } from './types';
 
 /**
diff --git a/packages/browser-utils/src/browser/browserTracingIntegration.ts b/packages/browser-utils/src/browser/browserTracingIntegration.ts
index 5954ca9d4502..02ea72497a3d 100644
--- a/packages/browser-utils/src/browser/browserTracingIntegration.ts
+++ b/packages/browser-utils/src/browser/browserTracingIntegration.ts
@@ -16,15 +16,10 @@ import {
 } from '@sentry/core';
 import type { Client, IntegrationFn, StartSpanOptions, TransactionSource } from '@sentry/types';
 import type { Span } from '@sentry/types';
-import {
-  addHistoryInstrumentationHandler,
-  browserPerformanceTimeOrigin,
-  getDomElement,
-  logger,
-  uuid4,
-} from '@sentry/utils';
-
-import { DEBUG_BUILD } from '../common/debug-build';
+import { browserPerformanceTimeOrigin, getDomElement, logger, uuid4 } from '@sentry/utils';
+
+import { DEBUG_BUILD } from '../debug-build';
+import { addHistoryInstrumentationHandler } from '../instrument/history';
 import { registerBackgroundTabDetection } from './backgroundtab';
 import {
   addPerformanceEntries,
diff --git a/packages/browser-utils/src/browser/instrument.ts b/packages/browser-utils/src/browser/instrument.ts
index e4af4805315a..535f584dddb1 100644
--- a/packages/browser-utils/src/browser/instrument.ts
+++ b/packages/browser-utils/src/browser/instrument.ts
@@ -1,6 +1,6 @@
 import { getFunctionName, logger } from '@sentry/utils';
 
-import { DEBUG_BUILD } from '../common/debug-build';
+import { DEBUG_BUILD } from '../debug-build';
 import { onCLS } from './web-vitals/getCLS';
 import { onFID } from './web-vitals/getFID';
 import { onLCP } from './web-vitals/getLCP';
diff --git a/packages/browser-utils/src/browser/metrics/index.ts b/packages/browser-utils/src/browser/metrics/index.ts
index 770ec8354596..ec3de991d593 100644
--- a/packages/browser-utils/src/browser/metrics/index.ts
+++ b/packages/browser-utils/src/browser/metrics/index.ts
@@ -5,7 +5,7 @@ import type { Measurements, Span, SpanAttributes, StartSpanOptions } from '@sent
 import { browserPerformanceTimeOrigin, getComponentName, htmlTreeAsString, logger, parseUrl } from '@sentry/utils';
 
 import { spanToJSON } from '@sentry/core';
-import { DEBUG_BUILD } from '../../common/debug-build';
+import { DEBUG_BUILD } from '../../debug-build';
 import {
   addClsInstrumentationHandler,
   addFidInstrumentationHandler,
diff --git a/packages/browser-utils/src/browser/request.ts b/packages/browser-utils/src/browser/request.ts
index b808136b0325..73038996d7c0 100644
--- a/packages/browser-utils/src/browser/request.ts
+++ b/packages/browser-utils/src/browser/request.ts
@@ -16,14 +16,13 @@ import {
 import type { HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/types';
 import {
   BAGGAGE_HEADER_NAME,
-  SENTRY_XHR_DATA_KEY,
   addFetchInstrumentationHandler,
-  addXhrInstrumentationHandler,
   browserPerformanceTimeOrigin,
   dynamicSamplingContextToSentryBaggageHeader,
   generateSentryTraceHeader,
   stringMatchesSomePattern,
 } from '@sentry/utils';
+import { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler } from '../instrument/xhr';
 
 import { addPerformanceInstrumentationHandler } from './instrument';
 import { WINDOW } from './types';
diff --git a/packages/browser-utils/src/common/debug-build.ts b/packages/browser-utils/src/debug-build.ts
similarity index 100%
rename from packages/browser-utils/src/common/debug-build.ts
rename to packages/browser-utils/src/debug-build.ts
diff --git a/packages/browser-utils/src/index.ts b/packages/browser-utils/src/index.ts
index 019639e8c0b3..0824c9f50358 100644
--- a/packages/browser-utils/src/index.ts
+++ b/packages/browser-utils/src/index.ts
@@ -12,4 +12,13 @@ export {
   addLcpInstrumentationHandler,
 } from './browser';
 
+export { addClickKeypressInstrumentationHandler } from './instrument/dom';
+
+export { addHistoryInstrumentationHandler } from './instrument/history';
+
+export {
+  addXhrInstrumentationHandler,
+  SENTRY_XHR_DATA_KEY,
+} from './instrument/xhr';
+
 export type { RequestInstrumentationOptions } from './browser';
diff --git a/packages/utils/src/instrument/dom.ts b/packages/browser-utils/src/instrument/dom.ts
similarity index 94%
rename from packages/utils/src/instrument/dom.ts
rename to packages/browser-utils/src/instrument/dom.ts
index aab64c8c149b..4dfa5992aa07 100644
--- a/packages/utils/src/instrument/dom.ts
+++ b/packages/browser-utils/src/instrument/dom.ts
@@ -1,13 +1,7 @@
-// TODO(v8): Move everything in this file into the browser package. Nothing here is generic and we run risk of leaking browser types into non-browser packages.
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
 import type { HandlerDataDom } from '@sentry/types';
 
-import { uuid4 } from '../misc';
-import { addNonEnumerableProperty, fill } from '../object';
-import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
+import { addHandler, addNonEnumerableProperty, fill, maybeInstrument, triggerHandlers, uuid4 } from '@sentry/utils';
+import { WINDOW } from '../browser/types';
 
 type SentryWrappedTarget = HTMLElement & { _sentryId?: string };
 
@@ -25,14 +19,13 @@ type RemoveEventListener = (
 type InstrumentedElement = Element & {
   __sentry_instrumentation_handlers__?: {
     [key in 'click' | 'keypress']?: {
-      handler?: Function;
+      handler?: unknown;
       /** The number of custom listeners attached to this element */
       refCount: number;
     };
   };
 };
 
-const WINDOW = GLOBAL_OBJ as unknown as Window;
 const DEBOUNCE_DURATION = 1000;
 
 let debounceTimerID: number | undefined;
@@ -71,7 +64,7 @@ export function instrumentDOM(): void {
   // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
   // guaranteed to fire at least once.)
   ['EventTarget', 'Node'].forEach((target: string) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
     const proto = (WINDOW as any)[target] && (WINDOW as any)[target].prototype;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
     if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
diff --git a/packages/utils/src/instrument/history.ts b/packages/browser-utils/src/instrument/history.ts
similarity index 78%
rename from packages/utils/src/instrument/history.ts
rename to packages/browser-utils/src/instrument/history.ts
index dc144c0e5818..c918cd4ce2dc 100644
--- a/packages/utils/src/instrument/history.ts
+++ b/packages/browser-utils/src/instrument/history.ts
@@ -1,15 +1,6 @@
-// TODO(v8): Move everything in this file into the browser package. Nothing here is generic and we run risk of leaking browser types into non-browser packages.
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
 import type { HandlerDataHistory } from '@sentry/types';
-
-import { fill } from '../object';
-import { supportsHistory } from '../supports';
-import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
-
-const WINDOW = GLOBAL_OBJ as unknown as Window;
+import { addHandler, fill, maybeInstrument, supportsHistory, triggerHandlers } from '@sentry/utils';
+import { WINDOW } from '../browser/types';
 
 let lastHref: string | undefined;
 
@@ -33,7 +24,7 @@ function instrumentHistory(): void {
   }
 
   const oldOnPopState = WINDOW.onpopstate;
-  WINDOW.onpopstate = function (this: WindowEventHandlers, ...args: any[]): any {
+  WINDOW.onpopstate = function (this: WindowEventHandlers, ...args: unknown[]) {
     const to = WINDOW.location.href;
     // keep track of the current URL state, as we always receive only the updated state
     const from = lastHref;
@@ -53,7 +44,7 @@ function instrumentHistory(): void {
   };
 
   function historyReplacementFunction(originalHistoryFunction: () => void): () => void {
-    return function (this: History, ...args: any[]): void {
+    return function (this: History, ...args: unknown[]): void {
       const url = args.length > 2 ? args[2] : undefined;
       if (url) {
         // coerce to string (this is what pushState does)
diff --git a/packages/utils/src/instrument/xhr.ts b/packages/browser-utils/src/instrument/xhr.ts
similarity index 86%
rename from packages/utils/src/instrument/xhr.ts
rename to packages/browser-utils/src/instrument/xhr.ts
index b00300fd553a..05db402872ed 100644
--- a/packages/utils/src/instrument/xhr.ts
+++ b/packages/browser-utils/src/instrument/xhr.ts
@@ -1,18 +1,12 @@
-// TODO(v8): Move everything in this file into the browser package. Nothing here is generic and we run risk of leaking browser types into non-browser packages.
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
 import type { HandlerDataXhr, SentryWrappedXMLHttpRequest, WrappedFunction } from '@sentry/types';
 
-import { isString } from '../is';
-import { fill } from '../object';
-import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
-
-const WINDOW = GLOBAL_OBJ as unknown as Window;
+import { addHandler, fill, isString, maybeInstrument, triggerHandlers } from '@sentry/utils';
+import { WINDOW } from '../browser/types';
 
 export const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';
 
+type WindowWithXhr = Window & { XMLHttpRequest?: typeof XMLHttpRequest };
+
 /**
  * Add an instrumentation handler for when an XHR request happens.
  * The handler function is called once when the request starts and once when it ends,
@@ -29,15 +23,14 @@ export function addXhrInstrumentationHandler(handler: (data: HandlerDataXhr) =>
 
 /** Exported only for tests. */
 export function instrumentXHR(): void {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  if (!(WINDOW as any).XMLHttpRequest) {
+  if (!(WINDOW as WindowWithXhr).XMLHttpRequest) {
     return;
   }
 
   const xhrproto = XMLHttpRequest.prototype;
 
   fill(xhrproto, 'open', function (originalOpen: () => void): () => void {
-    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: any[]): void {
+    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: unknown[]): void {
       const startTimestamp = Date.now();
 
       // open() should always be called with two or more arguments
@@ -87,8 +80,8 @@ export function instrumentXHR(): void {
       };
 
       if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {
-        fill(this, 'onreadystatechange', function (original: WrappedFunction): Function {
-          return function (this: SentryWrappedXMLHttpRequest, ...readyStateArgs: any[]): void {
+        fill(this, 'onreadystatechange', function (original: WrappedFunction) {
+          return function (this: SentryWrappedXMLHttpRequest, ...readyStateArgs: unknown[]): void {
             onreadystatechangeHandler();
             return original.apply(this, readyStateArgs);
           };
@@ -100,7 +93,7 @@ export function instrumentXHR(): void {
       // Intercepting `setRequestHeader` to access the request headers of XHR instance.
       // This will only work for user/library defined headers, not for the default/browser-assigned headers.
       // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.
-      fill(this, 'setRequestHeader', function (original: WrappedFunction): Function {
+      fill(this, 'setRequestHeader', function (original: WrappedFunction) {
         return function (this: SentryWrappedXMLHttpRequest, ...setRequestHeaderArgs: unknown[]): void {
           const [header, value] = setRequestHeaderArgs;
 
@@ -119,7 +112,7 @@ export function instrumentXHR(): void {
   });
 
   fill(xhrproto, 'send', function (originalSend: () => void): () => void {
-    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: any[]): void {
+    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: unknown[]): void {
       const sentryXhrData = this[SENTRY_XHR_DATA_KEY];
 
       if (!sentryXhrData) {
diff --git a/packages/browser-utils/test/browser/request.test.ts b/packages/browser-utils/test/browser/request.test.ts
index 8855203ce136..0671e8d5805c 100644
--- a/packages/browser-utils/test/browser/request.test.ts
+++ b/packages/browser-utils/test/browser/request.test.ts
@@ -1,6 +1,7 @@
-/* eslint-disable deprecation/deprecation */
 import * as utils from '@sentry/utils';
 
+import * as xhrInstrumentation from '../../src/instrument/xhr';
+
 import { extractNetworkProtocol, instrumentOutgoingRequests, shouldAttachHeaders } from '../../src/browser/request';
 import { WINDOW } from '../../src/browser/types';
 
@@ -17,7 +18,7 @@ describe('instrumentOutgoingRequests', () => {
 
   it('instruments fetch and xhr requests', () => {
     const addFetchSpy = jest.spyOn(utils, 'addFetchInstrumentationHandler');
-    const addXhrSpy = jest.spyOn(utils, 'addXhrInstrumentationHandler');
+    const addXhrSpy = jest.spyOn(xhrInstrumentation, 'addXhrInstrumentationHandler');
 
     instrumentOutgoingRequests();
 
@@ -34,7 +35,7 @@ describe('instrumentOutgoingRequests', () => {
   });
 
   it('does not instrument xhr requests if traceXHR is false', () => {
-    const addXhrSpy = jest.spyOn(utils, 'addXhrInstrumentationHandler');
+    const addXhrSpy = jest.spyOn(xhrInstrumentation, 'addXhrInstrumentationHandler');
 
     instrumentOutgoingRequests({ traceXHR: false });
 
diff --git a/packages/utils/test/instrument/dom.test.ts b/packages/browser-utils/test/instrument/dom.test.ts
similarity index 75%
rename from packages/utils/test/instrument/dom.test.ts
rename to packages/browser-utils/test/instrument/dom.test.ts
index 28745109e0f8..ad1dc2fd82fa 100644
--- a/packages/utils/test/instrument/dom.test.ts
+++ b/packages/browser-utils/test/instrument/dom.test.ts
@@ -1,7 +1,7 @@
 import { instrumentDOM } from '../../src/instrument/dom';
 
-jest.mock('../../src/worldwide', () => {
-  const original = jest.requireActual('../../src/worldwide');
+jest.mock('@sentry/utils', () => {
+  const original = jest.requireActual('@sentry/utils');
 
   return {
     ...original,
diff --git a/packages/utils/test/instrument/xhr.test.ts b/packages/browser-utils/test/instrument/xhr.test.ts
similarity index 75%
rename from packages/utils/test/instrument/xhr.test.ts
rename to packages/browser-utils/test/instrument/xhr.test.ts
index 60485ff1d398..46fa1a477521 100644
--- a/packages/utils/test/instrument/xhr.test.ts
+++ b/packages/browser-utils/test/instrument/xhr.test.ts
@@ -1,8 +1,7 @@
 import { instrumentXHR } from '../../src/instrument/xhr';
 
-jest.mock('../../src/worldwide', () => {
-  const original = jest.requireActual('../../src/worldwide');
-
+jest.mock('@sentry/utils', () => {
+  const original = jest.requireActual('@sentry/utils');
   return {
     ...original,
     GLOBAL_OBJ: {
diff --git a/packages/browser/src/integrations/breadcrumbs.ts b/packages/browser/src/integrations/breadcrumbs.ts
index 474432fedb48..e3c1120fca57 100644
--- a/packages/browser/src/integrations/breadcrumbs.ts
+++ b/packages/browser/src/integrations/breadcrumbs.ts
@@ -1,28 +1,28 @@
+import {
+  SENTRY_XHR_DATA_KEY,
+  addClickKeypressInstrumentationHandler,
+  addHistoryInstrumentationHandler,
+  addXhrInstrumentationHandler,
+} from '@sentry-internal/browser-utils';
 import { addBreadcrumb, defineIntegration, getClient } from '@sentry/core';
 import type {
+  Breadcrumb,
   Client,
   Event as SentryEvent,
+  FetchBreadcrumbData,
+  FetchBreadcrumbHint,
   HandlerDataConsole,
   HandlerDataDom,
   HandlerDataFetch,
   HandlerDataHistory,
   HandlerDataXhr,
   IntegrationFn,
-} from '@sentry/types';
-import type {
-  Breadcrumb,
-  FetchBreadcrumbData,
-  FetchBreadcrumbHint,
   XhrBreadcrumbData,
   XhrBreadcrumbHint,
-} from '@sentry/types/build/types/breadcrumb';
+} from '@sentry/types';
 import {
-  SENTRY_XHR_DATA_KEY,
-  addClickKeypressInstrumentationHandler,
   addConsoleInstrumentationHandler,
   addFetchInstrumentationHandler,
-  addHistoryInstrumentationHandler,
-  addXhrInstrumentationHandler,
   getComponentName,
   getEventDescription,
   htmlTreeAsString,
diff --git a/packages/browser/src/integrations/httpclient.ts b/packages/browser/src/integrations/httpclient.ts
index e8d5d596d975..b48cc69d09c0 100644
--- a/packages/browser/src/integrations/httpclient.ts
+++ b/packages/browser/src/integrations/httpclient.ts
@@ -1,11 +1,10 @@
+import { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler } from '@sentry-internal/browser-utils';
 import { captureEvent, defineIntegration, getClient, isSentryRequestUrl } from '@sentry/core';
 import type { Client, Event as SentryEvent, IntegrationFn, SentryWrappedXMLHttpRequest } from '@sentry/types';
 import {
   GLOBAL_OBJ,
-  SENTRY_XHR_DATA_KEY,
   addExceptionMechanism,
   addFetchInstrumentationHandler,
-  addXhrInstrumentationHandler,
   logger,
   supportsNativeFetch,
 } from '@sentry/utils';
diff --git a/packages/browser/src/profiling/integration.ts b/packages/browser/src/profiling/integration.ts
index af88bd8d91e6..585ad28802b3 100644
--- a/packages/browser/src/profiling/integration.ts
+++ b/packages/browser/src/profiling/integration.ts
@@ -1,6 +1,5 @@
 import { defineIntegration, getActiveSpan, getRootSpan } from '@sentry/core';
-import type { EventEnvelope, IntegrationFn, Span } from '@sentry/types';
-import type { Profile } from '@sentry/types/src/profiling';
+import type { EventEnvelope, IntegrationFn, Profile, Span } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
diff --git a/packages/browser/src/profiling/utils.ts b/packages/browser/src/profiling/utils.ts
index a9dd735a3812..4682633d101c 100644
--- a/packages/browser/src/profiling/utils.ts
+++ b/packages/browser/src/profiling/utils.ts
@@ -1,8 +1,17 @@
 /* eslint-disable max-lines */
 
 import { DEFAULT_ENVIRONMENT, getClient, spanToJSON } from '@sentry/core';
-import type { DebugImage, Envelope, Event, EventEnvelope, Span, StackFrame, StackParser } from '@sentry/types';
-import type { Profile, ThreadCpuProfile } from '@sentry/types/src/profiling';
+import type {
+  DebugImage,
+  Envelope,
+  Event,
+  EventEnvelope,
+  Profile,
+  Span,
+  StackFrame,
+  StackParser,
+  ThreadCpuProfile,
+} from '@sentry/types';
 import { GLOBAL_OBJ, browserPerformanceTimeOrigin, forEachEnvelopeItem, logger, uuid4 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
diff --git a/packages/browser/src/sdk.ts b/packages/browser/src/sdk.ts
index 88411c082106..9c25dc9750eb 100644
--- a/packages/browser/src/sdk.ts
+++ b/packages/browser/src/sdk.ts
@@ -9,14 +9,9 @@ import {
   startSession,
 } from '@sentry/core';
 import type { DsnLike, Integration, Options, UserFeedback } from '@sentry/types';
-import {
-  addHistoryInstrumentationHandler,
-  consoleSandbox,
-  logger,
-  stackParserFromStackParserOptions,
-  supportsFetch,
-} from '@sentry/utils';
+import { consoleSandbox, logger, stackParserFromStackParserOptions, supportsFetch } from '@sentry/utils';
 
+import { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';
 import { dedupeIntegration } from '@sentry/core';
 import type { BrowserClientOptions, BrowserOptions } from './client';
 import { BrowserClient } from './client';
diff --git a/packages/deno/src/integrations/breadcrumbs.ts b/packages/deno/src/integrations/breadcrumbs.ts
index 58c75624b90d..47953d4d7ce8 100644
--- a/packages/deno/src/integrations/breadcrumbs.ts
+++ b/packages/deno/src/integrations/breadcrumbs.ts
@@ -1,6 +1,13 @@
 import { addBreadcrumb, defineIntegration, getClient } from '@sentry/core';
-import type { Client, Event as SentryEvent, HandlerDataConsole, HandlerDataFetch, IntegrationFn } from '@sentry/types';
-import type { FetchBreadcrumbData, FetchBreadcrumbHint } from '@sentry/types/build/types/breadcrumb';
+import type {
+  Client,
+  Event as SentryEvent,
+  FetchBreadcrumbData,
+  FetchBreadcrumbHint,
+  HandlerDataConsole,
+  HandlerDataFetch,
+  IntegrationFn,
+} from '@sentry/types';
 import {
   addConsoleInstrumentationHandler,
   addFetchInstrumentationHandler,
diff --git a/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts b/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts
index 4ce349f1bb2e..fa504dcdeec2 100644
--- a/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts
+++ b/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts
@@ -1,5 +1,6 @@
+import { SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';
 import type { Breadcrumb, XhrBreadcrumbData } from '@sentry/types';
-import { SENTRY_XHR_DATA_KEY, logger } from '@sentry/utils';
+import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../../debug-build';
 import type {
diff --git a/packages/replay-internal/src/util/addGlobalListeners.ts b/packages/replay-internal/src/util/addGlobalListeners.ts
index 164b054ba2ac..70344413d3ba 100644
--- a/packages/replay-internal/src/util/addGlobalListeners.ts
+++ b/packages/replay-internal/src/util/addGlobalListeners.ts
@@ -1,6 +1,9 @@
+import {
+  addClickKeypressInstrumentationHandler,
+  addHistoryInstrumentationHandler,
+} from '@sentry-internal/browser-utils';
 import { addEventProcessor, getClient } from '@sentry/core';
 import type { DynamicSamplingContext } from '@sentry/types';
-import { addClickKeypressInstrumentationHandler, addHistoryInstrumentationHandler } from '@sentry/utils';
 
 import { handleAfterSendEvent } from '../coreHandlers/handleAfterSendEvent';
 import { handleBeforeSendEvent } from '../coreHandlers/handleBeforeSendEvent';
diff --git a/packages/replay-internal/test/integration/beforeAddRecordingEvent.test.ts b/packages/replay-internal/test/integration/beforeAddRecordingEvent.test.ts
index c6b14d1f1bb8..a8331149838b 100644
--- a/packages/replay-internal/test/integration/beforeAddRecordingEvent.test.ts
+++ b/packages/replay-internal/test/integration/beforeAddRecordingEvent.test.ts
@@ -1,6 +1,6 @@
+import * as SentryBrowserUtils from '@sentry-internal/browser-utils';
 import * as SentryCore from '@sentry/core';
 import type { Transport } from '@sentry/types';
-import * as SentryUtils from '@sentry/utils';
 
 import type { Replay } from '../../src/integration';
 import type { ReplayContainer } from '../../src/replay';
@@ -31,7 +31,7 @@ describe('Integration | beforeAddRecordingEvent', () => {
 
   beforeAll(async () => {
     jest.setSystemTime(new Date(BASE_TIMESTAMP));
-    jest.spyOn(SentryUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
+    jest.spyOn(SentryBrowserUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
       domHandler = handler;
     });
 
diff --git a/packages/replay-internal/test/integration/flush.test.ts b/packages/replay-internal/test/integration/flush.test.ts
index b40d6c78906d..ee4cf456fbf9 100644
--- a/packages/replay-internal/test/integration/flush.test.ts
+++ b/packages/replay-internal/test/integration/flush.test.ts
@@ -1,3 +1,4 @@
+import * as SentryBrowserUtils from '@sentry-internal/browser-utils';
 import * as SentryUtils from '@sentry/utils';
 
 import { DEFAULT_FLUSH_MIN_DELAY, MAX_REPLAY_DURATION, WINDOW } from '../../src/constants';
@@ -44,7 +45,7 @@ describe('Integration | flush', () => {
   let mockAddPerformanceEntries: MockAddPerformanceEntries;
 
   beforeAll(async () => {
-    jest.spyOn(SentryUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
+    jest.spyOn(SentryBrowserUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
       domHandler = handler;
     });
 
diff --git a/packages/replay-internal/test/integration/sendReplayEvent.test.ts b/packages/replay-internal/test/integration/sendReplayEvent.test.ts
index ff887c4b629b..58cdecaf1c65 100644
--- a/packages/replay-internal/test/integration/sendReplayEvent.test.ts
+++ b/packages/replay-internal/test/integration/sendReplayEvent.test.ts
@@ -1,6 +1,6 @@
+import * as SentryBrowserUtils from '@sentry-internal/browser-utils';
 import * as SentryCore from '@sentry/core';
 import type { Transport } from '@sentry/types';
-import * as SentryUtils from '@sentry/utils';
 
 import { DEFAULT_FLUSH_MIN_DELAY, WINDOW } from '../../src/constants';
 import type { ReplayContainer } from '../../src/replay';
@@ -30,7 +30,7 @@ describe('Integration | sendReplayEvent', () => {
 
   beforeAll(async () => {
     jest.setSystemTime(new Date(BASE_TIMESTAMP));
-    jest.spyOn(SentryUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
+    jest.spyOn(SentryBrowserUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
       domHandler = handler;
     });
 
diff --git a/packages/replay-internal/test/integration/stop.test.ts b/packages/replay-internal/test/integration/stop.test.ts
index d1af26e74776..3afbe3eeef1a 100644
--- a/packages/replay-internal/test/integration/stop.test.ts
+++ b/packages/replay-internal/test/integration/stop.test.ts
@@ -1,4 +1,4 @@
-import * as SentryUtils from '@sentry/utils';
+import * as SentryBrowserUtils from '@sentry-internal/browser-utils';
 
 import { WINDOW } from '../../src/constants';
 import type { Replay } from '../../src/integration';
@@ -27,7 +27,7 @@ describe('Integration | stop', () => {
 
   beforeAll(async () => {
     jest.setSystemTime(new Date(BASE_TIMESTAMP));
-    mockAddDomInstrumentationHandler = jest.spyOn(SentryUtils, 'addClickKeypressInstrumentationHandler');
+    mockAddDomInstrumentationHandler = jest.spyOn(SentryBrowserUtils, 'addClickKeypressInstrumentationHandler');
 
     ({ replay, integration } = await mockSdk());
 
diff --git a/packages/replay-internal/test/mocks/resetSdkMock.ts b/packages/replay-internal/test/mocks/resetSdkMock.ts
index 3596ad4d29d2..47a1522a4c63 100644
--- a/packages/replay-internal/test/mocks/resetSdkMock.ts
+++ b/packages/replay-internal/test/mocks/resetSdkMock.ts
@@ -23,8 +23,8 @@ export async function resetSdkMock({ replayOptions, sentryOptions, autoStart }:
   // Clear all handlers that have been registered
   resetInstrumentationHandlers();
 
-  const SentryUtils = await import('@sentry/utils');
-  jest.spyOn(SentryUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
+  const SentryBrowserUtils = await import('@sentry-internal/browser-utils');
+  jest.spyOn(SentryBrowserUtils, 'addClickKeypressInstrumentationHandler').mockImplementation(handler => {
     domHandler = handler;
   });
   const { mockRrweb } = await import('./mockRrweb');
diff --git a/packages/replay-internal/test/unit/coreHandlers/handleNetworkBreadcrumbs.test.ts b/packages/replay-internal/test/unit/coreHandlers/handleNetworkBreadcrumbs.test.ts
index de16549d081e..b3522c0ceb6c 100644
--- a/packages/replay-internal/test/unit/coreHandlers/handleNetworkBreadcrumbs.test.ts
+++ b/packages/replay-internal/test/unit/coreHandlers/handleNetworkBreadcrumbs.test.ts
@@ -1,3 +1,4 @@
+import { SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';
 import type {
   Breadcrumb,
   BreadcrumbHint,
@@ -5,7 +6,6 @@ import type {
   SentryWrappedXMLHttpRequest,
   XhrBreadcrumbHint,
 } from '@sentry/types';
-import { SENTRY_XHR_DATA_KEY } from '@sentry/utils';
 
 import { BASE_TIMESTAMP } from '../..';
 import { NETWORK_BODY_MAX_SIZE } from '../../../src/constants';
diff --git a/packages/utils/src/instrument/console.ts b/packages/utils/src/instrument/console.ts
index 7570f58a55dc..f75faa3346c2 100644
--- a/packages/utils/src/instrument/console.ts
+++ b/packages/utils/src/instrument/console.ts
@@ -5,7 +5,7 @@ import type { ConsoleLevel, HandlerDataConsole } from '@sentry/types';
 import { CONSOLE_LEVELS, originalConsoleMethods } from '../logger';
 import { fill } from '../object';
 import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
+import { addHandler, maybeInstrument, triggerHandlers } from './handlers';
 
 /**
  * Add an instrumentation handler for when a console.xxx method is called.
diff --git a/packages/utils/src/instrument/fetch.ts b/packages/utils/src/instrument/fetch.ts
index 472f48283a47..9c663f88baf0 100644
--- a/packages/utils/src/instrument/fetch.ts
+++ b/packages/utils/src/instrument/fetch.ts
@@ -4,7 +4,7 @@ import type { HandlerDataFetch } from '@sentry/types';
 import { fill } from '../object';
 import { supportsNativeFetch } from '../supports';
 import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
+import { addHandler, maybeInstrument, triggerHandlers } from './handlers';
 
 type FetchResource = string | { toString(): string } | { url: string };
 
diff --git a/packages/utils/src/instrument/globalError.ts b/packages/utils/src/instrument/globalError.ts
index 0bf50c52f2c4..a3ee2149817f 100644
--- a/packages/utils/src/instrument/globalError.ts
+++ b/packages/utils/src/instrument/globalError.ts
@@ -1,7 +1,7 @@
 import type { HandlerDataError } from '@sentry/types';
 
 import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
+import { addHandler, maybeInstrument, triggerHandlers } from './handlers';
 
 let _oldOnErrorHandler: (typeof GLOBAL_OBJ)['onerror'] | null = null;
 
diff --git a/packages/utils/src/instrument/globalUnhandledRejection.ts b/packages/utils/src/instrument/globalUnhandledRejection.ts
index c92f4d723b0d..878540500dac 100644
--- a/packages/utils/src/instrument/globalUnhandledRejection.ts
+++ b/packages/utils/src/instrument/globalUnhandledRejection.ts
@@ -3,7 +3,7 @@
 import type { HandlerDataUnhandledRejection } from '@sentry/types';
 
 import { GLOBAL_OBJ } from '../worldwide';
-import { addHandler, maybeInstrument, triggerHandlers } from './_handlers';
+import { addHandler, maybeInstrument, triggerHandlers } from './handlers';
 
 let _oldOnUnhandledRejectionHandler: (typeof GLOBAL_OBJ)['onunhandledrejection'] | null = null;
 
diff --git a/packages/utils/src/instrument/_handlers.ts b/packages/utils/src/instrument/handlers.ts
similarity index 100%
rename from packages/utils/src/instrument/_handlers.ts
rename to packages/utils/src/instrument/handlers.ts
diff --git a/packages/utils/src/instrument/index.ts b/packages/utils/src/instrument/index.ts
index 40f2f0fe917c..ee84f1375522 100644
--- a/packages/utils/src/instrument/index.ts
+++ b/packages/utils/src/instrument/index.ts
@@ -1,23 +1,17 @@
-// TODO(v8): Consider moving this file (or at least parts of it) into the browser package. The registered handlers are mostly non-generic and we risk leaking runtime specific code into generic packages.
-
-import { resetInstrumentationHandlers } from './_handlers';
 import { addConsoleInstrumentationHandler } from './console';
-import { addClickKeypressInstrumentationHandler } from './dom';
 import { addFetchInstrumentationHandler } from './fetch';
 import { addGlobalErrorInstrumentationHandler } from './globalError';
 import { addGlobalUnhandledRejectionInstrumentationHandler } from './globalUnhandledRejection';
-import { addHistoryInstrumentationHandler } from './history';
-import { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler } from './xhr';
+import { addHandler, maybeInstrument, resetInstrumentationHandlers, triggerHandlers } from './handlers';
 
 export {
   addConsoleInstrumentationHandler,
-  addClickKeypressInstrumentationHandler,
-  addXhrInstrumentationHandler,
   addFetchInstrumentationHandler,
-  addHistoryInstrumentationHandler,
   addGlobalErrorInstrumentationHandler,
   addGlobalUnhandledRejectionInstrumentationHandler,
-  SENTRY_XHR_DATA_KEY,
+  addHandler,
+  maybeInstrument,
+  triggerHandlers,
   // Only exported for tests
   resetInstrumentationHandlers,
 };

From 0ad046a8a4d273a42f4b6f93a3cbbc8b099146c7 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Mon, 8 Apr 2024 09:26:33 -0400
Subject: [PATCH 07/64] build: Reorganize size limit and restructure limits
 (#11454)

Next week I'm going to play around with optimizing feedback/replay
packages as per what we saw in
https://github.com/getsentry/sentry-javascript/pull/11452.

In prep for that work I re-organized size limit and made the limits a
little more sensible.

The size bot comment will be a little messed up because we renamed the
fields, but after we merge should be a lot better.
---
 .size-limit.js | 217 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 132 insertions(+), 85 deletions(-)

diff --git a/.size-limit.js b/.size-limit.js
index 68e7f534efa6..7fd6db3be736 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -1,32 +1,32 @@
 module.exports = [
-  // Main browser webpack builds
+  // Browser SDK (ESM)
   {
-    name: '@sentry/browser (incl. Tracing, Replay, Feedback)',
+    name: '@sentry/browser',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, replayIntegration, browserTracingIntegration, feedbackIntegration }',
+    import: createImport('init'),
     gzip: true,
-    limit: '90 KB',
+    limit: '24 KB',
   },
   {
-    name: '@sentry/browser (incl. Tracing, Replay)',
+    name: '@sentry/browser (incl. Tracing)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, replayIntegration, browserTracingIntegration }',
+    import: createImport('init', 'browserTracingIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '34 KB',
   },
   {
-    name: '@sentry/browser (incl. Tracing, Replay with Canvas)',
+    name: '@sentry/browser (incl. Tracing, Replay)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, replayIntegration, browserTracingIntegration, replayCanvasIntegration }',
+    import: createImport('init', 'browserTracingIntegration', 'replayIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '70 KB',
   },
   {
     name: '@sentry/browser (incl. Tracing, Replay) - with treeshaking flags',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, replayIntegration, browserTracingIntegration }',
+    import: createImport('init', 'browserTracingIntegration', 'replayIntegration'),
     gzip: true,
-    limit: '75 KB',
+    limit: '65 KB',
     modifyWebpackConfig: function (config) {
       const webpack = require('webpack');
       config.plugins.push(
@@ -41,134 +41,181 @@ module.exports = [
     },
   },
   {
-    name: '@sentry/browser (incl. Tracing)',
+    name: '@sentry/browser (incl. Tracing, Replay with Canvas)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, browserTracingIntegration }',
+    import: createImport('init', 'browserTracingIntegration', 'replayIntegration', 'replayCanvasIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '75 KB',
   },
   {
-    name: '@sentry/browser (incl. browserTracingIntegration)',
+    name: '@sentry/browser (incl. Tracing, Replay, Feedback)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, browserTracingIntegration }',
+    import: createImport('init', 'browserTracingIntegration', 'replayIntegration', 'feedbackIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '80 KB',
   },
   {
-    name: '@sentry/browser (incl. feedbackIntegration)',
+    name: '@sentry/browser (incl. Feedback)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, feedbackIntegration }',
+    import: createImport('init', 'feedbackIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '35 KB',
   },
   {
-    name: '@sentry/browser (incl. feedbackModalIntegration)',
+    name: '@sentry/browser (incl. Feedback, Feedback Modal)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, feedbackIntegration, feedbackModalIntegration }',
+    import: createImport('init', 'feedbackIntegration', 'feedbackModalIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '35 KB',
   },
   {
-    name: '@sentry/browser (incl. feedbackScreenshotIntegration)',
+    name: '@sentry/browser (incl. Feedback, Feedback Modal, Feedback Screenshot)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, feedbackIntegration, feedbackModalIntegration, feedbackScreenshotIntegration }',
+    import: createImport('init', 'feedbackIntegration', 'feedbackModalIntegration', 'feedbackScreenshotIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '35 KB',
   },
   {
     name: '@sentry/browser (incl. sendFeedback)',
     path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init, sendFeedback }',
+    import: createImport('init', 'sendFeedback'),
     gzip: true,
-    limit: '90 KB',
+    limit: '30 KB',
   },
+  // React SDK (ESM)
   {
-    name: '@sentry/browser',
-    path: 'packages/browser/build/npm/esm/index.js',
-    import: '{ init }',
+    name: '@sentry/react',
+    path: 'packages/react/build/esm/index.js',
+    import: createImport('init', 'ErrorBoundary'),
     gzip: true,
-    limit: '90 KB',
+    limit: '27 KB',
   },
-
-  // Browser CDN bundles
   {
-    name: 'CDN Bundle (incl. Tracing, Replay, Feedback)',
-    path: 'packages/browser/build/bundles/bundle.tracing.replay.feedback.min.js',
+    name: '@sentry/react (incl. Tracing)',
+    path: 'packages/react/build/esm/index.js',
+    import: createImport('init', 'ErrorBoundary', 'reactRouterV6BrowserTracingIntegration'),
     gzip: true,
-    limit: '90 KB',
+    limit: '37 KB',
   },
+  // Vue SDK (ESM)
   {
-    name: 'CDN Bundle (incl. Tracing, Replay)',
-    path: 'packages/browser/build/bundles/bundle.tracing.replay.min.js',
+    name: '@sentry/vue',
+    path: 'packages/vue/build/esm/index.js',
+    import: createImport('init'),
     gzip: true,
-    limit: '90 KB',
+    limit: '28 KB',
   },
   {
-    name: 'CDN Bundle (incl. Tracing)',
-    path: 'packages/browser/build/bundles/bundle.tracing.min.js',
+    name: '@sentry/vue (incl. Tracing)',
+    path: 'packages/vue/build/esm/index.js',
+    import: createImport('init', 'browserTracingIntegration'),
+    gzip: true,
+    limit: '38 KB',
+  },
+  // Svelte SDK (ESM)
+  {
+    name: '@sentry/svelte',
+    path: 'packages/svelte/build/esm/index.js',
+    import: createImport('init'),
     gzip: true,
-    limit: '40 KB',
+    limit: '24 KB',
   },
+  // Browser CDN bundles
   {
     name: 'CDN Bundle',
-    path: 'packages/browser/build/bundles/bundle.min.js',
+    path: createCDNPath('bundle.min.js'),
     gzip: true,
-    limit: '30 KB',
+    limit: '26 KB',
+  },
+  {
+    name: 'CDN Bundle (incl. Tracing)',
+    path: createCDNPath('bundle.tracing.min.js'),
+    gzip: true,
+    limit: '36 KB',
+  },
+  {
+    name: 'CDN Bundle (incl. Tracing, Replay)',
+    path: createCDNPath('bundle.tracing.replay.min.js'),
+    gzip: true,
+    limit: '70 KB',
+  },
+  {
+    name: 'CDN Bundle (incl. Tracing, Replay, Feedback)',
+    path: createCDNPath('bundle.tracing.replay.feedback.min.js'),
+    gzip: true,
+    limit: '75 KB',
   },
-
   // browser CDN bundles (non-gzipped)
   {
-    name: 'CDN Bundle (incl. Tracing, Replay) - uncompressed',
-    path: 'packages/browser/build/bundles/bundle.tracing.replay.min.js',
+    name: 'CDN Bundle - uncompressed',
+    path: createCDNPath('bundle.min.js'),
     gzip: false,
     brotli: false,
-    limit: '260 KB',
+    limit: '80 KB',
   },
   {
     name: 'CDN Bundle (incl. Tracing) - uncompressed',
-    path: 'packages/browser/build/bundles/bundle.tracing.min.js',
+    path: createCDNPath('bundle.tracing.min.js'),
     gzip: false,
     brotli: false,
-    limit: '120 KB',
+    limit: '105 KB',
   },
   {
-    name: 'CDN Bundle - uncompressed',
-    path: 'packages/browser/build/bundles/bundle.min.js',
+    name: 'CDN Bundle (incl. Tracing, Replay) - uncompressed',
+    path: createCDNPath('bundle.tracing.replay.min.js'),
     gzip: false,
     brotli: false,
-    limit: '80 KB',
-  },
-
-  // React
-  {
-    name: '@sentry/react (incl. Tracing, Replay)',
-    path: 'packages/react/build/esm/index.js',
-    import: '{ init, browserTracingIntegration, replayIntegration }',
-    gzip: true,
-    limit: '90 KB',
+    limit: '220 KB',
   },
+  // Next.js SDK (ESM)
   {
-    name: '@sentry/react',
-    path: 'packages/react/build/esm/index.js',
-    import: '{ init }',
-    gzip: true,
-    limit: '90 KB',
-  },
-
-  // Next.js
-  // TODO: Re-enable these, when we figure out why they break...
-  /*  {
-    name: '@sentry/nextjs Client (incl. Tracing, Replay)',
+    name: '@sentry/nextjs (client)',
     path: 'packages/nextjs/build/esm/client/index.js',
-    import: '{ init, browserTracingIntegration, replayIntegration }',
-    gzip: true,
-    limit: '110 KB',
+    import: createImport('init'),
+    ignore: ['next/router', 'next/constants'],
+    gzip: true,
+    limit: '37 KB',
+  },
+  // SvelteKit SDK (ESM)
+  {
+    name: '@sentry/sveltekit (client)',
+    path: 'packages/sveltekit/build/esm/client/index.js',
+    import: createImport('init'),
+    ignore: ['$app/stores'],
+    gzip: true,
+    limit: '37 KB',
+  },
+  // Node SDK (ESM)
+  {
+    name: '@sentry/node',
+    path: 'packages/node/build/esm/index.js',
+    import: createImport('init'),
+    ignore: [
+      'node:http',
+      'node:https',
+      'node:diagnostics_channel',
+      'async_hooks',
+      'child_process',
+      'fs',
+      'os',
+      'path',
+      'inspector',
+      'worker_threads',
+      'http',
+      'stream',
+      'zlib',
+      'net',
+      'tls',
+    ],
+    gzip: true,
+    limit: '150 KB',
   },
-  {
-    name: '@sentry/nextjs Client',
-    path: 'packages/nextjs/build/esm/client/index.js',
-    import: '{ init }',
-    gzip: true,
-    limit: '57 KB',
-  }, */
 ];
+
+function createImport(...args) {
+  return `{ ${args.join(', ')} }`;
+}
+
+function createCDNPath(name) {
+  return `packages/browser/build/bundles/${name}`;
+}

From e4436943e6f075b2660f6c6482d8edd39a9810a2 Mon Sep 17 00:00:00 2001
From: Tim Fish <tim@timfish.uk>
Date: Mon, 8 Apr 2024 15:26:59 +0200
Subject: [PATCH 08/64] fix(test): Some ANR tests should test the transport
 (#11465)

All of the ANR tests were verified over stdout. This PR ensures some of
the basic tests actually send events over http to ensure the transport
is fully tested.
---
 .../suites/anr/basic-session.js                  |  3 +--
 .../node-integration-tests/suites/anr/basic.js   |  3 +--
 .../node-integration-tests/suites/anr/basic.mjs  |  3 +--
 .../suites/anr/isolated.mjs                      |  3 +--
 .../node-integration-tests/suites/anr/test.ts    | 16 ++++++++++++----
 5 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/anr/basic-session.js b/dev-packages/node-integration-tests/suites/anr/basic-session.js
index 5661e08b850b..c6415b6358da 100644
--- a/dev-packages/node-integration-tests/suites/anr/basic-session.js
+++ b/dev-packages/node-integration-tests/suites/anr/basic-session.js
@@ -8,9 +8,8 @@ setTimeout(() => {
 }, 10000);
 
 Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  dsn: process.env.SENTRY_DSN,
   release: '1.0',
-  debug: true,
   integrations: [Sentry.anrIntegration({ captureStackTrace: true, anrThreshold: 100 })],
   autoSessionTracking: true,
 });
diff --git a/dev-packages/node-integration-tests/suites/anr/basic.js b/dev-packages/node-integration-tests/suites/anr/basic.js
index d98b18216703..b1dddf958d46 100644
--- a/dev-packages/node-integration-tests/suites/anr/basic.js
+++ b/dev-packages/node-integration-tests/suites/anr/basic.js
@@ -8,9 +8,8 @@ setTimeout(() => {
 }, 10000);
 
 Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  dsn: process.env.SENTRY_DSN,
   release: '1.0',
-  debug: true,
   autoSessionTracking: false,
   integrations: [Sentry.anrIntegration({ captureStackTrace: true, anrThreshold: 100 })],
 });
diff --git a/dev-packages/node-integration-tests/suites/anr/basic.mjs b/dev-packages/node-integration-tests/suites/anr/basic.mjs
index 77bb9ae3626d..c3e74222f587 100644
--- a/dev-packages/node-integration-tests/suites/anr/basic.mjs
+++ b/dev-packages/node-integration-tests/suites/anr/basic.mjs
@@ -8,9 +8,8 @@ setTimeout(() => {
 }, 10000);
 
 Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  dsn: process.env.SENTRY_DSN,
   release: '1.0',
-  debug: true,
   autoSessionTracking: false,
   integrations: [Sentry.anrIntegration({ captureStackTrace: true, anrThreshold: 100 })],
 });
diff --git a/dev-packages/node-integration-tests/suites/anr/isolated.mjs b/dev-packages/node-integration-tests/suites/anr/isolated.mjs
index d9b179c63e71..2f36575fbbd2 100644
--- a/dev-packages/node-integration-tests/suites/anr/isolated.mjs
+++ b/dev-packages/node-integration-tests/suites/anr/isolated.mjs
@@ -8,9 +8,8 @@ setTimeout(() => {
 }, 10000);
 
 Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  dsn: process.env.SENTRY_DSN,
   release: '1.0',
-  debug: true,
   autoSessionTracking: false,
   integrations: [Sentry.anrIntegration({ captureStackTrace: true, anrThreshold: 100 })],
 });
diff --git a/dev-packages/node-integration-tests/suites/anr/test.ts b/dev-packages/node-integration-tests/suites/anr/test.ts
index b0299f4a038d..6af5d46bfb50 100644
--- a/dev-packages/node-integration-tests/suites/anr/test.ts
+++ b/dev-packages/node-integration-tests/suites/anr/test.ts
@@ -66,15 +66,19 @@ conditionalTest({ min: 16 })('should report ANR when event loop blocked', () =>
   });
 
   test('CJS', done => {
-    createRunner(__dirname, 'basic.js').expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'basic.js').withMockSentryServer().expect({ event: EXPECTED_ANR_EVENT }).start(done);
   });
 
   test('ESM', done => {
-    createRunner(__dirname, 'basic.mjs').expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'basic.mjs').withMockSentryServer().expect({ event: EXPECTED_ANR_EVENT }).start(done);
   });
 
   test('With --inspect', done => {
-    createRunner(__dirname, 'basic.mjs').withFlags('--inspect').expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'basic.mjs')
+      .withMockSentryServer()
+      .withFlags('--inspect')
+      .expect({ event: EXPECTED_ANR_EVENT })
+      .start(done);
   });
 
   test('should exit', done => {
@@ -97,6 +101,7 @@ conditionalTest({ min: 16 })('should report ANR when event loop blocked', () =>
 
   test('With session', done => {
     createRunner(__dirname, 'basic-session.js')
+      .withMockSentryServer()
       .expect({
         session: {
           status: 'abnormal',
@@ -142,6 +147,9 @@ conditionalTest({ min: 16 })('should report ANR when event loop blocked', () =>
   };
 
   test('fetches correct isolated scope', done => {
-    createRunner(__dirname, 'isolated.mjs').expect({ event: EXPECTED_ISOLATED_EVENT }).start(done);
+    createRunner(__dirname, 'isolated.mjs')
+      .withMockSentryServer()
+      .expect({ event: EXPECTED_ISOLATED_EVENT })
+      .start(done);
   });
 });

From 4239d2f172ba12b918cf7241a6e1cc125c1f61b1 Mon Sep 17 00:00:00 2001
From: Tim Fish <tim@timfish.uk>
Date: Mon, 8 Apr 2024 15:36:57 +0200
Subject: [PATCH 09/64] fix(core): Don't log error from Inbound Filters
 integration (#11473)

Closes #11462
---
 packages/core/src/integrations/inboundfilters.ts | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/packages/core/src/integrations/inboundfilters.ts b/packages/core/src/integrations/inboundfilters.ts
index 9c64476568c7..66eafcf4db40 100644
--- a/packages/core/src/integrations/inboundfilters.ts
+++ b/packages/core/src/integrations/inboundfilters.ts
@@ -155,10 +155,6 @@ function _getPossibleEventMessages(event: Event): string[] {
     }
   }
 
-  if (DEBUG_BUILD && possibleMessages.length === 0) {
-    logger.error(`Could not extract message for event ${getEventDescription(event)}`);
-  }
-
   return possibleMessages;
 }
 

From d7c6fe3fefb9fedffb015cefec070e8e86dadf0c Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Mon, 8 Apr 2024 15:41:25 +0200
Subject: [PATCH 10/64] feat: Export `spanToJSON` and `spanToTraceHeader` from
 all relevant packages (#11474)

---
 packages/aws-serverless/src/index.ts          | 1 +
 packages/browser/src/exports.ts               | 1 +
 packages/bun/src/index.ts                     | 1 +
 packages/deno/src/index.ts                    | 2 ++
 packages/google-cloud-serverless/src/index.ts | 1 +
 packages/node/src/index.ts                    | 1 +
 packages/remix/src/index.server.ts            | 2 ++
 packages/sveltekit/src/server/index.ts        | 2 ++
 packages/vercel-edge/src/index.ts             | 2 ++
 9 files changed, 13 insertions(+)

diff --git a/packages/aws-serverless/src/index.ts b/packages/aws-serverless/src/index.ts
index 68e0a587fb0c..5cf5a9375462 100644
--- a/packages/aws-serverless/src/index.ts
+++ b/packages/aws-serverless/src/index.ts
@@ -93,6 +93,7 @@ export {
   spotlightIntegration,
   initOpenTelemetry,
   spanToJSON,
+  spanToTraceHeader,
   trpcMiddleware,
 } from '@sentry/node';
 
diff --git a/packages/browser/src/exports.ts b/packages/browser/src/exports.ts
index 2efa7f8ec6d6..fa38e5373110 100644
--- a/packages/browser/src/exports.ts
+++ b/packages/browser/src/exports.ts
@@ -56,6 +56,7 @@ export {
   captureSession,
   endSession,
   spanToJSON,
+  spanToTraceHeader,
 } from '@sentry/core';
 
 export {
diff --git a/packages/bun/src/index.ts b/packages/bun/src/index.ts
index db54dcdd6fb5..a91dbd48b6f9 100644
--- a/packages/bun/src/index.ts
+++ b/packages/bun/src/index.ts
@@ -113,6 +113,7 @@ export {
   spotlightIntegration,
   initOpenTelemetry,
   spanToJSON,
+  spanToTraceHeader,
   trpcMiddleware,
 } from '@sentry/node';
 
diff --git a/packages/deno/src/index.ts b/packages/deno/src/index.ts
index a78a2392a429..a554d807b418 100644
--- a/packages/deno/src/index.ts
+++ b/packages/deno/src/index.ts
@@ -74,6 +74,8 @@ export {
   startSession,
   captureSession,
   endSession,
+  spanToJSON,
+  spanToTraceHeader,
 } from '@sentry/core';
 
 export { DenoClient } from './client';
diff --git a/packages/google-cloud-serverless/src/index.ts b/packages/google-cloud-serverless/src/index.ts
index d07dab055ae2..2bf45cf22b98 100644
--- a/packages/google-cloud-serverless/src/index.ts
+++ b/packages/google-cloud-serverless/src/index.ts
@@ -93,6 +93,7 @@ export {
   spotlightIntegration,
   initOpenTelemetry,
   spanToJSON,
+  spanToTraceHeader,
   trpcMiddleware,
 } from '@sentry/node';
 
diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts
index 0960d1a12762..818596d0c4fe 100644
--- a/packages/node/src/index.ts
+++ b/packages/node/src/index.ts
@@ -102,6 +102,7 @@ export {
   withActiveSpan,
   getRootSpan,
   spanToJSON,
+  spanToTraceHeader,
   trpcMiddleware,
 } from '@sentry/core';
 
diff --git a/packages/remix/src/index.server.ts b/packages/remix/src/index.server.ts
index ff3d0eb5c51b..41db9c117147 100644
--- a/packages/remix/src/index.server.ts
+++ b/packages/remix/src/index.server.ts
@@ -96,6 +96,8 @@ export {
   spotlightIntegration,
   setupFastifyErrorHandler,
   trpcMiddleware,
+  spanToJSON,
+  spanToTraceHeader,
 } from '@sentry/node';
 
 // Keeping the `*` exports for backwards compatibility and types
diff --git a/packages/sveltekit/src/server/index.ts b/packages/sveltekit/src/server/index.ts
index 066ede9295aa..4cba1a3e825e 100644
--- a/packages/sveltekit/src/server/index.ts
+++ b/packages/sveltekit/src/server/index.ts
@@ -70,6 +70,8 @@ export {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
   trpcMiddleware,
+  spanToJSON,
+  spanToTraceHeader,
 } from '@sentry/node';
 
 // We can still leave this for the carrier init and type exports
diff --git a/packages/vercel-edge/src/index.ts b/packages/vercel-edge/src/index.ts
index 58fdc6bdd9c4..466c122b7ca6 100644
--- a/packages/vercel-edge/src/index.ts
+++ b/packages/vercel-edge/src/index.ts
@@ -69,6 +69,8 @@ export {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
   trpcMiddleware,
+  spanToJSON,
+  spanToTraceHeader,
 } from '@sentry/core';
 
 export { VercelEdgeClient } from './client';

From f644fd6d515de71bb72b7be9dacb6cef731d1fd9 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 8 Apr 2024 14:44:51 +0100
Subject: [PATCH 11/64] feat(core): Allow to pass scope to
 `withIsolationScope()` (#11478)

Also adds tests for this for core, vercel-edge and opentelemetry.

NOTE: In core, this does not do anything, as we cannot actually update
the isolation scope in browser.

Co-authored-by: Luca Forstner <luca.forstner@sentry.io>
---
 packages/core/src/currentScopes.ts            |  39 ++++-
 packages/core/test/lib/scope.test.ts          | 144 ++++++++++++++---
 .../test/asyncContextStrategy.test.ts         | 129 +++++++++++++++
 packages/vercel-edge/src/async.ts             |   6 +-
 packages/vercel-edge/test/async.test.ts       | 150 ++++++++++++++++++
 5 files changed, 436 insertions(+), 32 deletions(-)
 create mode 100644 packages/vercel-edge/test/async.test.ts

diff --git a/packages/core/src/currentScopes.ts b/packages/core/src/currentScopes.ts
index 1e68c9583372..e0b598c1ad39 100644
--- a/packages/core/src/currentScopes.ts
+++ b/packages/core/src/currentScopes.ts
@@ -74,15 +74,44 @@ export function withScope<T>(
  *
  * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in "normal"
  * applications directly because it comes with pitfalls. Use at your own risk!
+ */
+export function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T;
+/**
+ * Set the provided isolation scope as active in the given callback. If no
+ * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the
+ * case, for example, in the browser).
+ *
+ * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.
  *
- * @param callback The callback in which the passed isolation scope is active. (Note: In environments without async
- * context strategy, the currently active isolation scope may change within execution of the callback.)
- * @returns The same value that `callback` returns.
+ * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in "normal"
+ * applications directly because it comes with pitfalls. Use at your own risk!
+ *
+ * If you pass in `undefined` as a scope, it will fork a new isolation scope, the same as if no scope is passed.
+ */
+export function withIsolationScope<T>(isolationScope: Scope | undefined, callback: (isolationScope: Scope) => T): T;
+/**
+ * Either creates a new active isolation scope, or sets the given isolation scope as active scope in the given callback.
  */
-export function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {
+export function withIsolationScope<T>(
+  ...rest:
+    | [callback: (isolationScope: Scope) => T]
+    | [isolationScope: Scope | undefined, callback: (isolationScope: Scope) => T]
+): T {
   const carrier = getMainCarrier();
   const acs = getAsyncContextStrategy(carrier);
-  return acs.withIsolationScope(callback);
+
+  // If a scope is defined, we want to make this the active scope instead of the default one
+  if (rest.length === 2) {
+    const [isolationScope, callback] = rest;
+
+    if (!isolationScope) {
+      return acs.withIsolationScope(callback);
+    }
+
+    return acs.withSetIsolationScope(isolationScope, callback);
+  }
+
+  return acs.withIsolationScope(rest[0]);
 }
 
 /**
diff --git a/packages/core/test/lib/scope.test.ts b/packages/core/test/lib/scope.test.ts
index bbd40af742d1..aadc26856c6e 100644
--- a/packages/core/test/lib/scope.test.ts
+++ b/packages/core/test/lib/scope.test.ts
@@ -5,6 +5,7 @@ import {
   getGlobalScope,
   getIsolationScope,
   withIsolationScope,
+  withScope,
 } from '../../src';
 
 import { Scope } from '../../src/scope';
@@ -853,40 +854,135 @@ describe('Scope', () => {
   });
 });
 
-describe('isolation scope', () => {
-  describe('withIsolationScope()', () => {
-    it('will pass an isolation scope without Sentry.init()', done => {
-      expect.assertions(1);
-      withIsolationScope(scope => {
-        expect(scope).toBeDefined();
-        done();
-      });
+describe('withScope()', () => {
+  beforeEach(() => {
+    getIsolationScope().clear();
+    getCurrentScope().clear();
+    getGlobalScope().clear();
+  });
+
+  it('will make the passed scope the active scope within the callback', done => {
+    withScope(scope => {
+      expect(getCurrentScope()).toBe(scope);
+      done();
+    });
+  });
+
+  it('will pass a scope that is different from the current active isolation scope', done => {
+    withScope(scope => {
+      expect(getIsolationScope()).not.toBe(scope);
+      done();
     });
+  });
 
-    it('will make the passed isolation scope the active isolation scope within the callback', done => {
-      expect.assertions(1);
-      withIsolationScope(scope => {
-        expect(getIsolationScope()).toBe(scope);
+  it('will always make the inner most passed scope the current isolation scope when nesting calls', done => {
+    withIsolationScope(_scope1 => {
+      withIsolationScope(scope2 => {
+        expect(getIsolationScope()).toBe(scope2);
         done();
       });
     });
+  });
+
+  it('forks the scope when not passing any scope', done => {
+    const initialScope = getCurrentScope();
+    initialScope.setTag('aa', 'aa');
 
-    it('will pass an isolation scope that is different from the current active scope', done => {
-      expect.assertions(1);
-      withIsolationScope(scope => {
-        expect(getCurrentScope()).not.toBe(scope);
+    withScope(scope => {
+      expect(getCurrentScope()).toBe(scope);
+      scope.setTag('bb', 'bb');
+      expect(scope).not.toBe(initialScope);
+      expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      done();
+    });
+  });
+
+  it('forks the scope when passing undefined', done => {
+    const initialScope = getCurrentScope();
+    initialScope.setTag('aa', 'aa');
+
+    withScope(undefined, scope => {
+      expect(getCurrentScope()).toBe(scope);
+      scope.setTag('bb', 'bb');
+      expect(scope).not.toBe(initialScope);
+      expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      done();
+    });
+  });
+
+  it('sets the passed in scope as active scope', done => {
+    const initialScope = getCurrentScope();
+    initialScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    withScope(customScope, scope => {
+      expect(getCurrentScope()).toBe(customScope);
+      expect(scope).toBe(customScope);
+      done();
+    });
+  });
+});
+
+describe('withIsolationScope()', () => {
+  beforeEach(() => {
+    getIsolationScope().clear();
+    getCurrentScope().clear();
+    getGlobalScope().clear();
+  });
+
+  it('will make the passed isolation scope the active isolation scope within the callback', done => {
+    withIsolationScope(scope => {
+      expect(getIsolationScope()).toBe(scope);
+      done();
+    });
+  });
+
+  it('will pass an isolation scope that is different from the current active scope', done => {
+    withIsolationScope(scope => {
+      expect(getCurrentScope()).not.toBe(scope);
+      done();
+    });
+  });
+
+  it('will always make the inner most passed scope the current scope when nesting calls', done => {
+    withIsolationScope(_scope1 => {
+      withIsolationScope(scope2 => {
+        expect(getIsolationScope()).toBe(scope2);
         done();
       });
     });
+  });
+
+  // Note: This is expected! In browser, we do not actually fork this
+  it('does not fork isolation scope when not passing any isolation scope', done => {
+    const isolationScope = getIsolationScope();
+
+    withIsolationScope(scope => {
+      expect(getIsolationScope()).toBe(scope);
+      expect(scope).toBe(isolationScope);
+      done();
+    });
+  });
 
-    it('will always make the inner most passed scope the current scope when nesting calls', done => {
-      expect.assertions(1);
-      withIsolationScope(_scope1 => {
-        withIsolationScope(scope2 => {
-          expect(getIsolationScope()).toBe(scope2);
-          done();
-        });
-      });
+  it('does not fork isolation scope when passing undefined', done => {
+    const isolationScope = getIsolationScope();
+
+    withIsolationScope(undefined, scope => {
+      expect(getIsolationScope()).toBe(scope);
+      expect(scope).toBe(isolationScope);
+      done();
+    });
+  });
+
+  it('ignores passed in isolation scope', done => {
+    const isolationScope = getIsolationScope();
+    const customIsolationScope = new Scope();
+
+    withIsolationScope(customIsolationScope, scope => {
+      expect(getIsolationScope()).toBe(isolationScope);
+      expect(scope).toBe(isolationScope);
+      done();
     });
   });
 });
diff --git a/packages/opentelemetry/test/asyncContextStrategy.test.ts b/packages/opentelemetry/test/asyncContextStrategy.test.ts
index 16eea942655e..f3b664fcaf44 100644
--- a/packages/opentelemetry/test/asyncContextStrategy.test.ts
+++ b/packages/opentelemetry/test/asyncContextStrategy.test.ts
@@ -1,5 +1,6 @@
 import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import {
+  Scope as ScopeClass,
   getCurrentScope,
   getIsolationScope,
   setAsyncContextStrategy,
@@ -298,4 +299,132 @@ describe('asyncContextStrategy', () => {
       });
     });
   });
+
+  describe('withScope()', () => {
+    it('will make the passed scope the active scope within the callback', done => {
+      withScope(scope => {
+        expect(getCurrentScope()).toBe(scope);
+        done();
+      });
+    });
+
+    it('will pass a scope that is different from the current active isolation scope', done => {
+      withScope(scope => {
+        expect(getIsolationScope()).not.toBe(scope);
+        done();
+      });
+    });
+
+    it('will always make the inner most passed scope the current scope when nesting calls', done => {
+      withIsolationScope(_scope1 => {
+        withIsolationScope(scope2 => {
+          expect(getIsolationScope()).toBe(scope2);
+          done();
+        });
+      });
+    });
+
+    it('forks the scope when not passing any scope', done => {
+      const initialScope = getCurrentScope();
+      initialScope.setTag('aa', 'aa');
+
+      withScope(scope => {
+        expect(getCurrentScope()).toBe(scope);
+        scope.setTag('bb', 'bb');
+        expect(scope).not.toBe(initialScope);
+        expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+        done();
+      });
+    });
+
+    it('forks the scope when passing undefined', done => {
+      const initialScope = getCurrentScope();
+      initialScope.setTag('aa', 'aa');
+
+      withScope(undefined, scope => {
+        expect(getCurrentScope()).toBe(scope);
+        scope.setTag('bb', 'bb');
+        expect(scope).not.toBe(initialScope);
+        expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+        done();
+      });
+    });
+
+    it('sets the passed in scope as active scope', done => {
+      const initialScope = getCurrentScope();
+      initialScope.setTag('aa', 'aa');
+
+      const customScope = new ScopeClass();
+
+      withScope(customScope, scope => {
+        expect(getCurrentScope()).toBe(customScope);
+        expect(scope).toBe(customScope);
+        done();
+      });
+    });
+  });
+
+  describe('withIsolationScope()', () => {
+    it('will make the passed isolation scope the active isolation scope within the callback', done => {
+      withIsolationScope(scope => {
+        expect(getIsolationScope()).toBe(scope);
+        done();
+      });
+    });
+
+    it('will pass an isolation scope that is different from the current active scope', done => {
+      withIsolationScope(scope => {
+        expect(getCurrentScope()).not.toBe(scope);
+        done();
+      });
+    });
+
+    it('will always make the inner most passed scope the current scope when nesting calls', done => {
+      withIsolationScope(_scope1 => {
+        withIsolationScope(scope2 => {
+          expect(getIsolationScope()).toBe(scope2);
+          done();
+        });
+      });
+    });
+
+    it('forks the isolation scope when not passing any isolation scope', done => {
+      const initialScope = getIsolationScope();
+      initialScope.setTag('aa', 'aa');
+
+      withIsolationScope(scope => {
+        expect(getIsolationScope()).toBe(scope);
+        scope.setTag('bb', 'bb');
+        expect(scope).not.toBe(initialScope);
+        expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+        done();
+      });
+    });
+
+    it('forks the isolation scope when passing undefined', done => {
+      const initialScope = getIsolationScope();
+      initialScope.setTag('aa', 'aa');
+
+      withIsolationScope(undefined, scope => {
+        expect(getIsolationScope()).toBe(scope);
+        scope.setTag('bb', 'bb');
+        expect(scope).not.toBe(initialScope);
+        expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+        done();
+      });
+    });
+
+    it('sets the passed in isolation scope as active isolation scope', done => {
+      const initialScope = getIsolationScope();
+      initialScope.setTag('aa', 'aa');
+
+      const customScope = new ScopeClass();
+
+      withIsolationScope(customScope, scope => {
+        expect(getIsolationScope()).toBe(customScope);
+        expect(scope).toBe(customScope);
+        done();
+      });
+    });
+  });
 });
diff --git a/packages/vercel-edge/src/async.ts b/packages/vercel-edge/src/async.ts
index 11b6b790df1a..50e2d80ad652 100644
--- a/packages/vercel-edge/src/async.ts
+++ b/packages/vercel-edge/src/async.ts
@@ -11,15 +11,15 @@ interface AsyncLocalStorage<T> {
   run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-const MaybeGlobalAsyncLocalStorage = (GLOBAL_OBJ as any).AsyncLocalStorage;
-
 let asyncStorage: AsyncLocalStorage<Hub>;
 
 /**
  * Sets the async context strategy to use AsyncLocalStorage which should be available in the edge runtime.
  */
 export function setAsyncLocalStorageAsyncContextStrategy(): void {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+  const MaybeGlobalAsyncLocalStorage = (GLOBAL_OBJ as any).AsyncLocalStorage;
+
   if (!MaybeGlobalAsyncLocalStorage) {
     DEBUG_BUILD &&
       logger.warn(
diff --git a/packages/vercel-edge/test/async.test.ts b/packages/vercel-edge/test/async.test.ts
new file mode 100644
index 000000000000..37b357ab4910
--- /dev/null
+++ b/packages/vercel-edge/test/async.test.ts
@@ -0,0 +1,150 @@
+import { Scope, getCurrentScope, getGlobalScope, getIsolationScope, withIsolationScope, withScope } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/utils';
+import { AsyncLocalStorage } from 'async_hooks';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../src/async';
+
+describe('withScope()', () => {
+  beforeEach(() => {
+    getIsolationScope().clear();
+    getCurrentScope().clear();
+    getGlobalScope().clear();
+
+    (GLOBAL_OBJ as any).AsyncLocalStorage = AsyncLocalStorage;
+    setAsyncLocalStorageAsyncContextStrategy();
+  });
+
+  it('will make the passed scope the active scope within the callback', done => {
+    withScope(scope => {
+      expect(getCurrentScope()).toBe(scope);
+      done();
+    });
+  });
+
+  it('will pass a scope that is different from the current active isolation scope', done => {
+    withScope(scope => {
+      expect(getIsolationScope()).not.toBe(scope);
+      done();
+    });
+  });
+
+  it('will always make the inner most passed scope the current scope when nesting calls', done => {
+    withIsolationScope(_scope1 => {
+      withIsolationScope(scope2 => {
+        expect(getIsolationScope()).toBe(scope2);
+        done();
+      });
+    });
+  });
+
+  it('forks the scope when not passing any scope', done => {
+    const initialScope = getCurrentScope();
+    initialScope.setTag('aa', 'aa');
+
+    withScope(scope => {
+      expect(getCurrentScope()).toBe(scope);
+      scope.setTag('bb', 'bb');
+      expect(scope).not.toBe(initialScope);
+      expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      done();
+    });
+  });
+
+  it('forks the scope when passing undefined', done => {
+    const initialScope = getCurrentScope();
+    initialScope.setTag('aa', 'aa');
+
+    withScope(undefined, scope => {
+      expect(getCurrentScope()).toBe(scope);
+      scope.setTag('bb', 'bb');
+      expect(scope).not.toBe(initialScope);
+      expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      done();
+    });
+  });
+
+  it('sets the passed in scope as active scope', done => {
+    const initialScope = getCurrentScope();
+    initialScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    withScope(customScope, scope => {
+      expect(getCurrentScope()).toBe(customScope);
+      expect(scope).toBe(customScope);
+      done();
+    });
+  });
+});
+
+describe('withIsolationScope()', () => {
+  beforeEach(() => {
+    getIsolationScope().clear();
+    getCurrentScope().clear();
+    getGlobalScope().clear();
+    (GLOBAL_OBJ as any).AsyncLocalStorage = AsyncLocalStorage;
+
+    setAsyncLocalStorageAsyncContextStrategy();
+  });
+
+  it('will make the passed isolation scope the active isolation scope within the callback', done => {
+    withIsolationScope(scope => {
+      expect(getIsolationScope()).toBe(scope);
+      done();
+    });
+  });
+
+  it('will pass an isolation scope that is different from the current active scope', done => {
+    withIsolationScope(scope => {
+      expect(getCurrentScope()).not.toBe(scope);
+      done();
+    });
+  });
+
+  it('will always make the inner most passed scope the current scope when nesting calls', done => {
+    withIsolationScope(_scope1 => {
+      withIsolationScope(scope2 => {
+        expect(getIsolationScope()).toBe(scope2);
+        done();
+      });
+    });
+  });
+
+  it('forks the isolation scope when not passing any isolation scope', done => {
+    const initialScope = getIsolationScope();
+    initialScope.setTag('aa', 'aa');
+
+    withIsolationScope(scope => {
+      expect(getIsolationScope()).toBe(scope);
+      scope.setTag('bb', 'bb');
+      expect(scope).not.toBe(initialScope);
+      expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      done();
+    });
+  });
+
+  it('forks the isolation scope when passing undefined', done => {
+    const initialScope = getIsolationScope();
+    initialScope.setTag('aa', 'aa');
+
+    withIsolationScope(undefined, scope => {
+      expect(getIsolationScope()).toBe(scope);
+      scope.setTag('bb', 'bb');
+      expect(scope).not.toBe(initialScope);
+      expect(scope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      done();
+    });
+  });
+
+  it('sets the passed in isolation scope as active isolation scope', done => {
+    const initialScope = getIsolationScope();
+    initialScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    withIsolationScope(customScope, scope => {
+      expect(getIsolationScope()).toBe(customScope);
+      expect(scope).toBe(customScope);
+      done();
+    });
+  });
+});

From 75d288c1947f1195f3e57c59c9121b2242f20b83 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 8 Apr 2024 15:02:16 +0100
Subject: [PATCH 12/64] feat(next): Handle existing root spans for isolation
 scope (#11479)

This updates handling of next.js instrumentation to re-use an isolation
scope from a root span.

This should ensure we have consistent isolation scopes, no matter if
next.js auto creates spans or not.
---
 .../withIsolationScopeOrReuseFromRootSpan.ts  | 39 ++++++++
 .../nextjs/src/common/utils/wrapperUtils.ts   |  4 +-
 .../common/withServerActionInstrumentation.ts |  4 +-
 .../src/common/wrapApiHandlerWithSentry.ts    |  4 +-
 .../wrapApiHandlerWithSentryVercelCrons.ts    |  5 +-
 .../wrapGenerationFunctionWithSentry.ts       |  4 +-
 .../src/common/wrapPageComponentWithSentry.ts |  7 +-
 .../src/common/wrapRouteHandlerWithSentry.ts  |  4 +-
 .../common/wrapServerComponentWithSentry.ts   |  4 +-
 ...hIsolationScopeOrReuseFromRootSpan.test.ts | 96 +++++++++++++++++++
 ...hIsolationScopeOrReuseFromRootSpan.test.ts | 96 +++++++++++++++++++
 11 files changed, 250 insertions(+), 17 deletions(-)
 create mode 100644 packages/nextjs/src/common/utils/withIsolationScopeOrReuseFromRootSpan.ts
 create mode 100644 packages/nextjs/test/edge/withIsolationScopeOrReuseFromRootSpan.test.ts
 create mode 100644 packages/nextjs/test/server/withIsolationScopeOrReuseFromRootSpan.test.ts

diff --git a/packages/nextjs/src/common/utils/withIsolationScopeOrReuseFromRootSpan.ts b/packages/nextjs/src/common/utils/withIsolationScopeOrReuseFromRootSpan.ts
new file mode 100644
index 000000000000..82231022b980
--- /dev/null
+++ b/packages/nextjs/src/common/utils/withIsolationScopeOrReuseFromRootSpan.ts
@@ -0,0 +1,39 @@
+import {
+  getActiveSpan,
+  getCapturedScopesOnSpan,
+  getDefaultIsolationScope,
+  getRootSpan,
+  spanToJSON,
+  withIsolationScope,
+} from '@sentry/core';
+import type { Scope } from '@sentry/types';
+
+/**
+ * Wrap a callback with a new isolation scope.
+ * However, if we have an active root span that was generated by next, we want to reuse the isolation scope from that span.
+ */
+export function withIsolationScopeOrReuseFromRootSpan<T>(cb: (isolationScope: Scope) => T): T {
+  const activeSpan = getActiveSpan();
+
+  if (!activeSpan) {
+    return withIsolationScope(cb);
+  }
+
+  const rootSpan = getRootSpan(activeSpan);
+
+  // Verify this is a next span
+  if (!spanToJSON(rootSpan).data?.['next.route']) {
+    return withIsolationScope(cb);
+  }
+
+  const scopes = getCapturedScopesOnSpan(rootSpan);
+
+  const isolationScope = scopes.isolationScope;
+
+  // If this is the default isolation scope, we still want to fork one
+  if (isolationScope === getDefaultIsolationScope()) {
+    return withIsolationScope(cb);
+  }
+
+  return withIsolationScope(isolationScope, cb);
+}
diff --git a/packages/nextjs/src/common/utils/wrapperUtils.ts b/packages/nextjs/src/common/utils/wrapperUtils.ts
index 311be587c439..ef14e19b02fa 100644
--- a/packages/nextjs/src/common/utils/wrapperUtils.ts
+++ b/packages/nextjs/src/common/utils/wrapperUtils.ts
@@ -10,13 +10,13 @@ import {
   startSpan,
   startSpanManual,
   withActiveSpan,
-  withIsolationScope,
 } from '@sentry/core';
 import type { Span } from '@sentry/types';
 import { isString } from '@sentry/utils';
 
 import { platformSupportsStreaming } from './platformSupportsStreaming';
 import { autoEndSpanOnResponseEnd, flushQueue } from './responseEnd';
+import { withIsolationScopeOrReuseFromRootSpan } from './withIsolationScopeOrReuseFromRootSpan';
 
 declare module 'http' {
   interface IncomingMessage {
@@ -89,7 +89,7 @@ export function withTracedServerSideDataFetcher<F extends (...args: any[]) => Pr
   },
 ): (...params: Parameters<F>) => Promise<ReturnType<F>> {
   return async function (this: unknown, ...args: Parameters<F>): Promise<ReturnType<F>> {
-    return withIsolationScope(async isolationScope => {
+    return withIsolationScopeOrReuseFromRootSpan(async isolationScope => {
       isolationScope.setSDKProcessingMetadata({
         request: req,
       });
diff --git a/packages/nextjs/src/common/withServerActionInstrumentation.ts b/packages/nextjs/src/common/withServerActionInstrumentation.ts
index ff089944ac76..a3e95575217a 100644
--- a/packages/nextjs/src/common/withServerActionInstrumentation.ts
+++ b/packages/nextjs/src/common/withServerActionInstrumentation.ts
@@ -6,7 +6,6 @@ import {
   getClient,
   handleCallbackErrors,
   startSpan,
-  withIsolationScope,
 } from '@sentry/core';
 import { logger } from '@sentry/utils';
 
@@ -14,6 +13,7 @@ import { DEBUG_BUILD } from './debug-build';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 interface Options {
   formData?: FormData;
@@ -58,7 +58,7 @@ async function withServerActionInstrumentationImplementation<A extends (...args:
   callback: A,
 ): Promise<ReturnType<A>> {
   addTracingExtensions();
-  return withIsolationScope(isolationScope => {
+  return withIsolationScopeOrReuseFromRootSpan(isolationScope => {
     const sendDefaultPii = getClient()?.getOptions().sendDefaultPii;
 
     let sentryTraceHeader;
diff --git a/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts
index 81b2f88e7888..1519667a7abd 100644
--- a/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts
@@ -5,7 +5,6 @@ import {
   continueTrace,
   setHttpStatus,
   startSpanManual,
-  withIsolationScope,
 } from '@sentry/core';
 import { consoleSandbox, isString, logger, objectify, stripUrlQueryAndFragment } from '@sentry/utils';
 
@@ -13,6 +12,7 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
 import type { AugmentedNextApiRequest, AugmentedNextApiResponse, NextApiHandler } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 /**
  * Wrap the given API route handler for tracing and error capturing. Thin wrapper around `withSentry`, which only
@@ -54,7 +54,7 @@ export function wrapApiHandlerWithSentry(apiHandler: NextApiHandler, parameteriz
 
       addTracingExtensions();
 
-      return withIsolationScope(isolationScope => {
+      return withIsolationScopeOrReuseFromRootSpan(isolationScope => {
         return continueTrace(
           {
             // TODO(v8): Make it so that continue trace will allow null as sentryTrace value and remove this fallback here
diff --git a/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts b/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts
index ec8791f95584..83f5b4aded98 100644
--- a/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts
+++ b/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts
@@ -1,7 +1,8 @@
-import { addTracingExtensions, captureCheckIn, withIsolationScope } from '@sentry/core';
+import { addTracingExtensions, captureCheckIn } from '@sentry/core';
 import type { NextApiRequest } from 'next';
 
 import type { VercelCronsConfig } from './types';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 type EdgeRequest = {
   nextUrl: URL;
@@ -19,7 +20,7 @@ export function wrapApiHandlerWithSentryVercelCrons<F extends (...args: any[]) =
   return new Proxy(handler, {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     apply: (originalFunction, thisArg, args: any[]) => {
-      return withIsolationScope(() => {
+      return withIsolationScopeOrReuseFromRootSpan(() => {
         if (!args || !args[0]) {
           return originalFunction.apply(thisArg, args);
         }
diff --git a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
index e0b771b7643b..e6dd1072a16b 100644
--- a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
+++ b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
@@ -8,7 +8,6 @@ import {
   getCurrentScope,
   handleCallbackErrors,
   startSpanManual,
-  withIsolationScope,
 } from '@sentry/core';
 import type { WebFetchHeaders } from '@sentry/types';
 import { propagationContextFromHeaders, winterCGHeadersToDict } from '@sentry/utils';
@@ -17,6 +16,7 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
 import type { GenerationFunctionContext } from '../common/types';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import { commonObjectToPropagationContext } from './utils/commonObjectTracing';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 /**
  * Wraps a generation function (e.g. generateMetadata) with Sentry error and performance instrumentation.
@@ -47,7 +47,7 @@ export function wrapGenerationFunctionWithSentry<F extends (...args: any[]) => a
         data = { params, searchParams };
       }
 
-      return withIsolationScope(isolationScope => {
+      return withIsolationScopeOrReuseFromRootSpan(isolationScope => {
         isolationScope.setSDKProcessingMetadata({
           request: {
             headers: headers ? winterCGHeadersToDict(headers) : undefined,
diff --git a/packages/nextjs/src/common/wrapPageComponentWithSentry.ts b/packages/nextjs/src/common/wrapPageComponentWithSentry.ts
index 90d7f739d531..b14b5cff2e07 100644
--- a/packages/nextjs/src/common/wrapPageComponentWithSentry.ts
+++ b/packages/nextjs/src/common/wrapPageComponentWithSentry.ts
@@ -1,5 +1,6 @@
-import { addTracingExtensions, captureException, getCurrentScope, withIsolationScope } from '@sentry/core';
+import { addTracingExtensions, captureException, getCurrentScope } from '@sentry/core';
 import { extractTraceparentData } from '@sentry/utils';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 interface FunctionComponent {
   (...args: unknown[]): unknown;
@@ -25,7 +26,7 @@ export function wrapPageComponentWithSentry(pageComponent: FunctionComponent | C
   if (isReactClassComponent(pageComponent)) {
     return class SentryWrappedPageComponent extends pageComponent {
       public render(...args: unknown[]): unknown {
-        return withIsolationScope(() => {
+        return withIsolationScopeOrReuseFromRootSpan(() => {
           const scope = getCurrentScope();
           // We extract the sentry trace data that is put in the component props by datafetcher wrappers
           const sentryTraceData =
@@ -60,7 +61,7 @@ export function wrapPageComponentWithSentry(pageComponent: FunctionComponent | C
   } else if (typeof pageComponent === 'function') {
     return new Proxy(pageComponent, {
       apply(target, thisArg, argArray: [{ _sentryTraceData?: string } | undefined]) {
-        return withIsolationScope(() => {
+        return withIsolationScopeOrReuseFromRootSpan(() => {
           const scope = getCurrentScope();
           // We extract the sentry trace data that is put in the component props by datafetcher wrappers
           const sentryTraceData = argArray?.[0]?._sentryTraceData;
diff --git a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
index 50300cf33b02..edee1e54cec4 100644
--- a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
@@ -8,7 +8,6 @@ import {
   handleCallbackErrors,
   setHttpStatus,
   startSpan,
-  withIsolationScope,
 } from '@sentry/core';
 import { winterCGHeadersToDict } from '@sentry/utils';
 
@@ -16,6 +15,7 @@ import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavi
 import type { RouteHandlerContext } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 /**
  * Wraps a Next.js route handler with performance and error instrumentation.
@@ -29,7 +29,7 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
   const { method, parameterizedRoute, headers } = context;
   return new Proxy(routeHandler, {
     apply: (originalFunction, thisArg, args) => {
-      return withIsolationScope(async isolationScope => {
+      return withIsolationScopeOrReuseFromRootSpan(async isolationScope => {
         isolationScope.setSDKProcessingMetadata({
           request: {
             headers: headers ? winterCGHeadersToDict(headers) : undefined,
diff --git a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
index f91a2181b58b..76521b71e0d1 100644
--- a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
+++ b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
@@ -7,7 +7,6 @@ import {
   getCurrentScope,
   handleCallbackErrors,
   startSpanManual,
-  withIsolationScope,
 } from '@sentry/core';
 import { propagationContextFromHeaders, winterCGHeadersToDict } from '@sentry/utils';
 
@@ -16,6 +15,7 @@ import { isNotFoundNavigationError, isRedirectNavigationError } from '../common/
 import type { ServerComponentContext } from '../common/types';
 import { commonObjectToPropagationContext } from './utils/commonObjectTracing';
 import { flushQueue } from './utils/responseEnd';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 /**
  * Wraps an `app` directory server component with Sentry error instrumentation.
@@ -34,7 +34,7 @@ export function wrapServerComponentWithSentry<F extends (...args: any[]) => any>
   return new Proxy(appDirComponent, {
     apply: (originalFunction, thisArg, args) => {
       // TODO: If we ever allow withIsolationScope to take a scope, we should pass a scope here that is shared between all of the server components, similar to what `commonObjectToPropagationContext` does.
-      return withIsolationScope(isolationScope => {
+      return withIsolationScopeOrReuseFromRootSpan(isolationScope => {
         const completeHeadersDict: Record<string, string> = context.headers
           ? winterCGHeadersToDict(context.headers)
           : {};
diff --git a/packages/nextjs/test/edge/withIsolationScopeOrReuseFromRootSpan.test.ts b/packages/nextjs/test/edge/withIsolationScopeOrReuseFromRootSpan.test.ts
new file mode 100644
index 000000000000..8f42b8a9264b
--- /dev/null
+++ b/packages/nextjs/test/edge/withIsolationScopeOrReuseFromRootSpan.test.ts
@@ -0,0 +1,96 @@
+import {
+  Scope,
+  getCurrentScope,
+  getGlobalScope,
+  getIsolationScope,
+  setCapturedScopesOnSpan,
+  startSpan,
+} from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/utils';
+import { init } from '@sentry/vercel-edge';
+import { AsyncLocalStorage } from 'async_hooks';
+
+import { withIsolationScopeOrReuseFromRootSpan } from '../../src/common/utils/withIsolationScopeOrReuseFromRootSpan';
+
+describe('withIsolationScopeOrReuseFromRootSpan', () => {
+  beforeEach(() => {
+    getIsolationScope().clear();
+    getCurrentScope().clear();
+    getGlobalScope().clear();
+    (GLOBAL_OBJ as any).AsyncLocalStorage = AsyncLocalStorage;
+
+    init({
+      enableTracing: true,
+    });
+  });
+
+  it('works without any span', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+      isolationScope.setTag('bb', 'bb');
+      expect(isolationScope).not.toBe(initialIsolationScope);
+      expect(isolationScope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+    });
+  });
+
+  it('works with a non-next.js span', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    startSpan({ name: 'other' }, span => {
+      setCapturedScopesOnSpan(span, getCurrentScope(), customScope);
+
+      withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+        isolationScope.setTag('bb', 'bb');
+        expect(isolationScope).not.toBe(initialIsolationScope);
+        expect(isolationScope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      });
+    });
+  });
+
+  it('works with a next.js span', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    startSpan(
+      {
+        name: 'other',
+        attributes: { 'next.route': 'aha' },
+      },
+      span => {
+        setCapturedScopesOnSpan(span, getCurrentScope(), customScope);
+
+        withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+          isolationScope.setTag('bb', 'bb');
+          expect(isolationScope).toBe(customScope);
+          expect(isolationScope.getScopeData().tags).toEqual({ bb: 'bb' });
+        });
+      },
+    );
+  });
+
+  it('works with a next.js span that has default isolation scope', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    startSpan(
+      {
+        name: 'other',
+        attributes: { 'next.route': 'aha' },
+      },
+      () => {
+        withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+          isolationScope.setTag('bb', 'bb');
+          expect(isolationScope).not.toBe(initialIsolationScope);
+          expect(isolationScope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+        });
+      },
+    );
+  });
+});
diff --git a/packages/nextjs/test/server/withIsolationScopeOrReuseFromRootSpan.test.ts b/packages/nextjs/test/server/withIsolationScopeOrReuseFromRootSpan.test.ts
new file mode 100644
index 000000000000..0cfc53e0a5b2
--- /dev/null
+++ b/packages/nextjs/test/server/withIsolationScopeOrReuseFromRootSpan.test.ts
@@ -0,0 +1,96 @@
+import {
+  Scope,
+  getCurrentScope,
+  getGlobalScope,
+  getIsolationScope,
+  setCapturedScopesOnSpan,
+  startSpan,
+} from '@sentry/core';
+import { init } from '@sentry/node';
+import { GLOBAL_OBJ } from '@sentry/utils';
+import { AsyncLocalStorage } from 'async_hooks';
+
+import { withIsolationScopeOrReuseFromRootSpan } from '../../src/common/utils/withIsolationScopeOrReuseFromRootSpan';
+
+describe('withIsolationScopeOrReuseFromRootSpan', () => {
+  beforeEach(() => {
+    getIsolationScope().clear();
+    getCurrentScope().clear();
+    getGlobalScope().clear();
+    (GLOBAL_OBJ as any).AsyncLocalStorage = AsyncLocalStorage;
+
+    init({
+      enableTracing: true,
+    });
+  });
+
+  it('works without any span', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+      isolationScope.setTag('bb', 'bb');
+      expect(isolationScope).not.toBe(initialIsolationScope);
+      expect(isolationScope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+    });
+  });
+
+  it('works with a non-next.js span', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    startSpan({ name: 'other' }, span => {
+      setCapturedScopesOnSpan(span, getCurrentScope(), customScope);
+
+      withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+        isolationScope.setTag('bb', 'bb');
+        expect(isolationScope).not.toBe(initialIsolationScope);
+        expect(isolationScope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+      });
+    });
+  });
+
+  it('works with a next.js span', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    const customScope = new Scope();
+
+    startSpan(
+      {
+        name: 'other',
+        attributes: { 'next.route': 'aha' },
+      },
+      span => {
+        setCapturedScopesOnSpan(span, getCurrentScope(), customScope);
+
+        withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+          isolationScope.setTag('bb', 'bb');
+          expect(isolationScope).toBe(customScope);
+          expect(isolationScope.getScopeData().tags).toEqual({ bb: 'bb' });
+        });
+      },
+    );
+  });
+
+  it('works with a next.js span that has default isolation scope', () => {
+    const initialIsolationScope = getIsolationScope();
+    initialIsolationScope.setTag('aa', 'aa');
+
+    startSpan(
+      {
+        name: 'other',
+        attributes: { 'next.route': 'aha' },
+      },
+      () => {
+        withIsolationScopeOrReuseFromRootSpan(isolationScope => {
+          isolationScope.setTag('bb', 'bb');
+          expect(isolationScope).not.toBe(initialIsolationScope);
+          expect(isolationScope.getScopeData().tags).toEqual({ aa: 'aa', bb: 'bb' });
+        });
+      },
+    );
+  });
+});

From 091d23b7a9b31786a12128757b3792d2bac03121 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Mon, 8 Apr 2024 10:15:12 -0400
Subject: [PATCH 13/64] test: Port ignoreErrors and denyUrls tests from karma
 runner (#11449)

I want to remove the karma/mocha based tests in the browser package. To
accomplish this, I'll be porting 1 test suite a day from the old
integration tests to playwright. Today is Day 3:
`packages/browser/test/integration/suites/config.js`

I was surprised we never had `ignoreErrors` or `denyUrls` tests in
playwright, so it's good to get the confidence that everything works
here.

ref https://github.com/getsentry/sentry-javascript/issues/11084
day 2: https://github.com/getsentry/sentry-javascript/pull/11436
---
 .../suites/public-api/denyUrls/init.js        | 14 +++++
 .../suites/public-api/denyUrls/subject.js     | 32 +++++++++++
 .../suites/public-api/denyUrls/test.ts        | 17 ++++++
 .../suites/public-api/ignoreErrors/init.js    | 14 +++++
 .../suites/public-api/ignoreErrors/subject.js |  3 +
 .../suites/public-api/ignoreErrors/test.ts    | 19 +++++++
 .../browser/test/integration/suites/config.js | 55 -------------------
 .../browser/test/integration/suites/shell.js  |  1 -
 8 files changed, 99 insertions(+), 56 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/denyUrls/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/denyUrls/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/denyUrls/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/test.ts
 delete mode 100644 packages/browser/test/integration/suites/config.js

diff --git a/dev-packages/browser-integration-tests/suites/public-api/denyUrls/init.js b/dev-packages/browser-integration-tests/suites/public-api/denyUrls/init.js
new file mode 100644
index 000000000000..c16b31fd1c85
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/denyUrls/init.js
@@ -0,0 +1,14 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+window._errorCount = 0;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  denyUrls: ['foo.js'],
+  beforeSend: event => {
+    window._errorCount++;
+    return event;
+  },
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/denyUrls/subject.js b/dev-packages/browser-integration-tests/suites/public-api/denyUrls/subject.js
new file mode 100644
index 000000000000..d0189ca3db75
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/denyUrls/subject.js
@@ -0,0 +1,32 @@
+/**
+ * We always filter on the caller, not the cause of the error
+ *
+ * > foo.js file called a function in bar.js
+ * > bar.js file called a function in baz.js
+ * > baz.js threw an error
+ *
+ * foo.js is denied in the `init` call (init.js), thus we filter it
+ * */
+var urlWithDeniedUrl = new Error('filter');
+urlWithDeniedUrl.stack =
+  'Error: bar\n' +
+  ' at http://localhost:5000/foo.js:7:19\n' +
+  ' at bar(http://localhost:5000/bar.js:2:3)\n' +
+  ' at baz(http://localhost:5000/baz.js:2:9)\n';
+
+/**
+ * > foo-pass.js file called a function in bar-pass.js
+ * > bar-pass.js file called a function in baz-pass.js
+ * > baz-pass.js threw an error
+ *
+ * foo-pass.js is *not* denied in the `init` call (init.js), thus we don't filter it
+ * */
+var urlWithoutDeniedUrl = new Error('pass');
+urlWithoutDeniedUrl.stack =
+  'Error: bar\n' +
+  ' at http://localhost:5000/foo-pass.js:7:19\n' +
+  ' at bar(http://localhost:5000/bar-pass.js:2:3)\n' +
+  ' at baz(http://localhost:5000/baz-pass.js:2:9)\n';
+
+Sentry.captureException(urlWithDeniedUrl);
+Sentry.captureException(urlWithoutDeniedUrl);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/denyUrls/test.ts b/dev-packages/browser-integration-tests/suites/public-api/denyUrls/test.ts
new file mode 100644
index 000000000000..c374e8ae766c
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/denyUrls/test.ts
@@ -0,0 +1,17 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/types';
+
+import { sentryTest } from '../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../utils/helpers';
+
+sentryTest('should allow to ignore specific urls', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  expect(eventData.exception?.values?.[0].type).toEqual('Error');
+  expect(eventData.exception?.values?.[0].value).toEqual('pass');
+
+  const count = await page.evaluate('window._errorCount');
+  expect(count).toEqual(1);
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/init.js b/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/init.js
new file mode 100644
index 000000000000..e66214c5c0bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/init.js
@@ -0,0 +1,14 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+window._errorCount = 0;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  ignoreErrors: ['ignoreErrorTest'],
+  beforeSend: event => {
+    window._errorCount++;
+    return event;
+  },
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/subject.js b/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/subject.js
new file mode 100644
index 000000000000..9f7883c97284
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/subject.js
@@ -0,0 +1,3 @@
+Sentry.captureException(new Error('foo'));
+Sentry.captureException(new Error('ignoreErrorTest'));
+Sentry.captureException(new Error('bar'));
diff --git a/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/test.ts b/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/test.ts
new file mode 100644
index 000000000000..35752ae39232
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/ignoreErrors/test.ts
@@ -0,0 +1,19 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/types';
+
+import { sentryTest } from '../../../utils/fixtures';
+import { getMultipleSentryEnvelopeRequests } from '../../../utils/helpers';
+
+sentryTest('should allow to ignore specific errors', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const events = await getMultipleSentryEnvelopeRequests<Event>(page, 2, { url });
+
+  expect(events[0].exception?.values?.[0].type).toEqual('Error');
+  expect(events[0].exception?.values?.[0].value).toEqual('foo');
+  expect(events[1].exception?.values?.[0].type).toEqual('Error');
+  expect(events[1].exception?.values?.[0].value).toEqual('bar');
+
+  const count = await page.evaluate('window._errorCount');
+  expect(count).toEqual(2);
+});
diff --git a/packages/browser/test/integration/suites/config.js b/packages/browser/test/integration/suites/config.js
deleted file mode 100644
index 2637ea8c13b7..000000000000
--- a/packages/browser/test/integration/suites/config.js
+++ /dev/null
@@ -1,55 +0,0 @@
-describe('config', function () {
-  it('should allow to ignore specific errors', function () {
-    return runInSandbox(sandbox, function () {
-      Sentry.captureException(new Error('foo'));
-      Sentry.captureException(new Error('ignoreErrorTest'));
-      Sentry.captureException(new Error('bar'));
-    }).then(function (summary) {
-      assert.equal(summary.events[0].exception.values[0].type, 'Error');
-      assert.equal(summary.events[0].exception.values[0].value, 'foo');
-      assert.equal(summary.events[1].exception.values[0].type, 'Error');
-      assert.equal(summary.events[1].exception.values[0].value, 'bar');
-    });
-  });
-
-  it('should allow to ignore specific urls', function () {
-    return runInSandbox(sandbox, function () {
-      /**
-       * We always filter on the caller, not the cause of the error
-       *
-       * > foo.js file called a function in bar.js
-       * > bar.js file called a function in baz.js
-       * > baz.js threw an error
-       *
-       * foo.js is denied in the `init` call (init.js), thus we filter it
-       * */
-      var urlWithDeniedUrl = new Error('filter');
-      urlWithDeniedUrl.stack =
-        'Error: bar\n' +
-        ' at http://localhost:5000/foo.js:7:19\n' +
-        ' at bar(http://localhost:5000/bar.js:2:3)\n' +
-        ' at baz(http://localhost:5000/baz.js:2:9)\n';
-
-      /**
-       * > foo-pass.js file called a function in bar-pass.js
-       * > bar-pass.js file called a function in baz-pass.js
-       * > baz-pass.js threw an error
-       *
-       * foo-pass.js is *not* denied in the `init` call (init.js), thus we don't filter it
-       * */
-      var urlWithoutDeniedUrl = new Error('pass');
-      urlWithoutDeniedUrl.stack =
-        'Error: bar\n' +
-        ' at http://localhost:5000/foo-pass.js:7:19\n' +
-        ' at bar(http://localhost:5000/bar-pass.js:2:3)\n' +
-        ' at baz(http://localhost:5000/baz-pass.js:2:9)\n';
-
-      Sentry.captureException(urlWithDeniedUrl);
-      Sentry.captureException(urlWithoutDeniedUrl);
-    }).then(function (summary) {
-      assert.lengthOf(summary.events, 1);
-      assert.equal(summary.events[0].exception.values[0].type, 'Error');
-      assert.equal(summary.events[0].exception.values[0].value, 'pass');
-    });
-  });
-});
diff --git a/packages/browser/test/integration/suites/shell.js b/packages/browser/test/integration/suites/shell.js
index e1555623b495..7df81ae2b53e 100644
--- a/packages/browser/test/integration/suites/shell.js
+++ b/packages/browser/test/integration/suites/shell.js
@@ -22,7 +22,6 @@ function runVariant(variant) {
     /**
      * The test runner will replace each of these placeholders with the contents of the corresponding file.
      */
-    {{ suites/config.js }} // biome-ignore format: No trailing commas
     {{ suites/onerror.js }} // biome-ignore format: No trailing commas
     {{ suites/onunhandledrejection.js }} // biome-ignore format: No trailing commas
     {{ suites/builtins.js }} // biome-ignore format: No trailing commas

From 022fcb6e56eca1582aeaa0e4b5f7780dd8cfe8a2 Mon Sep 17 00:00:00 2001
From: Catherine Lee <55311782+c298lee@users.noreply.github.com>
Date: Mon, 8 Apr 2024 10:31:50 -0400
Subject: [PATCH 14/64] ref(feedback): Configure font size (#11437)

Font sizes were set instead of using config option
---
 packages/feedback/src/core/components/Actor.css.ts   | 4 ++--
 packages/feedback/src/modal/components/Dialog.css.ts | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/packages/feedback/src/core/components/Actor.css.ts b/packages/feedback/src/core/components/Actor.css.ts
index 38c542d6e1b7..de295e9fc1f4 100644
--- a/packages/feedback/src/core/components/Actor.css.ts
+++ b/packages/feedback/src/core/components/Actor.css.ts
@@ -23,9 +23,9 @@ export function createActorStyles(): HTMLStyleElement {
 
   border-radius: var(--border-radius);
   cursor: pointer;
-  font-size: 14px;
-  font-weight: 600;
   font-family: inherit;
+  font-size: var(--font-size);
+  font-weight: 600;
   padding: 12px 16px;
   text-decoration: none;
   z-index: 9000;
diff --git a/packages/feedback/src/modal/components/Dialog.css.ts b/packages/feedback/src/modal/components/Dialog.css.ts
index 72fe0bd59cb4..9a8e3dc8aa68 100644
--- a/packages/feedback/src/modal/components/Dialog.css.ts
+++ b/packages/feedback/src/modal/components/Dialog.css.ts
@@ -128,7 +128,7 @@ export function createDialogStyles(): HTMLStyleElement {
   border: var(--input-border);
   border-radius: var(--form-content-border-radius);
   color: var(--input-foreground);
-  font-size: 14px;
+  font-size: var(--font-size);
   font-weight: 500;
   padding: 6px 12px;
 }
@@ -153,10 +153,10 @@ export function createDialogStyles(): HTMLStyleElement {
   border: var(--cancel-border);
   border-radius: var(--form-content-border-radius);
   cursor: pointer;
-  font-size: 14px;
+  font-family: inherit;
+  font-size: var(--font-size);
   font-weight: 600;
   padding: 6px 16px;
-  font-family: inherit;
 }
 .btn[disabled] {
   opacity: 0.6;

From f7db230b4e2f8f65a5c7fdd0012cfffc93fa1c4c Mon Sep 17 00:00:00 2001
From: Onur Temizkan <onur@narval.co.uk>
Date: Mon, 8 Apr 2024 22:19:05 +0100
Subject: [PATCH 15/64] feat(remix): Skip span creation for `OPTIONS` and
 `HEAD` requests. (#11149)

Fixes: https://github.com/getsentry/sentry-javascript/issues/11105

Skips span creation for `OPTIONS` and `HEAD` requests in
`wrapRequestHandler`, which apparently are the unwanted requests
mentioned in #11105. We can also implement a more precise filtering but
this seems to resolve it on my local test application.
---
 packages/remix/src/utils/instrumentServer.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/packages/remix/src/utils/instrumentServer.ts b/packages/remix/src/utils/instrumentServer.ts
index 419e5e4ba0f2..593163a96c24 100644
--- a/packages/remix/src/utils/instrumentServer.ts
+++ b/packages/remix/src/utils/instrumentServer.ts
@@ -430,6 +430,13 @@ function wrapRequestHandler(origRequestHandler: RequestHandler, build: ServerBui
       return origRequestHandler.call(this, request, loadContext);
     }
 
+    const upperCaseMethod = request.method.toUpperCase();
+
+    // We don't want to wrap OPTIONS and HEAD requests
+    if (upperCaseMethod === 'OPTIONS' || upperCaseMethod === 'HEAD') {
+      return origRequestHandler.call(this, request, loadContext);
+    }
+
     return withIsolationScope(async isolationScope => {
       const options = getClient()?.getOptions();
 

From 7383f8ab00d5cd534ed19e59a260e18d194c23c8 Mon Sep 17 00:00:00 2001
From: Ryan Albrecht <ryan.albrecht@sentry.io>
Date: Mon, 8 Apr 2024 14:37:18 -0700
Subject: [PATCH 16/64] ref(feedback): Refactor Feedback types into
 @sentry/types and reduce the exported surface area (#11355)

You can read this commit-by-commit to watch the refactor unfold

The situation is: after
https://github.com/getsentry/sentry-javascript/pull/11342 is merged, all
the code inside each of the
`packages/feedback/src/[core|modal|screenshot]` will be split up into
separate integrations. These integrations can't share the same
`src/types/*.ts` definitions anymore. Therefore type definitions will
need to live in @sentry/types instead.

This PR moves all the types, and since they'll be public now in that
package, i refactored things to reduce the public surface area and
improve names where possible.
The only non-type changes in here are where we move `createDialog.ts`
and `createInput.ts` into their respective `integration.ts` files, no
code changes at all.

Related to https://github.com/getsentry/sentry-javascript/issues/11435
---
 .../feedback/src/core/createMainStyles.ts     |   9 +-
 packages/feedback/src/core/integration.ts     |  38 +++----
 packages/feedback/src/core/sendFeedback.ts    |  11 +-
 packages/feedback/src/core/types.ts           |  19 ++++
 packages/feedback/src/index.ts                |   3 -
 .../src/modal/components/DialogContainer.tsx  |   2 +-
 .../src/modal/components/DialogHeader.tsx     |   2 +-
 .../feedback/src/modal/components/Form.tsx    |  31 +++---
 .../src/modal/components/SentryLogo.ts        |   2 +-
 packages/feedback/src/modal/createDialog.tsx  |  95 ----------------
 packages/feedback/src/modal/integration.ts    |  22 ----
 packages/feedback/src/modal/integration.tsx   |  94 ++++++++++++++++
 .../components/ScreenshotEditor.tsx           |  10 +-
 .../feedback/src/screenshot/createInput.ts    |  33 ------
 .../feedback/src/screenshot/integration.ts    |  48 ++++++---
 packages/feedback/src/types/index.ts          | 101 ------------------
 packages/feedback/src/util/mergeOptions.ts    |   3 +-
 packages/feedback/src/util/validate.ts        |   2 +-
 packages/types/src/feedback.ts                |  31 ------
 .../types => types/src/feedback}/config.ts    |   0
 .../src/types => types/src/feedback}/form.ts  |   2 +-
 packages/types/src/feedback/index.ts          |  83 ++++++++++++++
 packages/types/src/feedback/sendFeedback.ts   |  54 ++++++++++
 .../src/types => types/src/feedback}/theme.ts |   0
 packages/types/src/index.ts                   |  13 ++-
 25 files changed, 346 insertions(+), 362 deletions(-)
 create mode 100644 packages/feedback/src/core/types.ts
 delete mode 100644 packages/feedback/src/modal/createDialog.tsx
 delete mode 100644 packages/feedback/src/modal/integration.ts
 create mode 100644 packages/feedback/src/modal/integration.tsx
 delete mode 100644 packages/feedback/src/screenshot/createInput.ts
 delete mode 100644 packages/feedback/src/types/index.ts
 delete mode 100644 packages/types/src/feedback.ts
 rename packages/{feedback/src/types => types/src/feedback}/config.ts (100%)
 rename packages/{feedback/src/types => types/src/feedback}/form.ts (72%)
 create mode 100644 packages/types/src/feedback/index.ts
 create mode 100644 packages/types/src/feedback/sendFeedback.ts
 rename packages/{feedback/src/types => types/src/feedback}/theme.ts (100%)

diff --git a/packages/feedback/src/core/createMainStyles.ts b/packages/feedback/src/core/createMainStyles.ts
index 9eb5bd4dc2ab..ca5f138cb960 100644
--- a/packages/feedback/src/core/createMainStyles.ts
+++ b/packages/feedback/src/core/createMainStyles.ts
@@ -1,7 +1,7 @@
+import type { FeedbackInternalOptions } from '@sentry/types';
 import { DOCUMENT } from '../constants';
-import type { FeedbackTheme, FeedbackThemes } from '../types';
 
-function getThemedCssVariables(theme: FeedbackTheme): string {
+function getThemedCssVariables(theme: FeedbackInternalOptions['themeLight']): string {
   return `
   --background: ${theme.background};
   --background-hover: ${theme.backgroundHover};
@@ -39,7 +39,10 @@ function getThemedCssVariables(theme: FeedbackTheme): string {
 /**
  * Creates <style> element for widget actor (button that opens the dialog)
  */
-export function createMainStyles(colorScheme: 'system' | 'dark' | 'light', themes: FeedbackThemes): HTMLStyleElement {
+export function createMainStyles(
+  colorScheme: 'system' | 'dark' | 'light',
+  themes: Pick<FeedbackInternalOptions, 'themeLight' | 'themeDark'>,
+): HTMLStyleElement {
   const style = DOCUMENT.createElement('style');
   style.textContent = `
 :host {
diff --git a/packages/feedback/src/core/integration.ts b/packages/feedback/src/core/integration.ts
index e0a0e273e6f0..e39b032bbc85 100644
--- a/packages/feedback/src/core/integration.ts
+++ b/packages/feedback/src/core/integration.ts
@@ -1,5 +1,11 @@
 import { getClient } from '@sentry/core';
-import type { Integration, IntegrationFn } from '@sentry/types';
+import type {
+  FeedbackDialog,
+  FeedbackInternalOptions,
+  FeedbackModalIntegration,
+  FeedbackScreenshotIntegration,
+  IntegrationFn,
+} from '@sentry/types';
 import { isBrowser, logger } from '@sentry/utils';
 import {
   ACTOR_LABEL,
@@ -17,34 +23,16 @@ import {
   SUBMIT_BUTTON_LABEL,
   SUCCESS_MESSAGE_TEXT,
 } from '../constants';
-import type { IFeedbackModalIntegration } from '../modal/integration';
-import type { IFeedbackScreenshotIntegration } from '../screenshot/integration';
-import type {
-  Dialog,
-  FeedbackInternalOptions,
-  OptionalFeedbackConfiguration,
-  OverrideFeedbackConfiguration,
-} from '../types';
 import { DEBUG_BUILD } from '../util/debug-build';
 import { isScreenshotSupported } from '../util/isScreenshotSupported';
 import { mergeOptions } from '../util/mergeOptions';
 import { Actor } from './components/Actor';
 import { createMainStyles } from './createMainStyles';
 import { sendFeedback } from './sendFeedback';
+import type { OptionalFeedbackConfiguration, OverrideFeedbackConfiguration } from './types';
 
 type Unsubscribe = () => void;
 
-interface PublicFeedbackIntegration {
-  attachTo: (el: Element | string, optionOverrides: OverrideFeedbackConfiguration) => () => void;
-  createWidget: (optionOverrides: OverrideFeedbackConfiguration & { shouldCreateActor?: boolean }) => Promise<Dialog>;
-  getWidget: () => Dialog | null;
-  remove: () => void;
-  openDialog: () => void;
-  closeDialog: () => void;
-  removeWidget: () => void;
-}
-export type IFeedbackIntegration = Integration & PublicFeedbackIntegration;
-
 /**
  * Allow users to capture user feedback and send it to Sentry.
  */
@@ -148,13 +136,13 @@ export const feedbackIntegration = (({
     return _shadow as ShadowRoot;
   };
 
-  const _loadAndRenderDialog = async (options: FeedbackInternalOptions): Promise<Dialog> => {
+  const _loadAndRenderDialog = async (options: FeedbackInternalOptions): Promise<FeedbackDialog> => {
     const client = getClient(); // TODO: getClient<BrowserClient>()
     if (!client) {
       throw new Error('Sentry Client is not initialized correctly');
     }
-    const modalIntegration = client.getIntegrationByName<IFeedbackModalIntegration>('FeedbackModal');
-    const screenshotIntegration = client.getIntegrationByName<IFeedbackScreenshotIntegration>('FeedbackScreenshot');
+    const modalIntegration = client.getIntegrationByName<FeedbackModalIntegration>('FeedbackModal');
+    const screenshotIntegration = client.getIntegrationByName<FeedbackScreenshotIntegration>('FeedbackScreenshot');
     const screenshotIsSupported = isScreenshotSupported();
 
     // START TEMP: Error messages
@@ -196,7 +184,7 @@ export const feedbackIntegration = (({
       throw new Error('Unable to attach to target element');
     }
 
-    let dialog: Dialog | null = null;
+    let dialog: FeedbackDialog | null = null;
     const handleClick = async (): Promise<void> => {
       if (!dialog) {
         dialog = await _loadAndRenderDialog({
@@ -264,7 +252,7 @@ export const feedbackIntegration = (({
     /**
      * Creates a new widget. Accepts partial options to override any options passed to constructor.
      */
-    async createWidget(optionOverrides: OverrideFeedbackConfiguration = {}): Promise<Dialog> {
+    async createWidget(optionOverrides: OverrideFeedbackConfiguration = {}): Promise<FeedbackDialog> {
       return _loadAndRenderDialog(mergeOptions(_options, optionOverrides));
     },
 
diff --git a/packages/feedback/src/core/sendFeedback.ts b/packages/feedback/src/core/sendFeedback.ts
index f3310303082a..5aa795fb16ca 100644
--- a/packages/feedback/src/core/sendFeedback.ts
+++ b/packages/feedback/src/core/sendFeedback.ts
@@ -1,17 +1,16 @@
 import { createAttachmentEnvelope, createEventEnvelope, getClient, withScope } from '@sentry/core';
-import type { FeedbackEvent, TransportMakeRequestResponse } from '@sentry/types';
+import type { FeedbackEvent, SendFeedback, SendFeedbackParams } from '@sentry/types';
 import { getLocationHref } from '@sentry/utils';
 import { FEEDBACK_API_SOURCE, FEEDBACK_WIDGET_SOURCE } from '../constants';
-import type { SendFeedbackOptions, SendFeedbackParams } from '../types';
 import { prepareFeedbackEvent } from '../util/prepareFeedbackEvent';
 
 /**
  * Public API to send a Feedback item to Sentry
  */
-export async function sendFeedback(
+export const sendFeedback: SendFeedback = (
   { name, email, message, attachments, source = FEEDBACK_API_SOURCE, url = getLocationHref() }: SendFeedbackParams,
-  { includeReplay = true }: SendFeedbackOptions = {},
-): Promise<TransportMakeRequestResponse> {
+  { includeReplay = true } = {},
+) => {
   if (!message) {
     throw new Error('Unable to submit feedback with empty message');
   }
@@ -97,7 +96,7 @@ export async function sendFeedback(
       throw error;
     }
   });
-}
+};
 
 /*
  * For reference, the fully built event looks something like this:
diff --git a/packages/feedback/src/core/types.ts b/packages/feedback/src/core/types.ts
new file mode 100644
index 000000000000..a85987301702
--- /dev/null
+++ b/packages/feedback/src/core/types.ts
@@ -0,0 +1,19 @@
+import type { FeedbackInternalOptions } from '@sentry/types';
+
+/**
+ * Partial configuration that overrides default configuration values
+ *
+ * This is the config that gets passed into the integration constructor
+ */
+export interface OptionalFeedbackConfiguration
+  extends Omit<Partial<FeedbackInternalOptions>, 'themeLight' | 'themeDark'> {
+  themeLight?: Partial<FeedbackInternalOptions['themeLight']>;
+  themeDark?: Partial<FeedbackInternalOptions['themeLight']>;
+}
+
+/**
+ * Partial configuration that overrides default configuration values
+ *
+ * This is the config that gets passed into the integration constructor
+ */
+export type OverrideFeedbackConfiguration = Omit<Partial<FeedbackInternalOptions>, 'themeLight' | 'themeDark'>;
diff --git a/packages/feedback/src/index.ts b/packages/feedback/src/index.ts
index c182c98669c3..245469a7f3d6 100644
--- a/packages/feedback/src/index.ts
+++ b/packages/feedback/src/index.ts
@@ -3,6 +3,3 @@ export { feedbackIntegration } from './core/integration';
 export { feedbackModalIntegration } from './modal/integration';
 export { getFeedback } from './core/getFeedback';
 export { feedbackScreenshotIntegration } from './screenshot/integration';
-
-export type { OptionalFeedbackConfiguration } from './types';
-export type { IFeedbackIntegration } from './core/integration';
diff --git a/packages/feedback/src/modal/components/DialogContainer.tsx b/packages/feedback/src/modal/components/DialogContainer.tsx
index 9c178ea9de2d..97d1b7f84e96 100644
--- a/packages/feedback/src/modal/components/DialogContainer.tsx
+++ b/packages/feedback/src/modal/components/DialogContainer.tsx
@@ -1,9 +1,9 @@
+import type { FeedbackFormData } from '@sentry/types';
 // biome-ignore lint/nursery/noUnusedImports: reason
 import { Fragment, h } from 'preact'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import type { VNode } from 'preact';
 import { useCallback, useMemo, useState } from 'preact/hooks';
 import { SUCCESS_MESSAGE_TIMEOUT } from '../../constants';
-import type { FeedbackFormData } from '../../types';
 import { DialogContent } from './DialogContent';
 import { DialogHeader } from './DialogHeader';
 import type { Props as HeaderProps } from './DialogHeader';
diff --git a/packages/feedback/src/modal/components/DialogHeader.tsx b/packages/feedback/src/modal/components/DialogHeader.tsx
index 2af30b580b56..0d6c66d8341c 100644
--- a/packages/feedback/src/modal/components/DialogHeader.tsx
+++ b/packages/feedback/src/modal/components/DialogHeader.tsx
@@ -1,8 +1,8 @@
+import type { FeedbackInternalOptions } from '@sentry/types';
 // biome-ignore lint/nursery/noUnusedImports: reason
 import { h } from 'preact'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import type { VNode } from 'preact';
 import { useMemo } from 'preact/hooks';
-import type { FeedbackInternalOptions } from '../../types';
 import type { Props as LogoProps } from './SentryLogo';
 import { SentryLogo } from './SentryLogo';
 
diff --git a/packages/feedback/src/modal/components/Form.tsx b/packages/feedback/src/modal/components/Form.tsx
index 960b4c3d9038..5b5c5aa80dd4 100644
--- a/packages/feedback/src/modal/components/Form.tsx
+++ b/packages/feedback/src/modal/components/Form.tsx
@@ -1,16 +1,15 @@
+import type {
+  FeedbackFormData,
+  FeedbackInternalOptions,
+  FeedbackScreenshotIntegration,
+  SendFeedback,
+} from '@sentry/types';
 import { logger } from '@sentry/utils';
 // biome-ignore lint/nursery/noUnusedImports: reason
 import { h } from 'preact'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import type { JSX, VNode } from 'preact';
 import { useCallback, useState } from 'preact/hooks';
 import { FEEDBACK_WIDGET_SOURCE } from '../../constants';
-import type {
-  FeedbackFormData,
-  FeedbackInternalOptions,
-  ScreenshotInput,
-  SendFeedbackOptions,
-  SendFeedbackParams,
-} from '../../types';
 import { DEBUG_BUILD } from '../../util/debug-build';
 import { getMissingFields } from '../../util/validate';
 
@@ -34,10 +33,10 @@ export interface Props
   defaultEmail: string;
   defaultName: string;
   onFormClose: () => void;
-  onSubmit: (data: SendFeedbackParams, options?: SendFeedbackOptions) => void;
+  onSubmit: SendFeedback;
   onSubmitSuccess: (data: FeedbackFormData) => void;
   onSubmitError: (error: Error) => void;
-  screenshotInput: ScreenshotInput | undefined;
+  screenshotInput: ReturnType<FeedbackScreenshotIntegration['createInput']> | undefined;
 }
 
 function retrieveStringValue(formData: FormData, key: string): string {
@@ -74,8 +73,8 @@ export function Form({
   const [error, setError] = useState<null | string>(null);
 
   const [showScreenshotInput, setShowScreenshotInput] = useState(false);
-  const ScreenshotInput = screenshotInput && screenshotInput.input;
-  const includeScreenshotValue = ScreenshotInput && showScreenshotInput;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ScreenshotInputComponent: any = screenshotInput && screenshotInput.input;
 
   const [screenshotError, setScreenshotError] = useState<null | Error>(null);
   const onScreenshotError = useCallback((error: Error) => {
@@ -112,7 +111,7 @@ export function Form({
           return;
         }
         const formData = new FormData(e.target);
-        const attachment = await (includeScreenshotValue ? screenshotInput.value() : undefined);
+        const attachment = await (screenshotInput && showScreenshotInput ? screenshotInput.value() : undefined);
         const data: FeedbackFormData = {
           name: retrieveStringValue(formData, 'name'),
           email: retrieveStringValue(formData, 'email'),
@@ -134,12 +133,14 @@ export function Form({
         // pass
       }
     },
-    [includeScreenshotValue, onSubmitSuccess, onSubmitError],
+    [screenshotInput && showScreenshotInput, onSubmitSuccess, onSubmitError],
   );
 
   return (
     <form class="form" onSubmit={handleSubmit}>
-      {includeScreenshotValue ? <ScreenshotInput onError={onScreenshotError} /> : null}
+      {ScreenshotInputComponent && showScreenshotInput ? (
+        <ScreenshotInputComponent onError={onScreenshotError} />
+      ) : null}
 
       <div class="form__right">
         <div class="form__top">
@@ -192,7 +193,7 @@ export function Form({
             />
           </label>
 
-          {ScreenshotInput ? (
+          {ScreenshotInputComponent ? (
             <label for="screenshot" class="form__label">
               <span class="form__label__text">Screenshot</span>
 
diff --git a/packages/feedback/src/modal/components/SentryLogo.ts b/packages/feedback/src/modal/components/SentryLogo.ts
index 1e32ad8efdcd..4c6cb9f81153 100644
--- a/packages/feedback/src/modal/components/SentryLogo.ts
+++ b/packages/feedback/src/modal/components/SentryLogo.ts
@@ -1,5 +1,5 @@
+import type { FeedbackInternalOptions } from '@sentry/types';
 import { DOCUMENT } from '../../constants';
-import type { FeedbackInternalOptions } from '../../types';
 import { setAttributesNS } from '../../util/setAttributesNS';
 
 const XMLNS = 'http://www.w3.org/2000/svg';
diff --git a/packages/feedback/src/modal/createDialog.tsx b/packages/feedback/src/modal/createDialog.tsx
deleted file mode 100644
index 626c1fe20d19..000000000000
--- a/packages/feedback/src/modal/createDialog.tsx
+++ /dev/null
@@ -1,95 +0,0 @@
-import { getCurrentScope } from '@sentry/core';
-import { h, render } from 'preact';
-import { DOCUMENT } from '../constants';
-import type { sendFeedback as sendFeedbackFn } from '../core/sendFeedback';
-import type { IFeedbackScreenshotIntegration } from '../screenshot/integration';
-import type { Dialog, FeedbackFormData, FeedbackInternalOptions } from '../types';
-import { createDialogStyles } from './components/Dialog.css';
-import { DialogComponent } from './components/DialogContainer';
-
-interface Props {
-  options: FeedbackInternalOptions;
-  screenshotIntegration: IFeedbackScreenshotIntegration | undefined;
-  sendFeedback: typeof sendFeedbackFn;
-  shadow: ShadowRoot;
-}
-
-export function createDialog({ options, screenshotIntegration, sendFeedback, shadow }: Props): Dialog {
-  const userKey = options.useSentryUser;
-  const scope = getCurrentScope();
-  const user = scope && scope.getUser();
-
-  const el = DOCUMENT.createElement('div');
-  const style = createDialogStyles();
-
-  const dialog = {
-    get el() {
-      return el;
-    },
-    appendToDom(): void {
-      if (!shadow.contains(style) && !shadow.contains(el)) {
-        shadow.appendChild(style);
-        shadow.appendChild(el);
-      }
-    },
-    removeFromDom(): void {
-      shadow.removeChild(el);
-      shadow.removeChild(style);
-    },
-    open() {
-      renderContent(true);
-      options.onFormOpen && options.onFormOpen();
-    },
-    close() {
-      renderContent(false);
-    },
-  };
-
-  const screenshotInput = screenshotIntegration && screenshotIntegration.createInput(h, dialog);
-
-  const renderContent = (open: boolean): void => {
-    render(
-      <DialogComponent
-        screenshotInput={screenshotInput}
-        colorScheme={options.colorScheme}
-        showBranding={options.showBranding}
-        showName={options.showName || options.isNameRequired}
-        showEmail={options.showEmail || options.isEmailRequired}
-        isNameRequired={options.isNameRequired}
-        isEmailRequired={options.isEmailRequired}
-        formTitle={options.formTitle}
-        cancelButtonLabel={options.cancelButtonLabel}
-        submitButtonLabel={options.submitButtonLabel}
-        emailLabel={options.emailLabel}
-        emailPlaceholder={options.emailPlaceholder}
-        messageLabel={options.messageLabel}
-        messagePlaceholder={options.messagePlaceholder}
-        nameLabel={options.nameLabel}
-        namePlaceholder={options.namePlaceholder}
-        defaultName={(userKey && user && user[userKey.name]) || ''}
-        defaultEmail={(userKey && user && user[userKey.email]) || ''}
-        successMessageText={options.successMessageText}
-        isRequiredText={options.isRequiredText}
-        onFormClose={() => {
-          renderContent(false);
-          options.onFormClose && options.onFormClose();
-        }}
-        onSubmit={sendFeedback}
-        onSubmitSuccess={(data: FeedbackFormData) => {
-          renderContent(false);
-          options.onSubmitSuccess && options.onSubmitSuccess(data);
-        }}
-        onSubmitError={(error: Error) => {
-          options.onSubmitError && options.onSubmitError(error);
-        }}
-        onFormSubmitted={() => {
-          options.onFormSubmitted && options.onFormSubmitted();
-        }}
-        open={open}
-      />,
-      el,
-    );
-  };
-
-  return dialog;
-}
diff --git a/packages/feedback/src/modal/integration.ts b/packages/feedback/src/modal/integration.ts
deleted file mode 100644
index fa034650f023..000000000000
--- a/packages/feedback/src/modal/integration.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { defineIntegration } from '@sentry/core';
-import type { Integration, IntegrationFn } from '@sentry/types';
-import { createDialog } from './createDialog';
-
-interface PublicFeedbackModalIntegration {
-  createDialog: typeof createDialog;
-}
-
-const INTEGRATION_NAME = 'FeedbackModal';
-
-export type IFeedbackModalIntegration = Integration & PublicFeedbackModalIntegration;
-
-export const _feedbackModalIntegration = (() => {
-  return {
-    name: INTEGRATION_NAME,
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setupOnce() {},
-    createDialog,
-  };
-}) satisfies IntegrationFn;
-
-export const feedbackModalIntegration = defineIntegration(_feedbackModalIntegration);
diff --git a/packages/feedback/src/modal/integration.tsx b/packages/feedback/src/modal/integration.tsx
new file mode 100644
index 000000000000..6f6cc8f5fef6
--- /dev/null
+++ b/packages/feedback/src/modal/integration.tsx
@@ -0,0 +1,94 @@
+import { getCurrentScope } from '@sentry/core';
+import type { CreateDialogProps, FeedbackFormData, FeedbackModalIntegration, IntegrationFn } from '@sentry/types';
+import { h, render } from 'preact';
+import { DOCUMENT } from '../constants';
+import { createDialogStyles } from './components/Dialog.css';
+import { DialogComponent } from './components/DialogContainer';
+
+export const feedbackModalIntegration = ((): FeedbackModalIntegration => {
+  return {
+    name: 'FeedbackModal',
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setupOnce() {},
+    createDialog: ({ options, screenshotIntegration, sendFeedback, shadow }: CreateDialogProps) => {
+      const shadowRoot = shadow as unknown as ShadowRoot;
+      const userKey = options.useSentryUser;
+      const scope = getCurrentScope();
+      const user = scope && scope.getUser();
+
+      const el = DOCUMENT.createElement('div');
+      const style = createDialogStyles();
+
+      const dialog = {
+        get el() {
+          return el;
+        },
+        appendToDom(): void {
+          if (!shadowRoot.contains(style) && !shadowRoot.contains(el)) {
+            shadowRoot.appendChild(style);
+            shadowRoot.appendChild(el);
+          }
+        },
+        removeFromDom(): void {
+          shadowRoot.removeChild(el);
+          shadowRoot.removeChild(style);
+        },
+        open() {
+          renderContent(true);
+          options.onFormOpen && options.onFormOpen();
+        },
+        close() {
+          renderContent(false);
+        },
+      };
+
+      const screenshotInput = screenshotIntegration && screenshotIntegration.createInput(h, dialog);
+
+      const renderContent = (open: boolean): void => {
+        render(
+          <DialogComponent
+            screenshotInput={screenshotInput}
+            colorScheme={options.colorScheme}
+            showBranding={options.showBranding}
+            showName={options.showName || options.isNameRequired}
+            showEmail={options.showEmail || options.isEmailRequired}
+            isNameRequired={options.isNameRequired}
+            isEmailRequired={options.isEmailRequired}
+            formTitle={options.formTitle}
+            cancelButtonLabel={options.cancelButtonLabel}
+            submitButtonLabel={options.submitButtonLabel}
+            emailLabel={options.emailLabel}
+            emailPlaceholder={options.emailPlaceholder}
+            messageLabel={options.messageLabel}
+            messagePlaceholder={options.messagePlaceholder}
+            nameLabel={options.nameLabel}
+            namePlaceholder={options.namePlaceholder}
+            defaultName={(userKey && user && user[userKey.name]) || ''}
+            defaultEmail={(userKey && user && user[userKey.email]) || ''}
+            successMessageText={options.successMessageText}
+            isRequiredText={options.isRequiredText}
+            onFormClose={() => {
+              renderContent(false);
+              options.onFormClose && options.onFormClose();
+            }}
+            onSubmit={sendFeedback}
+            onSubmitSuccess={(data: FeedbackFormData) => {
+              renderContent(false);
+              options.onSubmitSuccess && options.onSubmitSuccess(data);
+            }}
+            onSubmitError={(error: Error) => {
+              options.onSubmitError && options.onSubmitError(error);
+            }}
+            onFormSubmitted={() => {
+              options.onFormSubmitted && options.onFormSubmitted();
+            }}
+            open={open}
+          />,
+          el,
+        );
+      };
+
+      return dialog;
+    },
+  };
+}) satisfies IntegrationFn;
diff --git a/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx b/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx
index f3c0e39970ce..0287b647ece0 100644
--- a/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx
+++ b/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx
@@ -1,10 +1,10 @@
+import type { FeedbackDialog } from '@sentry/types';
 /* eslint-disable max-lines */
 import type { ComponentType, VNode, h as hType } from 'preact';
 // biome-ignore lint: needed for preact
 import { h } from 'preact'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { useCallback, useEffect, useMemo, useRef, useState } from 'preact/hooks';
 import { CROP_COLOR, DOCUMENT, WINDOW } from '../../constants';
-import type { Dialog } from '../../types';
 import { createScreenshotInputStyles } from './ScreenshotInput.css';
 import { useTakeScreenshot } from './useTakeScreenshot';
 
@@ -16,7 +16,7 @@ const DPI = WINDOW.devicePixelRatio;
 interface FactoryParams {
   h: typeof hType;
   imageBuffer: HTMLCanvasElement;
-  dialog: Dialog;
+  dialog: FeedbackDialog;
 }
 
 interface Props {
@@ -219,7 +219,7 @@ export function makeScreenshotEditorComponent({ h, imageBuffer, dialog }: Factor
 
     useTakeScreenshot({
       onBeforeScreenshot: useCallback(() => {
-        dialog.el.style.display = 'none';
+        (dialog.el as HTMLElement).style.display = 'none';
       }, []),
       onScreenshot: useCallback(
         (imageSource: HTMLVideoElement) => {
@@ -234,13 +234,13 @@ export function makeScreenshotEditorComponent({ h, imageBuffer, dialog }: Factor
         [imageBuffer],
       ),
       onAfterScreenshot: useCallback(() => {
-        dialog.el.style.display = 'block';
+        (dialog.el as HTMLElement).style.display = 'block';
         const container = canvasContainerRef.current;
         container && container.appendChild(imageBuffer);
         resizeCropper();
       }, []),
       onError: useCallback(error => {
-        dialog.el.style.display = 'block';
+        (dialog.el as HTMLElement).style.display = 'block';
         onError(error);
       }, []),
     });
diff --git a/packages/feedback/src/screenshot/createInput.ts b/packages/feedback/src/screenshot/createInput.ts
deleted file mode 100644
index 679a82f5dfba..000000000000
--- a/packages/feedback/src/screenshot/createInput.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import type { Attachment } from '@sentry/types';
-import type { h as hType } from 'preact';
-import { DOCUMENT } from '../constants';
-import type { Dialog, ScreenshotInput } from '../types';
-import { makeScreenshotEditorComponent } from './components/ScreenshotEditor';
-
-/**
- *
- */
-export function createInput(h: typeof hType, dialog: Dialog): ScreenshotInput {
-  const imageBuffer = DOCUMENT.createElement('canvas');
-
-  return {
-    input: makeScreenshotEditorComponent({ h, imageBuffer, dialog }),
-
-    value: async () => {
-      const blob = await new Promise<Parameters<BlobCallback>[0]>(resolve => {
-        imageBuffer.toBlob(resolve, 'image/png');
-      });
-      if (blob) {
-        const data = new Uint8Array(await blob.arrayBuffer());
-        const attachment: Attachment = {
-          data,
-          filename: 'screenshot.png',
-          contentType: 'application/png',
-          // attachmentType?: string;
-        };
-        return attachment;
-      }
-      return;
-    },
-  };
-}
diff --git a/packages/feedback/src/screenshot/integration.ts b/packages/feedback/src/screenshot/integration.ts
index 3b959b971d70..f4d8a287ad96 100644
--- a/packages/feedback/src/screenshot/integration.ts
+++ b/packages/feedback/src/screenshot/integration.ts
@@ -1,22 +1,38 @@
-import { defineIntegration } from '@sentry/core';
-import type { Integration, IntegrationFn } from '@sentry/types';
-import { createInput } from './createInput';
+import type { FeedbackDialog, FeedbackScreenshotIntegration, IntegrationFn } from '@sentry/types';
+import type { Attachment } from '@sentry/types';
+import type { h as hType } from 'preact';
+import { DOCUMENT } from '../constants';
+import { makeScreenshotEditorComponent } from './components/ScreenshotEditor';
 
-interface PublicFeedbackScreenshotIntegration {
-  createInput: typeof createInput;
-}
-
-const INTEGRATION_NAME = 'FeedbackScreenshot';
-
-export type IFeedbackScreenshotIntegration = Integration & PublicFeedbackScreenshotIntegration;
-
-export const _feedbackScreenshotIntegration = (() => {
+export const feedbackScreenshotIntegration = ((): FeedbackScreenshotIntegration => {
   return {
-    name: INTEGRATION_NAME,
+    name: 'FeedbackScreenshot',
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     setupOnce() {},
-    createInput,
+    createInput: (h: unknown, dialog: FeedbackDialog) => {
+      const imageBuffer = DOCUMENT.createElement('canvas');
+
+      return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        input: makeScreenshotEditorComponent({ h: h as typeof hType, imageBuffer, dialog }) as any,
+
+        value: async () => {
+          const blob = await new Promise<Parameters<BlobCallback>[0]>(resolve => {
+            imageBuffer.toBlob(resolve, 'image/png');
+          });
+          if (blob) {
+            const data = new Uint8Array(await blob.arrayBuffer());
+            const attachment: Attachment = {
+              data,
+              filename: 'screenshot.png',
+              contentType: 'application/png',
+              // attachmentType?: string;
+            };
+            return attachment;
+          }
+          return undefined;
+        },
+      };
+    },
   };
 }) satisfies IntegrationFn;
-
-export const feedbackScreenshotIntegration = defineIntegration(_feedbackScreenshotIntegration);
diff --git a/packages/feedback/src/types/index.ts b/packages/feedback/src/types/index.ts
deleted file mode 100644
index cee1bae6ab87..000000000000
--- a/packages/feedback/src/types/index.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import type { Attachment } from '@sentry/types';
-import type { ComponentType } from 'preact';
-import type {
-  FeedbackCallbacks,
-  FeedbackGeneralConfiguration,
-  FeedbackTextConfiguration,
-  FeedbackThemeConfiguration,
-} from './config';
-import type { FeedbackTheme } from './theme';
-
-export type { FeedbackFormData } from './form';
-
-export { FeedbackTheme };
-export interface FeedbackThemes {
-  themeDark: FeedbackTheme;
-  themeLight: FeedbackTheme;
-}
-
-/**
- * The integration's internal `options` member where every value should be set
- */
-export interface FeedbackInternalOptions
-  extends FeedbackGeneralConfiguration,
-    FeedbackThemeConfiguration,
-    FeedbackTextConfiguration,
-    FeedbackCallbacks {}
-
-/**
- * Partial configuration that overrides default configuration values
- *
- * This is the config that gets passed into the integration constructor
- */
-export interface OptionalFeedbackConfiguration
-  extends Omit<Partial<FeedbackInternalOptions>, 'themeLight' | 'themeDark'> {
-  themeLight?: Partial<FeedbackTheme>;
-  themeDark?: Partial<FeedbackTheme>;
-}
-
-/**
- * Partial configuration that overrides default configuration values
- *
- * This is the config that gets passed into the integration constructor
- */
-export type OverrideFeedbackConfiguration = Omit<Partial<FeedbackInternalOptions>, 'themeLight' | 'themeDark'>;
-
-export interface SendFeedbackParams {
-  message: string;
-  name?: string;
-  email?: string;
-  attachments?: Attachment[];
-  url?: string;
-  source?: string;
-}
-
-export interface SendFeedbackOptions {
-  /**
-   * Should include replay with the feedback?
-   */
-  includeReplay?: boolean;
-}
-
-export interface Dialog {
-  /**
-   * The HTMLElement that is containing all the form content
-   */
-  el: HTMLElement;
-
-  /**
-   * Insert the Dialog into the Shadow DOM.
-   *
-   * The Dialog starts in the `closed` state where no inner HTML is rendered.
-   */
-  appendToDom: () => void;
-
-  /**
-   * Remove the dialog from the Shadow DOM
-   */
-  removeFromDom: () => void;
-
-  /**
-   * Open/Show the dialog & form inside it
-   */
-  open: () => void;
-
-  /**
-   * Close/Hide the dialog & form inside it
-   */
-  close: () => void;
-}
-
-export interface ScreenshotInput {
-  /**
-   * The preact component
-   */
-  input: ComponentType<{ onError: (error: Error) => void }>;
-
-  /**
-   * The image/screenshot bytes
-   */
-  value: () => Promise<Attachment | undefined>;
-}
diff --git a/packages/feedback/src/util/mergeOptions.ts b/packages/feedback/src/util/mergeOptions.ts
index da7f4c271f14..8e7961fc9a21 100644
--- a/packages/feedback/src/util/mergeOptions.ts
+++ b/packages/feedback/src/util/mergeOptions.ts
@@ -1,4 +1,5 @@
-import type { FeedbackFormData, FeedbackInternalOptions, OptionalFeedbackConfiguration } from '../types';
+import type { FeedbackFormData, FeedbackInternalOptions } from '@sentry/types';
+import type { OptionalFeedbackConfiguration } from '../core/types';
 
 /**
  * Quick and dirty deep merge for the Feedback integration options
diff --git a/packages/feedback/src/util/validate.ts b/packages/feedback/src/util/validate.ts
index 5ab14743bf03..5525e191dd9d 100644
--- a/packages/feedback/src/util/validate.ts
+++ b/packages/feedback/src/util/validate.ts
@@ -1,4 +1,4 @@
-import type { FeedbackFormData, FeedbackInternalOptions } from '../types';
+import type { FeedbackFormData, FeedbackInternalOptions } from '@sentry/types';
 
 export type Props = Pick<
   FeedbackInternalOptions,
diff --git a/packages/types/src/feedback.ts b/packages/types/src/feedback.ts
deleted file mode 100644
index 37dfe9818994..000000000000
--- a/packages/types/src/feedback.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import type { Event } from './event';
-import type { User } from './user';
-
-/**
- * Crash report feedback object
- */
-export interface UserFeedback {
-  event_id: string;
-  email: User['email'];
-  name: string;
-  comments: string;
-}
-
-interface FeedbackContext extends Record<string, unknown> {
-  message: string;
-  contact_email?: string;
-  name?: string;
-  replay_id?: string;
-  url?: string;
-}
-
-/**
- * NOTE: These types are still considered Alpha and subject to change.
- * @hidden
- */
-export interface FeedbackEvent extends Event {
-  type: 'feedback';
-  contexts: Event['contexts'] & {
-    feedback: FeedbackContext;
-  };
-}
diff --git a/packages/feedback/src/types/config.ts b/packages/types/src/feedback/config.ts
similarity index 100%
rename from packages/feedback/src/types/config.ts
rename to packages/types/src/feedback/config.ts
diff --git a/packages/feedback/src/types/form.ts b/packages/types/src/feedback/form.ts
similarity index 72%
rename from packages/feedback/src/types/form.ts
rename to packages/types/src/feedback/form.ts
index d669ad7ea22e..13c76f55fae1 100644
--- a/packages/feedback/src/types/form.ts
+++ b/packages/types/src/feedback/form.ts
@@ -1,4 +1,4 @@
-import type { Attachment } from '@sentry/types';
+import type { Attachment } from '../attachment';
 
 export type FeedbackFormData = {
   name: string;
diff --git a/packages/types/src/feedback/index.ts b/packages/types/src/feedback/index.ts
new file mode 100644
index 000000000000..477ae46d8f92
--- /dev/null
+++ b/packages/types/src/feedback/index.ts
@@ -0,0 +1,83 @@
+import type { Attachment } from '../attachment';
+import type { Integration } from '../integration';
+
+import type {
+  FeedbackCallbacks,
+  FeedbackGeneralConfiguration,
+  FeedbackTextConfiguration,
+  FeedbackThemeConfiguration,
+} from './config';
+
+export type { FeedbackFormData } from './form';
+
+import type { FeedbackEvent, SendFeedback, SendFeedbackParams, UserFeedback } from './sendFeedback';
+export type { FeedbackEvent, UserFeedback, SendFeedback, SendFeedbackParams };
+
+/**
+ * The integration's internal `options` member where every value should be set
+ */
+export interface FeedbackInternalOptions
+  extends FeedbackGeneralConfiguration,
+    FeedbackThemeConfiguration,
+    FeedbackTextConfiguration,
+    FeedbackCallbacks {}
+
+type HTMLElement = unknown;
+export interface FeedbackDialog {
+  /**
+   * The HTMLElement that is containing all the form content
+   */
+  el: HTMLElement;
+
+  /**
+   * Insert the Dialog into the Shadow DOM.
+   *
+   * The Dialog starts in the `closed` state where no inner HTML is rendered.
+   */
+  appendToDom: () => void;
+
+  /**
+   * Remove the dialog from the Shadow DOM
+   */
+  removeFromDom: () => void;
+
+  /**
+   * Open/Show the dialog & form inside it
+   */
+  open: () => void;
+
+  /**
+   * Close/Hide the dialog & form inside it
+   */
+  close: () => void;
+}
+
+type ShadowRoot = unknown;
+export interface CreateDialogProps {
+  options: FeedbackInternalOptions;
+  screenshotIntegration: FeedbackScreenshotIntegration | undefined;
+  sendFeedback: SendFeedback;
+  shadow: ShadowRoot;
+}
+export interface FeedbackModalIntegration extends Integration {
+  createDialog: (props: CreateDialogProps) => FeedbackDialog;
+}
+
+type HType = unknown;
+type VNode = unknown;
+export interface FeedbackScreenshotIntegration extends Integration {
+  createInput: (
+    h: HType,
+    dialog: FeedbackDialog,
+  ) => {
+    /**
+     * The preact component
+     */
+    input: (props: { onError: (error: Error) => void }) => VNode;
+
+    /**
+     * The image/screenshot bytes
+     */
+    value: () => Promise<Attachment | undefined>;
+  };
+}
diff --git a/packages/types/src/feedback/sendFeedback.ts b/packages/types/src/feedback/sendFeedback.ts
new file mode 100644
index 000000000000..612e0cff001d
--- /dev/null
+++ b/packages/types/src/feedback/sendFeedback.ts
@@ -0,0 +1,54 @@
+import type { Attachment } from '../attachment';
+import type { Event } from '../event';
+import type { TransportMakeRequestResponse } from '../transport';
+import type { User } from '../user';
+
+/**
+ * Crash report feedback object
+ */
+export interface UserFeedback {
+  event_id: string;
+  email: User['email'];
+  name: string;
+  comments: string;
+}
+
+interface FeedbackContext extends Record<string, unknown> {
+  message: string;
+  contact_email?: string;
+  name?: string;
+  replay_id?: string;
+  url?: string;
+}
+
+/**
+ * NOTE: These types are still considered Alpha and subject to change.
+ * @hidden
+ */
+export interface FeedbackEvent extends Event {
+  type: 'feedback';
+  contexts: Event['contexts'] & {
+    feedback: FeedbackContext;
+  };
+}
+
+export interface SendFeedbackParams {
+  message: string;
+  name?: string;
+  email?: string;
+  attachments?: Attachment[];
+  url?: string;
+  source?: string;
+}
+
+interface SendFeedbackOptions {
+  /**
+   * Should include replay with the feedback?
+   */
+  includeReplay?: boolean;
+}
+
+export type SendFeedback = (
+  params: SendFeedbackParams,
+  options?: SendFeedbackOptions,
+) => Promise<TransportMakeRequestResponse>;
diff --git a/packages/feedback/src/types/theme.ts b/packages/types/src/feedback/theme.ts
similarity index 100%
rename from packages/feedback/src/types/theme.ts
rename to packages/types/src/feedback/theme.ts
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index e1ceb7e7e4e2..2e2c61dad4b6 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -69,7 +69,18 @@ export type {
   Profile,
 } from './profiling';
 export type { ReplayEvent, ReplayRecordingData, ReplayRecordingMode } from './replay';
-export type { FeedbackEvent, UserFeedback } from './feedback';
+export type {
+  FeedbackDialog,
+  FeedbackEvent,
+  FeedbackFormData,
+  FeedbackInternalOptions,
+  FeedbackModalIntegration,
+  FeedbackScreenshotIntegration,
+  SendFeedback,
+  SendFeedbackParams,
+  CreateDialogProps,
+  UserFeedback,
+} from './feedback';
 export type { QueryParams, Request, SanitizedRequestData } from './request';
 export type { Runtime } from './runtime';
 export type { CaptureContext, Scope, ScopeContext, ScopeData } from './scope';

From da758e31c9903098fcb54ec7e6fded22578c46ae Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Tue, 9 Apr 2024 09:13:28 +0200
Subject: [PATCH 17/64] test(e2e): Assert correct isolation scopes in Next.js
 (#11480)

---
 .../app/generation-functions/page.tsx         |   6 +
 .../tests/generation-functions.test.ts        |  10 +-
 .../app/edge-server-components/error/page.tsx |   5 +
 .../app/edge-server-components/page.tsx       |   6 +
 .../app/route-handlers/[param]/edge/route.ts  |   5 +
 .../app/route-handlers/[param]/error/route.ts |   6 +
 .../app/server-component/faulty/page.tsx      |  15 +++
 .../nextjs-app-dir/middleware.ts              |   5 +
 .../nextjs-app-dir/pages/api/edge-endpoint.ts |   6 +
 .../pages/api/error-edge-endpoint.ts          |   5 +
 .../pages/pages-router/ssr-error-fc.tsx       |   6 +
 .../nextjs-app-dir/tests/edge-route.test.ts   |  10 +-
 .../nextjs-app-dir/tests/edge.test.ts         |  12 +-
 .../nextjs-app-dir/tests/middleware.test.ts   |  10 +-
 .../tests/pages-ssr-errors.test.ts            |  14 ++-
 .../tests/route-handlers.test.ts              |  12 ++
 .../tests/server-components.test.ts           | 105 ++++++++++++++++++
 .../nextjs-app-dir/tests/transactions.test.ts |  69 ------------
 .../src/common/wrapMiddlewareWithSentry.ts    |  13 ++-
 .../src/edge/wrapApiHandlerWithSentry.ts      |  23 ++--
 20 files changed, 251 insertions(+), 92 deletions(-)
 create mode 100644 dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/server-component/faulty/page.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/server-components.test.ts

diff --git a/dev-packages/e2e-tests/test-applications/nextjs-14/app/generation-functions/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-14/app/generation-functions/page.tsx
index 5ae73102057d..92bee1dbac4b 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-14/app/generation-functions/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-14/app/generation-functions/page.tsx
@@ -1,3 +1,6 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export const dynamic = 'force-dynamic';
 
 export default function Page() {
@@ -9,6 +12,9 @@ export async function generateMetadata({
 }: {
   searchParams: { [key: string]: string | string[] | undefined };
 }) {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   if (searchParams['shouldThrowInGenerateMetadata']) {
     throw new Error('generateMetadata Error');
   }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-14/tests/generation-functions.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-14/tests/generation-functions.test.ts
index 52c28e1d974a..da08ccb481bf 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-14/tests/generation-functions.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-14/tests/generation-functions.test.ts
@@ -37,8 +37,14 @@ test('Should send a transaction and an error event for a faulty generateMetadata
 
   await page.goto(`/generation-functions?metadataTitle=${testTitle}&shouldThrowInGenerateMetadata=1`);
 
-  expect(await transactionPromise).toBeDefined();
-  expect(await errorEventPromise).toBeDefined();
+  const errorEvent = await errorEventPromise;
+  const transactionEvent = await transactionPromise;
+
+  // Assert that isolation scope works properly
+  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+  expect(transactionEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(transactionEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
 
 test('Should send a transaction event for a generateViewport() function invokation', async ({ page }) => {
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/error/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/error/page.tsx
index 35d15616fd1c..1a86e2ac59cf 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/error/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/error/page.tsx
@@ -1,7 +1,12 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export const dynamic = 'force-dynamic';
 
 export const runtime = 'edge';
 
 export default async function Page() {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
   throw new Error('Edge Server Component Error');
 }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/page.tsx
index c7a6a8887e90..9d6ec241fca6 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/edge-server-components/page.tsx
@@ -1,7 +1,13 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export const dynamic = 'force-dynamic';
 
 export const runtime = 'edge';
 
 export default async function Page() {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   return <h1>Hello world!</h1>;
 }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts
index a43862231568..8879a85c488a 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts
@@ -1,3 +1,5 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
 import { NextResponse } from 'next/server';
 
 export const runtime = 'edge';
@@ -7,5 +9,8 @@ export async function PATCH() {
 }
 
 export async function DELETE(): Promise<Response> {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   throw new Error('route-handler-edge-error');
 }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts
index e2de561c4783..e873849d22df 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts
@@ -1,3 +1,9 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export async function PUT(): Promise<Response> {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   throw new Error('route-handler-error');
 }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/server-component/faulty/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/server-component/faulty/page.tsx
new file mode 100644
index 000000000000..f31b3f1899da
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/server-component/faulty/page.tsx
@@ -0,0 +1,15 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
+export const dynamic = 'force-dynamic';
+
+export default async function FaultyServerComponent() {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
+  if (Math.random() + 1 > 0) {
+    throw new Error('I am a faulty server component');
+  }
+
+  return null;
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/middleware.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/middleware.ts
index a491ccde0a91..6096fcfb1493 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/middleware.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/middleware.ts
@@ -1,7 +1,12 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
 import { NextResponse } from 'next/server';
 import type { NextRequest } from 'next/server';
 
 export async function middleware(request: NextRequest) {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   if (request.headers.has('x-should-throw')) {
     throw new Error('Middleware Error');
   }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/edge-endpoint.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/edge-endpoint.ts
index b2b2dfdf4fc3..6236aa63d936 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/edge-endpoint.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/edge-endpoint.ts
@@ -1,8 +1,14 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export const config = {
   runtime: 'edge',
 };
 
 export default async function handler() {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   return new Response(
     JSON.stringify({
       name: 'Jim Halpert',
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/error-edge-endpoint.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/error-edge-endpoint.ts
index 043112494c23..ed1a0acdf412 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/error-edge-endpoint.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/api/error-edge-endpoint.ts
@@ -1,5 +1,10 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export const config = { runtime: 'edge' };
 
 export default () => {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
   throw new Error('Edge Route Error');
 };
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/pages-router/ssr-error-fc.tsx b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/pages-router/ssr-error-fc.tsx
index 6342caec47ca..552aeae3b331 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/pages-router/ssr-error-fc.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/pages/pages-router/ssr-error-fc.tsx
@@ -1,4 +1,10 @@
+import { getDefaultIsolationScope } from '@sentry/core';
+import * as Sentry from '@sentry/nextjs';
+
 export default function Page() {
+  Sentry.setTag('my-isolated-tag', true);
+  Sentry.setTag('my-global-scope-isolated-tag', getDefaultIsolationScope().getScopeData().tags['my-isolated-tag']); // We set this tag to be able to assert that the previously set tag has not leaked into the global isolation scope
+
   throw new Error('Pages SSR Error FC');
   return <div>Hello world!</div>;
 }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge-route.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge-route.test.ts
index cbe9dcafae71..33bf951337a8 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge-route.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge-route.test.ts
@@ -40,6 +40,10 @@ test('Should create a transaction with error status for faulty edge routes', asy
   expect(edgerouteTransaction.contexts?.trace?.status).toBe('internal_error');
   expect(edgerouteTransaction.contexts?.trace?.op).toBe('http.server');
   expect(edgerouteTransaction.contexts?.runtime?.name).toBe('vercel-edge');
+
+  // Assert that isolation scope works properly
+  expect(edgerouteTransaction.tags?.['my-isolated-tag']).toBe(true);
+  expect(edgerouteTransaction.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
 
 test('Should record exceptions for faulty edge routes', async ({ request }) => {
@@ -51,5 +55,9 @@ test('Should record exceptions for faulty edge routes', async ({ request }) => {
     // Noop
   });
 
-  expect(await errorEventPromise).toBeDefined();
+  const errorEvent = await errorEventPromise;
+
+  // Assert that isolation scope works properly
+  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge.test.ts
index 4e69abbdd3e2..f5f3e70c9770 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/edge.test.ts
@@ -8,7 +8,13 @@ test('Should record exceptions for faulty edge server components', async ({ page
 
   await page.goto('/edge-server-components/error');
 
-  expect(await errorEventPromise).toBeDefined();
+  const errorEvent = await errorEventPromise;
+
+  expect(errorEvent).toBeDefined();
+
+  // Assert that isolation scope works properly
+  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
 
 test('Should record transaction for edge server components', async ({ page }) => {
@@ -22,4 +28,8 @@ test('Should record transaction for edge server components', async ({ page }) =>
 
   expect(serverComponentTransaction).toBeDefined();
   expect(serverComponentTransaction.request?.headers).toBeDefined();
+
+  // Assert that isolation scope works properly
+  expect(serverComponentTransaction.tags?.['my-isolated-tag']).toBe(true);
+  expect(serverComponentTransaction.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/middleware.test.ts
index 240e04ebe37f..79b07bd37a15 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/middleware.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/middleware.test.ts
@@ -14,6 +14,10 @@ test('Should create a transaction for middleware', async ({ request }) => {
   expect(middlewareTransaction.contexts?.trace?.status).toBe('ok');
   expect(middlewareTransaction.contexts?.trace?.op).toBe('middleware.nextjs');
   expect(middlewareTransaction.contexts?.runtime?.name).toBe('vercel-edge');
+
+  // Assert that isolation scope works properly
+  expect(middlewareTransaction.tags?.['my-isolated-tag']).toBe(true);
+  expect(middlewareTransaction.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
 
 test('Should create a transaction with error status for faulty middleware', async ({ request }) => {
@@ -43,7 +47,11 @@ test('Records exceptions happening in middleware', async ({ request }) => {
     // Noop
   });
 
-  expect(await errorEventPromise).toBeDefined();
+  const errorEvent = await errorEventPromise;
+
+  // Assert that isolation scope works properly
+  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
 
 test('Should trace outgoing fetch requests inside middleware and create breadcrumbs for it', async ({ request }) => {
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/pages-ssr-errors.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/pages-ssr-errors.test.ts
index 73f8bd5e31b9..3e6396c4a618 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/pages-ssr-errors.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/pages-ssr-errors.test.ts
@@ -24,7 +24,7 @@ test('Will capture error for SSR rendering error with a connected trace (Functio
     return errorEvent?.exception?.values?.[0]?.value === 'Pages SSR Error FC';
   });
 
-  const serverComponentTransaction = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
+  const ssrTransactionPromise = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
     return (
       transactionEvent?.transaction === '/pages-router/ssr-error-fc' &&
       (await errorEventPromise).contexts?.trace?.trace_id === transactionEvent.contexts?.trace?.trace_id
@@ -33,6 +33,14 @@ test('Will capture error for SSR rendering error with a connected trace (Functio
 
   await page.goto('/pages-router/ssr-error-fc');
 
-  expect(await errorEventPromise).toBeDefined();
-  expect(await serverComponentTransaction).toBeDefined();
+  const errorEvent = await errorEventPromise;
+  const ssrTransaction = await ssrTransactionPromise;
+
+  // Assert that isolation scope works properly
+  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+
+  // TODO(lforst): Reuse SSR request span isolation scope to fix the following two assertions
+  // expect(ssrTransaction.tags?.['my-isolated-tag']).toBe(true);
+  // expect(ssrTransaction.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts
index 70f9bb32d3bc..84969d7c84ca 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts
@@ -48,6 +48,12 @@ test('Should record exceptions and transactions for faulty route handlers', asyn
   const routehandlerTransaction = await routehandlerTransactionPromise;
   const routehandlerError = await errorEventPromise;
 
+  // Assert that isolation scope works properly
+  expect(routehandlerTransaction.tags?.['my-isolated-tag']).toBe(true);
+  expect(routehandlerTransaction.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+  expect(routehandlerError.tags?.['my-isolated-tag']).toBe(true);
+  expect(routehandlerError.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+
   expect(routehandlerTransaction.contexts?.trace?.status).toBe('unknown_error');
   expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
 
@@ -87,6 +93,12 @@ test.describe('Edge runtime', () => {
     const routehandlerTransaction = await routehandlerTransactionPromise;
     const routehandlerError = await errorEventPromise;
 
+    // Assert that isolation scope works properly
+    expect(routehandlerTransaction.tags?.['my-isolated-tag']).toBe(true);
+    expect(routehandlerTransaction.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+    expect(routehandlerError.tags?.['my-isolated-tag']).toBe(true);
+    expect(routehandlerError.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+
     expect(routehandlerTransaction.contexts?.trace?.status).toBe('internal_error');
     expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
     expect(routehandlerTransaction.contexts?.runtime?.name).toBe('vercel-edge');
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/server-components.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/server-components.test.ts
new file mode 100644
index 000000000000..00aeae924fcc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/server-components.test.ts
@@ -0,0 +1,105 @@
+import { expect, test } from '@playwright/test';
+import { waitForError, waitForTransaction } from '@sentry-internal/event-proxy-server';
+import axios, { AxiosError } from 'axios';
+
+const authToken = process.env.E2E_TEST_AUTH_TOKEN;
+const sentryTestOrgSlug = process.env.E2E_TEST_SENTRY_ORG_SLUG;
+const sentryTestProject = process.env.E2E_TEST_SENTRY_TEST_PROJECT;
+const EVENT_POLLING_TIMEOUT = 90_000;
+
+test('Sends a transaction for a server component', async ({ page }) => {
+  // TODO: Fix that this is flakey on dev server - might be an SDK bug
+  test.skip(process.env.TEST_ENV === 'production', 'Flakey on dev-server');
+
+  const serverComponentTransactionPromise = waitForTransaction('nextjs-13-app-dir', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'function.nextjs' &&
+      transactionEvent?.transaction === 'Page Server Component (/server-component/parameter/[...parameters])'
+    );
+  });
+
+  await page.goto('/server-component/parameter/1337/42');
+
+  const transactionEvent = await serverComponentTransactionPromise;
+  const transactionEventId = transactionEvent.event_id;
+
+  expect(transactionEvent.request?.headers).toBeDefined();
+
+  await expect
+    .poll(
+      async () => {
+        try {
+          const response = await axios.get(
+            `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${transactionEventId}/`,
+            { headers: { Authorization: `Bearer ${authToken}` } },
+          );
+
+          return response.status;
+        } catch (e) {
+          if (e instanceof AxiosError && e.response) {
+            if (e.response.status !== 404) {
+              throw e;
+            } else {
+              return e.response.status;
+            }
+          } else {
+            throw e;
+          }
+        }
+      },
+      {
+        timeout: EVENT_POLLING_TIMEOUT,
+      },
+    )
+    .toBe(200);
+});
+
+test('Should not set an error status on a server component transaction when it redirects', async ({ page }) => {
+  // TODO: Fix that this is flakey on dev server - might be an SDK bug
+  test.skip(process.env.TEST_ENV === 'production', 'Flakey on dev-server');
+
+  const serverComponentTransactionPromise = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
+    return transactionEvent?.transaction === 'Page Server Component (/server-component/redirect)';
+  });
+
+  await page.goto('/server-component/redirect');
+
+  expect((await serverComponentTransactionPromise).contexts?.trace?.status).not.toBe('internal_error');
+});
+
+test('Should set a "not_found" status on a server component transaction when notFound() is called', async ({
+  page,
+}) => {
+  // TODO: Fix that this is flakey on dev server - might be an SDK bug
+  test.skip(process.env.TEST_ENV === 'production', 'Flakey on dev-server');
+
+  const serverComponentTransactionPromise = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
+    return transactionEvent?.transaction === 'Page Server Component (/server-component/not-found)';
+  });
+
+  await page.goto('/server-component/not-found');
+
+  expect((await serverComponentTransactionPromise).contexts?.trace?.status).toBe('not_found');
+});
+
+test('Should capture an error and transaction with correct status for a faulty server component', async ({ page }) => {
+  const transactionEventPromise = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
+    return transactionEvent?.transaction === 'Page Server Component (/server-component/faulty)';
+  });
+
+  const errorEventPromise = waitForError('nextjs-13-app-dir', errorEvent => {
+    return errorEvent?.exception?.values?.[0]?.value === 'I am a faulty server component';
+  });
+
+  await page.goto('/server-component/faulty');
+
+  const transactionEvent = await transactionEventPromise;
+  const errorEvent = await errorEventPromise;
+
+  expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+
+  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+  expect(transactionEvent.tags?.['my-isolated-tag']).toBe(true);
+  expect(transactionEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
+});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/transactions.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/transactions.test.ts
index 57ddb57f75cf..5f7d4dc8496d 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/transactions.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/transactions.test.ts
@@ -48,75 +48,6 @@ test('Sends a pageload transaction', async ({ page }) => {
     .toBe(200);
 });
 
-if (process.env.TEST_ENV === 'production') {
-  // TODO: Fix that this is flakey on dev server - might be an SDK bug
-  test('Sends a transaction for a server component', async ({ page }) => {
-    const serverComponentTransactionPromise = waitForTransaction('nextjs-13-app-dir', transactionEvent => {
-      return (
-        transactionEvent?.contexts?.trace?.op === 'function.nextjs' &&
-        transactionEvent?.transaction === 'Page Server Component (/server-component/parameter/[...parameters])'
-      );
-    });
-
-    await page.goto('/server-component/parameter/1337/42');
-
-    const transactionEvent = await serverComponentTransactionPromise;
-    const transactionEventId = transactionEvent.event_id;
-
-    expect(transactionEvent.request?.headers).toBeDefined();
-
-    await expect
-      .poll(
-        async () => {
-          try {
-            const response = await axios.get(
-              `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${transactionEventId}/`,
-              { headers: { Authorization: `Bearer ${authToken}` } },
-            );
-
-            return response.status;
-          } catch (e) {
-            if (e instanceof AxiosError && e.response) {
-              if (e.response.status !== 404) {
-                throw e;
-              } else {
-                return e.response.status;
-              }
-            } else {
-              throw e;
-            }
-          }
-        },
-        {
-          timeout: EVENT_POLLING_TIMEOUT,
-        },
-      )
-      .toBe(200);
-  });
-
-  test('Should not set an error status on a server component transaction when it redirects', async ({ page }) => {
-    const serverComponentTransactionPromise = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
-      return transactionEvent?.transaction === 'Page Server Component (/server-component/redirect)';
-    });
-
-    await page.goto('/server-component/redirect');
-
-    expect((await serverComponentTransactionPromise).contexts?.trace?.status).not.toBe('internal_error');
-  });
-
-  test('Should set a "not_found" status on a server component transaction when notFound() is called', async ({
-    page,
-  }) => {
-    const serverComponentTransactionPromise = waitForTransaction('nextjs-13-app-dir', async transactionEvent => {
-      return transactionEvent?.transaction === 'Page Server Component (/server-component/not-found)';
-    });
-
-    await page.goto('/server-component/not-found');
-
-    expect((await serverComponentTransactionPromise).contexts?.trace?.status).toBe('not_found');
-  });
-}
-
 test('Should send a transaction for instrumented server actions', async ({ page }) => {
   const nextjsVersion = packageJson.dependencies.next;
   const nextjsMajor = Number(nextjsVersion.split('.')[0]);
diff --git a/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts b/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
index 66cbbb046300..25b0e2b6d5d4 100644
--- a/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
+++ b/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
@@ -1,5 +1,6 @@
 import type { EdgeRouteHandler } from '../edge/types';
 import { withEdgeWrapping } from './utils/edgeWrapperUtils';
+import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
 /**
  * Wraps Next.js middleware with Sentry error and performance instrumentation.
@@ -12,11 +13,13 @@ export function wrapMiddlewareWithSentry<H extends EdgeRouteHandler>(
 ): (...params: Parameters<H>) => Promise<ReturnType<H>> {
   return new Proxy(middleware, {
     apply: (wrappingTarget, thisArg, args: Parameters<H>) => {
-      return withEdgeWrapping(wrappingTarget, {
-        spanDescription: 'middleware',
-        spanOp: 'middleware.nextjs',
-        mechanismFunctionName: 'withSentryMiddleware',
-      }).apply(thisArg, args);
+      return withIsolationScopeOrReuseFromRootSpan(() => {
+        return withEdgeWrapping(wrappingTarget, {
+          spanDescription: 'middleware',
+          spanOp: 'middleware.nextjs',
+          mechanismFunctionName: 'withSentryMiddleware',
+        }).apply(thisArg, args);
+      });
     },
   });
 }
diff --git a/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
index f66a03ee9586..717090905f6a 100644
--- a/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
+++ b/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
@@ -1,6 +1,7 @@
-import { getActiveSpan } from '@sentry/core';
+import { getActiveSpan } from '@sentry/vercel-edge';
 
 import { withEdgeWrapping } from '../common/utils/edgeWrapperUtils';
+import { withIsolationScopeOrReuseFromRootSpan } from '../common/utils/withIsolationScopeOrReuseFromRootSpan';
 import type { EdgeRouteHandler } from './types';
 
 /**
@@ -16,16 +17,18 @@ export function wrapApiHandlerWithSentry<H extends EdgeRouteHandler>(
 
       const activeSpan = getActiveSpan();
 
-      const wrappedHandler = withEdgeWrapping(wrappingTarget, {
-        spanDescription:
-          activeSpan || !(req instanceof Request)
-            ? `handler (${parameterizedRoute})`
-            : `${req.method} ${parameterizedRoute}`,
-        spanOp: activeSpan ? 'function' : 'http.server',
-        mechanismFunctionName: 'wrapApiHandlerWithSentry',
-      });
+      return withIsolationScopeOrReuseFromRootSpan(() => {
+        const wrappedHandler = withEdgeWrapping(wrappingTarget, {
+          spanDescription:
+            activeSpan || !(req instanceof Request)
+              ? `handler (${parameterizedRoute})`
+              : `${req.method} ${parameterizedRoute}`,
+          spanOp: activeSpan ? 'function' : 'http.server',
+          mechanismFunctionName: 'wrapApiHandlerWithSentry',
+        });
 
-      return wrappedHandler.apply(thisArg, args);
+        return wrappedHandler.apply(thisArg, args);
+      });
     },
   });
 }

From 14e5373e3e15f25a7a644eb3b75aab056a3fa455 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Tue, 9 Apr 2024 09:13:39 +0200
Subject: [PATCH 18/64] build(ci): Run dependabot for opentelemetry
 dependencies (#11492)

These are deps we may want to keep more up to date than we usually do,
so generating update PRs for them may be helpful.
---
 .github/dependabot.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 6a938d15facc..33d8c9ed27c0 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -15,6 +15,9 @@ updates:
     allow:
       - dependency-name: "@sentry/cli"
       - dependency-name: "@sentry/vite-plugin"
+      - dependency-name: "@opentelemetry/*"
+      - dependency-name: "@prisma/instrumentation"
+      - dependency-name: "opentelemetry-instrumentation-fetch-node"
     versioning-strategy: increase
     commit-message:
       prefix: feat

From f46b29e3b42f4726440a6f11ca4f270a36377382 Mon Sep 17 00:00:00 2001
From: C-A de Salaberry <cadesalaberry@yahoo.com>
Date: Tue, 9 Apr 2024 15:18:10 +0200
Subject: [PATCH 19/64] doc(types): Add jsdoc for breadcrumbs (#11504)

When interacting with the Breadcrumd API, I had some trouble finding the
correct documentation. I retrieved my changes for the previous
[PR](https://github.com/getsentry/sentry-javascript/pull/11119) to make
sure the JSDoc is updated with the actual doc.
---
 packages/types/src/breadcrumb.ts | 59 +++++++++++++++++++++++++++++++-
 1 file changed, 58 insertions(+), 1 deletion(-)

diff --git a/packages/types/src/breadcrumb.ts b/packages/types/src/breadcrumb.ts
index 21a6a481fbec..464df180e59d 100644
--- a/packages/types/src/breadcrumb.ts
+++ b/packages/types/src/breadcrumb.ts
@@ -1,13 +1,70 @@
 import type { SeverityLevel } from './severity';
 
-/** JSDoc */
+/**
+ * Sentry uses breadcrumbs to create a trail of events that happened prior to an issue.
+ * These events are very similar to traditional logs but can record more rich structured data.
+ *
+ * @link https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/
+ */
 export interface Breadcrumb {
+  /**
+   * By default, all breadcrumbs are recorded as default, which makes them appear as a Debug entry, but Sentry provides
+   * other types that influence how the breadcrumbs are rendered. For more information, see the description of
+   * recognized breadcrumb types.
+   *
+   * @summary The type of breadcrumb.
+   * @link https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types
+   */
   type?: string;
+
+  /**
+   * Allowed values are, from highest to lowest:
+   * `fatal`, `error`, `warning`, `info`, and `debug`.
+   * Levels are used in the UI to emphasize and deemphasize the crumb. The default is `info`.
+   *
+   * @summary This defines the severity level of the breadcrumb.
+   */
   level?: SeverityLevel;
+
   event_id?: string;
+
+  /**
+   * Typically it is a module name or a descriptive string. For instance, `ui.click` could be used to
+   * indicate that a click happened in the UI or flask could be used to indicate that the event originated in
+   * the Flask framework.
+   * @private Internally we render some crumbs' color and icon based on the provided category.
+   *          For more information, see the description of recognized breadcrumb types.
+   * @summary A dotted string indicating what the crumb is or from where it comes.
+   * @link    https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types
+   */
   category?: string;
+
+  /**
+   * If a message is provided, it is rendered as text with all whitespace preserved.
+   *
+   * @summary Human-readable message for the breadcrumb.
+   */
   message?: string;
+
+  /**
+   * Contains a dictionary whose contents depend on the breadcrumb type.
+   * Additional parameters that are unsupported by the type are rendered as a key/value table.
+   *
+   * @summary Arbitrary data associated with this breadcrumb.
+   */
   data?: { [key: string]: any };
+
+  /**
+   * The format is a numeric (integer or float) value representing
+   * the number of seconds that have elapsed since the Unixepoch.
+   * Breadcrumbs are most useful when they include a timestamp, as it creates a timeline
+   * leading up to an event expection/error.
+   *
+   * @note The API supports a string as defined in RFC 3339, but the SDKs only support a numeric value for now.
+   *
+   * @summary A timestamp representing when the breadcrumb occurred.
+   * @link https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#:~:text=is%20info.-,timestamp,-(recommended)
+   */
   timestamp?: number;
 }
 

From 76a286908a7e047c40411eefac6e0a37b4648567 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Tue, 9 Apr 2024 15:22:59 +0200
Subject: [PATCH 20/64] fix(node): Ensure isolation scope is correctly cloned
 for non-recording spans (#11503)

Our Http instrumentation didn't clone the isolation scope
correctly when the request span is not recording.
We early returned if the span was not a server kind
span. However, non-recording spans apparently have no span kind, so we
wrongfully early returned in the check for non-recording spans.
---
 .../handle-error-tracesSampleRate-0/server.ts | 22 +++++++++++
 .../handle-error-tracesSampleRate-0/test.ts   | 39 +++++++++++++++++++
 .../server.ts                                 |  4 +-
 .../test.ts                                   |  8 ++--
 packages/node/src/integrations/http.ts        | 15 ++++++-
 .../node/src/integrations/tracing/express.ts  |  9 ++++-
 6 files changed, 88 insertions(+), 9 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/server.ts
 create mode 100644 dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/test.ts
 rename dev-packages/node-integration-tests/suites/express/{handle-error => handle-error-tracesSampleRate-unset}/server.ts (83%)
 rename dev-packages/node-integration-tests/suites/express/{handle-error => handle-error-tracesSampleRate-unset}/test.ts (74%)

diff --git a/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/server.ts b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/server.ts
new file mode 100644
index 000000000000..3f52580dda1d
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/server.ts
@@ -0,0 +1,22 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  transport: loggingTransport,
+  tracesSampleRate: 1,
+});
+
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+
+app.get('/test/express/:id', req => {
+  throw new Error(`test_error with id ${req.params.id}`);
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/test.ts b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/test.ts
new file mode 100644
index 000000000000..f76edf06bedb
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/test.ts
@@ -0,0 +1,39 @@
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('should capture and send Express controller error with txn name if tracesSampleRate is 0', done => {
+  const runner = createRunner(__dirname, 'server.ts')
+    .ignore('session', 'sessions', 'transaction')
+    .expect({
+      event: {
+        exception: {
+          values: [
+            {
+              mechanism: {
+                type: 'middleware',
+                handled: false,
+              },
+              type: 'Error',
+              value: 'test_error with id 123',
+              stacktrace: {
+                frames: expect.arrayContaining([
+                  expect.objectContaining({
+                    function: expect.any(String),
+                    lineno: expect.any(Number),
+                    colno: expect.any(Number),
+                  }),
+                ]),
+              },
+            },
+          ],
+        },
+        transaction: 'GET /test/express/:id',
+      },
+    })
+    .start(done);
+
+  expect(() => runner.makeRequest('get', '/test/express/123')).rejects.toThrow();
+});
diff --git a/dev-packages/node-integration-tests/suites/express/handle-error/server.ts b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-unset/server.ts
similarity index 83%
rename from dev-packages/node-integration-tests/suites/express/handle-error/server.ts
rename to dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-unset/server.ts
index 1f452fbecc97..38833d7a9bc7 100644
--- a/dev-packages/node-integration-tests/suites/express/handle-error/server.ts
+++ b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-unset/server.ts
@@ -12,8 +12,8 @@ import express from 'express';
 
 const app = express();
 
-app.get('/test/express', () => {
-  throw new Error('test_error');
+app.get('/test/express/:id', req => {
+  throw new Error(`test_error with id ${req.params.id}`);
 });
 
 Sentry.setupExpressErrorHandler(app);
diff --git a/dev-packages/node-integration-tests/suites/express/handle-error/test.ts b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-unset/test.ts
similarity index 74%
rename from dev-packages/node-integration-tests/suites/express/handle-error/test.ts
rename to dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-unset/test.ts
index fca4d270da40..c48a3b1f9444 100644
--- a/dev-packages/node-integration-tests/suites/express/handle-error/test.ts
+++ b/dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-unset/test.ts
@@ -4,9 +4,9 @@ afterAll(() => {
   cleanupChildProcesses();
 });
 
-test('should capture and send Express controller error.', done => {
+test('should capture and send Express controller error if tracesSampleRate is not set.', done => {
   const runner = createRunner(__dirname, 'server.ts')
-    .ignore('session', 'sessions')
+    .ignore('session', 'sessions', 'transaction')
     .expect({
       event: {
         exception: {
@@ -17,7 +17,7 @@ test('should capture and send Express controller error.', done => {
                 handled: false,
               },
               type: 'Error',
-              value: 'test_error',
+              value: 'test_error with id 123',
               stacktrace: {
                 frames: expect.arrayContaining([
                   expect.objectContaining({
@@ -34,5 +34,5 @@ test('should capture and send Express controller error.', done => {
     })
     .start(done);
 
-  expect(() => runner.makeRequest('get', '/test/express')).rejects.toThrow();
+  expect(() => runner.makeRequest('get', '/test/express/123')).rejects.toThrow();
 });
diff --git a/packages/node/src/integrations/http.ts b/packages/node/src/integrations/http.ts
index 1c7c9bc8842e..c5eefdc6fb2e 100644
--- a/packages/node/src/integrations/http.ts
+++ b/packages/node/src/integrations/http.ts
@@ -1,4 +1,4 @@
-import type { ServerResponse } from 'http';
+import type { ClientRequest, IncomingMessage, ServerResponse } from 'http';
 import type { Span } from '@opentelemetry/api';
 import { SpanKind } from '@opentelemetry/api';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
@@ -93,7 +93,9 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
           requestHook: (span, req) => {
             addOriginToSpan(span, 'auto.http.otel.http');
 
-            if (getSpanKind(span) !== SpanKind.SERVER) {
+            // both, incoming requests and "client" requests made within the app trigger the requestHook
+            // we only want to isolate and further annotate incoming requests (IncomingMessage)
+            if (_isClientRequest(req)) {
               return;
             }
 
@@ -179,3 +181,12 @@ function _addRequestBreadcrumb(span: Span, response: HTTPModuleRequestIncomingMe
     },
   );
 }
+
+/**
+ * Determines if @param req is a ClientRequest, meaning the request was created within the express app
+ * and it's an outgoing request.
+ * Checking for properties instead of using `instanceOf` to avoid importing the request classes.
+ */
+function _isClientRequest(req: ClientRequest | IncomingMessage): req is ClientRequest {
+  return 'outputData' in req && 'outputSize' in req && !('client' in req) && !('statusCode' in req);
+}
diff --git a/packages/node/src/integrations/tracing/express.ts b/packages/node/src/integrations/tracing/express.ts
index 57ea1cb75ac0..8d430b939c41 100644
--- a/packages/node/src/integrations/tracing/express.ts
+++ b/packages/node/src/integrations/tracing/express.ts
@@ -1,10 +1,12 @@
 import type * as http from 'http';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
-import { defineIntegration } from '@sentry/core';
+import { defineIntegration, getDefaultIsolationScope } from '@sentry/core';
 import { captureException, getClient, getIsolationScope } from '@sentry/core';
 import type { IntegrationFn } from '@sentry/types';
 
+import { logger } from '@sentry/utils';
+import { DEBUG_BUILD } from '../../debug-build';
 import type { NodeClient } from '../../sdk/client';
 import { addOriginToSpan } from '../../utils/addOriginToSpan';
 
@@ -19,6 +21,11 @@ const _expressIntegration = (() => {
               addOriginToSpan(span, 'auto.http.otel.express');
             },
             spanNameHook(info, defaultName) {
+              if (getIsolationScope() === getDefaultIsolationScope()) {
+                DEBUG_BUILD &&
+                  logger.warn('Isolation scope is still default isolation scope - skipping setting transactionName');
+                return defaultName;
+              }
               if (info.layerType === 'request_handler') {
                 // type cast b/c Otel unfortunately types info.request as any :(
                 const req = info.request as { method?: string };

From 4676ca33373c0982b9a9d4aeb0ca2e586a73c61e Mon Sep 17 00:00:00 2001
From: Sigrid Huemer <32902192+s1gr1d@users.noreply.github.com>
Date: Tue, 9 Apr 2024 15:27:23 +0200
Subject: [PATCH 21/64] fix(nextjs): Remove Http integration from Next.js
 (#11304)

Next.js provides their own OTel http integration, which conflicts with
ours
ref https://github.com/getsentry/sentry-javascript/pull/11016
added commit from this PR:
https://github.com/getsentry/sentry-javascript/pull/11319

---------

Co-authored-by: Luca Forstner <luca.forstner@sentry.io>
Co-authored-by: Francesco Novy <francesco.novy@sentry.io>
---
 .../tests/request-instrumentation.test.ts     |  23 ++--
 .../tests/route-handlers.test.ts              |   1 +
 packages/nextjs/package.json                  |   2 +
 .../src/common/wrapRouteHandlerWithSentry.ts  | 129 ++++++++++--------
 packages/nextjs/src/server/index.ts           |   8 +-
 .../requestIsolationScopeIntegration.ts       |  44 ++++++
 packages/opentelemetry/src/utils/mapStatus.ts |  10 +-
 7 files changed, 147 insertions(+), 70 deletions(-)
 create mode 100644 packages/nextjs/src/server/requestIsolationScopeIntegration.ts

diff --git a/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts
index 7dbe20e2efb6..3e25a99133da 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts
@@ -19,16 +19,15 @@ test('Should send a transaction with a fetch span', async ({ page }) => {
     }),
   );
 
-  // TODO: Uncomment the below when fixed. For whatever reason that we now have accepted, spans created with Node.js' http.get() will not attach themselves to transactions.
-  // More info: https://github.com/getsentry/sentry-javascript/pull/11016/files#diff-10fa195789425786c6e5e769380be18790768f0b76319ee41bbb488d9fe50405R4
-  // expect((await transactionPromise).spans).toContainEqual(
-  //   expect.objectContaining({
-  //     data: expect.objectContaining({
-  //       'http.method': 'GET',
-  //       'sentry.op': 'http.client',
-  //       'sentry.origin': 'auto.http.otel.http',
-  //     }),
-  //     description: 'GET http://example.com/',
-  //   }),
-  // );
+  expect((await transactionPromise).spans).toContainEqual(
+    expect.objectContaining({
+      data: expect.objectContaining({
+        'http.method': 'GET',
+        'sentry.op': 'http.client',
+        // todo: without the HTTP integration in the Next.js SDK, this is set to 'manual' -> we could rename this to be more specific
+        'sentry.origin': 'manual',
+      }),
+      description: 'GET http://example.com/',
+    }),
+  );
 });
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts
index 84969d7c84ca..21e0bf4c745f 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts
@@ -56,6 +56,7 @@ test('Should record exceptions and transactions for faulty route handlers', asyn
 
   expect(routehandlerTransaction.contexts?.trace?.status).toBe('unknown_error');
   expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
+  expect(routehandlerTransaction.contexts?.trace?.origin).toBe('auto.function.nextjs');
 
   expect(routehandlerError.exception?.values?.[0].value).toBe('route-handler-error');
   // TODO: Uncomment once we update the scope transaction name on the server side
diff --git a/packages/nextjs/package.json b/packages/nextjs/package.json
index 293401d7d41e..fd88dbac90a2 100644
--- a/packages/nextjs/package.json
+++ b/packages/nextjs/package.json
@@ -65,12 +65,14 @@
     "access": "public"
   },
   "dependencies": {
+    "@opentelemetry/api": "1.7.0",
     "@rollup/plugin-commonjs": "24.0.0",
     "@sentry/core": "8.0.0-alpha.9",
     "@sentry/node": "8.0.0-alpha.9",
     "@sentry/react": "8.0.0-alpha.9",
     "@sentry/types": "8.0.0-alpha.9",
     "@sentry/utils": "8.0.0-alpha.9",
+    "@sentry/opentelemetry": "8.0.0-alpha.9",
     "@sentry/vercel-edge": "8.0.0-alpha.9",
     "@sentry/webpack-plugin": "2.16.0",
     "chalk": "3.0.0",
diff --git a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
index edee1e54cec4..e82b4a3b4bdd 100644
--- a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
@@ -1,22 +1,58 @@
 import {
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   addTracingExtensions,
   captureException,
-  continueTrace,
+  getActiveSpan,
+  getRootSpan,
   handleCallbackErrors,
   setHttpStatus,
   startSpan,
 } from '@sentry/core';
+import type { Span } from '@sentry/types';
 import { winterCGHeadersToDict } from '@sentry/utils';
-
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import type { RouteHandlerContext } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
 import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
+/** As our own HTTP integration is disabled (src/server/index.ts) the rootSpan comes from Next.js.
+ * In case there is no root span, we start a new span. */
+function startOrUpdateSpan(spanName: string, cb: (rootSpan: Span) => Promise<Response>): Promise<Response> {
+  const activeSpan = getActiveSpan();
+  const rootSpan = activeSpan && getRootSpan(activeSpan);
+
+  if (rootSpan) {
+    rootSpan.updateName(spanName);
+    rootSpan.setAttributes({
+      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
+    });
+
+    return cb(rootSpan);
+  } else {
+    return startSpan(
+      {
+        op: 'http.server',
+        name: spanName,
+        forceTransaction: true,
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
+        },
+      },
+      (span: Span) => {
+        return cb(span);
+      },
+    );
+  }
+}
+
 /**
  * Wraps a Next.js route handler with performance and error instrumentation.
  */
@@ -26,7 +62,9 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
   context: RouteHandlerContext,
 ): (...args: Parameters<F>) => ReturnType<F> extends Promise<unknown> ? ReturnType<F> : Promise<ReturnType<F>> {
   addTracingExtensions();
+
   const { method, parameterizedRoute, headers } = context;
+
   return new Proxy(routeHandler, {
     apply: (originalFunction, thisArg, args) => {
       return withIsolationScopeOrReuseFromRootSpan(async isolationScope => {
@@ -35,63 +73,44 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
             headers: headers ? winterCGHeadersToDict(headers) : undefined,
           },
         });
-        return continueTrace(
-          {
-            // TODO(v8): Make it so that continue trace will allow null as sentryTrace value and remove this fallback here
-            sentryTrace: headers?.get('sentry-trace') ?? undefined,
-            baggage: headers?.get('baggage'),
-          },
-          async () => {
-            try {
-              return await startSpan(
-                {
-                  op: 'http.server',
-                  name: `${method} ${parameterizedRoute}`,
-                  forceTransaction: true,
-                  attributes: {
-                    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
-                    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
-                  },
-                },
-                async span => {
-                  const response: Response = await handleCallbackErrors(
-                    () => originalFunction.apply(thisArg, args),
-                    error => {
-                      // Next.js throws errors when calling `redirect()`. We don't wanna report these.
-                      if (isRedirectNavigationError(error)) {
-                        // Don't do anything
-                      } else if (isNotFoundNavigationError(error)) {
-                        span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
-                      } else {
-                        captureException(error, {
-                          mechanism: {
-                            handled: false,
-                          },
-                        });
-                      }
-                    },
-                  );
 
-                  try {
-                    if (span && response.status) {
-                      setHttpStatus(span, response.status);
-                    }
-                  } catch {
-                    // best effort - response may be undefined?
-                  }
+        try {
+          return await startOrUpdateSpan(`${method} ${parameterizedRoute}`, async (rootSpan: Span) => {
+            const response: Response = await handleCallbackErrors(
+              () => originalFunction.apply(thisArg, args),
+              error => {
+                // Next.js throws errors when calling `redirect()`. We don't wanna report these.
+                if (isRedirectNavigationError(error)) {
+                  // Don't do anything
+                } else if (isNotFoundNavigationError(error) && rootSpan) {
+                  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
+                } else {
+                  captureException(error, {
+                    mechanism: {
+                      handled: false,
+                    },
+                  });
+                }
+              },
+            );
 
-                  return response;
-                },
-              );
-            } finally {
-              if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
-                // 1. Edge transport requires manual flushing
-                // 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
-                await flushQueue();
+            try {
+              if (rootSpan && response.status) {
+                setHttpStatus(rootSpan, response.status);
               }
+            } catch {
+              // best effort - response may be undefined?
             }
-          },
-        );
+
+            return response;
+          });
+        } finally {
+          if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
+            // 1. Edge transport requires manual flushing
+            // 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
+            await flushQueue();
+          }
+        }
       });
     },
   });
diff --git a/packages/nextjs/src/server/index.ts b/packages/nextjs/src/server/index.ts
index 4dc6910d49eb..de5ac52c4f18 100644
--- a/packages/nextjs/src/server/index.ts
+++ b/packages/nextjs/src/server/index.ts
@@ -12,6 +12,7 @@ import { onUncaughtExceptionIntegration } from './onUncaughtExceptionIntegration
 
 export * from '@sentry/node';
 import type { EventProcessor } from '@sentry/types';
+import { requestIsolationScopeIntegration } from './requestIsolationScopeIntegration';
 
 export { captureUnderscoreErrorException } from '../common/_error';
 export { onUncaughtExceptionIntegration } from './onUncaughtExceptionIntegration';
@@ -75,10 +76,13 @@ export function init(options: NodeOptions): void {
     ...getDefaultIntegrations(options).filter(
       integration =>
         integration.name !== 'OnUncaughtException' &&
-        // Next.js comes with its own Node-Fetch instrumentation so we shouldn't add ours on-top
-        integration.name !== 'NodeFetch',
+        // Next.js comes with its own Node-Fetch instrumentation, so we shouldn't add ours on-top
+        integration.name !== 'NodeFetch' &&
+        // Next.js comes with its own Http instrumentation for OTel which lead to double spans for route handler requests
+        integration.name !== 'Http',
     ),
     onUncaughtExceptionIntegration(),
+    requestIsolationScopeIntegration(),
   ];
 
   // This value is injected at build time, based on the output directory specified in the build config. Though a default
diff --git a/packages/nextjs/src/server/requestIsolationScopeIntegration.ts b/packages/nextjs/src/server/requestIsolationScopeIntegration.ts
new file mode 100644
index 000000000000..b6020d891d8b
--- /dev/null
+++ b/packages/nextjs/src/server/requestIsolationScopeIntegration.ts
@@ -0,0 +1,44 @@
+import { SpanKind } from '@opentelemetry/api';
+import {
+  defineIntegration,
+  getCapturedScopesOnSpan,
+  getCurrentScope,
+  getIsolationScope,
+  getRootSpan,
+  setCapturedScopesOnSpan,
+  spanToJSON,
+} from '@sentry/core';
+import { getSpanKind } from '@sentry/opentelemetry';
+
+/**
+ * This integration is responsible for creating isolation scopes for incoming Http requests.
+ * We do so by waiting for http spans to be created and then forking the isolation scope.
+ *
+ * Normally the isolation scopes would be created by our Http instrumentation, however Next.js brings it's own Http
+ * instrumentation so we had to disable ours.
+ */
+export const requestIsolationScopeIntegration = defineIntegration(() => {
+  return {
+    name: 'RequestIsolationScope',
+    setup(client) {
+      client.on('spanStart', span => {
+        const spanJson = spanToJSON(span);
+        const data = spanJson.data || {};
+
+        // The following check is a heuristic to determine whether the started span is a span that tracks an incoming HTTP request
+        if (
+          (getSpanKind(span) === SpanKind.SERVER && data['http.method']) ||
+          (span === getRootSpan(span) && data['next.route'])
+        ) {
+          const scopes = getCapturedScopesOnSpan(span);
+
+          // Update the isolation scope, isolate this request
+          const isolationScope = (scopes.isolationScope || getIsolationScope()).clone();
+          const scope = scopes.scope || getCurrentScope();
+
+          setCapturedScopesOnSpan(span, scope, isolationScope);
+        }
+      });
+    },
+  };
+});
diff --git a/packages/opentelemetry/src/utils/mapStatus.ts b/packages/opentelemetry/src/utils/mapStatus.ts
index ab40589e813c..7e8682e92b55 100644
--- a/packages/opentelemetry/src/utils/mapStatus.ts
+++ b/packages/opentelemetry/src/utils/mapStatus.ts
@@ -26,6 +26,10 @@ const canonicalGrpcErrorCodesMap: Record<string, SpanStatus['message']> = {
   '16': 'unauthenticated',
 } as const;
 
+const isStatusErrorMessageValid = (message: string): boolean => {
+  return Object.values(canonicalGrpcErrorCodesMap).includes(message as SpanStatus['message']);
+};
+
 /**
  * Get a Sentry span status from an otel span.
  */
@@ -39,7 +43,11 @@ export function mapStatus(span: AbstractSpan): SpanStatus {
       return { code: SPAN_STATUS_OK };
       // If the span is already marked as erroneous we return that exact status
     } else if (status.code === SpanStatusCode.ERROR) {
-      return { code: SPAN_STATUS_ERROR, message: status.message };
+      if (typeof status.message === 'undefined' || isStatusErrorMessageValid(status.message)) {
+        return { code: SPAN_STATUS_ERROR, message: status.message };
+      } else {
+        return { code: SPAN_STATUS_ERROR, message: 'unknown_error' };
+      }
     }
   }
 

From 1c47e578f4cbf65876685c6072a7123c1e74e3a5 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Tue, 9 Apr 2024 15:56:32 +0200
Subject: [PATCH 22/64] ci(canary): Fix canary tests (#11502)

Fixes the Canary tests by ensuring we cache node modules and files in
dev-packages as well.

In the debugging process, I also moved a few things around - e.g. the
playwright dependency stuff now happens in CI, not in the build commands
everywhere.
---
 .github/workflows/canary.yml                 | 22 +++++++++++---------
 dev-packages/event-proxy-server/package.json |  2 +-
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/canary.yml b/.github/workflows/canary.yml
index 9d34f7878785..6d1c24fe5d45 100644
--- a/.github/workflows/canary.yml
+++ b/.github/workflows/canary.yml
@@ -12,6 +12,13 @@ on:
 env:
   HEAD_COMMIT: ${{ github.event.inputs.commit || github.sha }}
 
+  CACHED_BUILD_PATHS: |
+    ${{ github.workspace }}/packages/*/*.tgz
+    ${{ github.workspace }}/dev-packages/event-proxy-server/build
+    ${{ github.workspace }}/node_modules
+    ${{ github.workspace }}/packages/*/node_modules
+    ${{ github.workspace }}/dev-packages/*/node_modules
+
 permissions:
   contents: read
   issues: write
@@ -33,10 +40,7 @@ jobs:
       - name: Check canary cache
         uses: actions/cache@v4
         with:
-          path: |
-            ${{ github.workspace }}/packages/*/*.tgz
-            ${{ github.workspace }}/node_modules
-            ${{ github.workspace }}/packages/*/node_modules
+          path: ${{ env.CACHED_BUILD_PATHS }}
           key: canary-${{ env.HEAD_COMMIT }}
       - name: Install dependencies
         run: yarn install
@@ -94,24 +98,22 @@ jobs:
       - uses: pnpm/action-setup@v2
         with:
           version: 8.3.1
+
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version-file: 'package.json'
+          node-version-file: 'dev-packages/e2e-tests/package.json'
 
       - name: Restore canary cache
         uses: actions/cache/restore@v4
         with:
-          path: |
-            ${{ github.workspace }}/packages/*/*.tgz
-            ${{ github.workspace }}/node_modules
-            ${{ github.workspace }}/packages/*/node_modules
+          path: ${{ env.CACHED_BUILD_PATHS }}
           key: canary-${{ env.HEAD_COMMIT }}
 
       - name: Get node version
         id: versions
         run: |
-          echo "echo node=$(jq -r '.volta.node' package.json)" >> $GITHUB_OUTPUT
+          echo "echo node=$(jq -r '.volta.node' dev-packages/e2e-tests/package.json)" >> $GITHUB_OUTPUT
 
       - name: Validate Verdaccio
         run: yarn test:validate
diff --git a/dev-packages/event-proxy-server/package.json b/dev-packages/event-proxy-server/package.json
index a0aad2fed4cf..2c70c0877079 100644
--- a/dev-packages/event-proxy-server/package.json
+++ b/dev-packages/event-proxy-server/package.json
@@ -39,7 +39,7 @@
     "build:types": "tsc -p tsconfig.types.json",
     "clean": "rimraf -g ./node_modules ./build"
   },
-  "dependencies": {
+  "devDependencies": {
     "@sentry/types": "8.0.0-alpha.9",
     "@sentry/utils": "8.0.0-alpha.9"
   },

From cdf20be686d22f2e8a0a70f0edb7314e41e78c78 Mon Sep 17 00:00:00 2001
From: Sigrid Huemer <32902192+s1gr1d@users.noreply.github.com>
Date: Tue, 9 Apr 2024 16:05:24 +0200
Subject: [PATCH 23/64] fix(browser-extension): Replace browser extension link
 (#11509)

ref https://github.com/getsentry/sentry-docs/pull/9571
---
 .../suites/manual-client/skip-init-browser-extension/test.ts  | 2 +-
 .../suites/manual-client/skip-init-chrome-extension/test.ts   | 2 +-
 packages/browser/src/sdk.ts                                   | 2 +-
 packages/browser/test/unit/sdk.test.ts                        | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/manual-client/skip-init-browser-extension/test.ts b/dev-packages/browser-integration-tests/suites/manual-client/skip-init-browser-extension/test.ts
index 41d2da3e9e9d..aeac53b9957a 100644
--- a/dev-packages/browser-integration-tests/suites/manual-client/skip-init-browser-extension/test.ts
+++ b/dev-packages/browser-integration-tests/suites/manual-client/skip-init-browser-extension/test.ts
@@ -28,7 +28,7 @@ sentryTest(
     expect(isInitialized).toEqual(false);
     expect(errorLogs.length).toEqual(1);
     expect(errorLogs[0]).toEqual(
-      '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+      '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',
     );
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/manual-client/skip-init-chrome-extension/test.ts b/dev-packages/browser-integration-tests/suites/manual-client/skip-init-chrome-extension/test.ts
index 401788b588a9..3c5cc9c7648b 100644
--- a/dev-packages/browser-integration-tests/suites/manual-client/skip-init-chrome-extension/test.ts
+++ b/dev-packages/browser-integration-tests/suites/manual-client/skip-init-chrome-extension/test.ts
@@ -26,6 +26,6 @@ sentryTest('should not initialize when inside a Chrome browser extension', async
   expect(isInitialized).toEqual(false);
   expect(errorLogs.length).toEqual(1);
   expect(errorLogs[0]).toEqual(
-    '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+    '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',
   );
 });
diff --git a/packages/browser/src/sdk.ts b/packages/browser/src/sdk.ts
index 9c25dc9750eb..d64981cb0c7a 100644
--- a/packages/browser/src/sdk.ts
+++ b/packages/browser/src/sdk.ts
@@ -135,7 +135,7 @@ export function init(browserOptions: BrowserOptions = {}): void {
     consoleSandbox(() => {
       // eslint-disable-next-line no-console
       console.error(
-        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',
       );
     });
     return;
diff --git a/packages/browser/test/unit/sdk.test.ts b/packages/browser/test/unit/sdk.test.ts
index f4a04d088135..f8f5125ff896 100644
--- a/packages/browser/test/unit/sdk.test.ts
+++ b/packages/browser/test/unit/sdk.test.ts
@@ -154,7 +154,7 @@ describe('init', () => {
 
       expect(consoleErrorSpy).toBeCalledTimes(1);
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',
       );
 
       consoleErrorSpy.mockRestore();
@@ -169,7 +169,7 @@ describe('init', () => {
 
       expect(consoleErrorSpy).toBeCalledTimes(1);
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',
       );
 
       consoleErrorSpy.mockRestore();

From 4759d4c603db558fe4e3552933510b9a4c85a954 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Tue, 9 Apr 2024 16:06:30 +0200
Subject: [PATCH 24/64] feat(opentelemetry): Export `getRequestSpanData`
 (#11508)

Instead of exporting `_INTERNAL` here, it's OK IMHO to export this. The
API is stable enough.
---
 packages/node/src/integrations/http.ts       |  4 ++--
 packages/node/src/integrations/node-fetch.ts |  4 ++--
 packages/opentelemetry/src/index.ts          | 12 +-----------
 3 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/packages/node/src/integrations/http.ts b/packages/node/src/integrations/http.ts
index c5eefdc6fb2e..633f27c7b64c 100644
--- a/packages/node/src/integrations/http.ts
+++ b/packages/node/src/integrations/http.ts
@@ -14,7 +14,7 @@ import {
   setCapturedScopesOnSpan,
   spanToJSON,
 } from '@sentry/core';
-import { _INTERNAL, getClient, getSpanKind } from '@sentry/opentelemetry';
+import { getClient, getRequestSpanData, getSpanKind } from '@sentry/opentelemetry';
 import type { IntegrationFn } from '@sentry/types';
 
 import { stripUrlQueryAndFragment } from '@sentry/utils';
@@ -162,7 +162,7 @@ function _addRequestBreadcrumb(span: Span, response: HTTPModuleRequestIncomingMe
     return;
   }
 
-  const data = _INTERNAL.getRequestSpanData(span);
+  const data = getRequestSpanData(span);
   addBreadcrumb(
     {
       category: 'http',
diff --git a/packages/node/src/integrations/node-fetch.ts b/packages/node/src/integrations/node-fetch.ts
index afa995d9b1ea..6379b7f04a53 100644
--- a/packages/node/src/integrations/node-fetch.ts
+++ b/packages/node/src/integrations/node-fetch.ts
@@ -3,7 +3,7 @@ import { SpanKind } from '@opentelemetry/api';
 import type { Instrumentation } from '@opentelemetry/instrumentation';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { addBreadcrumb, defineIntegration } from '@sentry/core';
-import { _INTERNAL, getSpanKind } from '@sentry/opentelemetry';
+import { getRequestSpanData, getSpanKind } from '@sentry/opentelemetry';
 import type { IntegrationFn } from '@sentry/types';
 import { logger } from '@sentry/utils';
 import { DEBUG_BUILD } from '../debug-build';
@@ -88,7 +88,7 @@ function _addRequestBreadcrumb(span: Span): void {
     return;
   }
 
-  const data = _INTERNAL.getRequestSpanData(span);
+  const data = getRequestSpanData(span);
   addBreadcrumb({
     category: 'http',
     data: {
diff --git a/packages/opentelemetry/src/index.ts b/packages/opentelemetry/src/index.ts
index 776dd8c50d0c..43f183be2139 100644
--- a/packages/opentelemetry/src/index.ts
+++ b/packages/opentelemetry/src/index.ts
@@ -1,4 +1,4 @@
-import { getRequestSpanData } from './utils/getRequestSpanData';
+export { getRequestSpanData } from './utils/getRequestSpanData';
 
 export type { OpenTelemetryClient } from './types';
 export { wrapClientClass } from './custom/client';
@@ -39,13 +39,3 @@ export { openTelemetrySetupCheck } from './utils/setupCheck';
 
 // Legacy
 export { getClient } from '@sentry/core';
-
-/**
- * The following internal utils are not considered public API and are subject to change.
- * @hidden
- */
-const _INTERNAL = {
-  getRequestSpanData,
-} as const;
-
-export { _INTERNAL };

From 5bcd1d886a7b2b38dde5d59ea3989c0f0ceb035a Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Tue, 9 Apr 2024 17:04:09 +0200
Subject: [PATCH 25/64] feat(sveltekit): Update scope transactionName when
 handling server-side request (#11511)

Update the scope's `transactionName` in the `sentryHandle`
instrumentation that's always invoked when a request is made to the
SvelteKit server.
---
 .../sveltekit-2/test/errors.server.test.ts        |  3 +--
 .../sveltekit/test/errors.server.test.ts          |  3 +--
 packages/sveltekit/src/server/handle.ts           | 15 +++++++++++++--
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2/test/errors.server.test.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2/test/errors.server.test.ts
index ffdfad2932c8..51488b103107 100644
--- a/dev-packages/e2e-tests/test-applications/sveltekit-2/test/errors.server.test.ts
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2/test/errors.server.test.ts
@@ -60,7 +60,6 @@ test.describe('server-side errors', () => {
       }),
     );
 
-    // TODO: Uncomment once we update the scope transaction name on the server side
-    // expect(errorEvent.transaction).toEqual('GET /server-route-error');
+    expect(errorEvent.transaction).toEqual('GET /server-route-error');
   });
 });
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit/test/errors.server.test.ts b/dev-packages/e2e-tests/test-applications/sveltekit/test/errors.server.test.ts
index 6274239a936b..d2215cf8e763 100644
--- a/dev-packages/e2e-tests/test-applications/sveltekit/test/errors.server.test.ts
+++ b/dev-packages/e2e-tests/test-applications/sveltekit/test/errors.server.test.ts
@@ -63,7 +63,6 @@ test.describe('server-side errors', () => {
       }),
     );
 
-    // TODO: Uncomment once we update the scope transaction name on the server side
-    // expect(errorEvent.transaction).toEqual('GET /server-route-error');
+    expect(errorEvent.transaction).toEqual('GET /server-route-error');
   });
 });
diff --git a/packages/sveltekit/src/server/handle.ts b/packages/sveltekit/src/server/handle.ts
index 0bb08be6ce50..ee55ed810e8e 100644
--- a/packages/sveltekit/src/server/handle.ts
+++ b/packages/sveltekit/src/server/handle.ts
@@ -2,6 +2,8 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   getActiveSpan,
+  getDefaultIsolationScope,
+  getIsolationScope,
   getRootSpan,
   setHttpStatus,
   spanToTraceHeader,
@@ -10,11 +12,12 @@ import {
 import { startSpan } from '@sentry/core';
 import { captureException, continueTrace } from '@sentry/node';
 import type { Span } from '@sentry/types';
-import { dynamicSamplingContextToSentryBaggageHeader, objectify } from '@sentry/utils';
+import { dynamicSamplingContextToSentryBaggageHeader, logger, objectify } from '@sentry/utils';
 import type { Handle, ResolveOptions } from '@sveltejs/kit';
 
 import { getDynamicSamplingContextFromSpan } from '@sentry/opentelemetry';
 
+import { DEBUG_BUILD } from '../common/debug-build';
 import { isHttpError, isRedirect } from '../common/utils';
 import { flushIfServerless, getTracePropagationData } from './utils';
 
@@ -183,6 +186,14 @@ async function instrumentHandle(
     return resolve(event);
   }
 
+  const routeName = `${event.request.method} ${event.route?.id || event.url.pathname}`;
+
+  if (getIsolationScope() !== getDefaultIsolationScope()) {
+    getIsolationScope().setTransactionName(routeName);
+  } else {
+    DEBUG_BUILD && logger.warn('Isolation scope is default isolation scope - skipping setting transactionName');
+  }
+
   try {
     const resolveResult = await startSpan(
       {
@@ -192,7 +203,7 @@ async function instrumentHandle(
           [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: event.route?.id ? 'route' : 'url',
           'http.method': event.request.method,
         },
-        name: `${event.request.method} ${event.route?.id || event.url.pathname}`,
+        name: routeName,
       },
       async (span?: Span) => {
         const res = await resolve(event, {

From 6c8cdcd5fff45204ca1c828c2adf80bb0ec80d08 Mon Sep 17 00:00:00 2001
From: Tim Fish <tim@timfish.uk>
Date: Tue, 9 Apr 2024 17:10:54 +0200
Subject: [PATCH 26/64] feat(core): Ensure replay envelopes are sent in order
 when offline (#11413)

Modifies `makeOfflineTransport` to allow replay envelopes to be
queued when offline and to ensure they are always send in order.

To do this we:
- Modify the store interface so it has `push`, `unshift` and `shift`
methods (BREAKING)
- Always queue replay envelopes in the store so there is never more than
one in-flight
- Always `unshift` failed envelopes so they're always sent in the same
order from the queue
---
 .../playwright.config.ts                      |   2 +-
 .../replay/captureReplayOffline/init.js       |  17 ++
 .../replay/captureReplayOffline/template.html |   9 +
 .../replay/captureReplayOffline/test.ts       |  45 ++++
 .../suites/transport/offline/init.js          |   2 +-
 packages/browser/src/transports/offline.ts    |  39 +++-
 .../test/unit/transports/offline.test.ts      |  27 ++-
 packages/core/src/transports/offline.ts       |  62 ++++--
 .../core/test/lib/transports/offline.test.ts  | 207 +++++++++++++-----
 9 files changed, 306 insertions(+), 104 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/template.html
 create mode 100644 dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/test.ts

diff --git a/dev-packages/browser-integration-tests/playwright.config.ts b/dev-packages/browser-integration-tests/playwright.config.ts
index 78a71108837f..77ed6014d230 100644
--- a/dev-packages/browser-integration-tests/playwright.config.ts
+++ b/dev-packages/browser-integration-tests/playwright.config.ts
@@ -11,7 +11,7 @@ const config: PlaywrightTestConfig = {
   testMatch: /test.ts/,
 
   use: {
-    trace: process.env.CI ? 'retry-with-trace' : 'off',
+    trace: process.env.CI ? 'retain-on-failure' : 'off',
   },
 
   projects: [
diff --git a/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/init.js b/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/init.js
new file mode 100644
index 000000000000..0e1297ae8710
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/init.js
@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+window.Replay = Sentry.replayIntegration({
+  flushMinDelay: 200,
+  flushMaxDelay: 200,
+  minReplayDuration: 0,
+});
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  sampleRate: 0,
+  replaysSessionSampleRate: 1.0,
+  replaysOnErrorSampleRate: 0.0,
+  transport: Sentry.makeBrowserOfflineTransport(),
+  integrations: [window.Replay],
+});
diff --git a/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/template.html b/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/template.html
new file mode 100644
index 000000000000..2b3e2f0b27b4
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/template.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <button onclick="console.log('Test log')">Click me</button>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/test.ts b/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/test.ts
new file mode 100644
index 000000000000..a74a2c891fad
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/replay/captureReplayOffline/test.ts
@@ -0,0 +1,45 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../utils/fixtures';
+import { getReplayEvent, shouldSkipReplayTest, waitForReplayRequest } from '../../../utils/replayHelpers';
+
+sentryTest('should capture replays offline', async ({ getLocalTestPath, page }) => {
+  // makeBrowserOfflineTransport is not included in any CDN bundles
+  if (shouldSkipReplayTest() || (process.env.PW_BUNDLE && process.env.PW_BUNDLE.startsWith('bundle'))) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+  const reqPromise1 = waitForReplayRequest(page, 1);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  // This would be the obvious way to test offline support but it doesn't appear to work!
+  // await context.setOffline(true);
+
+  // Abort the first envelope request so the event gets queued
+  await page.route(/ingest\.sentry\.io/, route => route.abort('internetdisconnected'), { times: 1 });
+
+  await page.goto(url);
+
+  await new Promise(resolve => setTimeout(resolve, 2_000));
+
+  // Now send a second event which should be queued after the the first one and force flushing the queue
+  await page.locator('button').click();
+
+  const replayEvent0 = getReplayEvent(await reqPromise0);
+  const replayEvent1 = getReplayEvent(await reqPromise1);
+
+  // Check that we received the envelopes in the correct order
+  expect(replayEvent0.timestamp).toBeGreaterThan(0);
+  expect(replayEvent1.timestamp).toBeGreaterThan(0);
+  expect(replayEvent0.timestamp).toBeLessThan(replayEvent1.timestamp || 0);
+});
diff --git a/dev-packages/browser-integration-tests/suites/transport/offline/init.js b/dev-packages/browser-integration-tests/suites/transport/offline/init.js
index a69f8a32b32a..e102d6a8a5a5 100644
--- a/dev-packages/browser-integration-tests/suites/transport/offline/init.js
+++ b/dev-packages/browser-integration-tests/suites/transport/offline/init.js
@@ -4,5 +4,5 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  transport: Sentry.makeBrowserOfflineTransport(Sentry.makeFetchTransport),
+  transport: Sentry.makeBrowserOfflineTransport(),
 });
diff --git a/packages/browser/src/transports/offline.ts b/packages/browser/src/transports/offline.ts
index dd7d9c70d929..4a435b2972fa 100644
--- a/packages/browser/src/transports/offline.ts
+++ b/packages/browser/src/transports/offline.ts
@@ -48,8 +48,8 @@ function keys(store: IDBObjectStore): Promise<number[]> {
   return promisifyRequest(store.getAllKeys() as IDBRequest<number[]>);
 }
 
-/** Insert into the store */
-export function insert(store: Store, value: Uint8Array | string, maxQueueSize: number): Promise<void> {
+/** Insert into the end of the store */
+export function push(store: Store, value: Uint8Array | string, maxQueueSize: number): Promise<void> {
   return store(store => {
     return keys(store).then(keys => {
       if (keys.length >= maxQueueSize) {
@@ -63,8 +63,23 @@ export function insert(store: Store, value: Uint8Array | string, maxQueueSize: n
   });
 }
 
+/** Insert into the front of the store */
+export function unshift(store: Store, value: Uint8Array | string, maxQueueSize: number): Promise<void> {
+  return store(store => {
+    return keys(store).then(keys => {
+      if (keys.length >= maxQueueSize) {
+        return;
+      }
+
+      // We insert with an decremented key so that the entries are popped in order
+      store.put(value, Math.min(...keys, 0) - 1);
+      return promisifyRequest(store.transaction);
+    });
+  });
+}
+
 /** Pop the oldest value from the store */
-export function pop(store: Store): Promise<Uint8Array | string | undefined> {
+export function shift(store: Store): Promise<Uint8Array | string | undefined> {
   return store(store => {
     return keys(store).then(keys => {
       if (keys.length === 0) {
@@ -79,7 +94,7 @@ export function pop(store: Store): Promise<Uint8Array | string | undefined> {
   });
 }
 
-export interface BrowserOfflineTransportOptions extends OfflineTransportOptions {
+export interface BrowserOfflineTransportOptions extends Omit<OfflineTransportOptions, 'createStore'> {
   /**
    * Name of indexedDb database to store envelopes in
    * Default: 'sentry-offline'
@@ -110,17 +125,25 @@ function createIndexedDbStore(options: BrowserOfflineTransportOptions): OfflineS
   }
 
   return {
-    insert: async (env: Envelope) => {
+    push: async (env: Envelope) => {
+      try {
+        const serialized = await serializeEnvelope(env);
+        await push(getStore(), serialized, options.maxQueueSize || 30);
+      } catch (_) {
+        //
+      }
+    },
+    unshift: async (env: Envelope) => {
       try {
         const serialized = await serializeEnvelope(env);
-        await insert(getStore(), serialized, options.maxQueueSize || 30);
+        await unshift(getStore(), serialized, options.maxQueueSize || 30);
       } catch (_) {
         //
       }
     },
-    pop: async () => {
+    shift: async () => {
       try {
-        const deserialized = await pop(getStore());
+        const deserialized = await shift(getStore());
         if (deserialized) {
           return parseEnvelope(deserialized);
         }
diff --git a/packages/browser/test/unit/transports/offline.test.ts b/packages/browser/test/unit/transports/offline.test.ts
index ccc206dbdf97..ed4cd770101d 100644
--- a/packages/browser/test/unit/transports/offline.test.ts
+++ b/packages/browser/test/unit/transports/offline.test.ts
@@ -11,7 +11,7 @@ import type {
 import { createEnvelope } from '@sentry/utils';
 
 import { MIN_DELAY } from '../../../../core/src/transports/offline';
-import { createStore, insert, makeBrowserOfflineTransport, pop } from '../../../src/transports/offline';
+import { createStore, makeBrowserOfflineTransport, push, shift, unshift } from '../../../src/transports/offline';
 
 function deleteDatabase(name: string): Promise<void> {
   return new Promise<void>((resolve, reject) => {
@@ -63,21 +63,24 @@ describe('makeOfflineTransport', () => {
     (global as any).TextDecoder = TextDecoder;
   });
 
-  it('indexedDb wrappers insert and pop', async () => {
+  it('indexedDb wrappers push, unshift and pop', async () => {
     const store = createStore('test', 'test');
-    const found = await pop(store);
+    const found = await shift(store);
     expect(found).toBeUndefined();
 
-    await insert(store, 'test1', 30);
-    await insert(store, new Uint8Array([1, 2, 3, 4, 5]), 30);
+    await push(store, 'test1', 30);
+    await push(store, new Uint8Array([1, 2, 3, 4, 5]), 30);
+    await unshift(store, 'test2', 30);
 
-    const found2 = await pop(store);
-    expect(found2).toEqual('test1');
-    const found3 = await pop(store);
-    expect(found3).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
+    const found2 = await shift(store);
+    expect(found2).toEqual('test2');
+    const found3 = await shift(store);
+    expect(found3).toEqual('test1');
+    const found4 = await shift(store);
+    expect(found4).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
 
-    const found4 = await pop(store);
-    expect(found4).toBeUndefined();
+    const found5 = await shift(store);
+    expect(found5).toBeUndefined();
   });
 
   it('Queues and retries envelope if wrapped transport throws error', async () => {
@@ -104,7 +107,7 @@ describe('makeOfflineTransport', () => {
     const result2 = await transport.send(ERROR_ENVELOPE);
     expect(result2).toEqual({ statusCode: 200 });
 
-    await delay(MIN_DELAY * 2);
+    await delay(MIN_DELAY * 5);
 
     expect(queuedCount).toEqual(1);
     expect(getSendCount()).toEqual(2);
diff --git a/packages/core/src/transports/offline.ts b/packages/core/src/transports/offline.ts
index 2e0db450ddfd..9d30b8cb34ec 100644
--- a/packages/core/src/transports/offline.ts
+++ b/packages/core/src/transports/offline.ts
@@ -7,13 +7,10 @@ export const MIN_DELAY = 100; // 100 ms
 export const START_DELAY = 5_000; // 5 seconds
 const MAX_DELAY = 3.6e6; // 1 hour
 
-function log(msg: string, error?: Error): void {
-  DEBUG_BUILD && logger.info(`[Offline]: ${msg}`, error);
-}
-
 export interface OfflineStore {
-  insert(env: Envelope): Promise<void>;
-  pop(): Promise<Envelope | undefined>;
+  push(env: Envelope): Promise<void>;
+  unshift(env: Envelope): Promise<void>;
+  shift(): Promise<Envelope | undefined>;
 }
 
 export type CreateOfflineStore = (options: OfflineTransportOptions) => OfflineStore;
@@ -53,19 +50,25 @@ type Timer = number | { unref?: () => void };
 export function makeOfflineTransport<TO>(
   createTransport: (options: TO) => Transport,
 ): (options: TO & OfflineTransportOptions) => Transport {
+  function log(...args: unknown[]): void {
+    DEBUG_BUILD && logger.info('[Offline]:', ...args);
+  }
+
   return options => {
     const transport = createTransport(options);
-    const store = options.createStore ? options.createStore(options) : undefined;
+
+    if (!options.createStore) {
+      throw new Error('No `createStore` function was provided');
+    }
+
+    const store = options.createStore(options);
 
     let retryDelay = START_DELAY;
     let flushTimer: Timer | undefined;
 
     function shouldQueue(env: Envelope, error: Error, retryDelay: number): boolean | Promise<boolean> {
-      // We don't queue Session Replay envelopes because they are:
-      // - Ordered and Replay relies on the response status to know when they're successfully sent.
-      // - Likely to fill the queue quickly and block other events from being sent.
-      // We also want to drop client reports because they can be generated when we retry sending events while offline.
-      if (envelopeContainsItemType(env, ['replay_event', 'replay_recording', 'client_report'])) {
+      // We want to drop client reports because they can be generated when we retry sending events while offline.
+      if (envelopeContainsItemType(env, ['client_report'])) {
         return false;
       }
 
@@ -77,10 +80,6 @@ export function makeOfflineTransport<TO>(
     }
 
     function flushIn(delay: number): void {
-      if (!store) {
-        return;
-      }
-
       if (flushTimer) {
         clearTimeout(flushTimer as ReturnType<typeof setTimeout>);
       }
@@ -88,10 +87,14 @@ export function makeOfflineTransport<TO>(
       flushTimer = setTimeout(async () => {
         flushTimer = undefined;
 
-        const found = await store.pop();
+        const found = await store.shift();
         if (found) {
           log('Attempting to send previously queued event');
-          void send(found).catch(e => {
+
+          // We should to update the sent_at timestamp to the current time.
+          found[0].sent_at = new Date().toISOString();
+
+          void send(found, true).catch(e => {
             log('Failed to retry sending', e);
           });
         }
@@ -113,7 +116,15 @@ export function makeOfflineTransport<TO>(
       retryDelay = Math.min(retryDelay * 2, MAX_DELAY);
     }
 
-    async function send(envelope: Envelope): Promise<TransportMakeRequestResponse> {
+    async function send(envelope: Envelope, isRetry: boolean = false): Promise<TransportMakeRequestResponse> {
+      // We queue all replay envelopes to avoid multiple replay envelopes being sent at the same time. If one fails, we
+      // need to retry them in order.
+      if (!isRetry && envelopeContainsItemType(envelope, ['replay_event', 'replay_recording'])) {
+        await store.push(envelope);
+        flushIn(MIN_DELAY);
+        return {};
+      }
+
       try {
         const result = await transport.send(envelope);
 
@@ -123,6 +134,8 @@ export function makeOfflineTransport<TO>(
           // If there's a retry-after header, use that as the next delay.
           if (result.headers && result.headers['retry-after']) {
             delay = parseRetryAfterHeader(result.headers['retry-after']);
+          } else if (result.headers && result.headers['x-sentry-rate-limits']) {
+            delay = 60_000; // 60 seconds
           } // If we have a server error, return now so we don't flush the queue.
           else if ((result.statusCode || 0) >= 400) {
             return result;
@@ -133,10 +146,15 @@ export function makeOfflineTransport<TO>(
         retryDelay = START_DELAY;
         return result;
       } catch (e) {
-        if (store && (await shouldQueue(envelope, e as Error, retryDelay))) {
-          await store.insert(envelope);
+        if (await shouldQueue(envelope, e as Error, retryDelay)) {
+          // If this envelope was a retry, we want to add it to the front of the queue so it's retried again first.
+          if (isRetry) {
+            await store.unshift(envelope);
+          } else {
+            await store.push(envelope);
+          }
           flushWithBackOff();
-          log('Error sending. Event queued', e as Error);
+          log('Error sending. Event queued.', e as Error);
           return {};
         } else {
           throw e;
diff --git a/packages/core/test/lib/transports/offline.test.ts b/packages/core/test/lib/transports/offline.test.ts
index 7e87115b9cdb..2368f61d5892 100644
--- a/packages/core/test/lib/transports/offline.test.ts
+++ b/packages/core/test/lib/transports/offline.test.ts
@@ -6,7 +6,6 @@ import type {
   InternalBaseTransportOptions,
   ReplayEnvelope,
   ReplayEvent,
-  Transport,
   TransportMakeRequestResponse,
 } from '@sentry/types';
 import {
@@ -15,6 +14,7 @@ import {
   createEventEnvelopeHeaders,
   dsnFromString,
   getSdkMetadataForEnvelopeHeader,
+  parseEnvelope,
 } from '@sentry/utils';
 
 import { createTransport } from '../../../src';
@@ -25,34 +25,40 @@ const ERROR_ENVELOPE = createEnvelope<EventEnvelope>({ event_id: 'aa3ff046696b4b
   [{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
 ]);
 
-const REPLAY_EVENT: ReplayEvent = {
-  type: 'replay_event',
-  timestamp: 1670837008.634,
-  error_ids: ['errorId'],
-  trace_ids: ['traceId'],
-  urls: ['https://example.com'],
-  replay_id: 'MY_REPLAY_ID',
-  segment_id: 3,
-  replay_type: 'buffer',
-};
+function REPLAY_EVENT(message: string): ReplayEvent {
+  return {
+    type: 'replay_event',
+    timestamp: 1670837008.634,
+    error_ids: ['errorId'],
+    trace_ids: ['traceId'],
+    urls: ['https://example.com'],
+    replay_id: 'MY_REPLAY_ID',
+    segment_id: 3,
+    replay_type: 'buffer',
+    message,
+  };
+}
 
 const DSN = dsnFromString('https://public@dsn.ingest.sentry.io/1337')!;
 
 const DATA = 'nothing';
 
-const RELAY_ENVELOPE = createEnvelope<ReplayEnvelope>(
-  createEventEnvelopeHeaders(REPLAY_EVENT, getSdkMetadataForEnvelopeHeader(REPLAY_EVENT), undefined, DSN),
-  [
-    [{ type: 'replay_event' }, REPLAY_EVENT],
+function REPLAY_ENVELOPE(message: string) {
+  const event = REPLAY_EVENT(message);
+  return createEnvelope<ReplayEnvelope>(
+    createEventEnvelopeHeaders(event, getSdkMetadataForEnvelopeHeader(event), undefined, DSN),
     [
-      {
-        type: 'replay_recording',
-        length: DATA.length,
-      },
-      DATA,
+      [{ type: 'replay_event' }, event],
+      [
+        {
+          type: 'replay_recording',
+          length: DATA.length,
+        },
+        DATA,
+      ],
     ],
-  ],
-);
+  );
+}
 
 const DEFAULT_DISCARDED_EVENTS: ClientReport['discarded_events'] = [
   {
@@ -79,22 +85,21 @@ const transportOptions = {
 
 type MockResult<T> = T | Error;
 
-const createTestTransport = (
-  ...sendResults: MockResult<TransportMakeRequestResponse>[]
-): { getSendCount: () => number; baseTransport: (options: InternalBaseTransportOptions) => Transport } => {
-  let sendCount = 0;
+const createTestTransport = (...sendResults: MockResult<TransportMakeRequestResponse>[]) => {
+  const sentEnvelopes: (string | Uint8Array)[] = [];
 
   return {
-    getSendCount: () => sendCount,
+    getSentEnvelopes: () => sentEnvelopes,
+    getSendCount: () => sentEnvelopes.length,
     baseTransport: (options: InternalBaseTransportOptions) =>
-      createTransport(options, () => {
+      createTransport(options, ({ body }) => {
         return new Promise((resolve, reject) => {
           const next = sendResults.shift();
 
           if (next instanceof Error) {
             reject(next);
           } else {
-            sendCount += 1;
+            sentEnvelopes.push(body);
             resolve(next as TransportMakeRequestResponse);
           }
         });
@@ -102,7 +107,7 @@ const createTestTransport = (
   };
 };
 
-type StoreEvents = ('add' | 'pop')[];
+type StoreEvents = ('push' | 'unshift' | 'shift')[];
 
 function createTestStore(...popResults: MockResult<Envelope | undefined>[]): {
   getCalls: () => StoreEvents;
@@ -113,14 +118,20 @@ function createTestStore(...popResults: MockResult<Envelope | undefined>[]): {
   return {
     getCalls: () => calls,
     store: (_: OfflineTransportOptions) => ({
-      insert: async env => {
+      push: async env => {
         if (popResults.length < 30) {
           popResults.push(env);
-          calls.push('add');
+          calls.push('push');
         }
       },
-      pop: async () => {
-        calls.push('pop');
+      unshift: async env => {
+        if (popResults.length < 30) {
+          popResults.unshift(env);
+          calls.push('unshift');
+        }
+      },
+      shift: async () => {
+        calls.push('shift');
         const next = popResults.shift();
 
         if (next instanceof Error) {
@@ -129,6 +140,7 @@ function createTestStore(...popResults: MockResult<Envelope | undefined>[]): {
 
         return next;
       },
+      count: async () => popResults.length,
     }),
   };
 }
@@ -170,10 +182,10 @@ describe('makeOfflineTransport', () => {
     await waitUntil(() => getCalls().length == 1, 1_000);
 
     // After a successful send, the store should be checked
-    expect(getCalls()).toEqual(['pop']);
+    expect(getCalls()).toEqual(['shift']);
   });
 
-  it('After successfully sending, sends further envelopes found in the store', async () => {
+  it('Envelopes are added after existing envelopes in the queue', async () => {
     const { getCalls, store } = createTestStore(ERROR_ENVELOPE);
     const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 }, { statusCode: 200 });
     const transport = makeOfflineTransport(baseTransport)({ ...transportOptions, createStore: store });
@@ -185,7 +197,7 @@ describe('makeOfflineTransport', () => {
 
     expect(getSendCount()).toEqual(2);
     // After a successful send from the store, the store should be checked again to ensure it's empty
-    expect(getCalls()).toEqual(['pop', 'pop']);
+    expect(getCalls()).toEqual(['shift', 'shift']);
   });
 
   it('Queues envelope if wrapped transport throws error', async () => {
@@ -208,7 +220,7 @@ describe('makeOfflineTransport', () => {
 
     expect(getSendCount()).toEqual(0);
     expect(queuedCount).toEqual(1);
-    expect(getCalls()).toEqual(['add']);
+    expect(getCalls()).toEqual(['push']);
   });
 
   it('Does not queue envelopes if status code >= 400', async () => {
@@ -242,18 +254,18 @@ describe('makeOfflineTransport', () => {
       const transport = makeOfflineTransport(baseTransport)({ ...transportOptions, createStore: store });
       const result = await transport.send(ERROR_ENVELOPE);
       expect(result).toEqual({});
-      expect(getCalls()).toEqual(['add']);
+      expect(getCalls()).toEqual(['push']);
 
       await waitUntil(() => getCalls().length === 3 && getSendCount() === 1, START_DELAY * 2);
 
       expect(getSendCount()).toEqual(1);
-      expect(getCalls()).toEqual(['add', 'pop', 'pop']);
+      expect(getCalls()).toEqual(['push', 'shift', 'shift']);
     },
     START_DELAY + 2_000,
   );
 
   it(
-    'When enabled, sends envelopes found in store shortly after startup',
+    'When flushAtStartup is enabled, sends envelopes found in store shortly after startup',
     async () => {
       const { getCalls, store } = createTestStore(ERROR_ENVELOPE, ERROR_ENVELOPE);
       const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 }, { statusCode: 200 });
@@ -267,7 +279,58 @@ describe('makeOfflineTransport', () => {
       await waitUntil(() => getCalls().length === 3 && getSendCount() === 2, START_DELAY * 2);
 
       expect(getSendCount()).toEqual(2);
-      expect(getCalls()).toEqual(['pop', 'pop', 'pop']);
+      expect(getCalls()).toEqual(['shift', 'shift', 'shift']);
+    },
+    START_DELAY + 2_000,
+  );
+
+  it(
+    'Unshifts envelopes on retry failure',
+    async () => {
+      const { getCalls, store } = createTestStore(ERROR_ENVELOPE);
+      const { getSendCount, baseTransport } = createTestTransport(new Error(), { statusCode: 200 });
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const _transport = makeOfflineTransport(baseTransport)({
+        ...transportOptions,
+        createStore: store,
+        flushAtStartup: true,
+      });
+
+      await waitUntil(() => getCalls().length === 2, START_DELAY * 2);
+
+      expect(getSendCount()).toEqual(0);
+      expect(getCalls()).toEqual(['shift', 'unshift']);
+    },
+    START_DELAY + 2_000,
+  );
+
+  it(
+    'Updates sent_at envelope header on retry',
+    async () => {
+      const testStartTime = new Date();
+
+      // Create an envelope with a sent_at header very far in the past
+      const env: EventEnvelope = [...ERROR_ENVELOPE];
+      env[0].sent_at = new Date(2020, 1, 1).toISOString();
+
+      const { getCalls, store } = createTestStore(ERROR_ENVELOPE);
+      const { getSentEnvelopes, baseTransport } = createTestTransport({ statusCode: 200 });
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const _transport = makeOfflineTransport(baseTransport)({
+        ...transportOptions,
+        createStore: store,
+        flushAtStartup: true,
+      });
+
+      await waitUntil(() => getCalls().length >= 1, START_DELAY * 2);
+      expect(getCalls()).toEqual(['shift']);
+
+      // When it gets shifted out of the store, the sent_at header should be updated
+      const envelopes = getSentEnvelopes().map(parseEnvelope) as EventEnvelope[];
+      expect(envelopes[0][0]).toBeDefined();
+      const sent_at = new Date(envelopes[0][0].sent_at);
+
+      expect(sent_at.getTime()).toBeGreaterThan(testStartTime.getTime());
     },
     START_DELAY + 2_000,
   );
@@ -289,23 +352,6 @@ describe('makeOfflineTransport', () => {
     expect(getCalls()).toEqual([]);
   });
 
-  it('should not store Relay envelopes on send failure', async () => {
-    const { getCalls, store } = createTestStore();
-    const { getSendCount, baseTransport } = createTestTransport(new Error());
-    const queuedCount = 0;
-    const transport = makeOfflineTransport(baseTransport)({
-      ...transportOptions,
-      createStore: store,
-      shouldStore: () => true,
-    });
-    const result = transport.send(RELAY_ENVELOPE);
-
-    await expect(result).rejects.toBeInstanceOf(Error);
-    expect(queuedCount).toEqual(0);
-    expect(getSendCount()).toEqual(0);
-    expect(getCalls()).toEqual([]);
-  });
-
   it('should not store client report envelopes on send failure', async () => {
     const { getCalls, store } = createTestStore();
     const { getSendCount, baseTransport } = createTestTransport(new Error());
@@ -323,6 +369,47 @@ describe('makeOfflineTransport', () => {
     expect(getCalls()).toEqual([]);
   });
 
+  it(
+    'Sends replay envelopes in order',
+    async () => {
+      const { getCalls, store } = createTestStore(REPLAY_ENVELOPE('1'), REPLAY_ENVELOPE('2'));
+      const { getSendCount, getSentEnvelopes, baseTransport } = createTestTransport(
+        new Error(),
+        { statusCode: 200 },
+        { statusCode: 200 },
+        { statusCode: 200 },
+      );
+      const transport = makeOfflineTransport(baseTransport)({ ...transportOptions, createStore: store });
+      const result = await transport.send(REPLAY_ENVELOPE('3'));
+
+      expect(result).toEqual({});
+      expect(getCalls()).toEqual(['push']);
+
+      await waitUntil(() => getCalls().length === 6 && getSendCount() === 3, START_DELAY * 5);
+
+      expect(getSendCount()).toEqual(3);
+      expect(getCalls()).toEqual([
+        // We're sending a replay envelope and they always get queued
+        'push',
+        // The first envelope popped out fails to send so it gets added to the front of the queue
+        'shift',
+        'unshift',
+        // The rest of the attempts succeed
+        'shift',
+        'shift',
+        'shift',
+      ]);
+
+      const envelopes = getSentEnvelopes().map(parseEnvelope);
+
+      // Ensure they're still in the correct order
+      expect((envelopes[0][1][0][1] as ErrorEvent).message).toEqual('1');
+      expect((envelopes[1][1][0][1] as ErrorEvent).message).toEqual('2');
+      expect((envelopes[2][1][0][1] as ErrorEvent).message).toEqual('3');
+    },
+    START_DELAY + 2_000,
+  );
+
   // eslint-disable-next-line jest/no-disabled-tests
   it.skip(
     'Follows the Retry-After header',
@@ -360,7 +447,7 @@ describe('makeOfflineTransport', () => {
 
       expect(getSendCount()).toEqual(2);
       expect(queuedCount).toEqual(0);
-      expect(getCalls()).toEqual(['pop', 'pop']);
+      expect(getCalls()).toEqual(['shift', 'shift']);
     },
     START_DELAY * 3,
   );

From 1067868fcf590099b1c4876db1e0b4cac1587999 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Tue, 9 Apr 2024 17:13:57 +0200
Subject: [PATCH 27/64] feat(hapi): Update scope `transactionName` when
 handling request (#11448)

This PR updates the scope's `transactionName` in our Hapi error handler.
Conveniently, we can access the parameterized route within our Hapi
plugin, meaning we're not constrained by reading route info from a
potential non-recording span.
---
 .../test-applications/node-hapi-app/src/app.js     |  9 +++++++++
 .../node-hapi-app/tests/server.test.ts             | 14 ++++++++++++++
 .../suites/tracing/hapi/scenario.js                |  8 ++++++++
 .../suites/tracing/hapi/test.ts                    | 14 ++++++++++++++
 .../node/src/integrations/tracing/hapi/index.ts    | 14 ++++++++++++++
 5 files changed, 59 insertions(+)

diff --git a/dev-packages/e2e-tests/test-applications/node-hapi-app/src/app.js b/dev-packages/e2e-tests/test-applications/node-hapi-app/src/app.js
index 95564255b60f..6d6f959410dd 100644
--- a/dev-packages/e2e-tests/test-applications/node-hapi-app/src/app.js
+++ b/dev-packages/e2e-tests/test-applications/node-hapi-app/src/app.js
@@ -44,6 +44,15 @@ const init = async () => {
     },
   });
 
+  server.route({
+    method: 'GET',
+    path: '/test-error/{id}',
+    handler: function (request) {
+      console.log('This is an error with id', request.params.id);
+      throw new Error(`This is an error with id ${request.params.id}`);
+    },
+  });
+
   server.route({
     method: 'GET',
     path: '/test-failure',
diff --git a/dev-packages/e2e-tests/test-applications/node-hapi-app/tests/server.test.ts b/dev-packages/e2e-tests/test-applications/node-hapi-app/tests/server.test.ts
index d50c68ac4e72..d0c8c5d19fb7 100644
--- a/dev-packages/e2e-tests/test-applications/node-hapi-app/tests/server.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-hapi-app/tests/server.test.ts
@@ -121,6 +121,20 @@ test('Sends successful transactions to Sentry', async ({ baseURL }) => {
     .toBe(200);
 });
 
+test('sends error with parameterized transaction name', async ({ baseURL }) => {
+  const errorEventPromise = waitForError('node-hapi-app', errorEvent => {
+    return errorEvent?.exception?.values?.[0]?.value === 'This is an error with id 123';
+  });
+
+  try {
+    await axios.get(`${baseURL}/test-error/123`);
+  } catch {}
+
+  const errorEvent = await errorEventPromise;
+
+  expect(errorEvent?.transaction).toBe('GET /test-error/{id}');
+});
+
 test('Sends parameterized transactions to Sentry', async ({ baseURL }) => {
   const pageloadTransactionEventPromise = waitForTransaction('node-hapi-app', transactionEvent => {
     return (
diff --git a/dev-packages/node-integration-tests/suites/tracing/hapi/scenario.js b/dev-packages/node-integration-tests/suites/tracing/hapi/scenario.js
index 69443559e9a8..184dcb3b8ea1 100644
--- a/dev-packages/node-integration-tests/suites/tracing/hapi/scenario.js
+++ b/dev-packages/node-integration-tests/suites/tracing/hapi/scenario.js
@@ -35,6 +35,14 @@ const init = async () => {
     },
   });
 
+  server.route({
+    method: 'GET',
+    path: '/error/{id}',
+    handler: (_request, _h) => {
+      return new Error('Sentry Test Error');
+    },
+  });
+
   server.route({
     method: 'GET',
     path: '/boom-error',
diff --git a/dev-packages/node-integration-tests/suites/tracing/hapi/test.ts b/dev-packages/node-integration-tests/suites/tracing/hapi/test.ts
index e5903c536a95..10967a6d6be2 100644
--- a/dev-packages/node-integration-tests/suites/tracing/hapi/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/hapi/test.ts
@@ -56,6 +56,20 @@ describe('hapi auto-instrumentation', () => {
       .makeRequest('get', '/error');
   });
 
+  test('CJS - should assign parameterized transactionName to error.', done => {
+    createRunner(__dirname, 'scenario.js')
+      .expect({
+        event: {
+          ...EXPECTED_ERROR_EVENT,
+          transaction: 'GET /error/{id}',
+        },
+      })
+      .ignore('transaction')
+      .expectError()
+      .start(done)
+      .makeRequest('get', '/error/123');
+  });
+
   test('CJS - should handle returned Boom errors in routes.', done => {
     createRunner(__dirname, 'scenario.js')
       .expect({
diff --git a/packages/node/src/integrations/tracing/hapi/index.ts b/packages/node/src/integrations/tracing/hapi/index.ts
index ac3766aaae86..c605a6cbd551 100644
--- a/packages/node/src/integrations/tracing/hapi/index.ts
+++ b/packages/node/src/integrations/tracing/hapi/index.ts
@@ -6,9 +6,13 @@ import {
   captureException,
   defineIntegration,
   getActiveSpan,
+  getDefaultIsolationScope,
+  getIsolationScope,
   getRootSpan,
 } from '@sentry/core';
 import type { IntegrationFn } from '@sentry/types';
+import { logger } from '@sentry/utils';
+import { DEBUG_BUILD } from '../../../debug-build';
 import type { Boom, RequestEvent, ResponseObject, Server } from './types';
 
 const _hapiIntegration = (() => {
@@ -58,6 +62,16 @@ export const hapiErrorPlugin = {
     const server = serverArg as unknown as Server;
 
     server.events.on('request', (request, event) => {
+      if (getIsolationScope() !== getDefaultIsolationScope()) {
+        const route = request.route;
+        if (route && route.path) {
+          getIsolationScope().setTransactionName(`${route.method?.toUpperCase() || 'GET'} ${route.path}`);
+        }
+      } else {
+        DEBUG_BUILD &&
+          logger.warn('Isolation scope is still the default isolation scope - skipping setting transactionName');
+      }
+
       const activeSpan = getActiveSpan();
       const rootSpan = activeSpan ? getRootSpan(activeSpan) : undefined;
 

From 0896e4f41400baba321602fd2e9dabd4560d9967 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Tue, 9 Apr 2024 17:32:13 +0200
Subject: [PATCH 28/64] feat(nestjs): Update scope transaction name with
 parameterized route (#11510)

This PR adds scope transactionName updating to our NestJS
instrumentation. Similarly to Hapi and Fastify, we can use a
framework-native component, an Interceptor, to assign the parameterized
route.

ref #10846
---
 .../node-nestjs-app/src/app.controller.ts     |  6 +-
 .../node-nestjs-app/src/app.service.ts        |  4 +-
 .../node-nestjs-app/tests/errors.test.ts      | 10 ++--
 .../nestjs-errors-no-express/scenario.ts      | 58 +++++++++++++++++++
 .../tracing/nestjs-errors-no-express/test.ts  | 39 +++++++++++++
 .../nestjs-errors-no-express/tsconfig.json    |  9 +++
 .../suites/tracing/nestjs-errors/scenario.ts  | 56 ++++++++++++++++++
 .../suites/tracing/nestjs-errors/test.ts      | 39 +++++++++++++
 .../tracing/nestjs-errors/tsconfig.json       |  9 +++
 .../tracing/nestjs-no-express/scenario.ts     | 58 +++++++++++++++++++
 .../suites/tracing/nestjs-no-express/test.ts  | 40 +++++++++++++
 .../tracing/nestjs-no-express/tsconfig.json   |  9 +++
 .../node/src/integrations/tracing/nest.ts     | 42 ++++++++++++--
 13 files changed, 365 insertions(+), 14 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/tsconfig.json
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-errors/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-errors/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-errors/tsconfig.json
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/tsconfig.json

diff --git a/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.controller.ts b/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.controller.ts
index 5dda4845d392..6350cb49f1c5 100644
--- a/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.controller.ts
+++ b/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.controller.ts
@@ -40,9 +40,9 @@ export class AppController1 {
     return this.appService.testError();
   }
 
-  @Get('test-exception')
-  async testException() {
-    return this.appService.testException();
+  @Get('test-exception/:id')
+  async testException(@Param('id') id: string) {
+    return this.appService.testException(id);
   }
 
   @Get('test-outgoing-fetch-external-allowed')
diff --git a/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.service.ts b/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.service.ts
index 387668889c24..79b01f26f51c 100644
--- a/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.service.ts
+++ b/dev-packages/e2e-tests/test-applications/node-nestjs-app/src/app.service.ts
@@ -48,8 +48,8 @@ export class AppService1 {
     return { exceptionId };
   }
 
-  testException() {
-    throw new Error('This is an exception');
+  testException(id: string) {
+    throw new Error(`This is an exception with id ${id}`);
   }
 
   async testOutgoingFetchExternalAllowed() {
diff --git a/dev-packages/e2e-tests/test-applications/node-nestjs-app/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/node-nestjs-app/tests/errors.test.ts
index 8d478c063472..ba7b0cf1849b 100644
--- a/dev-packages/e2e-tests/test-applications/node-nestjs-app/tests/errors.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-nestjs-app/tests/errors.test.ts
@@ -43,11 +43,11 @@ test('Sends captured error to Sentry', async ({ baseURL }) => {
 
 test('Sends exception to Sentry', async ({ baseURL }) => {
   const errorEventPromise = waitForError('node-nestjs-app', event => {
-    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception';
+    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception with id 123';
   });
 
   try {
-    axios.get(`${baseURL}/test-exception`);
+    axios.get(`${baseURL}/test-exception/123`);
   } catch {
     // this results in an error, but we don't care - we want to check the error event
   }
@@ -55,16 +55,16 @@ test('Sends exception to Sentry', async ({ baseURL }) => {
   const errorEvent = await errorEventPromise;
 
   expect(errorEvent.exception?.values).toHaveLength(1);
-  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception');
+  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception with id 123');
 
   expect(errorEvent.request).toEqual({
     method: 'GET',
     cookies: {},
     headers: expect.any(Object),
-    url: 'http://localhost:3030/test-exception',
+    url: 'http://localhost:3030/test-exception/123',
   });
 
-  expect(errorEvent.transaction).toEqual('GET /test-exception');
+  expect(errorEvent.transaction).toEqual('GET /test-exception/:id');
 
   expect(errorEvent.contexts?.trace).toEqual({
     trace_id: expect.any(String),
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/scenario.ts
new file mode 100644
index 000000000000..bcf4c3adb432
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/scenario.ts
@@ -0,0 +1,58 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck These are only tests
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/explicit-member-accessibility */
+import { loggingTransport, sendPortToRunner } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 0,
+  transport: loggingTransport,
+  integrations: integrations => integrations.filter(i => i.name !== 'Express'),
+  debug: true,
+});
+
+import { Controller, Get, Injectable, Module, Param } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+const port = 3480;
+
+// Stop the process from exiting before the transaction is sent
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+setInterval(() => {}, 1000);
+
+@Injectable()
+class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+
+@Controller()
+class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get('test-exception/:id')
+  async testException(@Param('id') id: string): void {
+    Sentry.captureException(new Error(`error with id ${id}`));
+  }
+}
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+class AppModule {}
+
+async function init(): Promise<void> {
+  const app = await NestFactory.create(AppModule);
+  Sentry.setupNestErrorHandler(app);
+  await app.listen(port);
+  sendPortToRunner(port);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+init();
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/test.ts b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/test.ts
new file mode 100644
index 000000000000..f38550469446
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/test.ts
@@ -0,0 +1,39 @@
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+jest.setTimeout(20000);
+
+const { TS_VERSION } = process.env;
+const isOldTS = TS_VERSION && TS_VERSION.startsWith('3.');
+
+// This is required to run the test with ts-node and decorators
+process.env.TS_NODE_PROJECT = `${__dirname}/tsconfig.json`;
+
+conditionalTest({ min: 16 })('nestjs auto instrumentation', () => {
+  afterAll(async () => {
+    cleanupChildProcesses();
+  });
+
+  test("should assign scope's transactionName if spans are not sampled and express integration is disabled", done => {
+    if (isOldTS) {
+      // Skipping test on old TypeScript
+      return done();
+    }
+
+    createRunner(__dirname, 'scenario.ts')
+      .expect({
+        event: {
+          exception: {
+            values: [
+              {
+                value: 'error with id 456',
+              },
+            ],
+          },
+          transaction: 'GET /test-exception/:id',
+        },
+      })
+      .start(done)
+      .makeRequest('get', '/test-exception/456');
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/tsconfig.json b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/tsconfig.json
new file mode 100644
index 000000000000..84b8f8d6c44e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors-no-express/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "include": ["scenario.ts"],
+  "compilerOptions": {
+    "module": "commonjs",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021",
+  }
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/scenario.ts
new file mode 100644
index 000000000000..8a00c25fab7a
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/scenario.ts
@@ -0,0 +1,56 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck These are only tests
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/explicit-member-accessibility */
+import { loggingTransport, sendPortToRunner } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 0,
+  transport: loggingTransport,
+});
+
+import { Controller, Get, Injectable, Module, Param } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+const port = 3460;
+
+// Stop the process from exiting before the transaction is sent
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+setInterval(() => {}, 1000);
+
+@Injectable()
+class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+
+@Controller()
+class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get('test-exception/:id')
+  async testException(@Param('id') id: string): void {
+    Sentry.captureException(new Error(`error with id ${id}`));
+  }
+}
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+class AppModule {}
+
+async function init(): Promise<void> {
+  const app = await NestFactory.create(AppModule);
+  Sentry.setupNestErrorHandler(app);
+  await app.listen(port);
+  sendPortToRunner(port);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+init();
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/test.ts b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/test.ts
new file mode 100644
index 000000000000..264cbe1482cc
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/test.ts
@@ -0,0 +1,39 @@
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+jest.setTimeout(20000);
+
+const { TS_VERSION } = process.env;
+const isOldTS = TS_VERSION && TS_VERSION.startsWith('3.');
+
+// This is required to run the test with ts-node and decorators
+process.env.TS_NODE_PROJECT = `${__dirname}/tsconfig.json`;
+
+conditionalTest({ min: 16 })('nestjs auto instrumentation', () => {
+  afterAll(async () => {
+    cleanupChildProcesses();
+  });
+
+  test("should assign scope's transactionName if spans are not sampled", done => {
+    if (isOldTS) {
+      // Skipping test on old TypeScript
+      return done();
+    }
+
+    createRunner(__dirname, 'scenario.ts')
+      .expect({
+        event: {
+          exception: {
+            values: [
+              {
+                value: 'error with id 123',
+              },
+            ],
+          },
+          transaction: 'GET /test-exception/:id',
+        },
+      })
+      .start(done)
+      .makeRequest('get', '/test-exception/123');
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/tsconfig.json b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/tsconfig.json
new file mode 100644
index 000000000000..84b8f8d6c44e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-errors/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "include": ["scenario.ts"],
+  "compilerOptions": {
+    "module": "commonjs",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021",
+  }
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/scenario.ts
new file mode 100644
index 000000000000..cffc8de263d2
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/scenario.ts
@@ -0,0 +1,58 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck These are only tests
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/explicit-member-accessibility */
+import { loggingTransport, sendPortToRunner } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1,
+  transport: loggingTransport,
+  integrations: integrations => integrations.filter(i => i.name !== 'Express'),
+  debug: true,
+});
+
+import { Controller, Get, Injectable, Module, Param } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+const port = 3470;
+
+// Stop the process from exiting before the transaction is sent
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+setInterval(() => {}, 1000);
+
+@Injectable()
+class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+
+@Controller()
+class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get('test-exception/:id')
+  async testException(@Param('id') id: string): void {
+    Sentry.captureException(new Error(`error with id ${id}`));
+  }
+}
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+class AppModule {}
+
+async function init(): Promise<void> {
+  const app = await NestFactory.create(AppModule);
+  Sentry.setupNestErrorHandler(app);
+  await app.listen(port);
+  sendPortToRunner(port);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+init();
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/test.ts b/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/test.ts
new file mode 100644
index 000000000000..70eb9e9aaa26
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/test.ts
@@ -0,0 +1,40 @@
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+jest.setTimeout(20000);
+
+const { TS_VERSION } = process.env;
+const isOldTS = TS_VERSION && TS_VERSION.startsWith('3.');
+
+// This is required to run the test with ts-node and decorators
+process.env.TS_NODE_PROJECT = `${__dirname}/tsconfig.json`;
+
+conditionalTest({ min: 16 })('nestjs auto instrumentation', () => {
+  afterAll(async () => {
+    cleanupChildProcesses();
+  });
+
+  test("should assign scope's transactionName if express integration is disabled", done => {
+    if (isOldTS) {
+      // Skipping test on old TypeScript
+      return done();
+    }
+
+    createRunner(__dirname, 'scenario.ts')
+      .ignore('transaction')
+      .expect({
+        event: {
+          exception: {
+            values: [
+              {
+                value: 'error with id 456',
+              },
+            ],
+          },
+          transaction: 'GET /test-exception/:id',
+        },
+      })
+      .start(done)
+      .makeRequest('get', '/test-exception/456');
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/tsconfig.json b/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/tsconfig.json
new file mode 100644
index 000000000000..84b8f8d6c44e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/nestjs-no-express/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "include": ["scenario.ts"],
+  "compilerOptions": {
+    "module": "commonjs",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021",
+  }
+}
diff --git a/packages/node/src/integrations/tracing/nest.ts b/packages/node/src/integrations/tracing/nest.ts
index fb9a211b2a1e..2371c4e93e35 100644
--- a/packages/node/src/integrations/tracing/nest.ts
+++ b/packages/node/src/integrations/tracing/nest.ts
@@ -1,7 +1,28 @@
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { NestInstrumentation } from '@opentelemetry/instrumentation-nestjs-core';
-import { captureException, defineIntegration } from '@sentry/core';
+import { captureException, defineIntegration, getDefaultIsolationScope, getIsolationScope } from '@sentry/core';
 import type { IntegrationFn } from '@sentry/types';
+import { logger } from '@sentry/utils';
+
+interface MinimalNestJsExecutionContext {
+  switchToHttp: () => {
+    // minimal request object
+    // according to official types, all properties are required but
+    // let's play it safe and assume they're optional
+    getRequest: () => {
+      route?: {
+        path?: string;
+      };
+      method?: string;
+    };
+  };
+}
+interface MinimalNestJsApp {
+  useGlobalFilters: (arg0: { catch(exception: unknown): void }) => void;
+  useGlobalInterceptors: (interceptor: {
+    intercept: (context: MinimalNestJsExecutionContext, next: { handle: () => void }) => void;
+  }) => void;
+}
 
 const _nestIntegration = (() => {
   return {
@@ -30,8 +51,21 @@ const SentryNestExceptionFilter = {
 /**
  * Setup an error handler for Nest.
  */
-export function setupNestErrorHandler(app: {
-  useGlobalFilters: (arg0: { catch(exception: unknown): void }) => void;
-}): void {
+export function setupNestErrorHandler(app: MinimalNestJsApp): void {
+  app.useGlobalInterceptors({
+    intercept(context, next) {
+      if (getIsolationScope() === getDefaultIsolationScope()) {
+        logger.warn('Isolation scope is still the default isolation scope, skipping setting transactionName.');
+        return next.handle();
+      }
+
+      const req = context.switchToHttp().getRequest();
+      if (req.route) {
+        getIsolationScope().setTransactionName(`${req.method?.toUpperCase() || 'GET'} ${req.route.path}`);
+      }
+      return next.handle();
+    },
+  });
+
   app.useGlobalFilters(SentryNestExceptionFilter);
 }

From 28b7d7557db4766dbde60b373264b8ecb3382556 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Tue, 9 Apr 2024 17:33:15 +0200
Subject: [PATCH 29/64] feat(fastify): Update scope `transactionName` when
 handling request (#11447)

This PR updates the isolation scope's `transactionName` by adding another
hook callback in our `setupFastifyErrorHandler` fastify plugin. This is
better than accessing the otel span for two reasons:

1. We can always update the transactionName, not just when a span is
sampled and recording
2. The `onRequest` hook is executed earlier in the lifecycle than the
`preHandler` hook that Otel uses to trigger the `requestHook` callback.
---
 .../node-fastify-app/src/app.js               |  4 +--
 .../node-fastify-app/tests/errors.test.ts     | 10 +++----
 .../tests/transactions.test.ts                | 17 +++++++++++
 .../node/src/integrations/tracing/fastify.ts  | 29 ++++++++++++++++++-
 4 files changed, 52 insertions(+), 8 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js b/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js
index ded1a2de7fcb..dbb239a4e340 100644
--- a/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js
@@ -55,8 +55,8 @@ app.get('/test-error', async function (req, res) {
   res.send({ exceptionId });
 });
 
-app.get('/test-exception', async function (req, res) {
-  throw new Error('This is an exception');
+app.get('/test-exception/:id', async function (req, res) {
+  throw new Error(`This is an exception with id ${req.params.id}`);
 });
 
 app.get('/test-outgoing-fetch-external-allowed', async function (req, res) {
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/errors.test.ts
index e9ee378fa00f..8a4dd6c9bcd7 100644
--- a/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/errors.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/errors.test.ts
@@ -41,11 +41,11 @@ test('Sends exception to Sentry', async ({ baseURL }) => {
 
 test('Sends correct error event', async ({ baseURL }) => {
   const errorEventPromise = waitForError('node-fastify-app', event => {
-    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception';
+    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception with id 123';
   });
 
   try {
-    await axios.get(`${baseURL}/test-exception`);
+    await axios.get(`${baseURL}/test-exception/123`);
   } catch {
     // this results in an error, but we don't care - we want to check the error event
   }
@@ -53,16 +53,16 @@ test('Sends correct error event', async ({ baseURL }) => {
   const errorEvent = await errorEventPromise;
 
   expect(errorEvent.exception?.values).toHaveLength(1);
-  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception');
+  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception with id 123');
 
   expect(errorEvent.request).toEqual({
     method: 'GET',
     cookies: {},
     headers: expect.any(Object),
-    url: 'http://localhost:3030/test-exception',
+    url: 'http://localhost:3030/test-exception/123',
   });
 
-  expect(errorEvent.transaction).toEqual('GET /test-exception');
+  expect(errorEvent.transaction).toEqual('GET /test-exception/:id');
 
   expect(errorEvent.contexts?.trace).toEqual({
     trace_id: expect.any(String),
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/transactions.test.ts b/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/transactions.test.ts
index 6d3ca7e8d6fd..0e2fe4f2215b 100644
--- a/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/transactions.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-app/tests/transactions.test.ts
@@ -56,6 +56,23 @@ test('Sends an API route transaction', async ({ baseURL }) => {
   expect(transactionEvent).toEqual(
     expect.objectContaining({
       spans: [
+        {
+          data: {
+            'plugin.name': 'fastify -> sentry-fastify-error-handler',
+            'fastify.type': 'middleware',
+            'hook.name': 'onRequest',
+            'otel.kind': 'INTERNAL',
+            'sentry.origin': 'manual',
+          },
+          description: 'middleware - fastify -> sentry-fastify-error-handler',
+          parent_span_id: expect.any(String),
+          span_id: expect.any(String),
+          start_timestamp: expect.any(Number),
+          status: 'ok',
+          timestamp: expect.any(Number),
+          trace_id: expect.any(String),
+          origin: 'manual',
+        },
         {
           data: {
             'plugin.name': 'fastify -> sentry-fastify-error-handler',
diff --git a/packages/node/src/integrations/tracing/fastify.ts b/packages/node/src/integrations/tracing/fastify.ts
index 3da89599401a..87a820bd238e 100644
--- a/packages/node/src/integrations/tracing/fastify.ts
+++ b/packages/node/src/integrations/tracing/fastify.ts
@@ -1,6 +1,6 @@
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { FastifyInstrumentation } from '@opentelemetry/instrumentation-fastify';
-import { captureException, defineIntegration } from '@sentry/core';
+import { captureException, defineIntegration, getIsolationScope } from '@sentry/core';
 import type { IntegrationFn } from '@sentry/types';
 
 import { addOriginToSpan } from '../../utils/addOriginToSpan';
@@ -35,6 +35,19 @@ interface Fastify {
   addHook: (hook: string, handler: (request: unknown, reply: unknown, error: Error) => void) => void;
 }
 
+/**
+ * Minimal request type containing properties around route information.
+ * Works for Fastify 3, 4 and presumably 5.
+ */
+interface FastifyRequestRouteInfo {
+  // since fastify@4.10.0
+  routeOptions?: {
+    url?: string;
+    method?: string;
+  };
+  routerPath?: string;
+}
+
 /**
  * Setup an error handler for Fastify.
  */
@@ -45,6 +58,20 @@ export function setupFastifyErrorHandler(fastify: Fastify): void {
         captureException(error);
       });
 
+      // registering `onRequest` hook here instead of using Otel `onRequest` callback b/c `onRequest` hook
+      // is ironically called in the fastify `preHandler` hook which is called later in the lifecycle:
+      // https://fastify.dev/docs/latest/Reference/Lifecycle/
+      fastify.addHook('onRequest', async (request, _reply) => {
+        const reqWithRouteInfo = request as FastifyRequestRouteInfo;
+
+        // Taken from Otel Fastify instrumentation:
+        // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/main/plugins/node/opentelemetry-instrumentation-fastify/src/instrumentation.ts#L94-L96
+        const routeName = reqWithRouteInfo.routeOptions?.url || reqWithRouteInfo.routerPath;
+        const method = reqWithRouteInfo.routeOptions?.method || 'GET';
+
+        getIsolationScope().setTransactionName(`${method} ${routeName}`);
+      });
+
       done();
     },
     {

From 2b09f91b2273b0412808918ea6abc4d03f956336 Mon Sep 17 00:00:00 2001
From: Ryan Albrecht <ryan.albrecht@sentry.io>
Date: Tue, 9 Apr 2024 09:12:43 -0700
Subject: [PATCH 30/64] feat(feedback): Maintain v7 compat in the
 @sentry-internal/feedback package (#11461)

Proceeding along the [plan to get feedback screenshots async
loading](https://github.com/getsentry/sentry-javascript/issues/11435#issuecomment-2038271957),
this PR imports the feedback modal back into the main package, so we can
maintain compatibility with the v7 version of the sdk, which did the
same.
---
 .size-limit.js                            | 10 +++++-----
 packages/feedback/src/core/integration.ts |  6 ++++--
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/.size-limit.js b/.size-limit.js
index 7fd6db3be736..d102cf8d63b0 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -52,28 +52,28 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'browserTracingIntegration', 'replayIntegration', 'feedbackIntegration'),
     gzip: true,
-    limit: '80 KB',
+    limit: '83 KB',
   },
   {
     name: '@sentry/browser (incl. Feedback)',
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'feedbackIntegration'),
     gzip: true,
-    limit: '35 KB',
+    limit: '37 KB',
   },
   {
     name: '@sentry/browser (incl. Feedback, Feedback Modal)',
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'feedbackIntegration', 'feedbackModalIntegration'),
     gzip: true,
-    limit: '35 KB',
+    limit: '37 KB',
   },
   {
     name: '@sentry/browser (incl. Feedback, Feedback Modal, Feedback Screenshot)',
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'feedbackIntegration', 'feedbackModalIntegration', 'feedbackScreenshotIntegration'),
     gzip: true,
-    limit: '35 KB',
+    limit: '37 KB',
   },
   {
     name: '@sentry/browser (incl. sendFeedback)',
@@ -143,7 +143,7 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing, Replay, Feedback)',
     path: createCDNPath('bundle.tracing.replay.feedback.min.js'),
     gzip: true,
-    limit: '75 KB',
+    limit: '83 KB',
   },
   // browser CDN bundles (non-gzipped)
   {
diff --git a/packages/feedback/src/core/integration.ts b/packages/feedback/src/core/integration.ts
index e39b032bbc85..b4a513ab3b9f 100644
--- a/packages/feedback/src/core/integration.ts
+++ b/packages/feedback/src/core/integration.ts
@@ -23,6 +23,7 @@ import {
   SUBMIT_BUTTON_LABEL,
   SUCCESS_MESSAGE_TEXT,
 } from '../constants';
+import { feedbackModalIntegration } from '../modal/integration';
 import { DEBUG_BUILD } from '../util/debug-build';
 import { isScreenshotSupported } from '../util/isScreenshotSupported';
 import { mergeOptions } from '../util/mergeOptions';
@@ -43,7 +44,7 @@ export const feedbackIntegration = (({
   autoInject = true,
   showEmail = true,
   showName = true,
-  showScreenshot = true,
+  showScreenshot = false,
   useSentryUser = {
     email: 'email',
     name: 'username',
@@ -141,7 +142,8 @@ export const feedbackIntegration = (({
     if (!client) {
       throw new Error('Sentry Client is not initialized correctly');
     }
-    const modalIntegration = client.getIntegrationByName<FeedbackModalIntegration>('FeedbackModal');
+    const modalIntegration: FeedbackModalIntegration = feedbackModalIntegration();
+    client.addIntegration(modalIntegration);
     const screenshotIntegration = client.getIntegrationByName<FeedbackScreenshotIntegration>('FeedbackScreenshot');
     const screenshotIsSupported = isScreenshotSupported();
 

From db18496791b6209f1125e0cdaf074a71352a79b6 Mon Sep 17 00:00:00 2001
From: Catherine Lee <55311782+c298lee@users.noreply.github.com>
Date: Tue, 9 Apr 2024 12:39:10 -0400
Subject: [PATCH 31/64] feat(feedback): Customize feedback placeholder text
 color (#11417)

Some browsers have a default gray colour for placeholder text. Added a
color and opacity style to placeholders so that the placeholder text is
lighter than input text.

|Before|After|
|------|------|
|<img width="304" alt="image"
src="https://github.com/getsentry/sentry-javascript/assets/55311782/dc6b218c-972f-429d-a214-1891e60b69e5">|<img
width="304" alt="image"
src="https://github.com/getsentry/sentry-javascript/assets/55311782/7dbadb0d-ef52-4203-b928-b7b1253e7552">|
|<img width="326" alt="image"
src="https://github.com/getsentry/sentry-javascript/assets/55311782/f1bf87e9-fabb-439e-a10c-94a92b5a9b9f">|<img
width="326" alt="image"
src="https://github.com/getsentry/sentry-javascript/assets/55311782/93a91c23-81d3-4203-89d1-495be1380371">|

Fixes https://github.com/getsentry/sentry-javascript/issues/10190
---
 packages/feedback/src/modal/components/Dialog.css.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/packages/feedback/src/modal/components/Dialog.css.ts b/packages/feedback/src/modal/components/Dialog.css.ts
index 9a8e3dc8aa68..037f64310120 100644
--- a/packages/feedback/src/modal/components/Dialog.css.ts
+++ b/packages/feedback/src/modal/components/Dialog.css.ts
@@ -133,6 +133,11 @@ export function createDialogStyles(): HTMLStyleElement {
   padding: 6px 12px;
 }
 
+.form__input::placeholder {
+  color: var(--input-foreground);
+  opacity: 0.65;
+}
+
 .form__input:focus-visible {
   outline: 1px auto var(--input-outline-focus);
 }

From 5542127d21e533ae694263d50291857ad08d6f15 Mon Sep 17 00:00:00 2001
From: Ryan Albrecht <ryan.albrecht@sentry.io>
Date: Tue, 9 Apr 2024 11:35:16 -0700
Subject: [PATCH 32/64] ref(feedback): Create stub integrations for feedback
 modal & screenshot integrations (#11342)

We're planning to split up the modal and screenshot functionality of the
feedback widget into their own integrations, so they can be loaded async
if folks want to do that. Loading async would have the benefit that the
code is only needed when the user interacts with the feedback widget,
and we're actually going to render the modal whether that be with or
without the screenshot input/editor.

This PR sets up some stubs for where the code will live. There's a bunch
of boilerplate for the new integrations inside packages/* and also lots
of exports to setup so that the stubs are available to be imported into
apps.

Currently if someone wanted to setup feedback with screenshots they
would be doing:
```javascript
import * as Sentry from "@sentry/browser";
import {feedbackIntegration, feedbackModalIntegration, feedbackScreenshotIntegration} from '@sentry-internal/feedback';

...
  integrations: [
    feedbackIntegration(),
    feedbackModalIntegration(),
    feedbackScreenshotIntegration(),
  ]
```

**After this PR people will keep doing that.**

In a followup PR we'll move the implementation from
`@sentry-internal/feedback` into the new
`@sentry-internal/feedback-modal` and
`@sentry-internal/feedback-screenshot`, so people will be able to do
this instead:
```diff
  import * as Sentry from "@sentry/browser";
- import {feedbackIntegration, feedbackModalIntegration, feedbackScreenshotIntegration} from '@sentry-internal/feedback';
+ import {feedbackIntegration} from '@sentry-internal/feedback';
+ import {feedbackModalIntegration} from '@sentry-internal/feedback-modal';
+ import {feedbackScreenshotIntegration} from '@sentry-internal/feedback-screenshot';

  ...
    integrations: [
      feedbackIntegration(),
      feedbackModalIntegration(),
      feedbackScreenshotIntegration(),
    ]
```
Equally valid, is people will be able to import everything from
`@sentry/browser` too, ie `import * as Sentry from "@sentry/browser";`
with `Sentry.feedbackScreenshotIntegration()`

Related to https://github.com/getsentry/sentry-javascript/issues/11435
---
 .craft.yml                                    | 10 ++-
 .github/workflows/build.yml                   |  2 +
 CODEOWNERS                                    |  2 +
 package.json                                  |  2 +
 packages/browser/package.json                 |  2 +
 packages/browser/src/index.bundle.feedback.ts |  4 +
 packages/browser/src/index.bundle.replay.ts   |  4 +
 .../index.bundle.tracing.replay.feedback.ts   |  4 +
 .../src/index.bundle.tracing.replay.ts        |  8 +-
 packages/browser/src/index.bundle.tracing.ts  |  9 ++-
 packages/browser/src/index.bundle.ts          |  4 +
 packages/browser/src/index.ts                 |  2 +
 .../test/unit/index.bundle.feedback.test.ts   | 10 ++-
 .../test/unit/index.bundle.replay.test.ts     | 14 +++-
 .../browser/test/unit/index.bundle.test.ts    | 15 +++-
 ...dex.bundle.tracing.replay.feedback.test.ts |  9 ++-
 .../unit/index.bundle.tracing.replay.test.ts  |  8 +-
 .../test/unit/index.bundle.tracing.test.ts    |  9 ++-
 packages/feedback-modal/.eslintignore         |  2 +
 packages/feedback-modal/.eslintrc.js          | 16 ++++
 packages/feedback-modal/.gitignore            |  4 +
 packages/feedback-modal/LICENSE               | 14 ++++
 packages/feedback-modal/README.md             | 14 ++++
 packages/feedback-modal/jest.config.js        |  6 ++
 packages/feedback-modal/package.json          | 76 +++++++++++++++++++
 .../feedback-modal/rollup.bundle.config.mjs   | 15 ++++
 packages/feedback-modal/rollup.npm.config.mjs | 20 +++++
 .../scripts/shim-preact-export.js             | 75 ++++++++++++++++++
 packages/feedback-modal/src/index.ts          |  1 +
 .../src/modal/integration.test.ts             |  8 ++
 .../feedback-modal/src/modal/integration.ts   | 15 ++++
 packages/feedback-modal/tsconfig.json         | 17 +++++
 packages/feedback-modal/tsconfig.test.json    | 15 ++++
 packages/feedback-modal/tsconfig.types.json   | 10 +++
 packages/feedback-screenshot/.eslintignore    |  2 +
 packages/feedback-screenshot/.eslintrc.js     | 16 ++++
 packages/feedback-screenshot/.gitignore       |  4 +
 packages/feedback-screenshot/LICENSE          | 14 ++++
 packages/feedback-screenshot/README.md        | 14 ++++
 packages/feedback-screenshot/jest.config.js   |  6 ++
 packages/feedback-screenshot/package.json     | 76 +++++++++++++++++++
 .../rollup.bundle.config.mjs                  | 15 ++++
 .../feedback-screenshot/rollup.npm.config.mjs | 20 +++++
 .../scripts/shim-preact-export.js             | 75 ++++++++++++++++++
 packages/feedback-screenshot/src/index.ts     |  1 +
 .../src/screenshot/integration.test.ts        |  8 ++
 .../src/screenshot/integration.ts             | 15 ++++
 packages/feedback-screenshot/tsconfig.json    | 17 +++++
 .../feedback-screenshot/tsconfig.test.json    | 15 ++++
 .../feedback-screenshot/tsconfig.types.json   | 10 +++
 packages/integration-shims/src/Feedback.ts    | 28 +++++++
 packages/integration-shims/src/index.ts       |  2 +-
 packages/nextjs/test/integration/package.json |  2 +
 packages/remix/test/integration/package.json  |  2 +
 54 files changed, 749 insertions(+), 19 deletions(-)
 create mode 100644 packages/feedback-modal/.eslintignore
 create mode 100644 packages/feedback-modal/.eslintrc.js
 create mode 100644 packages/feedback-modal/.gitignore
 create mode 100644 packages/feedback-modal/LICENSE
 create mode 100644 packages/feedback-modal/README.md
 create mode 100644 packages/feedback-modal/jest.config.js
 create mode 100644 packages/feedback-modal/package.json
 create mode 100644 packages/feedback-modal/rollup.bundle.config.mjs
 create mode 100644 packages/feedback-modal/rollup.npm.config.mjs
 create mode 100644 packages/feedback-modal/scripts/shim-preact-export.js
 create mode 100644 packages/feedback-modal/src/index.ts
 create mode 100644 packages/feedback-modal/src/modal/integration.test.ts
 create mode 100644 packages/feedback-modal/src/modal/integration.ts
 create mode 100644 packages/feedback-modal/tsconfig.json
 create mode 100644 packages/feedback-modal/tsconfig.test.json
 create mode 100644 packages/feedback-modal/tsconfig.types.json
 create mode 100644 packages/feedback-screenshot/.eslintignore
 create mode 100644 packages/feedback-screenshot/.eslintrc.js
 create mode 100644 packages/feedback-screenshot/.gitignore
 create mode 100644 packages/feedback-screenshot/LICENSE
 create mode 100644 packages/feedback-screenshot/README.md
 create mode 100644 packages/feedback-screenshot/jest.config.js
 create mode 100644 packages/feedback-screenshot/package.json
 create mode 100644 packages/feedback-screenshot/rollup.bundle.config.mjs
 create mode 100644 packages/feedback-screenshot/rollup.npm.config.mjs
 create mode 100644 packages/feedback-screenshot/scripts/shim-preact-export.js
 create mode 100644 packages/feedback-screenshot/src/index.ts
 create mode 100644 packages/feedback-screenshot/src/screenshot/integration.test.ts
 create mode 100644 packages/feedback-screenshot/src/screenshot/integration.ts
 create mode 100644 packages/feedback-screenshot/tsconfig.json
 create mode 100644 packages/feedback-screenshot/tsconfig.test.json
 create mode 100644 packages/feedback-screenshot/tsconfig.types.json

diff --git a/.craft.yml b/.craft.yml
index bc1446711d2c..820c50f199fd 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -32,7 +32,15 @@ targets:
   - name: npm
     id: '@sentry-internal/feedback'
     includeNames: /^sentry-internal-feedback-\d.*\.tgz$/
-  ## 1.8 ReplayCanvas package (browser only)
+  ## 1.8 Feedback Modal package (browser only)
+  - name: npm
+    id: '@sentry-internal/feedback-modal'
+    includeNames: /^sentry-internal-feedback-modal-\d.*\.tgz$/
+  ## 1.9 Feedback Screenshot package (browser only)
+  - name: npm
+    id: '@sentry-internal/feedback-screenshot'
+    includeNames: /^sentry-internal-feedback-screenshot-\d.*\.tgz$/
+  ## 1.10 ReplayCanvas package (browser only)
   - name: npm
     id: '@sentry-internal/replay-canvas'
     includeNames: /^sentry-internal-replay-canvas-\d.*\.tgz$/
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index b131d8cb2717..ddaeed70dab9 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -105,6 +105,8 @@ jobs:
               - 'packages/replay/**'
               - 'packages/replay-canvas/**'
               - 'packages/feedback/**'
+              - 'packages/feedback-modal/**'
+              - 'packages/feedback-screenshot/**'
               - 'packages/wasm/**'
             browser_integration:
               - *shared
diff --git a/CODEOWNERS b/CODEOWNERS
index 6ae2679deafa..0cbff3b53444 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -2,4 +2,6 @@ packages/replay                                   @getsentry/replay-sdk-web
 packages/replay-worker                            @getsentry/replay-sdk-web
 packages/replay-canvas                            @getsentry/replay-sdk-web
 packages/feedback                                 @getsentry/replay-sdk-web
+packages/feedback-modal                           @getsentry/replay-sdk-web
+packages/feedback-screenshot                      @getsentry/replay-sdk-web
 dev-packages/browser-integration-tests/suites/replay  @getsentry/replay-sdk-web
diff --git a/package.json b/package.json
index 00945d179e72..91351e047d3a 100644
--- a/package.json
+++ b/package.json
@@ -56,6 +56,8 @@
     "packages/eslint-config-sdk",
     "packages/eslint-plugin-sdk",
     "packages/feedback",
+    "packages/feedback-modal",
+    "packages/feedback-screenshot",
     "packages/gatsby",
     "packages/google-cloud-serverless",
     "packages/integration-shims",
diff --git a/packages/browser/package.json b/packages/browser/package.json
index d748c97dff02..927cbd41a045 100644
--- a/packages/browser/package.json
+++ b/packages/browser/package.json
@@ -43,6 +43,8 @@
   },
   "dependencies": {
     "@sentry-internal/browser-utils": "8.0.0-alpha.9",
+    "@sentry-internal/feedback-modal": "8.0.0-alpha.9",
+    "@sentry-internal/feedback-screenshot": "8.0.0-alpha.9",
     "@sentry-internal/feedback": "8.0.0-alpha.9",
     "@sentry-internal/replay": "8.0.0-alpha.9",
     "@sentry-internal/replay-canvas": "8.0.0-alpha.9",
diff --git a/packages/browser/src/index.bundle.feedback.ts b/packages/browser/src/index.bundle.feedback.ts
index de24e36e2a60..193cac1a5f06 100644
--- a/packages/browser/src/index.bundle.feedback.ts
+++ b/packages/browser/src/index.bundle.feedback.ts
@@ -1,5 +1,7 @@
 // This is exported so the loader does not fail when switching off Replay/Tracing
 import { feedbackIntegration, getFeedback } from '@sentry-internal/feedback';
+import { feedbackModalIntegration } from '@sentry-internal/feedback-modal';
+import { feedbackScreenshotIntegration } from '@sentry-internal/feedback-screenshot';
 import {
   addTracingExtensionsShim,
   browserTracingIntegrationShim,
@@ -12,6 +14,8 @@ export {
   addTracingExtensionsShim as addTracingExtensions,
   replayIntegrationShim as replayIntegration,
   feedbackIntegration,
+  feedbackModalIntegration,
+  feedbackScreenshotIntegration,
   getFeedback,
 };
 // Note: We do not export a shim for `Span` here, as that is quite complex and would blow up the bundle
diff --git a/packages/browser/src/index.bundle.replay.ts b/packages/browser/src/index.bundle.replay.ts
index ec0a50c92905..0c0bb6ca40ef 100644
--- a/packages/browser/src/index.bundle.replay.ts
+++ b/packages/browser/src/index.bundle.replay.ts
@@ -3,6 +3,8 @@ import {
   addTracingExtensionsShim,
   browserTracingIntegrationShim,
   feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
 } from '@sentry-internal/integration-shims';
 import { replayIntegration } from '@sentry-internal/replay';
 
@@ -12,5 +14,7 @@ export {
   addTracingExtensionsShim as addTracingExtensions,
   replayIntegration,
   feedbackIntegrationShim as feedbackIntegration,
+  feedbackModalIntegrationShim as feedbackModalIntegration,
+  feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
 };
 // Note: We do not export a shim for `Span` here, as that is quite complex and would blow up the bundle
diff --git a/packages/browser/src/index.bundle.tracing.replay.feedback.ts b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
index 6133fc2870f5..d26ccf1ba230 100644
--- a/packages/browser/src/index.bundle.tracing.replay.feedback.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
@@ -4,6 +4,8 @@ import {
   startBrowserTracingPageLoadSpan,
 } from '@sentry-internal/browser-utils';
 import { feedbackIntegration, getFeedback } from '@sentry-internal/feedback';
+import { feedbackModalIntegration } from '@sentry-internal/feedback-modal';
+import { feedbackScreenshotIntegration } from '@sentry-internal/feedback-screenshot';
 import { replayIntegration } from '@sentry-internal/replay';
 import { addTracingExtensions } from '@sentry/core';
 
@@ -23,6 +25,8 @@ export {
 
 export {
   feedbackIntegration,
+  feedbackModalIntegration,
+  feedbackScreenshotIntegration,
   replayIntegration,
   browserTracingIntegration,
   addTracingExtensions,
diff --git a/packages/browser/src/index.bundle.tracing.replay.ts b/packages/browser/src/index.bundle.tracing.replay.ts
index f949ea43541a..628ebeb19651 100644
--- a/packages/browser/src/index.bundle.tracing.replay.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.ts
@@ -3,7 +3,11 @@ import {
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
 } from '@sentry-internal/browser-utils';
-import { feedbackIntegrationShim } from '@sentry-internal/integration-shims';
+import {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+} from '@sentry-internal/integration-shims';
 import { replayIntegration } from '@sentry-internal/replay';
 import { addTracingExtensions } from '@sentry/core';
 
@@ -24,6 +28,8 @@ export {
 export {
   replayIntegration,
   feedbackIntegrationShim as feedbackIntegration,
+  feedbackModalIntegrationShim as feedbackModalIntegration,
+  feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
   browserTracingIntegration,
   addTracingExtensions,
   startBrowserTracingNavigationSpan,
diff --git a/packages/browser/src/index.bundle.tracing.ts b/packages/browser/src/index.bundle.tracing.ts
index 1b4f89f935df..29c463fae586 100644
--- a/packages/browser/src/index.bundle.tracing.ts
+++ b/packages/browser/src/index.bundle.tracing.ts
@@ -4,7 +4,12 @@ import {
   startBrowserTracingPageLoadSpan,
 } from '@sentry-internal/browser-utils';
 // This is exported so the loader does not fail when switching off Replay
-import { feedbackIntegrationShim, replayIntegrationShim } from '@sentry-internal/integration-shims';
+import {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+  replayIntegrationShim,
+} from '@sentry-internal/integration-shims';
 import { addTracingExtensions } from '@sentry/core';
 
 // We are patching the global object with our hub extension methods
@@ -23,6 +28,8 @@ export {
 
 export {
   feedbackIntegrationShim as feedbackIntegration,
+  feedbackModalIntegrationShim as feedbackModalIntegration,
+  feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
   replayIntegrationShim as replayIntegration,
   browserTracingIntegration,
   addTracingExtensions,
diff --git a/packages/browser/src/index.bundle.ts b/packages/browser/src/index.bundle.ts
index b27672414b20..10482f8135cf 100644
--- a/packages/browser/src/index.bundle.ts
+++ b/packages/browser/src/index.bundle.ts
@@ -3,6 +3,8 @@ import {
   addTracingExtensionsShim,
   browserTracingIntegrationShim,
   feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
   replayIntegrationShim,
 } from '@sentry-internal/integration-shims';
 
@@ -11,6 +13,8 @@ export {
   addTracingExtensionsShim as addTracingExtensions,
   browserTracingIntegrationShim as browserTracingIntegration,
   feedbackIntegrationShim as feedbackIntegration,
+  feedbackModalIntegrationShim as feedbackModalIntegration,
+  feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
   replayIntegrationShim as replayIntegration,
 };
 // Note: We do not export a shim for `Span` here, as that is quite complex and would blow up the bundle
diff --git a/packages/browser/src/index.ts b/packages/browser/src/index.ts
index 54dd27f8b8b5..8d8069d2460c 100644
--- a/packages/browser/src/index.ts
+++ b/packages/browser/src/index.ts
@@ -35,6 +35,8 @@ export {
   getFeedback,
   sendFeedback,
 } from '@sentry-internal/feedback';
+export { feedbackModalIntegration } from '@sentry-internal/feedback-modal';
+export { feedbackScreenshotIntegration } from '@sentry-internal/feedback-screenshot';
 
 export {
   defaultRequestInstrumentationOptions,
diff --git a/packages/browser/test/unit/index.bundle.feedback.test.ts b/packages/browser/test/unit/index.bundle.feedback.test.ts
index 5a3451cb3ef0..c403144d4306 100644
--- a/packages/browser/test/unit/index.bundle.feedback.test.ts
+++ b/packages/browser/test/unit/index.bundle.feedback.test.ts
@@ -1,11 +1,13 @@
 import { replayIntegrationShim } from '@sentry-internal/integration-shims';
-import { feedbackIntegration } from '@sentry/browser';
+import { feedbackIntegration, feedbackModalIntegration, feedbackScreenshotIntegration } from '@sentry/browser';
 
-import * as TracingReplayBundle from '../../src/index.bundle.feedback';
+import * as FeedbackBundle from '../../src/index.bundle.feedback';
 
 describe('index.bundle.feedback', () => {
   it('has correct exports', () => {
-    expect(TracingReplayBundle.replayIntegration).toBe(replayIntegrationShim);
-    expect(TracingReplayBundle.feedbackIntegration).toBe(feedbackIntegration);
+    expect(FeedbackBundle.replayIntegration).toBe(replayIntegrationShim);
+    expect(FeedbackBundle.feedbackIntegration).toBe(feedbackIntegration);
+    expect(FeedbackBundle.feedbackModalIntegration).toBe(feedbackModalIntegration);
+    expect(FeedbackBundle.feedbackScreenshotIntegration).toBe(feedbackScreenshotIntegration);
   });
 });
diff --git a/packages/browser/test/unit/index.bundle.replay.test.ts b/packages/browser/test/unit/index.bundle.replay.test.ts
index 479e6b23393b..4e3d4e344734 100644
--- a/packages/browser/test/unit/index.bundle.replay.test.ts
+++ b/packages/browser/test/unit/index.bundle.replay.test.ts
@@ -1,11 +1,17 @@
-import { feedbackIntegrationShim } from '@sentry-internal/integration-shims';
+import {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+} from '@sentry-internal/integration-shims';
 import { replayIntegration } from '@sentry/browser';
 
-import * as TracingReplayBundle from '../../src/index.bundle.replay';
+import * as ReplayBundle from '../../src/index.bundle.replay';
 
 describe('index.bundle.replay', () => {
   it('has correct exports', () => {
-    expect(TracingReplayBundle.replayIntegration).toBe(replayIntegration);
-    expect(TracingReplayBundle.feedbackIntegration).toBe(feedbackIntegrationShim);
+    expect(ReplayBundle.replayIntegration).toBe(replayIntegration);
+    expect(ReplayBundle.feedbackIntegration).toBe(feedbackIntegrationShim);
+    expect(ReplayBundle.feedbackModalIntegration).toBe(feedbackModalIntegrationShim);
+    expect(ReplayBundle.feedbackScreenshotIntegration).toBe(feedbackScreenshotIntegrationShim);
   });
 });
diff --git a/packages/browser/test/unit/index.bundle.test.ts b/packages/browser/test/unit/index.bundle.test.ts
index 9ef9f38d8db5..f02e2528f802 100644
--- a/packages/browser/test/unit/index.bundle.test.ts
+++ b/packages/browser/test/unit/index.bundle.test.ts
@@ -1,10 +1,17 @@
-import { feedbackIntegrationShim, replayIntegrationShim } from '@sentry-internal/integration-shims';
+import {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+  replayIntegrationShim,
+} from '@sentry-internal/integration-shims';
 
-import * as TracingBundle from '../../src/index.bundle';
+import * as Bundle from '../../src/index.bundle';
 
 describe('index.bundle', () => {
   it('has correct exports', () => {
-    expect(TracingBundle.replayIntegration).toBe(replayIntegrationShim);
-    expect(TracingBundle.feedbackIntegration).toBe(feedbackIntegrationShim);
+    expect(Bundle.replayIntegration).toBe(replayIntegrationShim);
+    expect(Bundle.feedbackIntegration).toBe(feedbackIntegrationShim);
+    expect(Bundle.feedbackModalIntegration).toBe(feedbackModalIntegrationShim);
+    expect(Bundle.feedbackScreenshotIntegration).toBe(feedbackScreenshotIntegrationShim);
   });
 });
diff --git a/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts b/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts
index a8440d160e2b..873c41bfc769 100644
--- a/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts
+++ b/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts
@@ -1,5 +1,10 @@
 import { browserTracingIntegration } from '@sentry-internal/browser-utils';
-import { feedbackIntegration, replayIntegration } from '@sentry/browser';
+import {
+  feedbackIntegration,
+  feedbackModalIntegration,
+  feedbackScreenshotIntegration,
+  replayIntegration,
+} from '@sentry/browser';
 
 import * as TracingReplayFeedbackBundle from '../../src/index.bundle.tracing.replay.feedback';
 
@@ -8,5 +13,7 @@ describe('index.bundle.tracing.replay.feedback', () => {
     expect(TracingReplayFeedbackBundle.replayIntegration).toBe(replayIntegration);
     expect(TracingReplayFeedbackBundle.browserTracingIntegration).toBe(browserTracingIntegration);
     expect(TracingReplayFeedbackBundle.feedbackIntegration).toBe(feedbackIntegration);
+    expect(TracingReplayFeedbackBundle.feedbackModalIntegration).toBe(feedbackModalIntegration);
+    expect(TracingReplayFeedbackBundle.feedbackScreenshotIntegration).toBe(feedbackScreenshotIntegration);
   });
 });
diff --git a/packages/browser/test/unit/index.bundle.tracing.replay.test.ts b/packages/browser/test/unit/index.bundle.tracing.replay.test.ts
index 18c286edffc9..3e2a79e081a9 100644
--- a/packages/browser/test/unit/index.bundle.tracing.replay.test.ts
+++ b/packages/browser/test/unit/index.bundle.tracing.replay.test.ts
@@ -1,5 +1,9 @@
 import { browserTracingIntegration } from '@sentry-internal/browser-utils';
-import { feedbackIntegrationShim } from '@sentry-internal/integration-shims';
+import {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+} from '@sentry-internal/integration-shims';
 import { replayIntegration } from '@sentry/browser';
 
 import * as TracingReplayBundle from '../../src/index.bundle.tracing.replay';
@@ -11,5 +15,7 @@ describe('index.bundle.tracing.replay', () => {
     expect(TracingReplayBundle.browserTracingIntegration).toBe(browserTracingIntegration);
 
     expect(TracingReplayBundle.feedbackIntegration).toBe(feedbackIntegrationShim);
+    expect(TracingReplayBundle.feedbackModalIntegration).toBe(feedbackModalIntegrationShim);
+    expect(TracingReplayBundle.feedbackScreenshotIntegration).toBe(feedbackScreenshotIntegrationShim);
   });
 });
diff --git a/packages/browser/test/unit/index.bundle.tracing.test.ts b/packages/browser/test/unit/index.bundle.tracing.test.ts
index 1bb1ca19eec1..10ec0c6f0fd2 100644
--- a/packages/browser/test/unit/index.bundle.tracing.test.ts
+++ b/packages/browser/test/unit/index.bundle.tracing.test.ts
@@ -1,5 +1,10 @@
 import { browserTracingIntegration } from '@sentry-internal/browser-utils';
-import { feedbackIntegrationShim, replayIntegrationShim } from '@sentry-internal/integration-shims';
+import {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+  replayIntegrationShim,
+} from '@sentry-internal/integration-shims';
 
 import * as TracingBundle from '../../src/index.bundle.tracing';
 
@@ -8,5 +13,7 @@ describe('index.bundle.tracing', () => {
     expect(TracingBundle.replayIntegration).toBe(replayIntegrationShim);
     expect(TracingBundle.browserTracingIntegration).toBe(browserTracingIntegration);
     expect(TracingBundle.feedbackIntegration).toBe(feedbackIntegrationShim);
+    expect(TracingBundle.feedbackModalIntegration).toBe(feedbackModalIntegrationShim);
+    expect(TracingBundle.feedbackScreenshotIntegration).toBe(feedbackScreenshotIntegrationShim);
   });
 });
diff --git a/packages/feedback-modal/.eslintignore b/packages/feedback-modal/.eslintignore
new file mode 100644
index 000000000000..b38db2f296ff
--- /dev/null
+++ b/packages/feedback-modal/.eslintignore
@@ -0,0 +1,2 @@
+node_modules/
+build/
diff --git a/packages/feedback-modal/.eslintrc.js b/packages/feedback-modal/.eslintrc.js
new file mode 100644
index 000000000000..0b547ffc828c
--- /dev/null
+++ b/packages/feedback-modal/.eslintrc.js
@@ -0,0 +1,16 @@
+// Note: All paths are relative to the directory in which eslint is being run, rather than the directory where this file
+// lives
+
+// ESLint config docs: https://eslint.org/docs/user-guide/configuring/
+
+module.exports = {
+  extends: ['../../.eslintrc.js'],
+  overrides: [
+    {
+      files: ['jest.setup.ts', 'jest.config.ts'],
+      parserOptions: {
+        project: ['tsconfig.test.json'],
+      },
+    },
+  ],
+};
diff --git a/packages/feedback-modal/.gitignore b/packages/feedback-modal/.gitignore
new file mode 100644
index 000000000000..363d3467c6fa
--- /dev/null
+++ b/packages/feedback-modal/.gitignore
@@ -0,0 +1,4 @@
+node_modules
+/*.tgz
+.eslintcache
+build
diff --git a/packages/feedback-modal/LICENSE b/packages/feedback-modal/LICENSE
new file mode 100644
index 000000000000..ea5e82344f87
--- /dev/null
+++ b/packages/feedback-modal/LICENSE
@@ -0,0 +1,14 @@
+Copyright (c) 2024 Sentry (https://sentry.io) and individual contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/feedback-modal/README.md b/packages/feedback-modal/README.md
new file mode 100644
index 000000000000..f4949a12b0d1
--- /dev/null
+++ b/packages/feedback-modal/README.md
@@ -0,0 +1,14 @@
+<p align="center">
+  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84">
+  </a>
+</p>
+
+# Sentry Integration for Feedback
+
+This integration supports our browser feedback SDK allowing us to code-split heavy UI components as needed.
+
+For the primary Feedback Integration see
+[Sentry Feedback SDK](https://github.com/getsentry/sentry-javascript/tree/develop/packages/feedback)
+
+Note: This package is only meant to be used internally.
diff --git a/packages/feedback-modal/jest.config.js b/packages/feedback-modal/jest.config.js
new file mode 100644
index 000000000000..cd02790794a7
--- /dev/null
+++ b/packages/feedback-modal/jest.config.js
@@ -0,0 +1,6 @@
+const baseConfig = require('../../jest/jest.config.js');
+
+module.exports = {
+  ...baseConfig,
+  testEnvironment: 'jsdom',
+};
diff --git a/packages/feedback-modal/package.json b/packages/feedback-modal/package.json
new file mode 100644
index 000000000000..831e6a29c266
--- /dev/null
+++ b/packages/feedback-modal/package.json
@@ -0,0 +1,76 @@
+{
+  "name": "@sentry-internal/feedback-modal",
+  "version": "8.0.0-alpha.9",
+  "description": "Sentry SDK integration for user feedback",
+  "repository": "git://github.com/getsentry/sentry-javascript.git",
+  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/feedback-modal",
+  "author": "Sentry",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.18"
+  },
+  "files": [
+    "cjs",
+    "esm",
+    "types",
+    "types-ts3.8"
+  ],
+  "main": "build/npm/cjs/index.js",
+  "module": "build/npm/esm/index.js",
+  "types": "build/npm/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./build/npm/types/index.d.ts",
+        "default": "./build/npm/esm/index.js"
+      },
+      "require": {
+        "types": "./build/npm/types/index.d.ts",
+        "default": "./build/npm/cjs/index.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "<4.9": {
+      "build/npm/types/index.d.ts": [
+        "build/npm/types-ts3.8/index.d.ts"
+      ]
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@sentry/core": "8.0.0-alpha.9",
+    "@sentry/types": "8.0.0-alpha.9",
+    "@sentry/utils": "8.0.0-alpha.9",
+    "preact": "^10.19.4"
+  },
+  "scripts": {
+    "build": "run-p build:transpile build:types build:bundle",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:bundle": "rollup -c rollup.bundle.config.mjs",
+    "build:dev": "run-p build:transpile build:types",
+    "build:types": "run-s build:types:core build:types:downlevel",
+    "build:types:core": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "yarn downlevel-dts build/npm/types build/npm/types-ts3.8 --to ts3.8 && yarn node ./scripts/shim-preact-export.js",
+    "build:watch": "run-p build:transpile:watch build:bundle:watch build:types:watch",
+    "build:dev:watch": "run-p build:transpile:watch build:types:watch",
+    "build:transpile:watch": "yarn build:transpile --watch",
+    "build:bundle:watch": "yarn build:bundle --watch",
+    "build:types:watch": "tsc -p tsconfig.types.json --watch",
+    "build:tarball": "ts-node ../../scripts/prepack.ts --bundles && npm pack ./build/npm",
+    "circularDepCheck": "madge --circular src/index.ts",
+    "clean": "rimraf build sentry-feedback-modal-*.tgz",
+    "fix": "eslint . --format stylish --fix",
+    "lint": "eslint . --format stylish",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "yalc:publish": "ts-node ../../scripts/prepack.ts --bundles && yalc publish ./build/npm --push --sig"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "sideEffects": false
+}
diff --git a/packages/feedback-modal/rollup.bundle.config.mjs b/packages/feedback-modal/rollup.bundle.config.mjs
new file mode 100644
index 000000000000..9fc71b68bc9d
--- /dev/null
+++ b/packages/feedback-modal/rollup.bundle.config.mjs
@@ -0,0 +1,15 @@
+import { makeBaseBundleConfig, makeBundleConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default makeBundleConfigVariants(
+  makeBaseBundleConfig({
+    bundleType: 'addon',
+    entrypoints: ['src/index.ts'],
+    jsVersion: 'es6',
+    licenseTitle: '@sentry-internal/feedback-modal',
+    outputFileBase: () => 'bundles/feedback-modal',
+    sucrase: {
+      jsxPragma: 'h',
+      jsxFragmentPragma: 'Fragment',
+    },
+  }),
+);
diff --git a/packages/feedback-modal/rollup.npm.config.mjs b/packages/feedback-modal/rollup.npm.config.mjs
new file mode 100644
index 000000000000..3dc031c5ff82
--- /dev/null
+++ b/packages/feedback-modal/rollup.npm.config.mjs
@@ -0,0 +1,20 @@
+import { makeBaseNPMConfig, makeNPMConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default makeNPMConfigVariants(
+  makeBaseNPMConfig({
+    hasBundles: true,
+    packageSpecificConfig: {
+      output: {
+        // set exports to 'named' or 'auto' so that rollup doesn't warn
+        exports: 'named',
+        // set preserveModules to false because for feedback we actually want
+        // to bundle everything into one file.
+        preserveModules: false,
+      },
+    },
+    sucrase: {
+      jsxPragma: 'h',
+      jsxFragmentPragma: 'Fragment',
+    },
+  }),
+);
diff --git a/packages/feedback-modal/scripts/shim-preact-export.js b/packages/feedback-modal/scripts/shim-preact-export.js
new file mode 100644
index 000000000000..bd74e4da0a05
--- /dev/null
+++ b/packages/feedback-modal/scripts/shim-preact-export.js
@@ -0,0 +1,75 @@
+// preact does not support more modern TypeScript versions, which breaks our users that depend on older
+// TypeScript versions. To fix this, we shim the types from preact to be any and remove the dependency on preact
+// for types directly. This script is meant to be run after the build/npm/types-ts3.8 directory is created.
+
+// Path: build/npm/types-ts3.8/global.d.ts
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * This regex looks for preact imports we can replace and shim out.
+ *
+ * Example:
+ * import { ComponentChildren, VNode } from 'preact';
+ */
+const preactImportRegex = /import\s*{\s*([\w\s,]+)\s*}\s*from\s*'preact'\s*;?/;
+
+function walk(dir) {
+  const files = fs.readdirSync(dir);
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.lstatSync(filePath);
+    if (stat.isDirectory()) {
+      walk(filePath);
+    } else {
+      if (filePath.endsWith('.d.ts')) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const capture = preactImportRegex.exec(content);
+        if (capture) {
+          const groups = capture[1].split(',').map(s => s.trim());
+
+          // This generates a shim snippet to replace the type imports from preact
+          // It generates a snippet based on the capture groups of preactImportRegex.
+          //
+          // Example:
+          //
+          // import type { ComponentChildren, VNode } from 'preact';
+          // becomes
+          // type ComponentChildren: any;
+          // type VNode: any;
+          const snippet = groups.reduce((acc, curr) => {
+            const searchableValue = curr.includes(' as ') ? curr.split(' as ')[1] : curr;
+
+            // look to see if imported as value, then we have to use declare const
+            if (content.includes(`typeof ${searchableValue}`)) {
+              return `${acc}declare const ${searchableValue}: any;\n`;
+            }
+
+            // look to see if generic type like Foo<T>
+            if (content.includes(`${searchableValue}<`)) {
+              return `${acc}type ${searchableValue}<T> = any;\n`;
+            }
+
+            // otherwise we can just leave as type
+            return `${acc}type ${searchableValue} = any;\n`;
+          }, '');
+
+          // we then can remove the import from preact
+          const newContent = content.replace(preactImportRegex, '// replaced import from preact');
+
+          // and write the new content to the file
+          fs.writeFileSync(filePath, snippet + newContent, 'utf8');
+        }
+      }
+    }
+  });
+}
+
+function run() {
+  // recurse through build/npm/types-ts3.8 directory
+  const dir = path.join('build', 'npm', 'types-ts3.8');
+  walk(dir);
+}
+
+run();
diff --git a/packages/feedback-modal/src/index.ts b/packages/feedback-modal/src/index.ts
new file mode 100644
index 000000000000..eff7430a6050
--- /dev/null
+++ b/packages/feedback-modal/src/index.ts
@@ -0,0 +1 @@
+export { feedbackModalIntegration } from './modal/integration';
diff --git a/packages/feedback-modal/src/modal/integration.test.ts b/packages/feedback-modal/src/modal/integration.test.ts
new file mode 100644
index 000000000000..d9eedd59c0f3
--- /dev/null
+++ b/packages/feedback-modal/src/modal/integration.test.ts
@@ -0,0 +1,8 @@
+import { feedbackModalIntegration } from './integration';
+
+describe('feedbackModalIntegration', () => {
+  it('should have createDialog', () => {
+    const instance = feedbackModalIntegration();
+    expect(instance).toHaveProperty('createDialog');
+  });
+});
diff --git a/packages/feedback-modal/src/modal/integration.ts b/packages/feedback-modal/src/modal/integration.ts
new file mode 100644
index 000000000000..f9e8a9ad64be
--- /dev/null
+++ b/packages/feedback-modal/src/modal/integration.ts
@@ -0,0 +1,15 @@
+import type { Integration, IntegrationFn } from '@sentry/types';
+
+export interface FeedbackModalIntegration extends Integration {
+  createDialog: unknown;
+}
+
+export const feedbackModalIntegration = ((): FeedbackModalIntegration => {
+  return {
+    name: 'FeedbackModal',
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setupOnce() {},
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    createDialog: () => {}, // TODO(ryan953): port this over from packages/feedback/src/modal
+  };
+}) satisfies IntegrationFn;
diff --git a/packages/feedback-modal/tsconfig.json b/packages/feedback-modal/tsconfig.json
new file mode 100644
index 000000000000..c1fc08578508
--- /dev/null
+++ b/packages/feedback-modal/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "esnext",
+
+    /* Preact Config */
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "skipLibCheck": true,
+    "baseUrl": "./",
+    "paths": {
+      "react": ["./node_modules/preact/compat/"],
+      "react-dom": ["./node_modules/preact/compat/"]
+    }
+  },
+  "include": ["src/**/*.ts","src/**/*.tsx"]
+}
diff --git a/packages/feedback-modal/tsconfig.test.json b/packages/feedback-modal/tsconfig.test.json
new file mode 100644
index 000000000000..ad87caa06c48
--- /dev/null
+++ b/packages/feedback-modal/tsconfig.test.json
@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+
+  "include": ["test/**/*.ts", "jest.config.ts", "jest.setup.ts"],
+
+  "compilerOptions": {
+    "types": ["node", "jest"],
+    "esModuleInterop": true,
+    "allowJs": true,
+    "noImplicitAny": true,
+    "noImplicitThis": false,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": false
+  }
+}
diff --git a/packages/feedback-modal/tsconfig.types.json b/packages/feedback-modal/tsconfig.types.json
new file mode 100644
index 000000000000..374fd9bc9364
--- /dev/null
+++ b/packages/feedback-modal/tsconfig.types.json
@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "build/npm/types"
+  }
+}
diff --git a/packages/feedback-screenshot/.eslintignore b/packages/feedback-screenshot/.eslintignore
new file mode 100644
index 000000000000..b38db2f296ff
--- /dev/null
+++ b/packages/feedback-screenshot/.eslintignore
@@ -0,0 +1,2 @@
+node_modules/
+build/
diff --git a/packages/feedback-screenshot/.eslintrc.js b/packages/feedback-screenshot/.eslintrc.js
new file mode 100644
index 000000000000..0b547ffc828c
--- /dev/null
+++ b/packages/feedback-screenshot/.eslintrc.js
@@ -0,0 +1,16 @@
+// Note: All paths are relative to the directory in which eslint is being run, rather than the directory where this file
+// lives
+
+// ESLint config docs: https://eslint.org/docs/user-guide/configuring/
+
+module.exports = {
+  extends: ['../../.eslintrc.js'],
+  overrides: [
+    {
+      files: ['jest.setup.ts', 'jest.config.ts'],
+      parserOptions: {
+        project: ['tsconfig.test.json'],
+      },
+    },
+  ],
+};
diff --git a/packages/feedback-screenshot/.gitignore b/packages/feedback-screenshot/.gitignore
new file mode 100644
index 000000000000..363d3467c6fa
--- /dev/null
+++ b/packages/feedback-screenshot/.gitignore
@@ -0,0 +1,4 @@
+node_modules
+/*.tgz
+.eslintcache
+build
diff --git a/packages/feedback-screenshot/LICENSE b/packages/feedback-screenshot/LICENSE
new file mode 100644
index 000000000000..ea5e82344f87
--- /dev/null
+++ b/packages/feedback-screenshot/LICENSE
@@ -0,0 +1,14 @@
+Copyright (c) 2024 Sentry (https://sentry.io) and individual contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/feedback-screenshot/README.md b/packages/feedback-screenshot/README.md
new file mode 100644
index 000000000000..f4949a12b0d1
--- /dev/null
+++ b/packages/feedback-screenshot/README.md
@@ -0,0 +1,14 @@
+<p align="center">
+  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84">
+  </a>
+</p>
+
+# Sentry Integration for Feedback
+
+This integration supports our browser feedback SDK allowing us to code-split heavy UI components as needed.
+
+For the primary Feedback Integration see
+[Sentry Feedback SDK](https://github.com/getsentry/sentry-javascript/tree/develop/packages/feedback)
+
+Note: This package is only meant to be used internally.
diff --git a/packages/feedback-screenshot/jest.config.js b/packages/feedback-screenshot/jest.config.js
new file mode 100644
index 000000000000..cd02790794a7
--- /dev/null
+++ b/packages/feedback-screenshot/jest.config.js
@@ -0,0 +1,6 @@
+const baseConfig = require('../../jest/jest.config.js');
+
+module.exports = {
+  ...baseConfig,
+  testEnvironment: 'jsdom',
+};
diff --git a/packages/feedback-screenshot/package.json b/packages/feedback-screenshot/package.json
new file mode 100644
index 000000000000..e29be49cb539
--- /dev/null
+++ b/packages/feedback-screenshot/package.json
@@ -0,0 +1,76 @@
+{
+  "name": "@sentry-internal/feedback-screenshot",
+  "version": "8.0.0-alpha.9",
+  "description": "Sentry SDK integration for user feedback",
+  "repository": "git://github.com/getsentry/sentry-javascript.git",
+  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/feedback-screenshot",
+  "author": "Sentry",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.18"
+  },
+  "files": [
+    "cjs",
+    "esm",
+    "types",
+    "types-ts3.8"
+  ],
+  "main": "build/npm/cjs/index.js",
+  "module": "build/npm/esm/index.js",
+  "types": "build/npm/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./build/npm/types/index.d.ts",
+        "default": "./build/npm/esm/index.js"
+      },
+      "require": {
+        "types": "./build/npm/types/index.d.ts",
+        "default": "./build/npm/cjs/index.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "<4.9": {
+      "build/npm/types/index.d.ts": [
+        "build/npm/types-ts3.8/index.d.ts"
+      ]
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@sentry/core": "8.0.0-alpha.9",
+    "@sentry/types": "8.0.0-alpha.9",
+    "@sentry/utils": "8.0.0-alpha.9",
+    "preact": "^10.19.4"
+  },
+  "scripts": {
+    "build": "run-p build:transpile build:types build:bundle",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:bundle": "rollup -c rollup.bundle.config.mjs",
+    "build:dev": "run-p build:transpile build:types",
+    "build:types": "run-s build:types:core build:types:downlevel",
+    "build:types:core": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "yarn downlevel-dts build/npm/types build/npm/types-ts3.8 --to ts3.8 && yarn node ./scripts/shim-preact-export.js",
+    "build:watch": "run-p build:transpile:watch build:bundle:watch build:types:watch",
+    "build:dev:watch": "run-p build:transpile:watch build:types:watch",
+    "build:transpile:watch": "yarn build:transpile --watch",
+    "build:bundle:watch": "yarn build:bundle --watch",
+    "build:types:watch": "tsc -p tsconfig.types.json --watch",
+    "build:tarball": "ts-node ../../scripts/prepack.ts --bundles && npm pack ./build/npm",
+    "circularDepCheck": "madge --circular src/index.ts",
+    "clean": "rimraf build sentry-feedback-screenshot-*.tgz",
+    "fix": "eslint . --format stylish --fix",
+    "lint": "eslint . --format stylish",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "yalc:publish": "ts-node ../../scripts/prepack.ts --bundles && yalc publish ./build/npm --push --sig"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "sideEffects": false
+}
diff --git a/packages/feedback-screenshot/rollup.bundle.config.mjs b/packages/feedback-screenshot/rollup.bundle.config.mjs
new file mode 100644
index 000000000000..5e2422f0bcd0
--- /dev/null
+++ b/packages/feedback-screenshot/rollup.bundle.config.mjs
@@ -0,0 +1,15 @@
+import { makeBaseBundleConfig, makeBundleConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default makeBundleConfigVariants(
+  makeBaseBundleConfig({
+    bundleType: 'addon',
+    entrypoints: ['src/index.ts'],
+    jsVersion: 'es6',
+    licenseTitle: '@sentry-internal/feedback-screenshot',
+    outputFileBase: () => 'bundles/feedback-screenshot',
+    sucrase: {
+      jsxPragma: 'h',
+      jsxFragmentPragma: 'Fragment',
+    },
+  }),
+);
diff --git a/packages/feedback-screenshot/rollup.npm.config.mjs b/packages/feedback-screenshot/rollup.npm.config.mjs
new file mode 100644
index 000000000000..3dc031c5ff82
--- /dev/null
+++ b/packages/feedback-screenshot/rollup.npm.config.mjs
@@ -0,0 +1,20 @@
+import { makeBaseNPMConfig, makeNPMConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default makeNPMConfigVariants(
+  makeBaseNPMConfig({
+    hasBundles: true,
+    packageSpecificConfig: {
+      output: {
+        // set exports to 'named' or 'auto' so that rollup doesn't warn
+        exports: 'named',
+        // set preserveModules to false because for feedback we actually want
+        // to bundle everything into one file.
+        preserveModules: false,
+      },
+    },
+    sucrase: {
+      jsxPragma: 'h',
+      jsxFragmentPragma: 'Fragment',
+    },
+  }),
+);
diff --git a/packages/feedback-screenshot/scripts/shim-preact-export.js b/packages/feedback-screenshot/scripts/shim-preact-export.js
new file mode 100644
index 000000000000..bd74e4da0a05
--- /dev/null
+++ b/packages/feedback-screenshot/scripts/shim-preact-export.js
@@ -0,0 +1,75 @@
+// preact does not support more modern TypeScript versions, which breaks our users that depend on older
+// TypeScript versions. To fix this, we shim the types from preact to be any and remove the dependency on preact
+// for types directly. This script is meant to be run after the build/npm/types-ts3.8 directory is created.
+
+// Path: build/npm/types-ts3.8/global.d.ts
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * This regex looks for preact imports we can replace and shim out.
+ *
+ * Example:
+ * import { ComponentChildren, VNode } from 'preact';
+ */
+const preactImportRegex = /import\s*{\s*([\w\s,]+)\s*}\s*from\s*'preact'\s*;?/;
+
+function walk(dir) {
+  const files = fs.readdirSync(dir);
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.lstatSync(filePath);
+    if (stat.isDirectory()) {
+      walk(filePath);
+    } else {
+      if (filePath.endsWith('.d.ts')) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const capture = preactImportRegex.exec(content);
+        if (capture) {
+          const groups = capture[1].split(',').map(s => s.trim());
+
+          // This generates a shim snippet to replace the type imports from preact
+          // It generates a snippet based on the capture groups of preactImportRegex.
+          //
+          // Example:
+          //
+          // import type { ComponentChildren, VNode } from 'preact';
+          // becomes
+          // type ComponentChildren: any;
+          // type VNode: any;
+          const snippet = groups.reduce((acc, curr) => {
+            const searchableValue = curr.includes(' as ') ? curr.split(' as ')[1] : curr;
+
+            // look to see if imported as value, then we have to use declare const
+            if (content.includes(`typeof ${searchableValue}`)) {
+              return `${acc}declare const ${searchableValue}: any;\n`;
+            }
+
+            // look to see if generic type like Foo<T>
+            if (content.includes(`${searchableValue}<`)) {
+              return `${acc}type ${searchableValue}<T> = any;\n`;
+            }
+
+            // otherwise we can just leave as type
+            return `${acc}type ${searchableValue} = any;\n`;
+          }, '');
+
+          // we then can remove the import from preact
+          const newContent = content.replace(preactImportRegex, '// replaced import from preact');
+
+          // and write the new content to the file
+          fs.writeFileSync(filePath, snippet + newContent, 'utf8');
+        }
+      }
+    }
+  });
+}
+
+function run() {
+  // recurse through build/npm/types-ts3.8 directory
+  const dir = path.join('build', 'npm', 'types-ts3.8');
+  walk(dir);
+}
+
+run();
diff --git a/packages/feedback-screenshot/src/index.ts b/packages/feedback-screenshot/src/index.ts
new file mode 100644
index 000000000000..2582220645d1
--- /dev/null
+++ b/packages/feedback-screenshot/src/index.ts
@@ -0,0 +1 @@
+export { feedbackScreenshotIntegration } from './screenshot/integration';
diff --git a/packages/feedback-screenshot/src/screenshot/integration.test.ts b/packages/feedback-screenshot/src/screenshot/integration.test.ts
new file mode 100644
index 000000000000..43acdd770670
--- /dev/null
+++ b/packages/feedback-screenshot/src/screenshot/integration.test.ts
@@ -0,0 +1,8 @@
+import { feedbackScreenshotIntegration } from './integration';
+
+describe('feedbackScreenshotIntegration', () => {
+  it('should have createInput', () => {
+    const instance = feedbackScreenshotIntegration();
+    expect(instance).toHaveProperty('createInput');
+  });
+});
diff --git a/packages/feedback-screenshot/src/screenshot/integration.ts b/packages/feedback-screenshot/src/screenshot/integration.ts
new file mode 100644
index 000000000000..ada4e7ec8b65
--- /dev/null
+++ b/packages/feedback-screenshot/src/screenshot/integration.ts
@@ -0,0 +1,15 @@
+import type { Integration, IntegrationFn } from '@sentry/types';
+
+export interface FeedbackScreenshotIntegration extends Integration {
+  createInput: unknown;
+}
+
+export const feedbackScreenshotIntegration = (() => {
+  return {
+    name: 'FeedbackScreenshot',
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setupOnce() {},
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    createInput: () => {}, // TODO(ryan953): port this over from packages/feedback/src/screenshot
+  };
+}) satisfies IntegrationFn;
diff --git a/packages/feedback-screenshot/tsconfig.json b/packages/feedback-screenshot/tsconfig.json
new file mode 100644
index 000000000000..c1fc08578508
--- /dev/null
+++ b/packages/feedback-screenshot/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "esnext",
+
+    /* Preact Config */
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "skipLibCheck": true,
+    "baseUrl": "./",
+    "paths": {
+      "react": ["./node_modules/preact/compat/"],
+      "react-dom": ["./node_modules/preact/compat/"]
+    }
+  },
+  "include": ["src/**/*.ts","src/**/*.tsx"]
+}
diff --git a/packages/feedback-screenshot/tsconfig.test.json b/packages/feedback-screenshot/tsconfig.test.json
new file mode 100644
index 000000000000..ad87caa06c48
--- /dev/null
+++ b/packages/feedback-screenshot/tsconfig.test.json
@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+
+  "include": ["test/**/*.ts", "jest.config.ts", "jest.setup.ts"],
+
+  "compilerOptions": {
+    "types": ["node", "jest"],
+    "esModuleInterop": true,
+    "allowJs": true,
+    "noImplicitAny": true,
+    "noImplicitThis": false,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": false
+  }
+}
diff --git a/packages/feedback-screenshot/tsconfig.types.json b/packages/feedback-screenshot/tsconfig.types.json
new file mode 100644
index 000000000000..374fd9bc9364
--- /dev/null
+++ b/packages/feedback-screenshot/tsconfig.types.json
@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "build/npm/types"
+  }
+}
diff --git a/packages/integration-shims/src/Feedback.ts b/packages/integration-shims/src/Feedback.ts
index e6bf1607927b..b0bb3f564779 100644
--- a/packages/integration-shims/src/Feedback.ts
+++ b/packages/integration-shims/src/Feedback.ts
@@ -13,8 +13,12 @@ const FEEDBACK_INTEGRATION_METHODS = [
 ] as const;
 
 type FeedbackSpecificMethods = Record<(typeof FEEDBACK_INTEGRATION_METHODS)[number], () => void>;
+type FeedbackModalSpecificMethods = { createDialog: () => void };
+type FeedbackScreenshotSpecificMethods = { createInput: () => void };
 
 interface FeedbackIntegration extends Integration, FeedbackSpecificMethods {}
+interface FeedbackModalIntegration extends Integration, FeedbackModalSpecificMethods {}
+interface FeedbackScreenshotIntegration extends Integration, FeedbackScreenshotSpecificMethods {}
 
 /**
  * This is a shim for the Feedback integration.
@@ -35,3 +39,27 @@ export function feedbackIntegrationShim(_options: unknown): FeedbackIntegration
     }, {} as FeedbackSpecificMethods) as FeedbackSpecificMethods),
   };
 }
+
+/**
+ * This is a shim for the FeedbackModal integration.
+ * It is needed in order for the CDN bundles to continue working when users add/remove feedback
+ * from it, without changing their config. This is necessary for the loader mechanism.
+ */
+export function feedbackModalIntegrationShim(): FeedbackModalIntegration {
+  return {
+    name: 'FeedbackModal',
+    createDialog: FAKE_FUNCTION,
+  };
+}
+
+/**
+ * This is a shim for the FeedbackScreenshot integration.
+ * It is needed in order for the CDN bundles to continue working when users add/remove feedback
+ * from it, without changing their config. This is necessary for the loader mechanism.
+ */
+export function feedbackScreenshotIntegrationShim(): FeedbackScreenshotIntegration {
+  return {
+    name: 'FeedbackScreenshot',
+    createInput: FAKE_FUNCTION,
+  };
+}
diff --git a/packages/integration-shims/src/index.ts b/packages/integration-shims/src/index.ts
index 5dfb2caabea1..f3c0937ff9d4 100644
--- a/packages/integration-shims/src/index.ts
+++ b/packages/integration-shims/src/index.ts
@@ -1,4 +1,4 @@
-export { feedbackIntegrationShim } from './Feedback';
+export { feedbackIntegrationShim, feedbackModalIntegrationShim, feedbackScreenshotIntegrationShim } from './Feedback';
 export { replayIntegrationShim } from './Replay';
 export {
   browserTracingIntegrationShim,
diff --git a/packages/nextjs/test/integration/package.json b/packages/nextjs/test/integration/package.json
index f4c547b5b687..0d17d6a049dc 100644
--- a/packages/nextjs/test/integration/package.json
+++ b/packages/nextjs/test/integration/package.json
@@ -34,6 +34,8 @@
     "@sentry-internal/replay": "file:../../../replay-internal",
     "@sentry-internal/replay-canvas": "file:../../../replay-canvas",
     "@sentry-internal/feedback": "file:../../../feedback",
+    "@sentry-internal/feedback-modal": "file:../../../feedback-modal",
+    "@sentry-internal/feedback-screenshot": "file:../../../feedback-screenshot",
     "@sentry/types": "file:../../../types",
     "@sentry/utils": "file:../../../utils",
     "@sentry/vercel-edge": "file:../../../vercel-edge"
diff --git a/packages/remix/test/integration/package.json b/packages/remix/test/integration/package.json
index 63560ec64e8b..f0f2bb631553 100644
--- a/packages/remix/test/integration/package.json
+++ b/packages/remix/test/integration/package.json
@@ -32,6 +32,8 @@
     "@sentry-internal/replay": "file:../../../replay-internal",
     "@sentry-internal/replay-canvas": "file:../../../replay-canvas",
     "@sentry-internal/feedback": "file:../../../feedback",
+    "@sentry-internal/feedback-modal": "file:../../../feedback-modal",
+    "@sentry-internal/feedback-screenshot": "file:../../../feedback-screenshot",
     "@sentry/types": "file:../../../types",
     "@sentry/utils": "file:../../../utils",
     "@vanilla-extract/css": "1.13.0",

From a1bb8d0e55a62e7d40d4dad803b491863639368f Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Wed, 10 Apr 2024 11:09:51 +0200
Subject: [PATCH 33/64] feat(koa): Update scope `transactionName` when creating
 router span (#11476)

Update the current scope's `transactionName` in our Koa
integration. Unfortunately, I didn't find a reliable way to get the
parameterized route in our error handler/via `app.use` because similarly
to Express, koa doesn't seem to expose this information before going
through the actual route layers.
---
 .../test-applications/node-koa-app/index.js   |  4 +++
 .../node-koa-app/tests/errors.test.ts         | 10 +++----
 packages/node/src/integrations/tracing/koa.ts | 29 +++++++++++++++++--
 3 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/node-koa-app/index.js b/dev-packages/e2e-tests/test-applications/node-koa-app/index.js
index 3ee16ab7200e..9d58bd6ca3b6 100644
--- a/dev-packages/e2e-tests/test-applications/node-koa-app/index.js
+++ b/dev-packages/e2e-tests/test-applications/node-koa-app/index.js
@@ -75,6 +75,10 @@ router1.get('/test-exception', async ctx => {
   throw new Error('This is an exception');
 });
 
+router1.get('/test-exception/:id', async ctx => {
+  throw new Error(`This is an exception with id ${ctx.params.id}`);
+});
+
 router1.get('/test-outgoing-fetch-external-allowed', async ctx => {
   const fetchResponse = await fetch(`http://localhost:${port2}/external-allowed`);
   const data = await fetchResponse.json();
diff --git a/dev-packages/e2e-tests/test-applications/node-koa-app/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/node-koa-app/tests/errors.test.ts
index 1d6cf604f176..5759c2bad543 100644
--- a/dev-packages/e2e-tests/test-applications/node-koa-app/tests/errors.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-koa-app/tests/errors.test.ts
@@ -41,11 +41,11 @@ test('Sends exception to Sentry', async ({ baseURL }) => {
 
 test('Sends correct error event', async ({ baseURL }) => {
   const errorEventPromise = waitForError('node-koa-app', event => {
-    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception';
+    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception with id 123';
   });
 
   try {
-    await axios.get(`${baseURL}/test-exception`);
+    await axios.get(`${baseURL}/test-exception/123`);
   } catch {
     // this results in an error, but we don't care - we want to check the error event
   }
@@ -53,16 +53,16 @@ test('Sends correct error event', async ({ baseURL }) => {
   const errorEvent = await errorEventPromise;
 
   expect(errorEvent.exception?.values).toHaveLength(1);
-  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception');
+  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception with id 123');
 
   expect(errorEvent.request).toEqual({
     method: 'GET',
     cookies: {},
     headers: expect.any(Object),
-    url: 'http://localhost:3030/test-exception',
+    url: 'http://localhost:3030/test-exception/123',
   });
 
-  expect(errorEvent.transaction).toEqual('GET /test-exception');
+  expect(errorEvent.transaction).toEqual('GET /test-exception/:id');
 
   expect(errorEvent.contexts?.trace).toEqual({
     trace_id: expect.any(String),
diff --git a/packages/node/src/integrations/tracing/koa.ts b/packages/node/src/integrations/tracing/koa.ts
index 2c3a57ebed3f..938e815e2b2f 100644
--- a/packages/node/src/integrations/tracing/koa.ts
+++ b/packages/node/src/integrations/tracing/koa.ts
@@ -1,14 +1,39 @@
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
-import { captureException, defineIntegration } from '@sentry/core';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import {
+  captureException,
+  defineIntegration,
+  getDefaultIsolationScope,
+  getIsolationScope,
+  spanToJSON,
+} from '@sentry/core';
 import type { IntegrationFn } from '@sentry/types';
+import { logger } from '@sentry/utils';
+import { DEBUG_BUILD } from '../../debug-build';
 
 const _koaIntegration = (() => {
   return {
     name: 'Koa',
     setupOnce() {
       registerInstrumentations({
-        instrumentations: [new KoaInstrumentation()],
+        instrumentations: [
+          new KoaInstrumentation({
+            requestHook(span, info) {
+              if (getIsolationScope() === getDefaultIsolationScope()) {
+                DEBUG_BUILD &&
+                  logger.warn('Isolation scope is default isolation scope - skipping setting transactionName');
+                return;
+              }
+              const attributes = spanToJSON(span).data;
+              const route = attributes && attributes[SemanticAttributes.HTTP_ROUTE];
+              const method = info.context.request.method.toUpperCase() || 'GET';
+              if (route) {
+                getIsolationScope().setTransactionName(`${method} ${route}`);
+              }
+            },
+          }),
+        ],
       });
     },
   };

From 15d6cb17909da3284a05d8da9356ef2ce0c3bc60 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Wed, 10 Apr 2024 11:53:56 +0200
Subject: [PATCH 34/64] feat(core): Implement `suppressTracing` (#11468)

This implements a new `suppressTracing` method which can be used to
ensure we do not send any spans inside of a callback.

Usage:

```js
await suppressTracing(() => {
  // do not capture any spans for this fetch!
  return fetch(...);
});
```

This also changes the behavior of starting child spans slightly to
actually create `NonRecordingSpan` as child spans when not sampled
(previously, we'd still create SentrySpans). I choose to continue to
create proper spans for unsampled transactions because it makes things
like picking name and stuff like this easier for the time being.
---
 .../test/browser/metrics/index.test.ts        |  4 +-
 .../test/browser/metrics/utils.test.ts        |  6 +-
 packages/bun/package.json                     |  1 +
 packages/bun/src/transports/index.ts          | 20 +++--
 packages/core/src/asyncContext.ts             |  5 +-
 packages/core/src/tracing/index.ts            |  1 +
 packages/core/src/tracing/trace.ts            | 71 +++++++++------
 packages/core/test/lib/tracing/trace.test.ts  | 86 ++++++++++++++++---
 .../devErrorSymbolicationEventProcessor.ts    | 25 +++---
 packages/node/src/transports/http.ts          |  6 +-
 .../opentelemetry/src/asyncContextStrategy.ts |  2 +
 packages/opentelemetry/src/index.ts           |  2 +
 .../src/utils/suppressTracing.ts              |  8 ++
 packages/opentelemetry/test/trace.test.ts     | 53 ++++++++++++
 14 files changed, 225 insertions(+), 65 deletions(-)
 create mode 100644 packages/opentelemetry/src/utils/suppressTracing.ts

diff --git a/packages/browser-utils/test/browser/metrics/index.test.ts b/packages/browser-utils/test/browser/metrics/index.test.ts
index b0015ca0a514..8c4476d4b6b2 100644
--- a/packages/browser-utils/test/browser/metrics/index.test.ts
+++ b/packages/browser-utils/test/browser/metrics/index.test.ts
@@ -32,7 +32,7 @@ const originalLocation = WINDOW.location;
 const resourceEntryName = 'https://example.com/assets/to/css';
 
 describe('_addMeasureSpans', () => {
-  const span = new SentrySpan({ op: 'pageload', name: '/' });
+  const span = new SentrySpan({ op: 'pageload', name: '/', sampled: true });
 
   beforeEach(() => {
     getCurrentScope().clear();
@@ -86,7 +86,7 @@ describe('_addMeasureSpans', () => {
 });
 
 describe('_addResourceSpans', () => {
-  const span = new SentrySpan({ op: 'pageload', name: '/' });
+  const span = new SentrySpan({ op: 'pageload', name: '/', sampled: true });
 
   beforeAll(() => {
     setGlobalLocation(mockWindowLocation);
diff --git a/packages/browser-utils/test/browser/metrics/utils.test.ts b/packages/browser-utils/test/browser/metrics/utils.test.ts
index ad9d0dc801f8..1ec79514af67 100644
--- a/packages/browser-utils/test/browser/metrics/utils.test.ts
+++ b/packages/browser-utils/test/browser/metrics/utils.test.ts
@@ -26,7 +26,7 @@ describe('startAndEndSpan()', () => {
   });
 
   it('creates a span with given properties', () => {
-    const parentSpan = new SentrySpan({ name: 'test' });
+    const parentSpan = new SentrySpan({ name: 'test', sampled: true });
     const span = startAndEndSpan(parentSpan, 100, 200, {
       name: 'evaluation',
       op: 'script',
@@ -40,7 +40,7 @@ describe('startAndEndSpan()', () => {
   });
 
   it('adjusts the start timestamp if child span starts before transaction', () => {
-    const parentSpan = new SentrySpan({ name: 'test', startTimestamp: 123 });
+    const parentSpan = new SentrySpan({ name: 'test', startTimestamp: 123, sampled: true });
     const span = startAndEndSpan(parentSpan, 100, 200, {
       name: 'script.js',
       op: 'resource',
@@ -52,7 +52,7 @@ describe('startAndEndSpan()', () => {
   });
 
   it('does not adjust start timestamp if child span starts after transaction', () => {
-    const parentSpan = new SentrySpan({ name: 'test', startTimestamp: 123 });
+    const parentSpan = new SentrySpan({ name: 'test', startTimestamp: 123, sampled: true });
     const span = startAndEndSpan(parentSpan, 150, 200, {
       name: 'script.js',
       op: 'resource',
diff --git a/packages/bun/package.json b/packages/bun/package.json
index d5454c17c88c..9bad7751c615 100644
--- a/packages/bun/package.json
+++ b/packages/bun/package.json
@@ -44,6 +44,7 @@
   "dependencies": {
     "@sentry/core": "8.0.0-alpha.9",
     "@sentry/node": "8.0.0-alpha.9",
+    "@sentry/opentelemetry": "8.0.0-alpha.9",
     "@sentry/types": "8.0.0-alpha.9",
     "@sentry/utils": "8.0.0-alpha.9"
   },
diff --git a/packages/bun/src/transports/index.ts b/packages/bun/src/transports/index.ts
index ad9832795fc4..b4968f2001c0 100644
--- a/packages/bun/src/transports/index.ts
+++ b/packages/bun/src/transports/index.ts
@@ -1,4 +1,4 @@
-import { createTransport } from '@sentry/core';
+import { createTransport, suppressTracing } from '@sentry/core';
 import type { BaseTransportOptions, Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';
 import { rejectedSyncPromise } from '@sentry/utils';
 
@@ -19,14 +19,16 @@ export function makeFetchTransport(options: BunTransportOptions): Transport {
     };
 
     try {
-      return fetch(options.url, requestOptions).then(response => {
-        return {
-          statusCode: response.status,
-          headers: {
-            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
-            'retry-after': response.headers.get('Retry-After'),
-          },
-        };
+      return suppressTracing(() => {
+        return fetch(options.url, requestOptions).then(response => {
+          return {
+            statusCode: response.status,
+            headers: {
+              'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
+              'retry-after': response.headers.get('Retry-After'),
+            },
+          };
+        });
       });
     } catch (e) {
       return rejectedSyncPromise(e);
diff --git a/packages/core/src/asyncContext.ts b/packages/core/src/asyncContext.ts
index 854b03ea9600..4627d4c2453d 100644
--- a/packages/core/src/asyncContext.ts
+++ b/packages/core/src/asyncContext.ts
@@ -1,7 +1,7 @@
 import type { Hub, Integration } from '@sentry/types';
 import type { Scope } from '@sentry/types';
 import { GLOBAL_OBJ } from '@sentry/utils';
-import type { startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from './tracing/trace';
+import type { startInactiveSpan, startSpan, startSpanManual, suppressTracing, withActiveSpan } from './tracing/trace';
 import type { getActiveSpan } from './utils/spanUtils';
 
 /**
@@ -62,6 +62,9 @@ export interface AsyncContextStrategy {
 
   /** Make a span the active span in the context of the callback. */
   withActiveSpan?: typeof withActiveSpan;
+
+  /** Suppress tracing in the given callback, ensuring no spans are generated inside of it.  */
+  suppressTracing?: typeof suppressTracing;
 }
 
 /**
diff --git a/packages/core/src/tracing/index.ts b/packages/core/src/tracing/index.ts
index 7cc86ae76531..a01fca60316a 100644
--- a/packages/core/src/tracing/index.ts
+++ b/packages/core/src/tracing/index.ts
@@ -14,6 +14,7 @@ export {
   startSpanManual,
   continueTrace,
   withActiveSpan,
+  suppressTracing,
 } from './trace';
 export { getDynamicSamplingContextFromClient, getDynamicSamplingContextFromSpan } from './dynamicSamplingContext';
 export { setMeasurement, timedEventsToMeasurements } from './measurement';
diff --git a/packages/core/src/tracing/trace.ts b/packages/core/src/tracing/trace.ts
index d21a567cecc5..c9e82163fef1 100644
--- a/packages/core/src/tracing/trace.ts
+++ b/packages/core/src/tracing/trace.ts
@@ -3,6 +3,7 @@ import type { ClientOptions, Scope, SentrySpanArguments, Span, SpanTimeInput, St
 import { propagationContextFromHeaders } from '@sentry/utils';
 import type { AsyncContextStrategy } from '../asyncContext';
 import { getMainCarrier } from '../asyncContext';
+
 import { getClient, getCurrentScope, getIsolationScope, withScope } from '../currentScopes';
 
 import { getAsyncContextStrategy } from '../hub';
@@ -25,6 +26,8 @@ import { SentrySpan } from './sentrySpan';
 import { SPAN_STATUS_ERROR } from './spanstatus';
 import { setCapturedScopesOnSpan } from './utils';
 
+const SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';
+
 /**
  * Wraps a function with a transaction/span and finishes the span after the function is done.
  * The created span is the active span and will be used as parent by other spans created inside the function
@@ -204,6 +207,20 @@ export function withActiveSpan<T>(span: Span | null, callback: (scope: Scope) =>
   });
 }
 
+/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */
+export function suppressTracing<T>(callback: () => T): T {
+  const acs = getAcs();
+
+  if (acs.suppressTracing) {
+    return acs.suppressTracing(callback);
+  }
+
+  return withScope(scope => {
+    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });
+    return callback();
+  });
+}
+
 function createChildSpanOrTransaction({
   parentSpan,
   spanContext,
@@ -223,7 +240,7 @@ function createChildSpanOrTransaction({
 
   let span: Span;
   if (parentSpan && !forceTransaction) {
-    span = _startChildSpan(parentSpan, spanContext);
+    span = _startChildSpan(parentSpan, scope, spanContext);
     addChildSpanToSpan(parentSpan, span);
   } else if (parentSpan) {
     // If we forced a transaction but have a parent span, make sure to continue from the parent span, not the scope
@@ -237,6 +254,7 @@ function createChildSpanOrTransaction({
         parentSpanId,
         ...spanContext,
       },
+      scope,
       parentSampled,
     );
 
@@ -258,6 +276,7 @@ function createChildSpanOrTransaction({
         parentSpanId,
         ...spanContext,
       },
+      scope,
       parentSampled,
     );
 
@@ -296,22 +315,24 @@ function getAcs(): AsyncContextStrategy {
   return getAsyncContextStrategy(carrier);
 }
 
-function _startRootSpan(spanArguments: SentrySpanArguments, parentSampled?: boolean): SentrySpan {
+function _startRootSpan(spanArguments: SentrySpanArguments, scope: Scope, parentSampled?: boolean): SentrySpan {
   const client = getClient();
   const options: Partial<ClientOptions> = (client && client.getOptions()) || {};
 
   const { name = '', attributes } = spanArguments;
-  const [sampled, sampleRate] = sampleSpan(options, {
-    name,
-    parentSampled,
-    attributes,
-    transactionContext: {
-      name,
-      parentSampled,
-    },
-  });
-
-  const transaction = new SentrySpan({
+  const [sampled, sampleRate] = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY]
+    ? [false]
+    : sampleSpan(options, {
+        name,
+        parentSampled,
+        attributes,
+        transactionContext: {
+          name,
+          parentSampled,
+        },
+      });
+
+  const rootSpan = new SentrySpan({
     ...spanArguments,
     attributes: {
       [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',
@@ -320,30 +341,32 @@ function _startRootSpan(spanArguments: SentrySpanArguments, parentSampled?: bool
     sampled,
   });
   if (sampleRate !== undefined) {
-    transaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);
+    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);
   }
 
   if (client) {
-    client.emit('spanStart', transaction);
+    client.emit('spanStart', rootSpan);
   }
 
-  return transaction;
+  return rootSpan;
 }
 
 /**
  * Creates a new `Span` while setting the current `Span.id` as `parentSpanId`.
  * This inherits the sampling decision from the parent span.
  */
-function _startChildSpan(parentSpan: Span, spanArguments: SentrySpanArguments): SentrySpan {
+function _startChildSpan(parentSpan: Span, scope: Scope, spanArguments: SentrySpanArguments): Span {
   const { spanId, traceId } = parentSpan.spanContext();
-  const sampled = spanIsSampled(parentSpan);
+  const sampled = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] ? false : spanIsSampled(parentSpan);
 
-  const childSpan = new SentrySpan({
-    ...spanArguments,
-    parentSpanId: spanId,
-    traceId,
-    sampled,
-  });
+  const childSpan = sampled
+    ? new SentrySpan({
+        ...spanArguments,
+        parentSpanId: spanId,
+        traceId,
+        sampled,
+      })
+    : new SentryNonRecordingSpan();
 
   addChildSpanToSpan(parentSpan, childSpan);
 
diff --git a/packages/core/test/lib/tracing/trace.test.ts b/packages/core/test/lib/tracing/trace.test.ts
index 02144174ef1f..7c3962021b2f 100644
--- a/packages/core/test/lib/tracing/trace.test.ts
+++ b/packages/core/test/lib/tracing/trace.test.ts
@@ -20,11 +20,12 @@ import {
   startInactiveSpan,
   startSpan,
   startSpanManual,
+  suppressTracing,
   withActiveSpan,
 } from '../../../src/tracing';
 import { SentryNonRecordingSpan } from '../../../src/tracing/sentryNonRecordingSpan';
 import { _setSpanForScope } from '../../../src/utils/spanOnScope';
-import { getActiveSpan, getRootSpan, getSpanDescendants } from '../../../src/utils/spanUtils';
+import { getActiveSpan, getRootSpan, getSpanDescendants, spanIsSampled } from '../../../src/utils/spanUtils';
 import { TestClient, getDefaultTestClientOptions } from '../../mocks/client';
 
 beforeAll(() => {
@@ -259,7 +260,7 @@ describe('startSpan', () => {
     const initialScope = getCurrentScope();
 
     const manualScope = initialScope.clone();
-    const parentSpan = new SentrySpan({ spanId: 'parent-span-id' });
+    const parentSpan = new SentrySpan({ spanId: 'parent-span-id', sampled: true });
     _setSpanForScope(manualScope, parentSpan);
 
     startSpan({ name: 'GET users/[id]', scope: manualScope }, span => {
@@ -490,7 +491,7 @@ describe('startSpan', () => {
   });
 
   it('uses implementation from ACS, if it exists', () => {
-    const staticSpan = new SentrySpan({ spanId: 'aha' });
+    const staticSpan = new SentrySpan({ spanId: 'aha', sampled: true });
 
     const carrier = getMainCarrier();
 
@@ -575,7 +576,7 @@ describe('startSpanManual', () => {
     const initialScope = getCurrentScope();
 
     const manualScope = initialScope.clone();
-    const parentSpan = new SentrySpan({ spanId: 'parent-span-id' });
+    const parentSpan = new SentrySpan({ spanId: 'parent-span-id', sampled: true });
     _setSpanForScope(manualScope, parentSpan);
 
     startSpanManual({ name: 'GET users/[id]', scope: manualScope }, (span, finish) => {
@@ -761,7 +762,7 @@ describe('startSpanManual', () => {
   });
 
   it('uses implementation from ACS, if it exists', () => {
-    const staticSpan = new SentrySpan({ spanId: 'aha' });
+    const staticSpan = new SentrySpan({ spanId: 'aha', sampled: true });
 
     const carrier = getMainCarrier();
 
@@ -840,7 +841,7 @@ describe('startInactiveSpan', () => {
     const initialScope = getCurrentScope();
 
     const manualScope = initialScope.clone();
-    const parentSpan = new SentrySpan({ spanId: 'parent-span-id' });
+    const parentSpan = new SentrySpan({ spanId: 'parent-span-id', sampled: true });
     _setSpanForScope(manualScope, parentSpan);
 
     const span = startInactiveSpan({ name: 'GET users/[id]', scope: manualScope });
@@ -994,7 +995,7 @@ describe('startInactiveSpan', () => {
     });
   });
 
-  it('includes the scope at the time the span was started when finished xxx', async () => {
+  it('includes the scope at the time the span was started when finished', async () => {
     const beforeSendTransaction = jest.fn(event => event);
 
     const client = new TestClient(
@@ -1048,7 +1049,7 @@ describe('startInactiveSpan', () => {
   });
 
   it('uses implementation from ACS, if it exists', () => {
-    const staticSpan = new SentrySpan({ spanId: 'aha' });
+    const staticSpan = new SentrySpan({ spanId: 'aha', sampled: true });
 
     const carrier = getMainCarrier();
 
@@ -1206,7 +1207,7 @@ describe('getActiveSpan', () => {
   });
 
   it('works with an active span on the scope', () => {
-    const activeSpan = new SentrySpan({ spanId: 'aha' });
+    const activeSpan = new SentrySpan({ spanId: 'aha', sampled: true });
 
     withActiveSpan(activeSpan, () => {
       const span = getActiveSpan();
@@ -1215,7 +1216,7 @@ describe('getActiveSpan', () => {
   });
 
   it('uses implementation from ACS, if it exists', () => {
-    const staticSpan = new SentrySpan({ spanId: 'aha' });
+    const staticSpan = new SentrySpan({ spanId: 'aha', sampled: true });
 
     const carrier = getMainCarrier();
 
@@ -1285,7 +1286,7 @@ describe('withActiveSpan()', () => {
   });
 
   it('uses implementation from ACS, if it exists', () => {
-    const staticSpan = new SentrySpan({ spanId: 'aha' });
+    const staticSpan = new SentrySpan({ spanId: 'aha', sampled: true });
     const staticScope = new Scope();
 
     const carrier = getMainCarrier();
@@ -1359,3 +1360,66 @@ describe('span hooks', () => {
     expect(endedSpans).toEqual(['span5', 'span3', 'span2', 'span1']);
   });
 });
+
+describe('suppressTracing', () => {
+  beforeEach(() => {
+    addTracingExtensions();
+
+    getCurrentScope().clear();
+    getIsolationScope().clear();
+    getGlobalScope().clear();
+
+    setAsyncContextStrategy(undefined);
+
+    const options = getDefaultTestClientOptions({ tracesSampleRate: 1 });
+    client = new TestClient(options);
+    setCurrentClient(client);
+    client.init();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('works for a root span', () => {
+    const span = suppressTracing(() => {
+      return startInactiveSpan({ name: 'span' });
+    });
+
+    expect(span.isRecording()).toBe(false);
+    expect(spanIsSampled(span)).toBe(false);
+  });
+
+  it('works for a child span', () => {
+    startSpan({ name: 'outer' }, span => {
+      expect(span.isRecording()).toBe(true);
+      expect(spanIsSampled(span)).toBe(true);
+
+      const child1 = startInactiveSpan({ name: 'inner1' });
+
+      expect(child1.isRecording()).toBe(true);
+      expect(spanIsSampled(child1)).toBe(true);
+
+      const child2 = suppressTracing(() => {
+        return startInactiveSpan({ name: 'span' });
+      });
+
+      expect(child2.isRecording()).toBe(false);
+      expect(spanIsSampled(child2)).toBe(false);
+    });
+  });
+
+  it('works for a child span with forceTransaction=true', () => {
+    startSpan({ name: 'outer' }, span => {
+      expect(span.isRecording()).toBe(true);
+      expect(spanIsSampled(span)).toBe(true);
+
+      const child = suppressTracing(() => {
+        return startInactiveSpan({ name: 'span', forceTransaction: true });
+      });
+
+      expect(child.isRecording()).toBe(false);
+      expect(spanIsSampled(child)).toBe(false);
+    });
+  });
+});
diff --git a/packages/nextjs/src/common/devErrorSymbolicationEventProcessor.ts b/packages/nextjs/src/common/devErrorSymbolicationEventProcessor.ts
index 525322e3784c..0af455e8b2f7 100644
--- a/packages/nextjs/src/common/devErrorSymbolicationEventProcessor.ts
+++ b/packages/nextjs/src/common/devErrorSymbolicationEventProcessor.ts
@@ -1,3 +1,4 @@
+import { suppressTracing } from '@sentry/core';
 import type { Event, EventHint } from '@sentry/types';
 import { GLOBAL_OBJ } from '@sentry/utils';
 import type { StackFrame } from 'stacktrace-parser';
@@ -40,17 +41,19 @@ async function resolveStackFrame(
 
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 3000);
-    const res = await fetch(
-      `${
-        // eslint-disable-next-line no-restricted-globals
-        typeof window === 'undefined' ? 'http://localhost:3000' : '' // TODO: handle the case where users define a different port
-      }${basePath}/__nextjs_original-stack-frame?${params.toString()}`,
-      {
-        signal: controller.signal,
-      },
-    ).finally(() => {
-      clearTimeout(timer);
-    });
+    const res = await suppressTracing(() =>
+      fetch(
+        `${
+          // eslint-disable-next-line no-restricted-globals
+          typeof window === 'undefined' ? 'http://localhost:3000' : '' // TODO: handle the case where users define a different port
+        }${basePath}/__nextjs_original-stack-frame?${params.toString()}`,
+        {
+          signal: controller.signal,
+        },
+      ).finally(() => {
+        clearTimeout(timer);
+      }),
+    );
 
     if (!res.ok || res.status === 204) {
       return null;
diff --git a/packages/node/src/transports/http.ts b/packages/node/src/transports/http.ts
index 4cbe7ece1f60..d4d7435bdc6d 100644
--- a/packages/node/src/transports/http.ts
+++ b/packages/node/src/transports/http.ts
@@ -2,9 +2,7 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { Readable } from 'stream';
 import { createGzip } from 'zlib';
-import { context } from '@opentelemetry/api';
-import { suppressTracing } from '@opentelemetry/core';
-import { createTransport } from '@sentry/core';
+import { createTransport, suppressTracing } from '@sentry/core';
 import type {
   BaseTransportOptions,
   Transport,
@@ -82,7 +80,7 @@ export function makeNodeTransport(options: NodeTransportOptions): Transport {
     : new nativeHttpModule.Agent({ keepAlive, maxSockets: 30, timeout: 2000 });
 
   // This ensures we do not generate any spans in OpenTelemetry for the transport
-  return context.with(suppressTracing(context.active()), () => {
+  return suppressTracing(() => {
     const requestExecutor = createRequestExecutor(options, options.httpModule ?? nativeHttpModule, agent);
     return createTransport(options, requestExecutor);
   });
diff --git a/packages/opentelemetry/src/asyncContextStrategy.ts b/packages/opentelemetry/src/asyncContextStrategy.ts
index 75169ab933ed..b7f66870d07f 100644
--- a/packages/opentelemetry/src/asyncContextStrategy.ts
+++ b/packages/opentelemetry/src/asyncContextStrategy.ts
@@ -13,6 +13,7 @@ import { startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from '.
 import type { CurrentScopes } from './types';
 import { getScopesFromContext } from './utils/contextData';
 import { getActiveSpan } from './utils/getActiveSpan';
+import { suppressTracing } from './utils/suppressTracing';
 
 /**
  * Sets the async context strategy to use follow the OTEL context under the hood.
@@ -122,5 +123,6 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
     // The types here don't fully align, because our own `Span` type is narrower
     // than the OTEL one - but this is OK for here, as we now we'll only have OTEL spans passed around
     withActiveSpan: withActiveSpan as typeof defaultWithActiveSpan,
+    suppressTracing: suppressTracing,
   });
 }
diff --git a/packages/opentelemetry/src/index.ts b/packages/opentelemetry/src/index.ts
index 43f183be2139..3d727c707897 100644
--- a/packages/opentelemetry/src/index.ts
+++ b/packages/opentelemetry/src/index.ts
@@ -23,6 +23,8 @@ export { isSentryRequestSpan } from './utils/isSentryRequest';
 export { getActiveSpan } from './utils/getActiveSpan';
 export { startSpan, startSpanManual, startInactiveSpan, withActiveSpan, continueTrace } from './trace';
 
+export { suppressTracing } from './utils/suppressTracing';
+
 // eslint-disable-next-line deprecation/deprecation
 export { setupGlobalHub } from './custom/hub';
 // eslint-disable-next-line deprecation/deprecation
diff --git a/packages/opentelemetry/src/utils/suppressTracing.ts b/packages/opentelemetry/src/utils/suppressTracing.ts
new file mode 100644
index 000000000000..38813fd3239c
--- /dev/null
+++ b/packages/opentelemetry/src/utils/suppressTracing.ts
@@ -0,0 +1,8 @@
+import { context } from '@opentelemetry/api';
+import { suppressTracing as suppressTracingImpl } from '@opentelemetry/core';
+
+/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */
+export function suppressTracing<T>(callback: () => T): T {
+  const ctx = suppressTracingImpl(context.active());
+  return context.with(ctx, callback);
+}
diff --git a/packages/opentelemetry/test/trace.test.ts b/packages/opentelemetry/test/trace.test.ts
index a871fe1fbeba..4ef8a8d90f6d 100644
--- a/packages/opentelemetry/test/trace.test.ts
+++ b/packages/opentelemetry/test/trace.test.ts
@@ -15,6 +15,7 @@ import {
   getRootSpan,
   spanIsSampled,
   spanToJSON,
+  suppressTracing,
   withScope,
 } from '@sentry/core';
 import type { Event, Scope } from '@sentry/types';
@@ -1575,6 +1576,58 @@ describe('continueTrace', () => {
   });
 });
 
+describe('suppressTracing', () => {
+  beforeEach(() => {
+    mockSdkInit({ enableTracing: true });
+  });
+
+  afterEach(() => {
+    cleanupOtel();
+  });
+
+  it('works for a root span', () => {
+    const span = suppressTracing(() => {
+      return startInactiveSpan({ name: 'span' });
+    });
+
+    expect(span.isRecording()).toBe(false);
+    expect(spanIsSampled(span)).toBe(false);
+  });
+
+  it('works for a child span', () => {
+    startSpan({ name: 'outer' }, span => {
+      expect(span.isRecording()).toBe(true);
+      expect(spanIsSampled(span)).toBe(true);
+
+      const child1 = startInactiveSpan({ name: 'inner1' });
+
+      expect(child1.isRecording()).toBe(true);
+      expect(spanIsSampled(child1)).toBe(true);
+
+      const child2 = suppressTracing(() => {
+        return startInactiveSpan({ name: 'span' });
+      });
+
+      expect(child2.isRecording()).toBe(false);
+      expect(spanIsSampled(child2)).toBe(false);
+    });
+  });
+
+  it('works for a child span with forceTransaction=true', () => {
+    startSpan({ name: 'outer' }, span => {
+      expect(span.isRecording()).toBe(true);
+      expect(spanIsSampled(span)).toBe(true);
+
+      const child = suppressTracing(() => {
+        return startInactiveSpan({ name: 'span', forceTransaction: true });
+      });
+
+      expect(child.isRecording()).toBe(false);
+      expect(spanIsSampled(child)).toBe(false);
+    });
+  });
+});
+
 function getSpanName(span: AbstractSpan): string | undefined {
   return spanHasName(span) ? span.name : undefined;
 }

From e4ec09ea438e3dd30de8a6d257ffa2814a469208 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Wed, 10 Apr 2024 12:39:38 +0200
Subject: [PATCH 35/64] feat(browser): Create spans as children of root span by
 default (#10986)

You can opt out of this by setting `parentSpanIsAlwaysRootSpan=false` in
your client options.

This means that in browser, any span will always be added to the active
root span, not the active span. This way, we should be able to avoid
problems with execution contexts etc.

Closes https://github.com/getsentry/sentry-javascript/issues/10944
---
 packages/browser/src/client.ts               |  11 +-
 packages/core/src/tracing/trace.ts           |  37 +++--
 packages/core/test/lib/tracing/trace.test.ts | 148 +++++++++++++++++++
 packages/svelte/src/performance.ts           |  35 ++---
 packages/svelte/test/performance.test.ts     |   6 +-
 packages/types/src/options.ts                |  13 ++
 6 files changed, 204 insertions(+), 46 deletions(-)

diff --git a/packages/browser/src/client.ts b/packages/browser/src/client.ts
index 882a27cf3881..78ab902e01a1 100644
--- a/packages/browser/src/client.ts
+++ b/packages/browser/src/client.ts
@@ -52,12 +52,17 @@ export class BrowserClient extends BaseClient<BrowserClientOptions> {
    * @param options Configuration options for this SDK.
    */
   public constructor(options: BrowserClientOptions) {
+    const opts = {
+      // We default this to true, as it is the safer scenario
+      parentSpanIsAlwaysRootSpan: true,
+      ...options,
+    };
     const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();
-    applySdkMetadata(options, 'browser', ['browser'], sdkSource);
+    applySdkMetadata(opts, 'browser', ['browser'], sdkSource);
 
-    super(options);
+    super(opts);
 
-    if (options.sendClientReports && WINDOW.document) {
+    if (opts.sendClientReports && WINDOW.document) {
       WINDOW.document.addEventListener('visibilitychange', () => {
         if (WINDOW.document.visibilityState === 'hidden') {
           this._flushOutcomes();
diff --git a/packages/core/src/tracing/trace.ts b/packages/core/src/tracing/trace.ts
index c9e82163fef1..4b6fe024fd88 100644
--- a/packages/core/src/tracing/trace.ts
+++ b/packages/core/src/tracing/trace.ts
@@ -1,5 +1,4 @@
 import type { ClientOptions, Scope, SentrySpanArguments, Span, SpanTimeInput, StartSpanOptions } from '@sentry/types';
-
 import { propagationContextFromHeaders } from '@sentry/utils';
 import type { AsyncContextStrategy } from '../asyncContext';
 import { getMainCarrier } from '../asyncContext';
@@ -11,13 +10,7 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE
 import { handleCallbackErrors } from '../utils/handleCallbackErrors';
 import { hasTracingEnabled } from '../utils/hasTracingEnabled';
 import { _getSpanForScope, _setSpanForScope } from '../utils/spanOnScope';
-import {
-  addChildSpanToSpan,
-  getActiveSpan,
-  spanIsSampled,
-  spanTimeInputToSeconds,
-  spanToJSON,
-} from '../utils/spanUtils';
+import { addChildSpanToSpan, getRootSpan, spanIsSampled, spanTimeInputToSeconds, spanToJSON } from '../utils/spanUtils';
 import { freezeDscOnSpan, getDynamicSamplingContextFromSpan } from './dynamicSamplingContext';
 import { logSpanStart } from './logSpans';
 import { sampleSpan } from './sampling';
@@ -47,7 +40,7 @@ export function startSpan<T>(context: StartSpanOptions, callback: (span: Span) =
   const spanContext = normalizeContext(context);
 
   return withScope(context.scope, scope => {
-    const parentSpan = _getSpanForScope(scope) as SentrySpan | undefined;
+    const parentSpan = getParentSpan(scope);
 
     const shouldSkipSpan = context.onlyIfParent && !parentSpan;
     const activeSpan = shouldSkipSpan
@@ -94,7 +87,7 @@ export function startSpanManual<T>(context: StartSpanOptions, callback: (span: S
   const spanContext = normalizeContext(context);
 
   return withScope(context.scope, scope => {
-    const parentSpan = _getSpanForScope(scope) as SentrySpan | undefined;
+    const parentSpan = getParentSpan(scope);
 
     const shouldSkipSpan = context.onlyIfParent && !parentSpan;
     const activeSpan = shouldSkipSpan
@@ -141,9 +134,9 @@ export function startInactiveSpan(context: StartSpanOptions): Span {
   }
 
   const spanContext = normalizeContext(context);
-  const parentSpan = context.scope
-    ? (_getSpanForScope(context.scope) as SentrySpan | undefined)
-    : (getActiveSpan() as SentrySpan | undefined);
+
+  const scope = context.scope || getCurrentScope();
+  const parentSpan = getParentSpan(scope);
 
   const shouldSkipSpan = context.onlyIfParent && !parentSpan;
 
@@ -151,8 +144,6 @@ export function startInactiveSpan(context: StartSpanOptions): Span {
     return new SentryNonRecordingSpan();
   }
 
-  const scope = context.scope || getCurrentScope();
-
   return createChildSpanOrTransaction({
     parentSpan,
     spanContext,
@@ -381,3 +372,19 @@ function _startChildSpan(parentSpan: Span, scope: Scope, spanArguments: SentrySp
 
   return childSpan;
 }
+
+function getParentSpan(scope: Scope): SentrySpan | undefined {
+  const span = _getSpanForScope(scope) as SentrySpan | undefined;
+
+  if (!span) {
+    return undefined;
+  }
+
+  const client = getClient();
+  const options: Partial<ClientOptions> = client ? client.getOptions() : {};
+  if (options.parentSpanIsAlwaysRootSpan) {
+    return getRootSpan(span) as SentrySpan;
+  }
+
+  return span;
+}
diff --git a/packages/core/test/lib/tracing/trace.test.ts b/packages/core/test/lib/tracing/trace.test.ts
index 7c3962021b2f..8fe6de43f219 100644
--- a/packages/core/test/lib/tracing/trace.test.ts
+++ b/packages/core/test/lib/tracing/trace.test.ts
@@ -417,6 +417,48 @@ describe('startSpan', () => {
     });
   });
 
+  describe('parentSpanIsAlwaysRootSpan', () => {
+    it('creates a span as child of root span if parentSpanIsAlwaysRootSpan=true', () => {
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 1,
+        parentSpanIsAlwaysRootSpan: true,
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+
+      startSpan({ name: 'parent span' }, span => {
+        expect(spanToJSON(span).parent_span_id).toBe(undefined);
+        startSpan({ name: 'child span' }, childSpan => {
+          expect(spanToJSON(childSpan).parent_span_id).toBe(span.spanContext().spanId);
+          startSpan({ name: 'grand child span' }, grandChildSpan => {
+            expect(spanToJSON(grandChildSpan).parent_span_id).toBe(span.spanContext().spanId);
+          });
+        });
+      });
+    });
+
+    it('does not creates a span as child of root span if parentSpanIsAlwaysRootSpan=false', () => {
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 1,
+        parentSpanIsAlwaysRootSpan: false,
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+
+      startSpan({ name: 'parent span' }, span => {
+        expect(spanToJSON(span).parent_span_id).toBe(undefined);
+        startSpan({ name: 'child span' }, childSpan => {
+          expect(spanToJSON(childSpan).parent_span_id).toBe(span.spanContext().spanId);
+          startSpan({ name: 'grand child span' }, grandChildSpan => {
+            expect(spanToJSON(grandChildSpan).parent_span_id).toBe(childSpan.spanContext().spanId);
+          });
+        });
+      });
+    });
+  });
+
   it('samples with a tracesSampler', () => {
     const tracesSampler = jest.fn(() => {
       return true;
@@ -751,6 +793,54 @@ describe('startSpanManual', () => {
     });
   });
 
+  describe('parentSpanIsAlwaysRootSpan', () => {
+    it('creates a span as child of root span if parentSpanIsAlwaysRootSpan=true', () => {
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 1,
+        parentSpanIsAlwaysRootSpan: true,
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+
+      startSpanManual({ name: 'parent span' }, span => {
+        expect(spanToJSON(span).parent_span_id).toBe(undefined);
+        startSpanManual({ name: 'child span' }, childSpan => {
+          expect(spanToJSON(childSpan).parent_span_id).toBe(span.spanContext().spanId);
+          startSpanManual({ name: 'grand child span' }, grandChildSpan => {
+            expect(spanToJSON(grandChildSpan).parent_span_id).toBe(span.spanContext().spanId);
+            grandChildSpan.end();
+          });
+          childSpan.end();
+        });
+        span.end();
+      });
+    });
+
+    it('does not creates a span as child of root span if parentSpanIsAlwaysRootSpan=false', () => {
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 1,
+        parentSpanIsAlwaysRootSpan: false,
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+
+      startSpanManual({ name: 'parent span' }, span => {
+        expect(spanToJSON(span).parent_span_id).toBe(undefined);
+        startSpanManual({ name: 'child span' }, childSpan => {
+          expect(spanToJSON(childSpan).parent_span_id).toBe(span.spanContext().spanId);
+          startSpanManual({ name: 'grand child span' }, grandChildSpan => {
+            expect(spanToJSON(grandChildSpan).parent_span_id).toBe(childSpan.spanContext().spanId);
+            grandChildSpan.end();
+          });
+          childSpan.end();
+        });
+        span.end();
+      });
+    });
+  });
+
   it('sets a child span reference on the parent span', () => {
     expect.assertions(1);
     startSpan({ name: 'outer' }, (outerSpan: any) => {
@@ -995,6 +1085,64 @@ describe('startInactiveSpan', () => {
     });
   });
 
+  describe('parentSpanIsAlwaysRootSpan', () => {
+    it('creates a span as child of root span if parentSpanIsAlwaysRootSpan=true', () => {
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 1,
+        parentSpanIsAlwaysRootSpan: true,
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+
+      const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+      expect(spanToJSON(inactiveSpan).parent_span_id).toBe(undefined);
+
+      startSpan({ name: 'parent span' }, span => {
+        const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+        expect(spanToJSON(inactiveSpan).parent_span_id).toBe(span.spanContext().spanId);
+
+        startSpan({ name: 'child span' }, () => {
+          const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+          expect(spanToJSON(inactiveSpan).parent_span_id).toBe(span.spanContext().spanId);
+
+          startSpan({ name: 'grand child span' }, () => {
+            const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+            expect(spanToJSON(inactiveSpan).parent_span_id).toBe(span.spanContext().spanId);
+          });
+        });
+      });
+    });
+
+    it('does not creates a span as child of root span if parentSpanIsAlwaysRootSpan=false', () => {
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 1,
+        parentSpanIsAlwaysRootSpan: false,
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+
+      const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+      expect(spanToJSON(inactiveSpan).parent_span_id).toBe(undefined);
+
+      startSpan({ name: 'parent span' }, span => {
+        const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+        expect(spanToJSON(inactiveSpan).parent_span_id).toBe(span.spanContext().spanId);
+
+        startSpan({ name: 'child span' }, childSpan => {
+          const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+          expect(spanToJSON(inactiveSpan).parent_span_id).toBe(childSpan.spanContext().spanId);
+
+          startSpan({ name: 'grand child span' }, grandChildSpan => {
+            const inactiveSpan = startInactiveSpan({ name: 'inactive span' });
+            expect(spanToJSON(inactiveSpan).parent_span_id).toBe(grandChildSpan.spanContext().spanId);
+          });
+        });
+      });
+    });
+  });
+
   it('includes the scope at the time the span was started when finished', async () => {
     const beforeSendTransaction = jest.fn(event => event);
 
diff --git a/packages/svelte/src/performance.ts b/packages/svelte/src/performance.ts
index fb5f80d0ffaf..100f9f732ddc 100644
--- a/packages/svelte/src/performance.ts
+++ b/packages/svelte/src/performance.ts
@@ -3,7 +3,7 @@ import type { Span } from '@sentry/types';
 import { afterUpdate, beforeUpdate, onMount } from 'svelte';
 import { current_component } from 'svelte/internal';
 
-import { getRootSpan, startInactiveSpan, withActiveSpan } from '@sentry/core';
+import { startInactiveSpan } from '@sentry/core';
 import { DEFAULT_COMPONENT_NAME, UI_SVELTE_INIT, UI_SVELTE_UPDATE } from './constants';
 import type { TrackComponentOptions } from './types';
 
@@ -34,17 +34,16 @@ export function trackComponent(options?: TrackComponentOptions): void {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   const componentName = `<${customComponentName || current_component.constructor.name || DEFAULT_COMPONENT_NAME}>`;
 
-  let initSpan: Span | undefined = undefined;
   if (mergedOptions.trackInit) {
-    initSpan = recordInitSpan(componentName);
+    recordInitSpan(componentName);
   }
 
   if (mergedOptions.trackUpdates) {
-    recordUpdateSpans(componentName, initSpan);
+    recordUpdateSpans(componentName);
   }
 }
 
-function recordInitSpan(componentName: string): Span | undefined {
+function recordInitSpan(componentName: string): void {
   const initSpan = startInactiveSpan({
     onlyIfParent: true,
     op: UI_SVELTE_INIT,
@@ -55,35 +54,21 @@ function recordInitSpan(componentName: string): Span | undefined {
   onMount(() => {
     initSpan.end();
   });
-
-  return initSpan;
 }
 
-function recordUpdateSpans(componentName: string, initSpan?: Span): void {
+function recordUpdateSpans(componentName: string): void {
   let updateSpan: Span | undefined;
   beforeUpdate(() => {
-    // We need to get the active transaction again because the initial one could
-    // already be finished or there is currently no transaction going on.
+    // If there is no active span, we skip
     const activeSpan = getActiveSpan();
     if (!activeSpan) {
       return;
     }
 
-    // If we are initializing the component when the update span is started, we start it as child
-    // of the init span. Else, we start it as a child of the transaction.
-    const parentSpan =
-      initSpan && initSpan.isRecording() && getRootSpan(initSpan) === getRootSpan(activeSpan)
-        ? initSpan
-        : getRootSpan(activeSpan);
-
-    if (!parentSpan) return;
-
-    updateSpan = withActiveSpan(parentSpan, () => {
-      return startInactiveSpan({
-        op: UI_SVELTE_UPDATE,
-        name: componentName,
-        attributes: { [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.svelte' },
-      });
+    updateSpan = startInactiveSpan({
+      op: UI_SVELTE_UPDATE,
+      name: componentName,
+      attributes: { [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.svelte' },
     });
   });
 
diff --git a/packages/svelte/test/performance.test.ts b/packages/svelte/test/performance.test.ts
index dd8baea00637..735a732f981a 100644
--- a/packages/svelte/test/performance.test.ts
+++ b/packages/svelte/test/performance.test.ts
@@ -33,7 +33,7 @@ describe('Sentry.trackComponent()', () => {
     });
   });
 
-  it('creates nested init and update spans on component initialization', async () => {
+  it('creates init and update spans on component initialization', async () => {
     startSpan({ name: 'outer' }, span => {
       expect(span).toBeDefined();
       render(DummyComponent, { props: { options: {} } });
@@ -73,7 +73,7 @@ describe('Sentry.trackComponent()', () => {
       description: '<Dummy$>',
       op: 'ui.svelte.update',
       origin: 'auto.ui.svelte',
-      parent_span_id: initSpanId,
+      parent_span_id: rootSpanId,
       span_id: expect.any(String),
       start_timestamp: expect.any(Number),
       timestamp: expect.any(Number),
@@ -128,7 +128,7 @@ describe('Sentry.trackComponent()', () => {
       description: '<Dummy$>',
       op: 'ui.svelte.update',
       origin: 'auto.ui.svelte',
-      parent_span_id: initSpanId,
+      parent_span_id: rootSpanId,
       span_id: expect.any(String),
       start_timestamp: expect.any(Number),
       timestamp: expect.any(Number),
diff --git a/packages/types/src/options.ts b/packages/types/src/options.ts
index c9c95140902d..bf41b16fc595 100644
--- a/packages/types/src/options.ts
+++ b/packages/types/src/options.ts
@@ -94,6 +94,19 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
    */
   enableTracing?: boolean;
 
+  /**
+   * If this is enabled, any spans started will always have their parent be the active root span,
+   * if there is any active span.
+   *
+   * This is necessary because in some environments (e.g. browser),
+   * we cannot guarantee an accurate active span.
+   * Because we cannot properly isolate execution environments,
+   * you may get wrong results when using e.g. nested `startSpan()` calls.
+   *
+   * To solve this, in these environments we'll by default enable this option.
+   */
+  parentSpanIsAlwaysRootSpan?: boolean;
+
   /**
    * Initial data to populate scope.
    */

From 700562ddec9012f76e90658b0e07934430fa1ef4 Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Wed, 10 Apr 2024 16:24:39 +0200
Subject: [PATCH 36/64] feat(node): Do not exit process by default when other
 `onUncaughtException` handlers are registered in
 `onUncaughtExceptionIntegration` (#11532)

---
 MIGRATION.md                                  | 11 ++++++++
 .../public-api/OnUncaughtException/test.ts    |  9 +++----
 packages/nextjs/src/server/index.ts           |  4 ---
 .../server/onUncaughtExceptionIntegration.ts  |  5 ----
 .../src/integrations/onuncaughtexception.ts   | 25 +++++++------------
 5 files changed, 24 insertions(+), 30 deletions(-)
 delete mode 100644 packages/nextjs/src/server/onUncaughtExceptionIntegration.ts

diff --git a/MIGRATION.md b/MIGRATION.md
index 51bf19cddb01..046906b2f0fd 100644
--- a/MIGRATION.md
+++ b/MIGRATION.md
@@ -1118,6 +1118,7 @@ Sentry.init({
 - [Updated behaviour of `extraErrorDataIntegration`](./MIGRATION.md#extraerrordataintegration-changes)
 - [Updated behaviour of `transactionContext` passed to `tracesSampler`](./MIGRATION.md#transactioncontext-no-longer-passed-to-tracessampler)
 - [Updated behaviour of `getClient()`](./MIGRATION.md#getclient-always-returns-a-client)
+- [Updated behaviour of the SDK in combination with `onUncaughtException` handlers in Node.js](./MIGRATION.md#behaviour-in-combination-with-onuncaughtexception-handlers-in-node.js)
 - [Removal of Client-Side health check transaction filters](./MIGRATION.md#removal-of-client-side-health-check-transaction-filters)
 - [Change of Replay default options (`unblock` and `unmask`)](./MIGRATION.md#change-of-replay-default-options-unblock-and-unmask)
 - [Angular Tracing Decorator renaming](./MIGRATION.md#angular-tracing-decorator-renaming)
@@ -1168,6 +1169,16 @@ some attributes may only be set later during the span lifecycle (and thus not be
 Sentry was actually initialized, using `getClient()` will thus not work anymore. Instead, you should use the new
 `Sentry.isInitialized()` utility to check this.
 
+#### Behaviour in combination with `onUncaughtException` handlers in Node.js
+
+Previously the SDK exited the process by default, even though additional `onUncaughtException` may have been registered,
+that would have prevented the process from exiting. You could opt out of this behaviour by setting the
+`exitEvenIfOtherHandlersAreRegistered: false` in the `onUncaughtExceptionIntegration` options. Up until now the value
+for this option defaulted to `true`.
+
+Going forward, the default value for `exitEvenIfOtherHandlersAreRegistered` will be `false`, meaning that the SDK will
+not exit your process when you have registered other `onUncaughtException` handlers.
+
 #### Removal of Client-Side health check transaction filters
 
 The SDK no longer filters out health check transactions by default. Instead, they are sent to Sentry but still dropped
diff --git a/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts b/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts
index c90dd989e37f..60523dc37684 100644
--- a/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts
@@ -15,15 +15,14 @@ describe('OnUncaughtException integration', () => {
     });
   });
 
-  test('should close process on uncaught error when additional listeners are registered', done => {
-    expect.assertions(3);
+  test('should not close process on uncaught error when additional listeners are registered', done => {
+    expect.assertions(2);
 
     const testScriptPath = path.resolve(__dirname, 'additional-listener-test-script.js');
 
     childProcess.exec(`node ${testScriptPath}`, { encoding: 'utf8' }, (err, stdout) => {
-      expect(err).not.toBeNull();
-      expect(err?.code).toBe(1);
-      expect(stdout).not.toBe("I'm alive!");
+      expect(err).toBeNull();
+      expect(stdout).toBe("I'm alive!");
       done();
     });
   });
diff --git a/packages/nextjs/src/server/index.ts b/packages/nextjs/src/server/index.ts
index de5ac52c4f18..d961d6717e4c 100644
--- a/packages/nextjs/src/server/index.ts
+++ b/packages/nextjs/src/server/index.ts
@@ -8,14 +8,12 @@ import { devErrorSymbolicationEventProcessor } from '../common/devErrorSymbolica
 import { getVercelEnv } from '../common/getVercelEnv';
 import { isBuild } from '../common/utils/isBuild';
 import { distDirRewriteFramesIntegration } from './distDirRewriteFramesIntegration';
-import { onUncaughtExceptionIntegration } from './onUncaughtExceptionIntegration';
 
 export * from '@sentry/node';
 import type { EventProcessor } from '@sentry/types';
 import { requestIsolationScopeIntegration } from './requestIsolationScopeIntegration';
 
 export { captureUnderscoreErrorException } from '../common/_error';
-export { onUncaughtExceptionIntegration } from './onUncaughtExceptionIntegration';
 
 const globalWithInjectedValues = GLOBAL_OBJ as typeof GLOBAL_OBJ & {
   __rewriteFramesDistDir__?: string;
@@ -75,13 +73,11 @@ export function init(options: NodeOptions): void {
   const customDefaultIntegrations = [
     ...getDefaultIntegrations(options).filter(
       integration =>
-        integration.name !== 'OnUncaughtException' &&
         // Next.js comes with its own Node-Fetch instrumentation, so we shouldn't add ours on-top
         integration.name !== 'NodeFetch' &&
         // Next.js comes with its own Http instrumentation for OTel which lead to double spans for route handler requests
         integration.name !== 'Http',
     ),
-    onUncaughtExceptionIntegration(),
     requestIsolationScopeIntegration(),
   ];
 
diff --git a/packages/nextjs/src/server/onUncaughtExceptionIntegration.ts b/packages/nextjs/src/server/onUncaughtExceptionIntegration.ts
deleted file mode 100644
index d9eada65fa95..000000000000
--- a/packages/nextjs/src/server/onUncaughtExceptionIntegration.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { onUncaughtExceptionIntegration as originalOnUncaughtExceptionIntegration } from '@sentry/node';
-
-export const onUncaughtExceptionIntegration: typeof originalOnUncaughtExceptionIntegration = options => {
-  return originalOnUncaughtExceptionIntegration({ ...options, exitEvenIfOtherHandlersAreRegistered: false });
-};
diff --git a/packages/node/src/integrations/onuncaughtexception.ts b/packages/node/src/integrations/onuncaughtexception.ts
index e56c3c0801d7..637174f12351 100644
--- a/packages/node/src/integrations/onuncaughtexception.ts
+++ b/packages/node/src/integrations/onuncaughtexception.ts
@@ -1,6 +1,5 @@
 import { captureException, defineIntegration } from '@sentry/core';
 import { getClient } from '@sentry/core';
-import type { IntegrationFn } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
@@ -13,17 +12,13 @@ type TaggedListener = NodeJS.UncaughtExceptionListener & {
   tag?: string;
 };
 
-// CAREFUL: Please think twice before updating the way _options looks because the Next.js SDK depends on it in `index.server.ts`
 interface OnUncaughtExceptionOptions {
-  // TODO(v8): Evaluate whether we should switch the default behaviour here.
-  // Also, we can evaluate using https://nodejs.org/api/process.html#event-uncaughtexceptionmonitor per default, and
-  // falling back to current behaviour when that's not available.
   /**
    * Controls if the SDK should register a handler to exit the process on uncaught errors:
    * - `true`: The SDK will exit the process on all uncaught errors.
    * - `false`: The SDK will only exit the process when there are no other `uncaughtException` handlers attached.
    *
-   * Default: `true`
+   * Default: `false`
    */
   exitEvenIfOtherHandlersAreRegistered: boolean;
 
@@ -40,24 +35,22 @@ interface OnUncaughtExceptionOptions {
 
 const INTEGRATION_NAME = 'OnUncaughtException';
 
-const _onUncaughtExceptionIntegration = ((options: Partial<OnUncaughtExceptionOptions> = {}) => {
-  const _options = {
-    exitEvenIfOtherHandlersAreRegistered: true,
+/**
+ * Add a global exception handler.
+ */
+export const onUncaughtExceptionIntegration = defineIntegration((options: Partial<OnUncaughtExceptionOptions> = {}) => {
+  const optionsWithDefaults = {
+    exitEvenIfOtherHandlersAreRegistered: false,
     ...options,
   };
 
   return {
     name: INTEGRATION_NAME,
     setup(client: NodeClient) {
-      global.process.on('uncaughtException', makeErrorHandler(client, _options));
+      global.process.on('uncaughtException', makeErrorHandler(client, optionsWithDefaults));
     },
   };
-}) satisfies IntegrationFn;
-
-/**
- * Add a global exception handler.
- */
-export const onUncaughtExceptionIntegration = defineIntegration(_onUncaughtExceptionIntegration);
+});
 
 type ErrorHandler = { _errorHandler: boolean } & ((error: Error) => void);
 

From 481debb7958916c030b768c17b5e0614d4cc2317 Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Wed, 10 Apr 2024 16:44:23 +0200
Subject: [PATCH 37/64] feat: Hoist `getCurrentHub` shim to core as
 `getCurrentHubShim` (#11537)

---
 .../src/getCurrentHubShim.ts}                    | 16 +++++++---------
 packages/core/src/index.ts                       |  3 +++
 .../opentelemetry/src/asyncContextStrategy.ts    | 10 +++++++---
 packages/opentelemetry/src/index.ts              |  2 +-
 4 files changed, 18 insertions(+), 13 deletions(-)
 rename packages/{opentelemetry/src/custom/getCurrentHub.ts => core/src/getCurrentHubShim.ts} (84%)

diff --git a/packages/opentelemetry/src/custom/getCurrentHub.ts b/packages/core/src/getCurrentHubShim.ts
similarity index 84%
rename from packages/opentelemetry/src/custom/getCurrentHub.ts
rename to packages/core/src/getCurrentHubShim.ts
index 9db09297d670..435004ce9f57 100644
--- a/packages/opentelemetry/src/custom/getCurrentHub.ts
+++ b/packages/core/src/getCurrentHubShim.ts
@@ -1,12 +1,9 @@
 import type { Client, EventHint, Hub, Integration, IntegrationClass, SeverityLevel } from '@sentry/types';
-
+import { addBreadcrumb } from './breadcrumbs';
+import { getClient, getCurrentScope, getIsolationScope, withScope } from './currentScopes';
 import {
-  addBreadcrumb,
   captureEvent,
   endSession,
-  getClient,
-  getCurrentScope,
-  getIsolationScope,
   setContext,
   setExtra,
   setExtras,
@@ -14,14 +11,14 @@ import {
   setTags,
   setUser,
   startSession,
-  withScope,
-} from '@sentry/core';
+} from './exports';
 
 /**
  * This is for legacy reasons, and returns a proxy object instead of a hub to be used.
+ *
  * @deprecated Use the methods directly.
  */
-export function getCurrentHub(): Hub {
+export function getCurrentHubShim(): Hub {
   return {
     bindClient(client: Client): void {
       const scope = getCurrentScope();
@@ -48,7 +45,8 @@ export function getCurrentHub(): Hub {
     setContext,
 
     getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {
-      return getClient()?.getIntegrationByName<T>(integration.id) || null;
+      const client = getClient();
+      return (client && client.getIntegrationByName<T>(integration.id)) || null;
     },
 
     startSession,
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 48bb5baf6afc..e3f827605aeb 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -106,3 +106,6 @@ export { BrowserMetricsAggregator } from './metrics/browser-aggregator';
 export { getMetricSummaryJsonForSpan } from './metrics/metric-summary';
 export { addTracingHeadersToFetchRequest, instrumentFetchRequest } from './fetch';
 export { trpcMiddleware } from './trpc';
+
+// eslint-disable-next-line deprecation/deprecation
+export { getCurrentHubShim } from './getCurrentHubShim';
diff --git a/packages/opentelemetry/src/asyncContextStrategy.ts b/packages/opentelemetry/src/asyncContextStrategy.ts
index b7f66870d07f..e28995a5d805 100644
--- a/packages/opentelemetry/src/asyncContextStrategy.ts
+++ b/packages/opentelemetry/src/asyncContextStrategy.ts
@@ -1,5 +1,10 @@
 import * as api from '@opentelemetry/api';
-import { getDefaultCurrentScope, getDefaultIsolationScope, setAsyncContextStrategy } from '@sentry/core';
+import {
+  getCurrentHubShim,
+  getDefaultCurrentScope,
+  getDefaultIsolationScope,
+  setAsyncContextStrategy,
+} from '@sentry/core';
 import type { withActiveSpan as defaultWithActiveSpan } from '@sentry/core';
 import type { Hub, Scope } from '@sentry/types';
 
@@ -8,7 +13,6 @@ import {
   SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY,
   SENTRY_FORK_SET_SCOPE_CONTEXT_KEY,
 } from './constants';
-import { getCurrentHub as _getCurrentHub } from './custom/getCurrentHub';
 import { startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from './trace';
 import type { CurrentScopes } from './types';
 import { getScopesFromContext } from './utils/contextData';
@@ -38,7 +42,7 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
 
   function getCurrentHub(): Hub {
     // eslint-disable-next-line deprecation/deprecation
-    const hub = _getCurrentHub();
+    const hub = getCurrentHubShim();
     return {
       ...hub,
       getScope: () => {
diff --git a/packages/opentelemetry/src/index.ts b/packages/opentelemetry/src/index.ts
index 3d727c707897..db5abb951f4c 100644
--- a/packages/opentelemetry/src/index.ts
+++ b/packages/opentelemetry/src/index.ts
@@ -28,7 +28,7 @@ export { suppressTracing } from './utils/suppressTracing';
 // eslint-disable-next-line deprecation/deprecation
 export { setupGlobalHub } from './custom/hub';
 // eslint-disable-next-line deprecation/deprecation
-export { getCurrentHub } from './custom/getCurrentHub';
+export { getCurrentHubShim } from '@sentry/core';
 export { setupEventContextTrace } from './setupEventContextTrace';
 
 export { setOpenTelemetryContextAsyncContextStrategy } from './asyncContextStrategy';

From c8bc80b804b54406824ac0d704d149ddeb9abb3e Mon Sep 17 00:00:00 2001
From: Tim Fish <tim@timfish.uk>
Date: Wed, 10 Apr 2024 23:08:12 +0200
Subject: [PATCH 38/64] feat(core): Update metric normalization (#11518)

Closes #11433

https://develop.sentry.dev/sdk/metrics/#normalization
---
 packages/core/src/metrics/aggregator.ts       | 10 +--
 .../core/src/metrics/browser-aggregator.ts    | 12 ++--
 packages/core/src/metrics/constants.ts        | 20 ------
 packages/core/src/metrics/utils.ts            | 62 ++++++++++++++++++-
 packages/core/test/lib/metrics/utils.test.ts  | 24 ++++++-
 5 files changed, 94 insertions(+), 34 deletions(-)

diff --git a/packages/core/src/metrics/aggregator.ts b/packages/core/src/metrics/aggregator.ts
index 8b56d190b88a..8752d2a10df7 100644
--- a/packages/core/src/metrics/aggregator.ts
+++ b/packages/core/src/metrics/aggregator.ts
@@ -1,11 +1,11 @@
 import type { Client, MeasurementUnit, MetricsAggregator as MetricsAggregatorBase, Primitive } from '@sentry/types';
 import { timestampInSeconds } from '@sentry/utils';
 import { updateMetricSummaryOnActiveSpan } from '../utils/spanUtils';
-import { DEFAULT_FLUSH_INTERVAL, MAX_WEIGHT, NAME_AND_TAG_KEY_NORMALIZATION_REGEX, SET_METRIC_TYPE } from './constants';
+import { DEFAULT_FLUSH_INTERVAL, MAX_WEIGHT, SET_METRIC_TYPE } from './constants';
 import { captureAggregateMetrics } from './envelope';
 import { METRIC_MAP } from './instance';
 import type { MetricBucket, MetricType } from './types';
-import { getBucketKey, sanitizeTags } from './utils';
+import { getBucketKey, sanitizeMetricKey, sanitizeTags, sanitizeUnit } from './utils';
 
 /**
  * A metrics aggregator that aggregates metrics in memory and flushes them periodically.
@@ -46,6 +46,7 @@ export class MetricsAggregator implements MetricsAggregatorBase {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       this._interval.unref();
     }
+
     this._flushShift = Math.floor((Math.random() * DEFAULT_FLUSH_INTERVAL) / 1000);
     this._forceFlush = false;
   }
@@ -57,13 +58,14 @@ export class MetricsAggregator implements MetricsAggregatorBase {
     metricType: MetricType,
     unsanitizedName: string,
     value: number | string,
-    unit: MeasurementUnit = 'none',
+    unsanitizedUnit: MeasurementUnit = 'none',
     unsanitizedTags: Record<string, Primitive> = {},
     maybeFloatTimestamp = timestampInSeconds(),
   ): void {
     const timestamp = Math.floor(maybeFloatTimestamp);
-    const name = unsanitizedName.replace(NAME_AND_TAG_KEY_NORMALIZATION_REGEX, '_');
+    const name = sanitizeMetricKey(unsanitizedName);
     const tags = sanitizeTags(unsanitizedTags);
+    const unit = sanitizeUnit(unsanitizedUnit as string);
 
     const bucketKey = getBucketKey(metricType, name, unit, tags);
 
diff --git a/packages/core/src/metrics/browser-aggregator.ts b/packages/core/src/metrics/browser-aggregator.ts
index 7d599f5aeba8..e087b45ca010 100644
--- a/packages/core/src/metrics/browser-aggregator.ts
+++ b/packages/core/src/metrics/browser-aggregator.ts
@@ -1,11 +1,11 @@
 import type { Client, MeasurementUnit, MetricsAggregator, Primitive } from '@sentry/types';
 import { timestampInSeconds } from '@sentry/utils';
 import { updateMetricSummaryOnActiveSpan } from '../utils/spanUtils';
-import { DEFAULT_BROWSER_FLUSH_INTERVAL, NAME_AND_TAG_KEY_NORMALIZATION_REGEX, SET_METRIC_TYPE } from './constants';
+import { DEFAULT_BROWSER_FLUSH_INTERVAL, SET_METRIC_TYPE } from './constants';
 import { captureAggregateMetrics } from './envelope';
 import { METRIC_MAP } from './instance';
 import type { MetricBucket, MetricType } from './types';
-import { getBucketKey, sanitizeTags } from './utils';
+import { getBucketKey, sanitizeMetricKey, sanitizeTags, sanitizeUnit } from './utils';
 
 /**
  * A simple metrics aggregator that aggregates metrics in memory and flushes them periodically.
@@ -32,13 +32,14 @@ export class BrowserMetricsAggregator implements MetricsAggregator {
     metricType: MetricType,
     unsanitizedName: string,
     value: number | string,
-    unit: MeasurementUnit | undefined = 'none',
+    unsanitizedUnit: MeasurementUnit | undefined = 'none',
     unsanitizedTags: Record<string, Primitive> | undefined = {},
     maybeFloatTimestamp: number | undefined = timestampInSeconds(),
   ): void {
     const timestamp = Math.floor(maybeFloatTimestamp);
-    const name = unsanitizedName.replace(NAME_AND_TAG_KEY_NORMALIZATION_REGEX, '_');
+    const name = sanitizeMetricKey(unsanitizedName);
     const tags = sanitizeTags(unsanitizedTags);
+    const unit = sanitizeUnit(unsanitizedUnit as string);
 
     const bucketKey = getBucketKey(metricType, name, unit, tags);
 
@@ -79,8 +80,7 @@ export class BrowserMetricsAggregator implements MetricsAggregator {
       return;
     }
 
-    // TODO(@anonrig): Use Object.values() when we support ES6+
-    const metricBuckets = Array.from(this._buckets).map(([, bucketItem]) => bucketItem);
+    const metricBuckets = Array.from(this._buckets.values());
     captureAggregateMetrics(this._client, metricBuckets);
 
     this._buckets.clear();
diff --git a/packages/core/src/metrics/constants.ts b/packages/core/src/metrics/constants.ts
index a5f3a87f57d5..ae1cd968723c 100644
--- a/packages/core/src/metrics/constants.ts
+++ b/packages/core/src/metrics/constants.ts
@@ -3,26 +3,6 @@ export const GAUGE_METRIC_TYPE = 'g' as const;
 export const SET_METRIC_TYPE = 's' as const;
 export const DISTRIBUTION_METRIC_TYPE = 'd' as const;
 
-/**
- * Normalization regex for metric names and metric tag names.
- *
- * This enforces that names and tag keys only contain alphanumeric characters,
- * underscores, forward slashes, periods, and dashes.
- *
- * See: https://develop.sentry.dev/sdk/metrics/#normalization
- */
-export const NAME_AND_TAG_KEY_NORMALIZATION_REGEX = /[^a-zA-Z0-9_/.-]+/g;
-
-/**
- * Normalization regex for metric tag values.
- *
- * This enforces that values only contain words, digits, or the following
- * special characters: _:/@.{}[\]$-
- *
- * See: https://develop.sentry.dev/sdk/metrics/#normalization
- */
-export const TAG_VALUE_NORMALIZATION_REGEX = /[^\w\d\s_:/@.{}[\]$-]+/g;
-
 /**
  * This does not match spec in https://develop.sentry.dev/sdk/metrics
  * but was chosen to optimize for the most common case in browser environments.
diff --git a/packages/core/src/metrics/utils.ts b/packages/core/src/metrics/utils.ts
index 7b1cf96a8462..bc1ff93e0002 100644
--- a/packages/core/src/metrics/utils.ts
+++ b/packages/core/src/metrics/utils.ts
@@ -1,6 +1,5 @@
 import type { MeasurementUnit, MetricBucketItem, Primitive } from '@sentry/types';
 import { dropUndefinedKeys } from '@sentry/utils';
-import { NAME_AND_TAG_KEY_NORMALIZATION_REGEX, TAG_VALUE_NORMALIZATION_REGEX } from './constants';
 import type { MetricType } from './types';
 
 /**
@@ -54,6 +53,63 @@ export function serializeMetricBuckets(metricBucketItems: MetricBucketItem[]): s
   return out;
 }
 
+/**
+ * Sanitizes units
+ *
+ * These Regex's are straight from the normalisation docs:
+ * https://develop.sentry.dev/sdk/metrics/#normalization
+ */
+export function sanitizeUnit(unit: string): string {
+  return unit.replace(/[^\w]+/gi, '_');
+}
+
+/**
+ * Sanitizes metric keys
+ *
+ * These Regex's are straight from the normalisation docs:
+ * https://develop.sentry.dev/sdk/metrics/#normalization
+ */
+export function sanitizeMetricKey(key: string): string {
+  return key.replace(/[^\w\-.]+/gi, '_');
+}
+
+/**
+ * Sanitizes metric keys
+ *
+ * These Regex's are straight from the normalisation docs:
+ * https://develop.sentry.dev/sdk/metrics/#normalization
+ */
+function sanitizeTagKey(key: string): string {
+  return key.replace(/[^\w\-./]+/gi, '');
+}
+
+/**
+ * These Regex's are straight from the normalisation docs:
+ * https://develop.sentry.dev/sdk/metrics/#normalization
+ */
+const tagValueReplacements: [string, string][] = [
+  ['\n', '\\n'],
+  ['\r', '\\r'],
+  ['\t', '\\t'],
+  ['\\', '\\\\'],
+  ['|', '\\u{7c}'],
+  [',', '\\u{2c}'],
+];
+
+function getCharOrReplacement(input: string): string {
+  for (const [search, replacement] of tagValueReplacements) {
+    if (input === search) {
+      return replacement;
+    }
+  }
+
+  return input;
+}
+
+function sanitizeTagValue(value: string): string {
+  return [...value].reduce((acc, char) => acc + getCharOrReplacement(char), '');
+}
+
 /**
  * Sanitizes tags.
  */
@@ -61,8 +117,8 @@ export function sanitizeTags(unsanitizedTags: Record<string, Primitive>): Record
   const tags: Record<string, string> = {};
   for (const key in unsanitizedTags) {
     if (Object.prototype.hasOwnProperty.call(unsanitizedTags, key)) {
-      const sanitizedKey = key.replace(NAME_AND_TAG_KEY_NORMALIZATION_REGEX, '_');
-      tags[sanitizedKey] = String(unsanitizedTags[key]).replace(TAG_VALUE_NORMALIZATION_REGEX, '');
+      const sanitizedKey = sanitizeTagKey(key);
+      tags[sanitizedKey] = sanitizeTagValue(String(unsanitizedTags[key]));
     }
   }
   return tags;
diff --git a/packages/core/test/lib/metrics/utils.test.ts b/packages/core/test/lib/metrics/utils.test.ts
index fe96404b72ea..e25014715748 100644
--- a/packages/core/test/lib/metrics/utils.test.ts
+++ b/packages/core/test/lib/metrics/utils.test.ts
@@ -4,7 +4,7 @@ import {
   GAUGE_METRIC_TYPE,
   SET_METRIC_TYPE,
 } from '../../../src/metrics/constants';
-import { getBucketKey } from '../../../src/metrics/utils';
+import { getBucketKey, sanitizeTags } from '../../../src/metrics/utils';
 
 describe('getBucketKey', () => {
   it.each([
@@ -18,4 +18,26 @@ describe('getBucketKey', () => {
   ])('should return', (metricType, name, unit, tags, expected) => {
     expect(getBucketKey(metricType, name, unit, tags)).toEqual(expected);
   });
+
+  it('should sanitize tags', () => {
+    const inputTags = {
+      'f-oo|bar': '%$foo/',
+      'foo$.$.$bar': 'blah{}',
+      'foö-bar': 'snöwmän',
+      route: 'GET /foo',
+      __bar__: 'this | or , that',
+      'foo/': 'hello!\n\r\t\\',
+    };
+
+    const outputTags = {
+      'f-oobar': '%$foo/',
+      'foo..bar': 'blah{}',
+      'fo-bar': 'snöwmän',
+      route: 'GET /foo',
+      __bar__: 'this \\u{7c} or \\u{2c} that',
+      'foo/': 'hello!\\n\\r\\t\\\\',
+    };
+
+    expect(sanitizeTags(inputTags)).toEqual(outputTags);
+  });
 });

From 9d0472bf7fb9af106214322cafca0fe61380ab36 Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Thu, 11 Apr 2024 07:30:40 +0200
Subject: [PATCH 39/64] feat(vercel-edge): Stop using hub (#11539)

---
 packages/vercel-edge/src/async.ts | 93 +++++++++++++++----------------
 1 file changed, 45 insertions(+), 48 deletions(-)

diff --git a/packages/vercel-edge/src/async.ts b/packages/vercel-edge/src/async.ts
index 50e2d80ad652..d0a9b8644d3f 100644
--- a/packages/vercel-edge/src/async.ts
+++ b/packages/vercel-edge/src/async.ts
@@ -1,5 +1,9 @@
-import { Hub as HubClass, getGlobalHub } from '@sentry/core';
-import { setAsyncContextStrategy } from '@sentry/core';
+import {
+  getCurrentHubShim,
+  getDefaultCurrentScope,
+  getDefaultIsolationScope,
+  setAsyncContextStrategy,
+} from '@sentry/core';
 import type { Hub, Scope } from '@sentry/types';
 import { GLOBAL_OBJ, logger } from '@sentry/utils';
 
@@ -11,7 +15,7 @@ interface AsyncLocalStorage<T> {
   run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
 }
 
-let asyncStorage: AsyncLocalStorage<Hub>;
+let asyncStorage: AsyncLocalStorage<{ scope: Scope; isolationScope: Scope }>;
 
 /**
  * Sets the async context strategy to use AsyncLocalStorage which should be available in the edge runtime.
@@ -32,68 +36,63 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
     asyncStorage = new MaybeGlobalAsyncLocalStorage();
   }
 
-  function getCurrentAsyncStorageHub(): Hub | undefined {
-    return asyncStorage.getStore();
+  function getScopes(): { scope: Scope; isolationScope: Scope } {
+    const scopes = asyncStorage.getStore();
+
+    if (scopes) {
+      return scopes;
+    }
+
+    // fallback behavior:
+    // if, for whatever reason, we can't find scopes on the context here, we have to fix this somehow
+    return {
+      scope: getDefaultCurrentScope(),
+      isolationScope: getDefaultIsolationScope(),
+    };
   }
 
   function getCurrentHub(): Hub {
-    return getCurrentAsyncStorageHub() || getGlobalHub();
+    // eslint-disable-next-line deprecation/deprecation
+    const hub = getCurrentHubShim();
+    return {
+      ...hub,
+      getScope: () => {
+        const scopes = getScopes();
+        return scopes.scope;
+      },
+      getIsolationScope: () => {
+        const scopes = getScopes();
+        return scopes.isolationScope;
+      },
+    };
   }
 
   function withScope<T>(callback: (scope: Scope) => T): T {
-    const parentHub = getCurrentHub();
-
-    /* eslint-disable deprecation/deprecation */
-    const client = parentHub.getClient();
-    const scope = parentHub.getScope().clone();
-    const isolationScope = parentHub.getIsolationScope();
-    const newHub = new HubClass(client, scope, isolationScope);
-    /* eslint-enable deprecation/deprecation */
-
-    return asyncStorage.run(newHub, () => {
+    const scope = getScopes().scope.clone();
+    const isolationScope = getScopes().isolationScope;
+    return asyncStorage.run({ scope, isolationScope }, () => {
       return callback(scope);
     });
   }
 
   function withSetScope<T>(scope: Scope, callback: (scope: Scope) => T): T {
-    const parentHub = getCurrentHub();
-
-    /* eslint-disable deprecation/deprecation */
-    const client = parentHub.getClient();
-    const isolationScope = parentHub.getIsolationScope();
-    const newHub = new HubClass(client, scope, isolationScope);
-    /* eslint-enable deprecation/deprecation */
-
-    return asyncStorage.run(newHub, () => {
+    const isolationScope = getScopes().isolationScope.clone();
+    return asyncStorage.run({ scope, isolationScope }, () => {
       return callback(scope);
     });
   }
 
   function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {
-    const parentHub = getCurrentHub();
-
-    /* eslint-disable deprecation/deprecation */
-    const client = parentHub.getClient();
-    const scope = parentHub.getScope().clone();
-    const isolationScope = parentHub.getIsolationScope().clone();
-    const newHub = new HubClass(client, scope, isolationScope);
-    /* eslint-enable deprecation/deprecation */
-
-    return asyncStorage.run(newHub, () => {
+    const scope = getScopes().scope;
+    const isolationScope = getScopes().isolationScope.clone();
+    return asyncStorage.run({ scope, isolationScope }, () => {
       return callback(isolationScope);
     });
   }
 
   function withSetIsolationScope<T>(isolationScope: Scope, callback: (isolationScope: Scope) => T): T {
-    const parentHub = getCurrentHub();
-
-    /* eslint-disable deprecation/deprecation */
-    const client = parentHub.getClient();
-    const scope = parentHub.getScope().clone();
-    const newHub = new HubClass(client, scope, isolationScope);
-    /* eslint-enable deprecation/deprecation */
-
-    return asyncStorage.run(newHub, () => {
+    const scope = getScopes().scope;
+    return asyncStorage.run({ scope, isolationScope }, () => {
       return callback(isolationScope);
     });
   }
@@ -104,9 +103,7 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
     withSetScope,
     withIsolationScope,
     withSetIsolationScope,
-    // eslint-disable-next-line deprecation/deprecation
-    getCurrentScope: () => getCurrentHub().getScope(),
-    // eslint-disable-next-line deprecation/deprecation
-    getIsolationScope: () => getCurrentHub().getIsolationScope(),
+    getCurrentScope: () => getScopes().scope,
+    getIsolationScope: () => getScopes().isolationScope,
   });
 }

From 5a60afd2a517359f86ae5cac20d294d074e142ca Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Thu, 11 Apr 2024 10:52:15 +0200
Subject: [PATCH 40/64] test(ci): Fix failing tests (#11554)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This hopefully fixes these tests that randomly started failing 😬
debugging this on CI, I saw that the second session envelope it sent was
about discarding session events because sending them failed. So ensuring
we don't drop the sessions should fix this, I think.
---
 .../suites/sessions/initial-scope/test.ts                 | 8 ++++++++
 .../suites/sessions/start-session/test.ts                 | 8 ++++++++
 .../suites/sessions/v7-hub-start-session/test.ts          | 8 ++++++++
 3 files changed, 24 insertions(+)

diff --git a/dev-packages/browser-integration-tests/suites/sessions/initial-scope/test.ts b/dev-packages/browser-integration-tests/suites/sessions/initial-scope/test.ts
index b7de815b7825..8a9ba80cdbc4 100644
--- a/dev-packages/browser-integration-tests/suites/sessions/initial-scope/test.ts
+++ b/dev-packages/browser-integration-tests/suites/sessions/initial-scope/test.ts
@@ -25,6 +25,14 @@ sentryTest('should start a new session with navigation.', async ({ getLocalTestP
   const url = await getLocalTestPath({ testDir: __dirname });
   await page.route('**/foo', (route: Route) => route.fulfill({ path: `${__dirname}/dist/index.html` }));
 
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
   const initSession = await getFirstSentryEnvelopeRequest<SessionContext>(page, url);
 
   await page.click('#navigate');
diff --git a/dev-packages/browser-integration-tests/suites/sessions/start-session/test.ts b/dev-packages/browser-integration-tests/suites/sessions/start-session/test.ts
index 1359f90ac0e0..62c969d2e76d 100644
--- a/dev-packages/browser-integration-tests/suites/sessions/start-session/test.ts
+++ b/dev-packages/browser-integration-tests/suites/sessions/start-session/test.ts
@@ -24,6 +24,14 @@ sentryTest('should start a new session with navigation.', async ({ getLocalTestP
   const url = await getLocalTestPath({ testDir: __dirname });
   await page.route('**/foo', (route: Route) => route.fulfill({ path: `${__dirname}/dist/index.html` }));
 
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
   const initSession = await getFirstSentryEnvelopeRequest<SessionContext>(page, url);
 
   await page.locator('#navigate').click();
diff --git a/dev-packages/browser-integration-tests/suites/sessions/v7-hub-start-session/test.ts b/dev-packages/browser-integration-tests/suites/sessions/v7-hub-start-session/test.ts
index 1359f90ac0e0..62c969d2e76d 100644
--- a/dev-packages/browser-integration-tests/suites/sessions/v7-hub-start-session/test.ts
+++ b/dev-packages/browser-integration-tests/suites/sessions/v7-hub-start-session/test.ts
@@ -24,6 +24,14 @@ sentryTest('should start a new session with navigation.', async ({ getLocalTestP
   const url = await getLocalTestPath({ testDir: __dirname });
   await page.route('**/foo', (route: Route) => route.fulfill({ path: `${__dirname}/dist/index.html` }));
 
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
   const initSession = await getFirstSentryEnvelopeRequest<SessionContext>(page, url);
 
   await page.locator('#navigate').click();

From 326f52aa7f18b169b7cad945dfac5f6c94a947e0 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Thu, 11 Apr 2024 11:24:12 +0200
Subject: [PATCH 41/64] fix(tracing): Fixes latest route name and source not
 updating correctly (#11533)

Forward port of
https://github.com/getsentry/sentry-javascript/pull/10702
---
 .../src/browser/browserTracingIntegration.ts  | 21 ++++++++++---------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/packages/browser-utils/src/browser/browserTracingIntegration.ts b/packages/browser-utils/src/browser/browserTracingIntegration.ts
index 02ea72497a3d..c0a786b600f9 100644
--- a/packages/browser-utils/src/browser/browserTracingIntegration.ts
+++ b/packages/browser-utils/src/browser/browserTracingIntegration.ts
@@ -169,8 +169,10 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
     startTrackingInteractions();
   }
 
-  let latestRouteName: string | undefined;
-  let latestRouteSource: TransactionSource | undefined;
+  const latestRoute: { name: string | undefined; source: TransactionSource | undefined } = {
+    name: undefined,
+    source: undefined,
+  };
 
   /** Create routing idle transaction. */
   function _createRouteSpan(client: Client, startSpanOptions: StartSpanOptions): Span {
@@ -190,8 +192,8 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
       finalStartSpanOptions.attributes = attributes;
     }
 
-    latestRouteName = finalStartSpanOptions.name;
-    latestRouteSource = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
+    latestRoute.name = finalStartSpanOptions.name;
+    latestRoute.source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
 
     const idleSpan = startIdleSpan(finalStartSpanOptions, {
       idleTimeout,
@@ -333,7 +335,7 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
       }
 
       if (_experiments.enableInteractions) {
-        registerInteractionListener(options, latestRouteName, latestRouteSource);
+        registerInteractionListener(options, latestRoute);
       }
 
       instrumentOutgoingRequests({
@@ -404,8 +406,7 @@ export function getMetaContent(metaName: string): string | undefined {
 /** Start listener for interaction transactions */
 function registerInteractionListener(
   options: BrowserTracingOptions,
-  latestRouteName: string | undefined,
-  latestRouteSource: TransactionSource | undefined,
+  latestRoute: { name: string | undefined; source: TransactionSource | undefined },
 ): void {
   let inflightInteractionSpan: Span | undefined;
   const registerInteractionTransaction = (): void => {
@@ -429,17 +430,17 @@ function registerInteractionListener(
       inflightInteractionSpan = undefined;
     }
 
-    if (!latestRouteName) {
+    if (!latestRoute.name) {
       DEBUG_BUILD && logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);
       return undefined;
     }
 
     inflightInteractionSpan = startIdleSpan(
       {
-        name: latestRouteName,
+        name: latestRoute.name,
         op,
         attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRouteSource || 'url',
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.source || 'url',
         },
       },
       {

From bb9efeda0ee4ab6c837d86f20737377ee857fe5e Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Thu, 11 Apr 2024 11:24:34 +0200
Subject: [PATCH 42/64] feat(tracing): Adds span envelope and datacategory
 (#11534)

Adds span envelopes and datacategory. For use with standalone inp spans

Forward port of
https://github.com/getsentry/sentry-javascript/pull/10706
---
 packages/core/src/index.ts         |  1 +
 packages/core/src/span.ts          | 22 ++++++++++++++++++++++
 packages/types/src/datacategory.ts |  2 ++
 packages/types/src/envelope.ts     | 11 +++++++++--
 packages/types/src/index.ts        |  2 ++
 packages/utils/src/envelope.ts     |  4 +++-
 6 files changed, 39 insertions(+), 3 deletions(-)
 create mode 100644 packages/core/src/span.ts

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index e3f827605aeb..89c602660df3 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -69,6 +69,7 @@ export {
 export { applyScopeDataToEvent, mergeScopeData } from './utils/applyScopeDataToEvent';
 export { prepareEvent } from './utils/prepareEvent';
 export { createCheckInEnvelope } from './checkin';
+export { createSpanEnvelope } from './span';
 export { hasTracingEnabled } from './utils/hasTracingEnabled';
 export { isSentryRequestUrl } from './utils/isSentryRequestUrl';
 export { handleCallbackErrors } from './utils/handleCallbackErrors';
diff --git a/packages/core/src/span.ts b/packages/core/src/span.ts
new file mode 100644
index 000000000000..405ceeddab30
--- /dev/null
+++ b/packages/core/src/span.ts
@@ -0,0 +1,22 @@
+import type { SpanEnvelope, SpanItem } from '@sentry/types';
+import type { Span } from '@sentry/types';
+import { createEnvelope } from '@sentry/utils';
+
+/**
+ * Create envelope from Span item.
+ */
+export function createSpanEnvelope(spans: Span[]): SpanEnvelope {
+  const headers: SpanEnvelope[0] = {
+    sent_at: new Date().toISOString(),
+  };
+
+  const items = spans.map(createSpanItem);
+  return createEnvelope<SpanEnvelope>(headers, items);
+}
+
+function createSpanItem(span: Span): SpanItem {
+  const spanHeaders: SpanItem[0] = {
+    type: 'span',
+  };
+  return [spanHeaders, span];
+}
diff --git a/packages/types/src/datacategory.ts b/packages/types/src/datacategory.ts
index 96e6d7ae65ae..de482bc3d7cc 100644
--- a/packages/types/src/datacategory.ts
+++ b/packages/types/src/datacategory.ts
@@ -28,5 +28,7 @@ export type DataCategory =
   | 'feedback'
   // Statsd type event for metrics
   | 'statsd'
+  // Span
+  | 'span'
   // Unknown data category
   | 'unknown';
diff --git a/packages/types/src/envelope.ts b/packages/types/src/envelope.ts
index 7a9ad2e4d5c3..9c5c045a4648 100644
--- a/packages/types/src/envelope.ts
+++ b/packages/types/src/envelope.ts
@@ -8,6 +8,7 @@ import type { Profile } from './profiling';
 import type { ReplayEvent, ReplayRecordingData } from './replay';
 import type { SdkInfo } from './sdkinfo';
 import type { SerializedSession, Session, SessionAggregates } from './session';
+import type { Span } from './span';
 
 // Based on: https://develop.sentry.dev/sdk/envelopes/
 
@@ -36,7 +37,8 @@ export type EnvelopeItemType =
   | 'replay_event'
   | 'replay_recording'
   | 'check_in'
-  | 'statsd';
+  | 'statsd'
+  | 'span';
 
 export type BaseEnvelopeHeaders = {
   [key: string]: unknown;
@@ -77,6 +79,7 @@ type ReplayRecordingItemHeaders = { type: 'replay_recording'; length: number };
 type CheckInItemHeaders = { type: 'check_in' };
 type StatsdItemHeaders = { type: 'statsd'; length: number };
 type ProfileItemHeaders = { type: 'profile' };
+type SpanItemHeaders = { type: 'span' };
 
 // TODO (v8): Replace `Event` with `SerializedEvent`
 export type EventItem = BaseEnvelopeItem<EventItemHeaders, Event>;
@@ -93,6 +96,7 @@ type ReplayRecordingItem = BaseEnvelopeItem<ReplayRecordingItemHeaders, ReplayRe
 export type StatsdItem = BaseEnvelopeItem<StatsdItemHeaders, string>;
 export type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;
 export type ProfileItem = BaseEnvelopeItem<ProfileItemHeaders, Profile>;
+export type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Span>;
 
 export type EventEnvelopeHeaders = { event_id: string; sent_at: string; trace?: DynamicSamplingContext };
 type SessionEnvelopeHeaders = { sent_at: string };
@@ -100,6 +104,7 @@ type CheckInEnvelopeHeaders = { trace?: DynamicSamplingContext };
 type ClientReportEnvelopeHeaders = BaseEnvelopeHeaders;
 type ReplayEnvelopeHeaders = BaseEnvelopeHeaders;
 type StatsdEnvelopeHeaders = BaseEnvelopeHeaders;
+type SpanEnvelopeHeaders = BaseEnvelopeHeaders;
 
 export type EventEnvelope = BaseEnvelope<
   EventEnvelopeHeaders,
@@ -110,6 +115,7 @@ export type ClientReportEnvelope = BaseEnvelope<ClientReportEnvelopeHeaders, Cli
 export type ReplayEnvelope = [ReplayEnvelopeHeaders, [ReplayEventItem, ReplayRecordingItem]];
 export type CheckInEnvelope = BaseEnvelope<CheckInEnvelopeHeaders, CheckInItem>;
 export type StatsdEnvelope = BaseEnvelope<StatsdEnvelopeHeaders, StatsdItem>;
+export type SpanEnvelope = BaseEnvelope<SpanEnvelopeHeaders, SpanItem>;
 
 export type Envelope =
   | EventEnvelope
@@ -117,5 +123,6 @@ export type Envelope =
   | ClientReportEnvelope
   | ReplayEnvelope
   | CheckInEnvelope
-  | StatsdEnvelope;
+  | StatsdEnvelope
+  | SpanEnvelope;
 export type EnvelopeItem = Envelope[1][number];
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 2e2c61dad4b6..50041db6eb0b 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -45,6 +45,8 @@ export type {
   StatsdItem,
   StatsdEnvelope,
   ProfileItem,
+  SpanEnvelope,
+  SpanItem,
 } from './envelope';
 export type { ExtendedError } from './error';
 export type { Event, EventHint, EventType, ErrorEvent, TransactionEvent } from './event';
diff --git a/packages/utils/src/envelope.ts b/packages/utils/src/envelope.ts
index 461bf6fcb47b..4c6a6eea724d 100644
--- a/packages/utils/src/envelope.ts
+++ b/packages/utils/src/envelope.ts
@@ -208,7 +208,9 @@ const ITEM_TYPE_TO_DATA_CATEGORY_MAP: Record<EnvelopeItemType, DataCategory> = {
   replay_recording: 'replay',
   check_in: 'monitor',
   feedback: 'feedback',
-  statsd: 'statsd',
+  span: 'span',
+  // TODO: This is a temporary workaround until we have a proper data category for metrics
+  statsd: 'unknown',
 };
 
 /**

From ac803e98c3b450296922d5d9605d8e0129639138 Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Thu, 11 Apr 2024 13:13:09 +0200
Subject: [PATCH 43/64] feat(core): Add default behaviour for
 `rewriteFramesIntegration` in browser (#11535)

---
 .../core/src/integrations/rewriteframes.ts    | 120 +++++++++++++-----
 .../lib/integrations/rewriteframes.test.ts    |  39 +++++-
 2 files changed, 128 insertions(+), 31 deletions(-)

diff --git a/packages/core/src/integrations/rewriteframes.ts b/packages/core/src/integrations/rewriteframes.ts
index ee842e86942f..3b81d141cdad 100644
--- a/packages/core/src/integrations/rewriteframes.ts
+++ b/packages/core/src/integrations/rewriteframes.ts
@@ -1,5 +1,5 @@
-import type { Event, IntegrationFn, StackFrame, Stacktrace } from '@sentry/types';
-import { basename, relative } from '@sentry/utils';
+import type { Event, StackFrame, Stacktrace } from '@sentry/types';
+import { GLOBAL_OBJ, basename, relative } from '@sentry/utils';
 import { defineIntegration } from '../integration';
 
 type StackFrameIteratee = (frame: StackFrame) => StackFrame;
@@ -7,39 +7,55 @@ type StackFrameIteratee = (frame: StackFrame) => StackFrame;
 const INTEGRATION_NAME = 'RewriteFrames';
 
 interface RewriteFramesOptions {
+  /**
+   * Root path (the beginning of the path) that will be stripped from the frames' filename.
+   *
+   * This option has slightly different behaviour in the browser and on servers:
+   * - In the browser, the value you provide in `root` will be stripped from the beginning stack frames' paths (if the path started with the value).
+   * - On the server, the root value will only replace the beginning of stack frame filepaths, when the path is absolute. If no `root` value is provided and the path is absolute, the frame will be reduced to only the filename and the provided `prefix` option.
+   *
+   * Browser example:
+   * - Original frame: `'http://example.com/my/path/static/asset.js'`
+   * - `root: 'http://example.com/my/path'`
+   * - `assetPrefix: 'app://'`
+   * - Resulting frame: `'app:///static/asset.js'`
+   *
+   * Server example:
+   * - Original frame: `'/User/local/my/path/static/asset.js'`
+   * - `root: '/User/local/my/path'`
+   * - `assetPrefix: 'app://'`
+   * - Resulting frame: `'app:///static/asset.js'`
+   */
   root?: string;
+
+  /**
+   * A custom prefix that stack frames will be prepended with.
+   *
+   * Default: `'app://'`
+   *
+   * This option has slightly different behaviour in the browser and on servers:
+   * - In the browser, the value you provide in `prefix` will prefix the resulting filename when the value you provided in `root` was applied. Effectively replacing whatever `root` matched in the beginning of the frame with `prefix`.
+   * - On the server, the prefix is applied to all stackframes with absolute paths. On Windows, the drive identifier (e.g. "C://") is replaced with the prefix.
+   */
   prefix?: string;
+
+  /**
+   * Defines an iterator that is used to iterate through all of the stack frames for modification before being sent to Sentry.
+   * Setting this option will effectively disable both the `root` and the `prefix` options.
+   */
   iteratee?: StackFrameIteratee;
 }
 
-const _rewriteFramesIntegration = ((options: RewriteFramesOptions = {}) => {
+/**
+ * Rewrite event frames paths.
+ */
+export const rewriteFramesIntegration = defineIntegration((options: RewriteFramesOptions = {}) => {
   const root = options.root;
   const prefix = options.prefix || 'app:///';
 
-  const iteratee: StackFrameIteratee =
-    options.iteratee ||
-    ((frame: StackFrame) => {
-      if (!frame.filename) {
-        return frame;
-      }
-      // Determine if this is a Windows frame by checking for a Windows-style prefix such as `C:\`
-      const isWindowsFrame =
-        /^[a-zA-Z]:\\/.test(frame.filename) ||
-        // or the presence of a backslash without a forward slash (which are not allowed on Windows)
-        (frame.filename.includes('\\') && !frame.filename.includes('/'));
-      // Check if the frame filename begins with `/`
-      const startsWithSlash = /^\//.test(frame.filename);
-      if (isWindowsFrame || startsWithSlash) {
-        const filename = isWindowsFrame
-          ? frame.filename
-              .replace(/^[a-zA-Z]:/, '') // remove Windows-style prefix
-              .replace(/\\/g, '/') // replace all `\\` instances with `/`
-          : frame.filename;
-        const base = root ? relative(root, filename) : basename(filename);
-        frame.filename = `${prefix}${base}`;
-      }
-      return frame;
-    });
+  const isBrowser = 'window' in GLOBAL_OBJ && GLOBAL_OBJ.window !== undefined;
+
+  const iteratee: StackFrameIteratee = options.iteratee || generateIteratee({ isBrowser, root, prefix });
 
   /** Process an exception event. */
   function _processExceptionsEvent(event: Event): Event {
@@ -81,9 +97,53 @@ const _rewriteFramesIntegration = ((options: RewriteFramesOptions = {}) => {
       return processedEvent;
     },
   };
-}) satisfies IntegrationFn;
+});
 
 /**
- * Rewrite event frames paths.
+ * Exported only for tests.
  */
-export const rewriteFramesIntegration = defineIntegration(_rewriteFramesIntegration);
+export function generateIteratee({
+  isBrowser,
+  root,
+  prefix,
+}: {
+  isBrowser: boolean;
+  root?: string;
+  prefix: string;
+}): StackFrameIteratee {
+  return (frame: StackFrame) => {
+    if (!frame.filename) {
+      return frame;
+    }
+
+    // Determine if this is a Windows frame by checking for a Windows-style prefix such as `C:\`
+    const isWindowsFrame =
+      /^[a-zA-Z]:\\/.test(frame.filename) ||
+      // or the presence of a backslash without a forward slash (which are not allowed on Windows)
+      (frame.filename.includes('\\') && !frame.filename.includes('/'));
+
+    // Check if the frame filename begins with `/`
+    const startsWithSlash = /^\//.test(frame.filename);
+
+    if (isBrowser) {
+      if (root) {
+        const oldFilename = frame.filename;
+        if (oldFilename.indexOf(root) === 0) {
+          frame.filename = oldFilename.replace(root, prefix);
+        }
+      }
+    } else {
+      if (isWindowsFrame || startsWithSlash) {
+        const filename = isWindowsFrame
+          ? frame.filename
+              .replace(/^[a-zA-Z]:/, '') // remove Windows-style prefix
+              .replace(/\\/g, '/') // replace all `\\` instances with `/`
+          : frame.filename;
+        const base = root ? relative(root, filename) : basename(filename);
+        frame.filename = `${prefix}${base}`;
+      }
+    }
+
+    return frame;
+  };
+}
diff --git a/packages/core/test/lib/integrations/rewriteframes.test.ts b/packages/core/test/lib/integrations/rewriteframes.test.ts
index 17d6ed4b9c5b..4c30de3a42a6 100644
--- a/packages/core/test/lib/integrations/rewriteframes.test.ts
+++ b/packages/core/test/lib/integrations/rewriteframes.test.ts
@@ -1,6 +1,6 @@
 import type { Event, StackFrame } from '@sentry/types';
 
-import { rewriteFramesIntegration } from '../../../src/integrations/rewriteframes';
+import { generateIteratee, rewriteFramesIntegration } from '../../../src/integrations/rewriteframes';
 
 let rewriteFrames: ReturnType<typeof rewriteFramesIntegration>;
 let exceptionEvent: Event;
@@ -11,6 +11,17 @@ let windowsExceptionEventWithoutPrefix: Event;
 let windowsExceptionEventWithBackslashPrefix: Event;
 let multipleStacktracesEvent: Event;
 
+const originalWindow = global.window;
+
+beforeAll(() => {
+  // @ts-expect-error We need to do this because the integration has different behaviour on the browser and on the client
+  global.window = undefined;
+});
+
+afterAll(() => {
+  global.window = originalWindow;
+});
+
 describe('RewriteFrames', () => {
   beforeEach(() => {
     exceptionEvent = {
@@ -298,4 +309,30 @@ describe('RewriteFrames', () => {
       expect(rewriteFrames.processEvent?.(brokenEvent, {}, {} as any)).toEqual(brokenEvent);
     });
   });
+
+  describe('generateIteratee()', () => {
+    describe('on the browser', () => {
+      it('should replace the `root` value in the filename with the `assetPrefix` value', () => {
+        const iteratee = generateIteratee({
+          isBrowser: true,
+          prefix: 'my-prefix://',
+          root: 'http://example.com/my/path',
+        });
+
+        const result = iteratee({ filename: 'http://example.com/my/path/static/asset.js' });
+        expect(result.filename).toBe('my-prefix:///static/asset.js');
+      });
+
+      it('should replace not the `root` value in the filename with the `assetPrefix` value, if the root value is not at the beginning of the frame', () => {
+        const iteratee = generateIteratee({
+          isBrowser: true,
+          prefix: 'my-prefix://',
+          root: '/my/path',
+        });
+
+        const result = iteratee({ filename: 'http://example.com/my/path/static/asset.js' });
+        expect(result.filename).toBe('http://example.com/my/path/static/asset.js'); // unchanged
+      });
+    });
+  });
 });

From 80c0ee6134b059d9617d4dc61ab5a2ceb68262db Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Thu, 11 Apr 2024 13:13:29 +0200
Subject: [PATCH 44/64] feat: Rename ESM loader hooks to `import` and `loader`
 (#11498)

---
 .../esm-loader-node-express-app/package.json  |  2 +-
 ...mplate.js => otelEsmImportHookTemplate.js} |  0
 ...mplate.js => otelEsmLoaderHookTemplate.js} |  0
 .../code/sentryNodeEsmHooksLoaderTemplate.js  |  1 -
 ....js => sentryNodeEsmImportHookTemplate.js} |  2 +-
 .../code/sentryNodeEsmLoaderHookTemplate.js   |  1 +
 dev-packages/rollup-utils/npmHelpers.mjs      | 20 +++++++++----------
 packages/astro/package.json                   |  8 ++++----
 packages/aws-serverless/package.json          |  8 ++++----
 packages/google-cloud-serverless/package.json |  8 ++++----
 packages/nextjs/package.json                  |  8 ++++----
 packages/node/package.json                    |  8 ++++----
 packages/remix/package.json                   |  8 ++++----
 13 files changed, 37 insertions(+), 37 deletions(-)
 rename dev-packages/rollup-utils/code/{otelEsmRegisterLoaderTemplate.js => otelEsmImportHookTemplate.js} (100%)
 rename dev-packages/rollup-utils/code/{otelEsmHooksLoaderTemplate.js => otelEsmLoaderHookTemplate.js} (100%)
 delete mode 100644 dev-packages/rollup-utils/code/sentryNodeEsmHooksLoaderTemplate.js
 rename dev-packages/rollup-utils/code/{sentryNodeEsmRegisterLoaderTemplate.js => sentryNodeEsmImportHookTemplate.js} (87%)
 create mode 100644 dev-packages/rollup-utils/code/sentryNodeEsmLoaderHookTemplate.js

diff --git a/dev-packages/e2e-tests/test-applications/esm-loader-node-express-app/package.json b/dev-packages/e2e-tests/test-applications/esm-loader-node-express-app/package.json
index 70055cdf8159..056929e63a76 100644
--- a/dev-packages/e2e-tests/test-applications/esm-loader-node-express-app/package.json
+++ b/dev-packages/e2e-tests/test-applications/esm-loader-node-express-app/package.json
@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "private": true,
   "scripts": {
-    "start": "node --import=@sentry/node/register src/app.mjs",
+    "start": "node --import=@sentry/node/import-hook src/app.mjs",
     "clean": "npx rimraf node_modules,pnpm-lock.yaml",
     "test:build": "pnpm install",
     "test:assert": "playwright test"
diff --git a/dev-packages/rollup-utils/code/otelEsmRegisterLoaderTemplate.js b/dev-packages/rollup-utils/code/otelEsmImportHookTemplate.js
similarity index 100%
rename from dev-packages/rollup-utils/code/otelEsmRegisterLoaderTemplate.js
rename to dev-packages/rollup-utils/code/otelEsmImportHookTemplate.js
diff --git a/dev-packages/rollup-utils/code/otelEsmHooksLoaderTemplate.js b/dev-packages/rollup-utils/code/otelEsmLoaderHookTemplate.js
similarity index 100%
rename from dev-packages/rollup-utils/code/otelEsmHooksLoaderTemplate.js
rename to dev-packages/rollup-utils/code/otelEsmLoaderHookTemplate.js
diff --git a/dev-packages/rollup-utils/code/sentryNodeEsmHooksLoaderTemplate.js b/dev-packages/rollup-utils/code/sentryNodeEsmHooksLoaderTemplate.js
deleted file mode 100644
index 06fb71a76860..000000000000
--- a/dev-packages/rollup-utils/code/sentryNodeEsmHooksLoaderTemplate.js
+++ /dev/null
@@ -1 +0,0 @@
-import '@sentry/node/hook';
diff --git a/dev-packages/rollup-utils/code/sentryNodeEsmRegisterLoaderTemplate.js b/dev-packages/rollup-utils/code/sentryNodeEsmImportHookTemplate.js
similarity index 87%
rename from dev-packages/rollup-utils/code/sentryNodeEsmRegisterLoaderTemplate.js
rename to dev-packages/rollup-utils/code/sentryNodeEsmImportHookTemplate.js
index 5a9fa441f106..a071457406a7 100644
--- a/dev-packages/rollup-utils/code/sentryNodeEsmRegisterLoaderTemplate.js
+++ b/dev-packages/rollup-utils/code/sentryNodeEsmImportHookTemplate.js
@@ -1,2 +1,2 @@
-import { getFormat, getSource, load, resolve } from '@sentry/node/register';
+import { getFormat, getSource, load, resolve } from '@sentry/node/loader-hook';
 export { getFormat, getSource, load, resolve };
diff --git a/dev-packages/rollup-utils/code/sentryNodeEsmLoaderHookTemplate.js b/dev-packages/rollup-utils/code/sentryNodeEsmLoaderHookTemplate.js
new file mode 100644
index 000000000000..d5167fd15bf9
--- /dev/null
+++ b/dev-packages/rollup-utils/code/sentryNodeEsmLoaderHookTemplate.js
@@ -0,0 +1 @@
+import '@sentry/node/import-hook';
diff --git a/dev-packages/rollup-utils/npmHelpers.mjs b/dev-packages/rollup-utils/npmHelpers.mjs
index ed6cc4492756..f984cbf518b9 100644
--- a/dev-packages/rollup-utils/npmHelpers.mjs
+++ b/dev-packages/rollup-utils/npmHelpers.mjs
@@ -151,23 +151,23 @@ export function makeOtelLoaders(outputFolder, hookVariant) {
     throw new Error('hookVariant is neither "otel" nor "sentry-node". Pick one.');
   }
 
-  const expectedRegisterLoaderLocation = `${outputFolder}/register.mjs`;
+  const expectedRegisterLoaderLocation = `${outputFolder}/import-hook.mjs`;
   const foundRegisterLoaderExport = Object.keys(packageDotJSON.exports ?? {}).some(key => {
     return packageDotJSON?.exports?.[key]?.import?.default === expectedRegisterLoaderLocation;
   });
   if (!foundRegisterLoaderExport) {
     throw new Error(
-      `You used the makeOtelLoaders() rollup utility without specifying the register loader inside \`exports[something].import.default\`. Please add "${expectedRegisterLoaderLocation}" as a value there (maybe check for typos - it needs to be "${expectedRegisterLoaderLocation}" exactly).`,
+      `You used the makeOtelLoaders() rollup utility without specifying the import hook inside \`exports[something].import.default\`. Please add "${expectedRegisterLoaderLocation}" as a value there (maybe check for typos - it needs to be "${expectedRegisterLoaderLocation}" exactly).`,
     );
   }
 
-  const expectedHooksLoaderLocation = `${outputFolder}/hook.mjs`;
+  const expectedHooksLoaderLocation = `${outputFolder}/loader-hook.mjs`;
   const foundHookLoaderExport = Object.keys(packageDotJSON.exports ?? {}).some(key => {
     return packageDotJSON?.exports?.[key]?.import?.default === expectedHooksLoaderLocation;
   });
   if (!foundHookLoaderExport) {
     throw new Error(
-      `You used the makeOtelLoaders() rollup utility without specifying the hook loader inside \`exports[something].import.default\`. Please add "${expectedHooksLoaderLocation}" as a value there (maybe check for typos - it needs to be "${expectedHooksLoaderLocation}" exactly).`,
+      `You used the makeOtelLoaders() rollup utility without specifying the loader hook inside \`exports[something].import.default\`. Please add "${expectedHooksLoaderLocation}" as a value there (maybe check for typos - it needs to be "${expectedHooksLoaderLocation}" exactly).`,
     );
   }
 
@@ -190,12 +190,12 @@ export function makeOtelLoaders(outputFolder, hookVariant) {
       input: path.join(
         __dirname,
         'code',
-        hookVariant === 'otel' ? 'otelEsmRegisterLoaderTemplate.js' : 'sentryNodeEsmRegisterLoaderTemplate.js',
+        hookVariant === 'otel' ? 'otelEsmImportHookTemplate.js' : 'sentryNodeEsmImportHookTemplate.js',
       ),
-      external: ['@opentelemetry/instrumentation/hook.mjs', '@sentry/node/register'],
+      external: /.*/,
       output: {
         format: 'esm',
-        file: path.join(outputFolder, 'register.mjs'),
+        file: path.join(outputFolder, 'import-hook.mjs'),
       },
     },
     // --loader hook
@@ -203,12 +203,12 @@ export function makeOtelLoaders(outputFolder, hookVariant) {
       input: path.join(
         __dirname,
         'code',
-        hookVariant === 'otel' ? 'otelEsmHooksLoaderTemplate.js' : 'sentryNodeEsmHooksLoaderTemplate.js',
+        hookVariant === 'otel' ? 'otelEsmLoaderHookTemplate.js' : 'sentryNodeEsmLoaderHookTemplate.js',
       ),
-      external: ['@opentelemetry/instrumentation/hook.mjs', '@sentry/node/hook'],
+      external: /.*/,
       output: {
         format: 'esm',
-        file: path.join(outputFolder, 'hook.mjs'),
+        file: path.join(outputFolder, 'loader-hook.mjs'),
       },
     },
   ]);
diff --git a/packages/astro/package.json b/packages/astro/package.json
index 457cdc36925f..9cb714697126 100644
--- a/packages/astro/package.json
+++ b/packages/astro/package.json
@@ -42,14 +42,14 @@
       "require": "./build/cjs/integration/middleware/index.js",
       "types": "./build/types/integration/middleware/index.types.d.ts"
     },
-    "./register": {
+    "./import": {
       "import": {
-        "default": "./build/register.mjs"
+        "default": "./build/import-hook.mjs"
       }
     },
-    "./hook": {
+    "./loader": {
       "import": {
-        "default": "./build/hook.mjs"
+        "default": "./build/loader-hook.mjs"
       }
     }
   },
diff --git a/packages/aws-serverless/package.json b/packages/aws-serverless/package.json
index e74dff71ce72..762f8422b549 100644
--- a/packages/aws-serverless/package.json
+++ b/packages/aws-serverless/package.json
@@ -25,14 +25,14 @@
         "default": "./build/npm/cjs/index.js"
       }
     },
-    "./register": {
+    "./import": {
       "import": {
-        "default": "./build/register.mjs"
+        "default": "./build/import-hook.mjs"
       }
     },
-    "./hook": {
+    "./loader": {
       "import": {
-        "default": "./build/hook.mjs"
+        "default": "./build/loader-hook.mjs"
       }
     }
   },
diff --git a/packages/google-cloud-serverless/package.json b/packages/google-cloud-serverless/package.json
index 06ca935cd97c..e575aecee51f 100644
--- a/packages/google-cloud-serverless/package.json
+++ b/packages/google-cloud-serverless/package.json
@@ -26,14 +26,14 @@
         "default": "./build/cjs/index.js"
       }
     },
-    "./register": {
+    "./import": {
       "import": {
-        "default": "./build/register.mjs"
+        "default": "./build/import-hook.mjs"
       }
     },
-    "./hook": {
+    "./loader": {
       "import": {
-        "default": "./build/hook.mjs"
+        "default": "./build/loader-hook.mjs"
       }
     }
   },
diff --git a/packages/nextjs/package.json b/packages/nextjs/package.json
index fd88dbac90a2..fec1a30a244a 100644
--- a/packages/nextjs/package.json
+++ b/packages/nextjs/package.json
@@ -43,14 +43,14 @@
       "import": "./build/esm/index.server.js",
       "types": "./build/types/index.types.d.ts"
     },
-    "./register": {
+    "./import": {
       "import": {
-        "default": "./build/register.mjs"
+        "default": "./build/import-hook.mjs"
       }
     },
-    "./hook": {
+    "./loader": {
       "import": {
-        "default": "./build/hook.mjs"
+        "default": "./build/loader-hook.mjs"
       }
     }
   },
diff --git a/packages/node/package.json b/packages/node/package.json
index 187384f24b89..c711fc35b620 100644
--- a/packages/node/package.json
+++ b/packages/node/package.json
@@ -31,14 +31,14 @@
         "default": "./build/cjs/index.js"
       }
     },
-    "./register": {
+    "./import": {
       "import": {
-        "default": "./build/register.mjs"
+        "default": "./build/import-hook.mjs"
       }
     },
-    "./hook": {
+    "./loader": {
       "import": {
-        "default": "./build/hook.mjs"
+        "default": "./build/loader-hook.mjs"
       }
     }
   },
diff --git a/packages/remix/package.json b/packages/remix/package.json
index d336a3288d4f..1146d9421531 100644
--- a/packages/remix/package.json
+++ b/packages/remix/package.json
@@ -34,14 +34,14 @@
       "node": "./build/cjs/index.server.js",
       "types": "./build/types/index.types.d.ts"
     },
-    "./register": {
+    "./import": {
       "import": {
-        "default": "./build/register.mjs"
+        "default": "./build/import-hook.mjs"
       }
     },
-    "./hook": {
+    "./loader": {
       "import": {
-        "default": "./build/hook.mjs"
+        "default": "./build/loader-hook.mjs"
       }
     }
   },

From 3a1f0287aef3b24f05b7d0cf7d0383b5c907b13a Mon Sep 17 00:00:00 2001
From: Sigrid Huemer <32902192+s1gr1d@users.noreply.github.com>
Date: Thu, 11 Apr 2024 14:21:44 +0200
Subject: [PATCH 45/64] feat(ratelimit): Add metrics rate limit (#11538)

closes https://github.com/getsentry/sentry-javascript/issues/11336

on v7: https://github.com/getsentry/sentry-javascript/pull/11505
https://github.com/getsentry/sentry-javascript/pull/11506
---
 packages/core/src/transports/base.ts  |  6 ++--
 packages/types/src/datacategory.ts    |  6 ++--
 packages/types/src/envelope.ts        |  2 ++
 packages/utils/src/envelope.ts        |  5 ++--
 packages/utils/src/ratelimit.ts       | 25 +++++++++++------
 packages/utils/test/ratelimit.test.ts | 40 +++++++++++++++++++++++++++
 6 files changed, 67 insertions(+), 17 deletions(-)

diff --git a/packages/core/src/transports/base.ts b/packages/core/src/transports/base.ts
index b942266457f9..0ad22d3d7a15 100644
--- a/packages/core/src/transports/base.ts
+++ b/packages/core/src/transports/base.ts
@@ -49,10 +49,10 @@ export function createTransport(
 
     // Drop rate limited items from envelope
     forEachEnvelopeItem(envelope, (item, type) => {
-      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);
-      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {
+      const dataCategory = envelopeItemTypeToDataCategory(type);
+      if (isRateLimited(rateLimits, dataCategory)) {
         const event: Event | undefined = getEventForEnvelopeItem(item, type);
-        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory, event);
+        options.recordDroppedEvent('ratelimit_backoff', dataCategory, event);
       } else {
         filteredEnvelopeItems.push(item);
       }
diff --git a/packages/types/src/datacategory.ts b/packages/types/src/datacategory.ts
index de482bc3d7cc..bd1c0b693e4d 100644
--- a/packages/types/src/datacategory.ts
+++ b/packages/types/src/datacategory.ts
@@ -1,7 +1,7 @@
 // This type is used in various places like Client Reports and Rate Limit Categories
 // See:
 // - https://develop.sentry.dev/sdk/rate-limiting/#definitions
-// - https://github.com/getsentry/relay/blob/c3b339e151c1e548ede489a01c65db82472c8751/relay-common/src/constants.rs#L139-L152
+// - https://github.com/getsentry/relay/blob/ec791fed9c2260688f25ea6a6d53ab913927e9a5/relay-base-schema/src/data_category.rs#L91
 // - https://develop.sentry.dev/sdk/client-reports/#envelope-item-payload under `discarded_events`
 export type DataCategory =
   // Reserved and only used in edgecases, unlikely to be ever actually used
@@ -26,8 +26,8 @@ export type DataCategory =
   | 'monitor'
   // Feedback type event (v2)
   | 'feedback'
-  // Statsd type event for metrics
-  | 'statsd'
+  // Metrics sent via the statsd or metrics envelope items
+  | 'metric_bucket'
   // Span
   | 'span'
   // Unknown data category
diff --git a/packages/types/src/envelope.ts b/packages/types/src/envelope.ts
index 9c5c045a4648..c72406b4539f 100644
--- a/packages/types/src/envelope.ts
+++ b/packages/types/src/envelope.ts
@@ -24,6 +24,8 @@ export type DynamicSamplingContext = {
   sampled?: string;
 };
 
+// https://github.com/getsentry/relay/blob/311b237cd4471042352fa45e7a0824b8995f216f/relay-server/src/envelope.rs#L154
+// https://develop.sentry.dev/sdk/envelopes/#data-model
 export type EnvelopeItemType =
   | 'client_report'
   | 'user_report'
diff --git a/packages/utils/src/envelope.ts b/packages/utils/src/envelope.ts
index 4c6a6eea724d..8b1345b112d7 100644
--- a/packages/utils/src/envelope.ts
+++ b/packages/utils/src/envelope.ts
@@ -209,8 +209,7 @@ const ITEM_TYPE_TO_DATA_CATEGORY_MAP: Record<EnvelopeItemType, DataCategory> = {
   check_in: 'monitor',
   feedback: 'feedback',
   span: 'span',
-  // TODO: This is a temporary workaround until we have a proper data category for metrics
-  statsd: 'unknown',
+  statsd: 'metric_bucket',
 };
 
 /**
@@ -220,7 +219,7 @@ export function envelopeItemTypeToDataCategory(type: EnvelopeItemType): DataCate
   return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
 }
 
-/** Extracts the minimal SDK info from from the metadata or an events */
+/** Extracts the minimal SDK info from the metadata or an events */
 export function getSdkMetadataForEnvelopeHeader(metadataOrEvent?: SdkMetadata | Event): SdkInfo | undefined {
   if (!metadataOrEvent || !metadataOrEvent.sdk) {
     return;
diff --git a/packages/utils/src/ratelimit.ts b/packages/utils/src/ratelimit.ts
index c3353c8034a6..77be8cf7fa9e 100644
--- a/packages/utils/src/ratelimit.ts
+++ b/packages/utils/src/ratelimit.ts
@@ -1,4 +1,4 @@
-import type { TransportMakeRequestResponse } from '@sentry/types';
+import type { DataCategory, TransportMakeRequestResponse } from '@sentry/types';
 
 // Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend
 export type RateLimits = Record<string, number>;
@@ -32,15 +32,15 @@ export function parseRetryAfterHeader(header: string, now: number = Date.now()):
  *
  * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.
  */
-export function disabledUntil(limits: RateLimits, category: string): number {
-  return limits[category] || limits.all || 0;
+export function disabledUntil(limits: RateLimits, dataCategory: DataCategory): number {
+  return limits[dataCategory] || limits.all || 0;
 }
 
 /**
  * Checks if a category is rate limited
  */
-export function isRateLimited(limits: RateLimits, category: string, now: number = Date.now()): boolean {
-  return disabledUntil(limits, category) > now;
+export function isRateLimited(limits: RateLimits, dataCategory: DataCategory, now: number = Date.now()): boolean {
+  return disabledUntil(limits, dataCategory) > now;
 }
 
 /**
@@ -67,23 +67,32 @@ export function updateRateLimits(
      * rate limit headers are of the form
      *     <header>,<header>,..
      * where each <header> is of the form
-     *     <retry_after>: <categories>: <scope>: <reason_code>
+     *     <retry_after>: <categories>: <scope>: <reason_code>: <namespaces>
      * where
      *     <retry_after> is a delay in seconds
      *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
      *         <category>;<category>;...
      *     <scope> is what's being limited (org, project, or key) - ignored by SDK
      *     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
+     *     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.
+     *         Only present if rate limit applies to the metric_bucket data category.
      */
     for (const limit of rateLimitHeader.trim().split(',')) {
-      const [retryAfter, categories] = limit.split(':', 2);
+      const [retryAfter, categories, , , namespaces] = limit.split(':', 5);
       const headerDelay = parseInt(retryAfter, 10);
       const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
       if (!categories) {
         updatedRateLimits.all = now + delay;
       } else {
         for (const category of categories.split(';')) {
-          updatedRateLimits[category] = now + delay;
+          if (category === 'metric_bucket') {
+            // namespaces will be present when category === 'metric_bucket'
+            if (!namespaces || namespaces.split(';').includes('custom')) {
+              updatedRateLimits[category] = now + delay;
+            }
+          } else {
+            updatedRateLimits[category] = now + delay;
+          }
         }
       }
     }
diff --git a/packages/utils/test/ratelimit.test.ts b/packages/utils/test/ratelimit.test.ts
index e9447aefcc73..5833548727f7 100644
--- a/packages/utils/test/ratelimit.test.ts
+++ b/packages/utils/test/ratelimit.test.ts
@@ -197,3 +197,43 @@ describe('updateRateLimits()', () => {
     expect(updatedRateLimits.all).toEqual(60_000);
   });
 });
+
+describe('data category "metric_bucket"', () => {
+  test('should add limit for `metric_bucket` category when namespaces contain "custom"', () => {
+    const rateLimits: RateLimits = {};
+    const headers = {
+      'retry-after': null,
+      'x-sentry-rate-limits': '42:metric_bucket:::custom',
+    };
+    const updatedRateLimits = updateRateLimits(rateLimits, { headers }, 0);
+    expect(updatedRateLimits.metric_bucket).toEqual(42 * 1000);
+  });
+
+  test('should not add limit for `metric_bucket` category when namespaces do not contain "custom"', () => {
+    const rateLimits: RateLimits = {};
+    const headers = {
+      'retry-after': null,
+      'x-sentry-rate-limits': '42:metric_bucket:::namespace1;namespace2',
+    };
+    const updatedRateLimits = updateRateLimits(rateLimits, { headers }, 0);
+    expect(updatedRateLimits.metric_bucket).toBeUndefined();
+  });
+
+  test('should add limit for `metric_bucket` category when namespaces are empty', () => {
+    const rateLimits: RateLimits = {};
+
+    const headers1 = {
+      'retry-after': null,
+      'x-sentry-rate-limits': '42:metric_bucket', // without semicolon at the end
+    };
+    const updatedRateLimits1 = updateRateLimits(rateLimits, { headers: headers1 }, 0);
+    expect(updatedRateLimits1.metric_bucket).toEqual(42 * 1000);
+
+    const headers2 = {
+      'retry-after': null,
+      'x-sentry-rate-limits': '42:metric_bucket:organization:quota_exceeded:', // with semicolon at the end
+    };
+    const updatedRateLimits2 = updateRateLimits(rateLimits, { headers: headers2 }, 0);
+    expect(updatedRateLimits2.metric_bucket).toEqual(42 * 1000);
+  });
+});

From 38b0daef6c4c1451774512e476870fea86c358b4 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Thu, 11 Apr 2024 15:57:26 +0200
Subject: [PATCH 46/64] feat(core): Remove most Hub class exports (#11536)

Remove top-level exports of the `Hub` class from all SDK
packages. The only package that still exports it is core for now because
we temporarily still need the class until we shimmed the return value of
`getCurrentHub`.

Furthermore also deprecate the `Hub` interface. However, this
interface will not be removed in v8 (prob v9) to keep support for
`getCurrentHub` during the v8 life cycle.
---
 .../suites/manual-client/browser-context/init.js    |  9 ++++++---
 packages/astro/src/index.server.ts                  |  1 -
 packages/aws-serverless/src/index.ts                |  1 -
 packages/browser/src/exports.ts                     |  1 -
 packages/bun/src/index.ts                           |  1 -
 packages/core/src/asyncContext.ts                   |  1 +
 packages/core/src/exports.ts                        | 13 ++++++-------
 packages/core/src/getCurrentHubShim.ts              |  6 +++++-
 packages/core/src/hub.ts                            |  6 ++++++
 packages/core/src/index.ts                          |  1 +
 packages/core/src/sdk.ts                            |  1 +
 packages/deno/src/index.ts                          |  1 -
 packages/google-cloud-serverless/src/index.ts       |  1 -
 packages/node/src/index.ts                          |  1 -
 packages/opentelemetry/src/asyncContextStrategy.ts  |  1 +
 packages/remix/src/index.server.ts                  |  1 -
 .../test/unit/session/createSession.test.ts         |  1 +
 packages/sveltekit/src/server/index.ts              |  1 -
 packages/types/src/hub.ts                           |  7 +++++++
 packages/types/src/index.ts                         |  1 +
 packages/vercel-edge/src/async.ts                   |  1 +
 packages/vercel-edge/src/index.ts                   |  1 -
 22 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/manual-client/browser-context/init.js b/dev-packages/browser-integration-tests/suites/manual-client/browser-context/init.js
index 4066402e4e15..64e5af159cb0 100644
--- a/dev-packages/browser-integration-tests/suites/manual-client/browser-context/init.js
+++ b/dev-packages/browser-integration-tests/suites/manual-client/browser-context/init.js
@@ -1,6 +1,6 @@
 import {
   BrowserClient,
-  Hub,
+  Scope,
   breadcrumbsIntegration,
   dedupeIntegration,
   defaultStackParser,
@@ -31,6 +31,9 @@ const client = new BrowserClient({
   integrations,
 });
 
-const hub = new Hub(client);
+const scope = new Scope();
+scope.setClient(client);
 
-hub.captureException(new Error('test client'));
+client.init();
+
+scope.captureException(new Error('test client'));
diff --git a/packages/astro/src/index.server.ts b/packages/astro/src/index.server.ts
index 7dd2e589b86c..e6beabd06e0e 100644
--- a/packages/astro/src/index.server.ts
+++ b/packages/astro/src/index.server.ts
@@ -23,7 +23,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   Scope,
   SDK_VERSION,
diff --git a/packages/aws-serverless/src/index.ts b/packages/aws-serverless/src/index.ts
index 5cf5a9375462..0f1e801f99ed 100644
--- a/packages/aws-serverless/src/index.ts
+++ b/packages/aws-serverless/src/index.ts
@@ -18,7 +18,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   Scope,
   SDK_VERSION,
diff --git a/packages/browser/src/exports.ts b/packages/browser/src/exports.ts
index fa38e5373110..e3087a0e58b4 100644
--- a/packages/browser/src/exports.ts
+++ b/packages/browser/src/exports.ts
@@ -35,7 +35,6 @@ export {
   getCurrentScope,
   getIsolationScope,
   getGlobalScope,
-  Hub,
   setCurrentClient,
   Scope,
   continueTrace,
diff --git a/packages/bun/src/index.ts b/packages/bun/src/index.ts
index a91dbd48b6f9..f13e3a666c50 100644
--- a/packages/bun/src/index.ts
+++ b/packages/bun/src/index.ts
@@ -37,7 +37,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   Scope,
   SDK_VERSION,
diff --git a/packages/core/src/asyncContext.ts b/packages/core/src/asyncContext.ts
index 4627d4c2453d..4e8fc5ac917e 100644
--- a/packages/core/src/asyncContext.ts
+++ b/packages/core/src/asyncContext.ts
@@ -13,6 +13,7 @@ export interface AsyncContextStrategy {
   /**
    * Gets the currently active hub.
    */
+  // eslint-disable-next-line deprecation/deprecation
   getCurrentHub: () => Hub;
 
   /**
diff --git a/packages/core/src/exports.ts b/packages/core/src/exports.ts
index 2ccb6ef530e8..b1c7e55776b1 100644
--- a/packages/core/src/exports.ts
+++ b/packages/core/src/exports.ts
@@ -19,7 +19,6 @@ import { GLOBAL_OBJ, isThenable, logger, timestampInSeconds, uuid4 } from '@sent
 import { DEFAULT_ENVIRONMENT } from './constants';
 import { getClient, getCurrentScope, getIsolationScope } from './currentScopes';
 import { DEBUG_BUILD } from './debug-build';
-import type { Hub } from './hub';
 import { closeSession, makeSession, updateSession } from './session';
 import type { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';
 import { parseEventHintOrCaptureContext } from './utils/prepareEvent';
@@ -71,7 +70,7 @@ export function captureEvent(event: Event, hint?: EventHint): string {
  * @param context Any kind of data. This data will be normalized.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function setContext(name: string, context: { [key: string]: any } | null): ReturnType<Hub['setContext']> {
+export function setContext(name: string, context: { [key: string]: any } | null): void {
   getIsolationScope().setContext(name, context);
 }
 
@@ -79,7 +78,7 @@ export function setContext(name: string, context: { [key: string]: any } | null)
  * Set an object that will be merged sent as extra data with the event.
  * @param extras Extras object to merge into current context.
  */
-export function setExtras(extras: Extras): ReturnType<Hub['setExtras']> {
+export function setExtras(extras: Extras): void {
   getIsolationScope().setExtras(extras);
 }
 
@@ -88,7 +87,7 @@ export function setExtras(extras: Extras): ReturnType<Hub['setExtras']> {
  * @param key String of extra
  * @param extra Any kind of data. This data will be normalized.
  */
-export function setExtra(key: string, extra: Extra): ReturnType<Hub['setExtra']> {
+export function setExtra(key: string, extra: Extra): void {
   getIsolationScope().setExtra(key, extra);
 }
 
@@ -96,7 +95,7 @@ export function setExtra(key: string, extra: Extra): ReturnType<Hub['setExtra']>
  * Set an object that will be merged sent as tags data with the event.
  * @param tags Tags context object to merge into current context.
  */
-export function setTags(tags: { [key: string]: Primitive }): ReturnType<Hub['setTags']> {
+export function setTags(tags: { [key: string]: Primitive }): void {
   getIsolationScope().setTags(tags);
 }
 
@@ -108,7 +107,7 @@ export function setTags(tags: { [key: string]: Primitive }): ReturnType<Hub['set
  * @param key String key of tag
  * @param value Value of tag
  */
-export function setTag(key: string, value: Primitive): ReturnType<Hub['setTag']> {
+export function setTag(key: string, value: Primitive): void {
   getIsolationScope().setTag(key, value);
 }
 
@@ -117,7 +116,7 @@ export function setTag(key: string, value: Primitive): ReturnType<Hub['setTag']>
  *
  * @param user User context object to be set in the current context. Pass `null` to unset the user.
  */
-export function setUser(user: User | null): ReturnType<Hub['setUser']> {
+export function setUser(user: User | null): void {
   getIsolationScope().setUser(user);
 }
 
diff --git a/packages/core/src/getCurrentHubShim.ts b/packages/core/src/getCurrentHubShim.ts
index 435004ce9f57..dd5df3e479e6 100644
--- a/packages/core/src/getCurrentHubShim.ts
+++ b/packages/core/src/getCurrentHubShim.ts
@@ -16,8 +16,12 @@ import {
 /**
  * This is for legacy reasons, and returns a proxy object instead of a hub to be used.
  *
- * @deprecated Use the methods directly.
+ * @deprecated Use the methods directly from the top level Sentry API (e.g. `Sentry.withScope`)
+ * For more information see our migration guide for
+ * [replacing `getCurrentHub` and `Hub`](https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#deprecate-hub)
+ * usage
  */
+// eslint-disable-next-line deprecation/deprecation
 export function getCurrentHubShim(): Hub {
   return {
     bindClient(client: Client): void {
diff --git a/packages/core/src/hub.ts b/packages/core/src/hub.ts
index de36626415ee..e68ff4cafc53 100644
--- a/packages/core/src/hub.ts
+++ b/packages/core/src/hub.ts
@@ -55,7 +55,9 @@ export interface Layer {
 
 /**
  * @inheritDoc
+ * @deprecated This class will be removed in v8 (tmp-deprecating so we're aware of where this is a problem)
  */
+// eslint-disable-next-line deprecation/deprecation
 export class Hub implements HubInterface {
   /** Is a {@link Layer}[] containing the client and scope */
   private readonly _stack: Layer[];
@@ -503,6 +505,7 @@ export class Hub implements HubInterface {
  *
  * @deprecated Use the respective replacement method directly instead.
  */
+// eslint-disable-next-line deprecation/deprecation
 export function getCurrentHub(): HubInterface {
   // Get main carrier (global for every environment)
   const carrier = getMainCarrier();
@@ -525,8 +528,10 @@ export function getDefaultIsolationScope(): Scope {
  * Get the global hub.
  * This will be removed during the v8 cycle and is only here to make migration easier.
  */
+// eslint-disable-next-line deprecation/deprecation
 export function getGlobalHub(): HubInterface {
   const registry = getMainCarrier();
+  // eslint-disable-next-line deprecation/deprecation
   const sentry = getSentryCarrier(registry) as { hub?: HubInterface };
 
   // If there's no hub, or its an old API, assign a new one
@@ -560,6 +565,7 @@ function withScope<T>(callback: (scope: ScopeInterface) => T): T {
 }
 
 function withSetScope<T>(scope: ScopeInterface, callback: (scope: ScopeInterface) => T): T {
+  // eslint-disable-next-line deprecation/deprecation
   const hub = getGlobalHub() as Hub;
   // eslint-disable-next-line deprecation/deprecation
   return hub.withScope(() => {
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 89c602660df3..757d52f12201 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -32,6 +32,7 @@ export {
 export {
   // eslint-disable-next-line deprecation/deprecation
   getCurrentHub,
+  // eslint-disable-next-line deprecation/deprecation
   Hub,
   getGlobalHub,
   getDefaultCurrentScope,
diff --git a/packages/core/src/sdk.ts b/packages/core/src/sdk.ts
index 3356774e14da..d4e4dafa5db7 100644
--- a/packages/core/src/sdk.ts
+++ b/packages/core/src/sdk.ts
@@ -55,6 +55,7 @@ export function setCurrentClient(client: Client): void {
   }
 }
 
+// eslint-disable-next-line deprecation/deprecation
 function isHubClass(hub: HubInterface): hub is Hub {
   // eslint-disable-next-line deprecation/deprecation
   return !!(hub as Hub).getStackTop;
diff --git a/packages/deno/src/index.ts b/packages/deno/src/index.ts
index a554d807b418..a03496fd0fdd 100644
--- a/packages/deno/src/index.ts
+++ b/packages/deno/src/index.ts
@@ -34,7 +34,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   Scope,
   SDK_VERSION,
diff --git a/packages/google-cloud-serverless/src/index.ts b/packages/google-cloud-serverless/src/index.ts
index 2bf45cf22b98..6acc37ce419b 100644
--- a/packages/google-cloud-serverless/src/index.ts
+++ b/packages/google-cloud-serverless/src/index.ts
@@ -18,7 +18,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   Scope,
   SDK_VERSION,
diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts
index 818596d0c4fe..ee037c6fdc8b 100644
--- a/packages/node/src/index.ts
+++ b/packages/node/src/index.ts
@@ -48,7 +48,6 @@ export {
   close,
   createTransport,
   flush,
-  Hub,
   SDK_VERSION,
   getSpanStatusFromHttpCode,
   setHttpStatus,
diff --git a/packages/opentelemetry/src/asyncContextStrategy.ts b/packages/opentelemetry/src/asyncContextStrategy.ts
index e28995a5d805..3ef7bf9ba2f2 100644
--- a/packages/opentelemetry/src/asyncContextStrategy.ts
+++ b/packages/opentelemetry/src/asyncContextStrategy.ts
@@ -40,6 +40,7 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
     };
   }
 
+  // eslint-disable-next-line deprecation/deprecation
   function getCurrentHub(): Hub {
     // eslint-disable-next-line deprecation/deprecation
     const hub = getCurrentHubShim();
diff --git a/packages/remix/src/index.server.ts b/packages/remix/src/index.server.ts
index 41db9c117147..219d642457e5 100644
--- a/packages/remix/src/index.server.ts
+++ b/packages/remix/src/index.server.ts
@@ -25,7 +25,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   NodeClient,
   Scope,
diff --git a/packages/replay-internal/test/unit/session/createSession.test.ts b/packages/replay-internal/test/unit/session/createSession.test.ts
index 2fc8779a5acb..5fb71c5eb70c 100644
--- a/packages/replay-internal/test/unit/session/createSession.test.ts
+++ b/packages/replay-internal/test/unit/session/createSession.test.ts
@@ -24,6 +24,7 @@ describe('Unit | session | createSession', () => {
     jest.spyOn(Sentry, 'getCurrentHub').mockImplementation(() => {
       return {
         captureEvent: captureEventMock,
+        // eslint-disable-next-line deprecation/deprecation
       } as unknown as Hub;
     });
   });
diff --git a/packages/sveltekit/src/server/index.ts b/packages/sveltekit/src/server/index.ts
index 4cba1a3e825e..e37efc7d9737 100644
--- a/packages/sveltekit/src/server/index.ts
+++ b/packages/sveltekit/src/server/index.ts
@@ -18,7 +18,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   NodeClient,
   setCurrentClient,
   Scope,
diff --git a/packages/types/src/hub.ts b/packages/types/src/hub.ts
index 53ecac91b507..6fa109145146 100644
--- a/packages/types/src/hub.ts
+++ b/packages/types/src/hub.ts
@@ -12,6 +12,13 @@ import type { User } from './user';
 /**
  * Internal class used to make sure we always have the latest internal functions
  * working in case we have a version conflict.
+ *
+ * @deprecated This interface will be removed in a future major version of the SDK in favour of
+ * `Scope` and `Client` objects and APIs.
+ *
+ * Most APIs referencing `Hub` are themselves and will be removed in version 8 of the SDK. More information:
+ * - [Migration Guide](https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#deprecate-hub)
+ *
  */
 export interface Hub {
   /**
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 50041db6eb0b..1ed8ec1755a6 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -53,6 +53,7 @@ export type { Event, EventHint, EventType, ErrorEvent, TransactionEvent } from '
 export type { EventProcessor } from './eventprocessor';
 export type { Exception } from './exception';
 export type { Extra, Extras } from './extra';
+// eslint-disable-next-line deprecation/deprecation
 export type { Hub } from './hub';
 export type { Integration, IntegrationClass, IntegrationFn } from './integration';
 export type { Mechanism } from './mechanism';
diff --git a/packages/vercel-edge/src/async.ts b/packages/vercel-edge/src/async.ts
index d0a9b8644d3f..8fbc8306492e 100644
--- a/packages/vercel-edge/src/async.ts
+++ b/packages/vercel-edge/src/async.ts
@@ -51,6 +51,7 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
     };
   }
 
+  // eslint-disable-next-line deprecation/deprecation
   function getCurrentHub(): Hub {
     // eslint-disable-next-line deprecation/deprecation
     const hub = getCurrentHubShim();
diff --git a/packages/vercel-edge/src/index.ts b/packages/vercel-edge/src/index.ts
index 466c122b7ca6..56ea97d4ab14 100644
--- a/packages/vercel-edge/src/index.ts
+++ b/packages/vercel-edge/src/index.ts
@@ -34,7 +34,6 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
-  Hub,
   setCurrentClient,
   Scope,
   SDK_VERSION,

From 621b691267e73b2b46befa4a543a9fc055b42e9a Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Thu, 11 Apr 2024 16:41:40 +0200
Subject: [PATCH 47/64] feat(replay): Merge packages together & ensure bundles
 are built (#11552)

This reverts https://github.com/getsentry/sentry-javascript/pull/11342
and instead generates multiple bundles etc. from the one
`@sentry-internal/feedback` package.

* The `feedback` CDN bundle integration includes the modal integration
for now.
* There is also a dedicated modal & screenshot integration on the CDN
* Also kept the shims etc. that Ryan added in the now-reverted PR
* Size limits now seem correct to me! I bumped them (as they now
correctly include the feedback modal etc), but you can see the diff to
the screenshots being included (it's not too high, really).
---
 .craft.yml                                    |  10 +-
 .github/workflows/build.yml                   |  14 +-
 .size-limit.js                                |   4 +-
 CODEOWNERS                                    |   2 -
 .../browser-integration-tests/package.json    |   2 +
 .../suites/feedback/captureFeedback/test.ts   |   8 +-
 .../hasSampling/init.js                       |   2 +-
 .../hasSampling/test.ts                       | 198 +++++++++---------
 .../utils/generatePlugin.ts                   |  12 +-
 .../utils/helpers.ts                          |  12 ++
 package.json                                  |   2 -
 packages/browser/package.json                 |   2 -
 packages/browser/src/index.bundle.feedback.ts |  14 +-
 packages/browser/src/index.bundle.replay.ts   |   6 +-
 .../index.bundle.tracing.replay.feedback.ts   |  23 +-
 .../src/index.bundle.tracing.replay.ts        |  22 +-
 packages/browser/src/index.bundle.tracing.ts  |  20 +-
 packages/browser/src/index.bundle.ts          |   2 +-
 packages/browser/src/index.ts                 |   4 +-
 .../browser/src/utils/lazyLoadIntegration.ts  |   2 +
 packages/feedback-modal/.eslintignore         |   2 -
 packages/feedback-modal/.eslintrc.js          |  16 --
 packages/feedback-modal/.gitignore            |   4 -
 packages/feedback-modal/LICENSE               |  14 --
 packages/feedback-modal/README.md             |  14 --
 packages/feedback-modal/jest.config.js        |   6 -
 packages/feedback-modal/package.json          |  76 -------
 .../feedback-modal/rollup.bundle.config.mjs   |  15 --
 packages/feedback-modal/rollup.npm.config.mjs |  20 --
 .../scripts/shim-preact-export.js             |  75 -------
 packages/feedback-modal/src/index.ts          |   1 -
 .../src/modal/integration.test.ts             |   8 -
 .../feedback-modal/src/modal/integration.ts   |  15 --
 packages/feedback-modal/tsconfig.json         |  17 --
 packages/feedback-modal/tsconfig.test.json    |  15 --
 packages/feedback-modal/tsconfig.types.json   |  10 -
 packages/feedback-screenshot/.eslintignore    |   2 -
 packages/feedback-screenshot/.eslintrc.js     |  16 --
 packages/feedback-screenshot/.gitignore       |   4 -
 packages/feedback-screenshot/LICENSE          |  14 --
 packages/feedback-screenshot/README.md        |  14 --
 packages/feedback-screenshot/jest.config.js   |   6 -
 packages/feedback-screenshot/package.json     |  76 -------
 .../rollup.bundle.config.mjs                  |  15 --
 .../feedback-screenshot/rollup.npm.config.mjs |  20 --
 .../scripts/shim-preact-export.js             |  75 -------
 packages/feedback-screenshot/src/index.ts     |   1 -
 .../src/screenshot/integration.test.ts        |   8 -
 .../src/screenshot/integration.ts             |  15 --
 packages/feedback-screenshot/tsconfig.json    |  17 --
 .../feedback-screenshot/tsconfig.test.json    |  15 --
 .../feedback-screenshot/tsconfig.types.json   |  10 -
 packages/feedback/package.json                |   2 +-
 packages/feedback/rollup.bundle.config.mjs    |  54 +++--
 packages/feedback/src/index.bundle.ts         |   6 +
 .../feedback/src/modal/components/Form.tsx    |   2 +-
 packages/integration-shims/src/index.ts       |   6 +-
 packages/nextjs/test/integration/package.json |   2 -
 packages/remix/test/integration/package.json  |   2 -
 59 files changed, 230 insertions(+), 821 deletions(-)
 delete mode 100644 packages/feedback-modal/.eslintignore
 delete mode 100644 packages/feedback-modal/.eslintrc.js
 delete mode 100644 packages/feedback-modal/.gitignore
 delete mode 100644 packages/feedback-modal/LICENSE
 delete mode 100644 packages/feedback-modal/README.md
 delete mode 100644 packages/feedback-modal/jest.config.js
 delete mode 100644 packages/feedback-modal/package.json
 delete mode 100644 packages/feedback-modal/rollup.bundle.config.mjs
 delete mode 100644 packages/feedback-modal/rollup.npm.config.mjs
 delete mode 100644 packages/feedback-modal/scripts/shim-preact-export.js
 delete mode 100644 packages/feedback-modal/src/index.ts
 delete mode 100644 packages/feedback-modal/src/modal/integration.test.ts
 delete mode 100644 packages/feedback-modal/src/modal/integration.ts
 delete mode 100644 packages/feedback-modal/tsconfig.json
 delete mode 100644 packages/feedback-modal/tsconfig.test.json
 delete mode 100644 packages/feedback-modal/tsconfig.types.json
 delete mode 100644 packages/feedback-screenshot/.eslintignore
 delete mode 100644 packages/feedback-screenshot/.eslintrc.js
 delete mode 100644 packages/feedback-screenshot/.gitignore
 delete mode 100644 packages/feedback-screenshot/LICENSE
 delete mode 100644 packages/feedback-screenshot/README.md
 delete mode 100644 packages/feedback-screenshot/jest.config.js
 delete mode 100644 packages/feedback-screenshot/package.json
 delete mode 100644 packages/feedback-screenshot/rollup.bundle.config.mjs
 delete mode 100644 packages/feedback-screenshot/rollup.npm.config.mjs
 delete mode 100644 packages/feedback-screenshot/scripts/shim-preact-export.js
 delete mode 100644 packages/feedback-screenshot/src/index.ts
 delete mode 100644 packages/feedback-screenshot/src/screenshot/integration.test.ts
 delete mode 100644 packages/feedback-screenshot/src/screenshot/integration.ts
 delete mode 100644 packages/feedback-screenshot/tsconfig.json
 delete mode 100644 packages/feedback-screenshot/tsconfig.test.json
 delete mode 100644 packages/feedback-screenshot/tsconfig.types.json
 create mode 100644 packages/feedback/src/index.bundle.ts

diff --git a/.craft.yml b/.craft.yml
index 820c50f199fd..bc1446711d2c 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -32,15 +32,7 @@ targets:
   - name: npm
     id: '@sentry-internal/feedback'
     includeNames: /^sentry-internal-feedback-\d.*\.tgz$/
-  ## 1.8 Feedback Modal package (browser only)
-  - name: npm
-    id: '@sentry-internal/feedback-modal'
-    includeNames: /^sentry-internal-feedback-modal-\d.*\.tgz$/
-  ## 1.9 Feedback Screenshot package (browser only)
-  - name: npm
-    id: '@sentry-internal/feedback-screenshot'
-    includeNames: /^sentry-internal-feedback-screenshot-\d.*\.tgz$/
-  ## 1.10 ReplayCanvas package (browser only)
+  ## 1.8 ReplayCanvas package (browser only)
   - name: npm
     id: '@sentry-internal/replay-canvas'
     includeNames: /^sentry-internal-replay-canvas-\d.*\.tgz$/
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ddaeed70dab9..81ca274c81b3 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -105,8 +105,6 @@ jobs:
               - 'packages/replay/**'
               - 'packages/replay-canvas/**'
               - 'packages/feedback/**'
-              - 'packages/feedback-modal/**'
-              - 'packages/feedback-screenshot/**'
               - 'packages/wasm/**'
             browser_integration:
               - *shared
@@ -413,6 +411,7 @@ jobs:
             ${{ github.workspace }}/packages/browser/build/bundles/**
             ${{ github.workspace }}/packages/replay/build/bundles/**
             ${{ github.workspace }}/packages/replay-canvas/build/bundles/**
+            ${{ github.workspace }}/packages/feedback/build/bundles/**
             ${{ github.workspace }}/packages/**/*.tgz
             ${{ github.workspace }}/packages/aws-serverless/build/aws/dist-serverless/*.zip
 
@@ -623,21 +622,20 @@ jobs:
           - bundle
           - bundle_min
           - bundle_replay
-          - bundle_replay_min
           - bundle_tracing
-          - bundle_tracing_min
           - bundle_tracing_replay
-          - bundle_tracing_replay_min
+          - bundle_tracing_replay_feedback
+          - bundle_tracing_replay_feedback_min
         project:
           - chromium
         include:
           # Only check all projects for esm & full bundle
           # We also shard the tests as they take the longest
-          - bundle: bundle_tracing_replay_min
+          - bundle: bundle_tracing_replay_feedback_min
             project: ''
             shard: 1
             shards: 2
-          - bundle: bundle_tracing_replay_min
+          - bundle: bundle_tracing_replay_feedback_min
             project: ''
             shard: 2
             shards: 2
@@ -654,7 +652,7 @@ jobs:
             shards: 3
         exclude:
           # Do not run the default chromium-only tests
-          - bundle: bundle_tracing_replay_min
+          - bundle: bundle_tracing_replay_feedback_min
             project: 'chromium'
           - bundle: esm
             project: 'chromium'
diff --git a/.size-limit.js b/.size-limit.js
index d102cf8d63b0..6e005fd7c3e7 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -73,7 +73,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'feedbackIntegration', 'feedbackModalIntegration', 'feedbackScreenshotIntegration'),
     gzip: true,
-    limit: '37 KB',
+    limit: '40 KB',
   },
   {
     name: '@sentry/browser (incl. sendFeedback)',
@@ -143,7 +143,7 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing, Replay, Feedback)',
     path: createCDNPath('bundle.tracing.replay.feedback.min.js'),
     gzip: true,
-    limit: '83 KB',
+    limit: '86 KB',
   },
   // browser CDN bundles (non-gzipped)
   {
diff --git a/CODEOWNERS b/CODEOWNERS
index 0cbff3b53444..6ae2679deafa 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -2,6 +2,4 @@ packages/replay                                   @getsentry/replay-sdk-web
 packages/replay-worker                            @getsentry/replay-sdk-web
 packages/replay-canvas                            @getsentry/replay-sdk-web
 packages/feedback                                 @getsentry/replay-sdk-web
-packages/feedback-modal                           @getsentry/replay-sdk-web
-packages/feedback-screenshot                      @getsentry/replay-sdk-web
 dev-packages/browser-integration-tests/suites/replay  @getsentry/replay-sdk-web
diff --git a/dev-packages/browser-integration-tests/package.json b/dev-packages/browser-integration-tests/package.json
index 4224af55ffc7..9a7e99ccb3a9 100644
--- a/dev-packages/browser-integration-tests/package.json
+++ b/dev-packages/browser-integration-tests/package.json
@@ -23,6 +23,8 @@
     "test:bundle:replay:min": "PW_BUNDLE=bundle_replay_min yarn test",
     "test:bundle:tracing": "PW_BUNDLE=bundle_tracing yarn test",
     "test:bundle:tracing:min": "PW_BUNDLE=bundle_tracing_min yarn test",
+    "test:bundle:full": "PW_BUNDLE=bundle_tracing_replay_feedback yarn test",
+    "test:bundle:full:min": "PW_BUNDLE=bundle_tracing_replay_feedback_min yarn test",
     "test:cjs": "PW_BUNDLE=cjs yarn test",
     "test:esm": "PW_BUNDLE=esm yarn test",
     "test:loader": "npx playwright test  -c playwright.loader.config.ts --project='chromium'",
diff --git a/dev-packages/browser-integration-tests/suites/feedback/captureFeedback/test.ts b/dev-packages/browser-integration-tests/suites/feedback/captureFeedback/test.ts
index 5d4ebe233c4d..b58efe858f25 100644
--- a/dev-packages/browser-integration-tests/suites/feedback/captureFeedback/test.ts
+++ b/dev-packages/browser-integration-tests/suites/feedback/captureFeedback/test.ts
@@ -1,10 +1,10 @@
 import { expect } from '@playwright/test';
 
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, getEnvelopeType } from '../../../utils/helpers';
+import { envelopeRequestParser, getEnvelopeType, shouldSkipFeedbackTest } from '../../../utils/helpers';
 
-sentryTest('should capture feedback (@sentry-internal/feedback import)', async ({ getLocalTestPath, page }) => {
-  if (process.env.PW_BUNDLE) {
+sentryTest('should capture feedback', async ({ getLocalTestPath, page }) => {
+  if (shouldSkipFeedbackTest()) {
     sentryTest.skip();
   }
 
@@ -39,7 +39,7 @@ sentryTest('should capture feedback (@sentry-internal/feedback import)', async (
   await page.locator('[name="name"]').fill('Jane Doe');
   await page.locator('[name="email"]').fill('janedoe@example.org');
   await page.locator('[name="message"]').fill('my example feedback');
-  await page.getByLabel('Send Bug Report').click();
+  await page.locator('[data-sentry-feedback] .btn--primary').click();
 
   const feedbackEvent = envelopeRequestParser((await feedbackRequestPromise).request());
   expect(feedbackEvent).toEqual({
diff --git a/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/init.js b/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/init.js
index 46441bdf2538..020e045c780d 100644
--- a/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/init.js
+++ b/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/init.js
@@ -5,7 +5,7 @@ window.Sentry = Sentry;
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   replaysOnErrorSampleRate: 1.0,
-  replaysSessionSampleRate: 0,
+  replaysSessionSampleRate: 1.0,
   integrations: [
     Sentry.replayIntegration({
       flushMinDelay: 200,
diff --git a/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/test.ts b/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/test.ts
index 6868caf99545..6768bf838e75 100644
--- a/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/test.ts
+++ b/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/test.ts
@@ -1,107 +1,111 @@
 import { expect } from '@playwright/test';
 
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, getEnvelopeType } from '../../../../utils/helpers';
-import { getCustomRecordingEvents, getReplayEvent, waitForReplayRequest } from '../../../../utils/replayHelpers';
-
-sentryTest(
-  'should capture feedback (@sentry-internal/feedback import)',
-  async ({ forceFlushReplay, getLocalTestPath, page }) => {
-    if (process.env.PW_BUNDLE) {
-      sentryTest.skip();
+import { envelopeRequestParser, getEnvelopeType, shouldSkipFeedbackTest } from '../../../../utils/helpers';
+import {
+  collectReplayRequests,
+  getReplayBreadcrumbs,
+  shouldSkipReplayTest,
+  waitForReplayRequest,
+} from '../../../../utils/replayHelpers';
+
+sentryTest('should capture feedback', async ({ forceFlushReplay, getLocalTestPath, page }) => {
+  if (shouldSkipFeedbackTest() || shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  const feedbackRequestPromise = page.waitForResponse(res => {
+    const req = res.request();
+
+    const postData = req.postData();
+    if (!postData) {
+      return false;
     }
 
-    const reqPromise0 = waitForReplayRequest(page, 0);
-    const reqPromise1 = waitForReplayRequest(page, 1);
-    const reqPromise2 = waitForReplayRequest(page, 2);
-    const feedbackRequestPromise = page.waitForResponse(res => {
-      const req = res.request();
-
-      const postData = req.postData();
-      if (!postData) {
-        return false;
-      }
-
-      try {
-        return getEnvelopeType(req) === 'feedback';
-      } catch (err) {
-        return false;
-      }
-    });
+    try {
+      return getEnvelopeType(req) === 'feedback';
+    } catch (err) {
+      return false;
+    }
+  });
 
-    await page.route('https://dsn.ingest.sentry.io/**/*', route => {
-      return route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify({ id: 'test-id' }),
-      });
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
     });
+  });
 
-    const url = await getLocalTestPath({ testDir: __dirname });
-
-    const [, , replayReq0] = await Promise.all([page.goto(url), page.getByText('Report a Bug').click(), reqPromise0]);
-
-    // Inputs are slow, these need to be serial
-    await page.locator('[name="name"]').fill('Jane Doe');
-    await page.locator('[name="email"]').fill('janedoe@example.org');
-    await page.locator('[name="message"]').fill('my example feedback');
-
-    // Force flush here, as inputs are slow and can cause click event to be in unpredictable segments
-    await Promise.all([forceFlushReplay(), reqPromise1]);
-
-    const [, feedbackResp, replayReq2] = await Promise.all([
-      page.getByLabel('Send Bug Report').click(),
-      feedbackRequestPromise,
-      reqPromise2,
-    ]);
-
-    const feedbackEvent = envelopeRequestParser(feedbackResp.request());
-    const replayEvent = getReplayEvent(replayReq0);
-    // Feedback breadcrumb is on second segment because we flush when "Report a Bug" is clicked
-    // And then the breadcrumb is sent when feedback form is submitted
-    const { breadcrumbs } = getCustomRecordingEvents(replayReq2);
-
-    expect(breadcrumbs).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          category: 'sentry.feedback',
-          data: { feedbackId: expect.any(String) },
-          timestamp: expect.any(Number),
-          type: 'default',
-        }),
-      ]),
-    );
-
-    expect(feedbackEvent).toEqual({
-      type: 'feedback',
-      breadcrumbs: expect.any(Array),
-      contexts: {
-        feedback: {
-          contact_email: 'janedoe@example.org',
-          message: 'my example feedback',
-          name: 'Jane Doe',
-          replay_id: replayEvent.event_id,
-          source: 'widget',
-          url: expect.stringContaining('/dist/index.html'),
-        },
-      },
-      level: 'info',
-      timestamp: expect.any(Number),
-      event_id: expect.stringMatching(/\w{32}/),
-      environment: 'production',
-      sdk: {
-        integrations: expect.arrayContaining(['Feedback']),
-        version: expect.any(String),
-        name: 'sentry.javascript.browser',
-        packages: expect.anything(),
-      },
-      request: {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  await Promise.all([page.goto(url), page.getByText('Report a Bug').click(), reqPromise0]);
+
+  const replayRequestPromise = collectReplayRequests(page, recordingEvents => {
+    return getReplayBreadcrumbs(recordingEvents).some(breadcrumb => breadcrumb.category === 'sentry.feedback');
+  });
+
+  // Inputs are slow, these need to be serial
+  await page.locator('[name="name"]').fill('Jane Doe');
+  await page.locator('[name="email"]').fill('janedoe@example.org');
+  await page.locator('[name="message"]').fill('my example feedback');
+
+  // Force flush here, as inputs are slow and can cause click event to be in unpredictable segments
+  await Promise.all([forceFlushReplay()]);
+
+  const [, feedbackResp] = await Promise.all([
+    page.locator('[data-sentry-feedback] .btn--primary').click(),
+    feedbackRequestPromise,
+  ]);
+
+  const { replayEvents, replayRecordingSnapshots } = await replayRequestPromise;
+  const breadcrumbs = getReplayBreadcrumbs(replayRecordingSnapshots);
+
+  const replayEvent = replayEvents[0];
+  const feedbackEvent = envelopeRequestParser(feedbackResp.request());
+
+  expect(breadcrumbs).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({
+        category: 'sentry.feedback',
+        data: { feedbackId: expect.any(String) },
+        timestamp: expect.any(Number),
+        type: 'default',
+      }),
+    ]),
+  );
+
+  expect(feedbackEvent).toEqual({
+    type: 'feedback',
+    breadcrumbs: expect.any(Array),
+    contexts: {
+      feedback: {
+        contact_email: 'janedoe@example.org',
+        message: 'my example feedback',
+        name: 'Jane Doe',
+        replay_id: replayEvent.event_id,
+        source: 'widget',
         url: expect.stringContaining('/dist/index.html'),
-        headers: {
-          'User-Agent': expect.stringContaining(''),
-        },
       },
-      platform: 'javascript',
-    });
-  },
-);
+    },
+    level: 'info',
+    timestamp: expect.any(Number),
+    event_id: expect.stringMatching(/\w{32}/),
+    environment: 'production',
+    sdk: {
+      integrations: expect.arrayContaining(['Feedback']),
+      version: expect.any(String),
+      name: 'sentry.javascript.browser',
+      packages: expect.anything(),
+    },
+    request: {
+      url: expect.stringContaining('/dist/index.html'),
+      headers: {
+        'User-Agent': expect.stringContaining(''),
+      },
+    },
+    platform: 'javascript',
+  });
+});
diff --git a/dev-packages/browser-integration-tests/utils/generatePlugin.ts b/dev-packages/browser-integration-tests/utils/generatePlugin.ts
index d2907ae47af1..9b967748208e 100644
--- a/dev-packages/browser-integration-tests/utils/generatePlugin.ts
+++ b/dev-packages/browser-integration-tests/utils/generatePlugin.ts
@@ -26,21 +26,14 @@ const useLoader = bundleKey.startsWith('loader');
 // In this case, if we encounter this import, we want to add this CDN bundle file instead
 const IMPORTED_INTEGRATION_CDN_BUNDLE_PATHS: Record<string, string> = {
   httpClientIntegration: 'httpclient',
-  HttpClient: 'httpclient',
   captureConsoleIntegration: 'captureconsole',
   CaptureConsole: 'captureconsole',
   debugIntegration: 'debug',
-  Debug: 'debug',
   rewriteFramesIntegration: 'rewriteframes',
-  RewriteFrames: 'rewriteframes',
   contextLinesIntegration: 'contextlines',
-  ContextLines: 'contextlines',
   extraErrorDataIntegration: 'extraerrordata',
-  ExtraErrorData: 'extraerrordata',
   reportingObserverIntegration: 'reportingobserver',
-  ReportingObserver: 'reportingobserver',
   sessionTimingIntegration: 'sessiontiming',
-  SessionTiming: 'sessiontiming',
 };
 
 const BUNDLE_PATHS: Record<string, Record<string, string>> = {
@@ -55,6 +48,8 @@ const BUNDLE_PATHS: Record<string, Record<string, string>> = {
     bundle_tracing_min: 'build/bundles/bundle.tracing.min.js',
     bundle_tracing_replay: 'build/bundles/bundle.tracing.replay.js',
     bundle_tracing_replay_min: 'build/bundles/bundle.tracing.replay.min.js',
+    bundle_tracing_replay_feedback: 'build/bundles/bundle.tracing.replay.feedback.js',
+    bundle_tracing_replay_feedback_min: 'build/bundles/bundle.tracing.replay.feedback.min.js',
     loader_base: 'build/bundles/bundle.min.js',
     loader_eager: 'build/bundles/bundle.min.js',
     loader_debug: 'build/bundles/bundle.debug.min.js',
@@ -227,7 +222,8 @@ class SentryScenarioGenerationPlugin {
           const integrationBundleKey = bundleKey
             .replace('loader_', 'bundle_')
             .replace('_replay', '')
-            .replace('_tracing', '');
+            .replace('_tracing', '')
+            .replace('_feedback', '');
 
           this.requiredIntegrations.forEach(integration => {
             const fileName = `${integration}.bundle.js`;
diff --git a/dev-packages/browser-integration-tests/utils/helpers.ts b/dev-packages/browser-integration-tests/utils/helpers.ts
index 0e54eea0fb31..2fc55acd51c7 100644
--- a/dev-packages/browser-integration-tests/utils/helpers.ts
+++ b/dev-packages/browser-integration-tests/utils/helpers.ts
@@ -189,6 +189,18 @@ export function shouldSkipTracingTest(): boolean {
   return bundle != null && !bundle.includes('tracing') && !bundle.includes('esm') && !bundle.includes('cjs');
 }
 
+/**
+ * We can only test replay tests in certain bundles/packages:
+ * - NPM (ESM, CJS)
+ * - CDN bundles that contain the Replay integration
+ *
+ * @returns `true` if we should skip the feedback test
+ */
+export function shouldSkipFeedbackTest(): boolean {
+  const bundle = process.env.PW_BUNDLE as string | undefined;
+  return bundle != null && !bundle.includes('feedback') && !bundle.includes('esm') && !bundle.includes('cjs');
+}
+
 /**
  * Waits until a number of requests matching urlRgx at the given URL arrive.
  * If the timout option is configured, this function will abort waiting, even if it hasn't reveived the configured
diff --git a/package.json b/package.json
index 91351e047d3a..00945d179e72 100644
--- a/package.json
+++ b/package.json
@@ -56,8 +56,6 @@
     "packages/eslint-config-sdk",
     "packages/eslint-plugin-sdk",
     "packages/feedback",
-    "packages/feedback-modal",
-    "packages/feedback-screenshot",
     "packages/gatsby",
     "packages/google-cloud-serverless",
     "packages/integration-shims",
diff --git a/packages/browser/package.json b/packages/browser/package.json
index 927cbd41a045..d748c97dff02 100644
--- a/packages/browser/package.json
+++ b/packages/browser/package.json
@@ -43,8 +43,6 @@
   },
   "dependencies": {
     "@sentry-internal/browser-utils": "8.0.0-alpha.9",
-    "@sentry-internal/feedback-modal": "8.0.0-alpha.9",
-    "@sentry-internal/feedback-screenshot": "8.0.0-alpha.9",
     "@sentry-internal/feedback": "8.0.0-alpha.9",
     "@sentry-internal/replay": "8.0.0-alpha.9",
     "@sentry-internal/replay-canvas": "8.0.0-alpha.9",
diff --git a/packages/browser/src/index.bundle.feedback.ts b/packages/browser/src/index.bundle.feedback.ts
index 193cac1a5f06..649011bd82ed 100644
--- a/packages/browser/src/index.bundle.feedback.ts
+++ b/packages/browser/src/index.bundle.feedback.ts
@@ -1,7 +1,4 @@
 // This is exported so the loader does not fail when switching off Replay/Tracing
-import { feedbackIntegration, getFeedback } from '@sentry-internal/feedback';
-import { feedbackModalIntegration } from '@sentry-internal/feedback-modal';
-import { feedbackScreenshotIntegration } from '@sentry-internal/feedback-screenshot';
 import {
   addTracingExtensionsShim,
   browserTracingIntegrationShim,
@@ -9,13 +6,16 @@ import {
 } from '@sentry-internal/integration-shims';
 
 export * from './index.bundle.base';
+
 export {
-  browserTracingIntegrationShim as browserTracingIntegration,
-  addTracingExtensionsShim as addTracingExtensions,
-  replayIntegrationShim as replayIntegration,
   feedbackIntegration,
   feedbackModalIntegration,
   feedbackScreenshotIntegration,
   getFeedback,
+} from '@sentry-internal/feedback';
+
+export {
+  browserTracingIntegrationShim as browserTracingIntegration,
+  addTracingExtensionsShim as addTracingExtensions,
+  replayIntegrationShim as replayIntegration,
 };
-// Note: We do not export a shim for `Span` here, as that is quite complex and would blow up the bundle
diff --git a/packages/browser/src/index.bundle.replay.ts b/packages/browser/src/index.bundle.replay.ts
index 0c0bb6ca40ef..bdc776374398 100644
--- a/packages/browser/src/index.bundle.replay.ts
+++ b/packages/browser/src/index.bundle.replay.ts
@@ -6,15 +6,15 @@ import {
   feedbackModalIntegrationShim,
   feedbackScreenshotIntegrationShim,
 } from '@sentry-internal/integration-shims';
-import { replayIntegration } from '@sentry-internal/replay';
 
 export * from './index.bundle.base';
+
+export { replayIntegration } from '@sentry-internal/replay';
+
 export {
   browserTracingIntegrationShim as browserTracingIntegration,
   addTracingExtensionsShim as addTracingExtensions,
-  replayIntegration,
   feedbackIntegrationShim as feedbackIntegration,
   feedbackModalIntegrationShim as feedbackModalIntegration,
   feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
 };
-// Note: We do not export a shim for `Span` here, as that is quite complex and would blow up the bundle
diff --git a/packages/browser/src/index.bundle.tracing.replay.feedback.ts b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
index d26ccf1ba230..7f178e87c789 100644
--- a/packages/browser/src/index.bundle.tracing.replay.feedback.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
@@ -1,17 +1,10 @@
-import {
-  browserTracingIntegration,
-  startBrowserTracingNavigationSpan,
-  startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
-import { feedbackIntegration, getFeedback } from '@sentry-internal/feedback';
-import { feedbackModalIntegration } from '@sentry-internal/feedback-modal';
-import { feedbackScreenshotIntegration } from '@sentry-internal/feedback-screenshot';
-import { replayIntegration } from '@sentry-internal/replay';
 import { addTracingExtensions } from '@sentry/core';
 
 // We are patching the global object with our hub extension methods
 addTracingExtensions();
 
+export * from './index.bundle.base';
+
 export {
   getActiveSpan,
   getRootSpan,
@@ -21,18 +14,20 @@ export {
   withActiveSpan,
   getSpanDescendants,
   setMeasurement,
+  addTracingExtensions,
 } from '@sentry/core';
 
 export {
   feedbackIntegration,
   feedbackModalIntegration,
   feedbackScreenshotIntegration,
-  replayIntegration,
+  getFeedback,
+} from '@sentry-internal/feedback';
+
+export {
   browserTracingIntegration,
-  addTracingExtensions,
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
-  getFeedback,
-};
+} from '@sentry-internal/browser-utils';
 
-export * from './index.bundle.base';
+export { replayIntegration } from '@sentry-internal/replay';
diff --git a/packages/browser/src/index.bundle.tracing.replay.ts b/packages/browser/src/index.bundle.tracing.replay.ts
index 628ebeb19651..494932f6aef3 100644
--- a/packages/browser/src/index.bundle.tracing.replay.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.ts
@@ -1,19 +1,15 @@
-import {
-  browserTracingIntegration,
-  startBrowserTracingNavigationSpan,
-  startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
 import {
   feedbackIntegrationShim,
   feedbackModalIntegrationShim,
   feedbackScreenshotIntegrationShim,
 } from '@sentry-internal/integration-shims';
-import { replayIntegration } from '@sentry-internal/replay';
 import { addTracingExtensions } from '@sentry/core';
 
 // We are patching the global object with our hub extension methods
 addTracingExtensions();
 
+export * from './index.bundle.base';
+
 export {
   getActiveSpan,
   getRootSpan,
@@ -23,17 +19,19 @@ export {
   withActiveSpan,
   getSpanDescendants,
   setMeasurement,
+  addTracingExtensions,
 } from '@sentry/core';
 
 export {
-  replayIntegration,
-  feedbackIntegrationShim as feedbackIntegration,
-  feedbackModalIntegrationShim as feedbackModalIntegration,
-  feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
   browserTracingIntegration,
-  addTracingExtensions,
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
+} from '@sentry-internal/browser-utils';
+
+export {
+  feedbackIntegrationShim as feedbackIntegration,
+  feedbackModalIntegrationShim as feedbackModalIntegration,
+  feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
 };
 
-export * from './index.bundle.base';
+export { replayIntegration } from '@sentry-internal/replay';
diff --git a/packages/browser/src/index.bundle.tracing.ts b/packages/browser/src/index.bundle.tracing.ts
index 29c463fae586..b020549f6968 100644
--- a/packages/browser/src/index.bundle.tracing.ts
+++ b/packages/browser/src/index.bundle.tracing.ts
@@ -1,8 +1,3 @@
-import {
-  browserTracingIntegration,
-  startBrowserTracingNavigationSpan,
-  startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
 // This is exported so the loader does not fail when switching off Replay
 import {
   feedbackIntegrationShim,
@@ -15,6 +10,8 @@ import { addTracingExtensions } from '@sentry/core';
 // We are patching the global object with our hub extension methods
 addTracingExtensions();
 
+export * from './index.bundle.base';
+
 export {
   getActiveSpan,
   getRootSpan,
@@ -24,17 +21,18 @@ export {
   withActiveSpan,
   getSpanDescendants,
   setMeasurement,
+  addTracingExtensions,
 } from '@sentry/core';
 
+export {
+  browserTracingIntegration,
+  startBrowserTracingNavigationSpan,
+  startBrowserTracingPageLoadSpan,
+} from '@sentry-internal/browser-utils';
+
 export {
   feedbackIntegrationShim as feedbackIntegration,
   feedbackModalIntegrationShim as feedbackModalIntegration,
   feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
   replayIntegrationShim as replayIntegration,
-  browserTracingIntegration,
-  addTracingExtensions,
-  startBrowserTracingPageLoadSpan,
-  startBrowserTracingNavigationSpan,
 };
-
-export * from './index.bundle.base';
diff --git a/packages/browser/src/index.bundle.ts b/packages/browser/src/index.bundle.ts
index 10482f8135cf..ce04413b4053 100644
--- a/packages/browser/src/index.bundle.ts
+++ b/packages/browser/src/index.bundle.ts
@@ -9,6 +9,7 @@ import {
 } from '@sentry-internal/integration-shims';
 
 export * from './index.bundle.base';
+
 export {
   addTracingExtensionsShim as addTracingExtensions,
   browserTracingIntegrationShim as browserTracingIntegration,
@@ -17,4 +18,3 @@ export {
   feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
   replayIntegrationShim as replayIntegration,
 };
-// Note: We do not export a shim for `Span` here, as that is quite complex and would blow up the bundle
diff --git a/packages/browser/src/index.ts b/packages/browser/src/index.ts
index 8d8069d2460c..bea2adda57ee 100644
--- a/packages/browser/src/index.ts
+++ b/packages/browser/src/index.ts
@@ -32,11 +32,11 @@ export { replayCanvasIntegration } from '@sentry-internal/replay-canvas';
 
 export {
   feedbackIntegration,
+  feedbackModalIntegration,
+  feedbackScreenshotIntegration,
   getFeedback,
   sendFeedback,
 } from '@sentry-internal/feedback';
-export { feedbackModalIntegration } from '@sentry-internal/feedback-modal';
-export { feedbackScreenshotIntegration } from '@sentry-internal/feedback-screenshot';
 
 export {
   defaultRequestInstrumentationOptions,
diff --git a/packages/browser/src/utils/lazyLoadIntegration.ts b/packages/browser/src/utils/lazyLoadIntegration.ts
index 19cf28f1af52..aaa5987a183c 100644
--- a/packages/browser/src/utils/lazyLoadIntegration.ts
+++ b/packages/browser/src/utils/lazyLoadIntegration.ts
@@ -8,6 +8,8 @@ const LazyLoadableIntegrations = {
   replayIntegration: 'replay',
   replayCanvasIntegration: 'replay-canvas',
   feedbackIntegration: 'feedback',
+  feedbackModalIntegration: 'feedback-modal',
+  feedbackScreenshotIntegration: 'feedback-screenshot',
   captureConsoleIntegration: 'captureconsole',
   contextLinesIntegration: 'contextlines',
   linkedErrorsIntegration: 'linkederrors',
diff --git a/packages/feedback-modal/.eslintignore b/packages/feedback-modal/.eslintignore
deleted file mode 100644
index b38db2f296ff..000000000000
--- a/packages/feedback-modal/.eslintignore
+++ /dev/null
@@ -1,2 +0,0 @@
-node_modules/
-build/
diff --git a/packages/feedback-modal/.eslintrc.js b/packages/feedback-modal/.eslintrc.js
deleted file mode 100644
index 0b547ffc828c..000000000000
--- a/packages/feedback-modal/.eslintrc.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// Note: All paths are relative to the directory in which eslint is being run, rather than the directory where this file
-// lives
-
-// ESLint config docs: https://eslint.org/docs/user-guide/configuring/
-
-module.exports = {
-  extends: ['../../.eslintrc.js'],
-  overrides: [
-    {
-      files: ['jest.setup.ts', 'jest.config.ts'],
-      parserOptions: {
-        project: ['tsconfig.test.json'],
-      },
-    },
-  ],
-};
diff --git a/packages/feedback-modal/.gitignore b/packages/feedback-modal/.gitignore
deleted file mode 100644
index 363d3467c6fa..000000000000
--- a/packages/feedback-modal/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-node_modules
-/*.tgz
-.eslintcache
-build
diff --git a/packages/feedback-modal/LICENSE b/packages/feedback-modal/LICENSE
deleted file mode 100644
index ea5e82344f87..000000000000
--- a/packages/feedback-modal/LICENSE
+++ /dev/null
@@ -1,14 +0,0 @@
-Copyright (c) 2024 Sentry (https://sentry.io) and individual contributors. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/feedback-modal/README.md b/packages/feedback-modal/README.md
deleted file mode 100644
index f4949a12b0d1..000000000000
--- a/packages/feedback-modal/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-<p align="center">
-  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
-    <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84">
-  </a>
-</p>
-
-# Sentry Integration for Feedback
-
-This integration supports our browser feedback SDK allowing us to code-split heavy UI components as needed.
-
-For the primary Feedback Integration see
-[Sentry Feedback SDK](https://github.com/getsentry/sentry-javascript/tree/develop/packages/feedback)
-
-Note: This package is only meant to be used internally.
diff --git a/packages/feedback-modal/jest.config.js b/packages/feedback-modal/jest.config.js
deleted file mode 100644
index cd02790794a7..000000000000
--- a/packages/feedback-modal/jest.config.js
+++ /dev/null
@@ -1,6 +0,0 @@
-const baseConfig = require('../../jest/jest.config.js');
-
-module.exports = {
-  ...baseConfig,
-  testEnvironment: 'jsdom',
-};
diff --git a/packages/feedback-modal/package.json b/packages/feedback-modal/package.json
deleted file mode 100644
index 831e6a29c266..000000000000
--- a/packages/feedback-modal/package.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
-  "name": "@sentry-internal/feedback-modal",
-  "version": "8.0.0-alpha.9",
-  "description": "Sentry SDK integration for user feedback",
-  "repository": "git://github.com/getsentry/sentry-javascript.git",
-  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/feedback-modal",
-  "author": "Sentry",
-  "license": "MIT",
-  "engines": {
-    "node": ">=14.18"
-  },
-  "files": [
-    "cjs",
-    "esm",
-    "types",
-    "types-ts3.8"
-  ],
-  "main": "build/npm/cjs/index.js",
-  "module": "build/npm/esm/index.js",
-  "types": "build/npm/types/index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": {
-        "types": "./build/npm/types/index.d.ts",
-        "default": "./build/npm/esm/index.js"
-      },
-      "require": {
-        "types": "./build/npm/types/index.d.ts",
-        "default": "./build/npm/cjs/index.js"
-      }
-    }
-  },
-  "typesVersions": {
-    "<4.9": {
-      "build/npm/types/index.d.ts": [
-        "build/npm/types-ts3.8/index.d.ts"
-      ]
-    }
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@sentry/core": "8.0.0-alpha.9",
-    "@sentry/types": "8.0.0-alpha.9",
-    "@sentry/utils": "8.0.0-alpha.9",
-    "preact": "^10.19.4"
-  },
-  "scripts": {
-    "build": "run-p build:transpile build:types build:bundle",
-    "build:transpile": "rollup -c rollup.npm.config.mjs",
-    "build:bundle": "rollup -c rollup.bundle.config.mjs",
-    "build:dev": "run-p build:transpile build:types",
-    "build:types": "run-s build:types:core build:types:downlevel",
-    "build:types:core": "tsc -p tsconfig.types.json",
-    "build:types:downlevel": "yarn downlevel-dts build/npm/types build/npm/types-ts3.8 --to ts3.8 && yarn node ./scripts/shim-preact-export.js",
-    "build:watch": "run-p build:transpile:watch build:bundle:watch build:types:watch",
-    "build:dev:watch": "run-p build:transpile:watch build:types:watch",
-    "build:transpile:watch": "yarn build:transpile --watch",
-    "build:bundle:watch": "yarn build:bundle --watch",
-    "build:types:watch": "tsc -p tsconfig.types.json --watch",
-    "build:tarball": "ts-node ../../scripts/prepack.ts --bundles && npm pack ./build/npm",
-    "circularDepCheck": "madge --circular src/index.ts",
-    "clean": "rimraf build sentry-feedback-modal-*.tgz",
-    "fix": "eslint . --format stylish --fix",
-    "lint": "eslint . --format stylish",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "yalc:publish": "ts-node ../../scripts/prepack.ts --bundles && yalc publish ./build/npm --push --sig"
-  },
-  "volta": {
-    "extends": "../../package.json"
-  },
-  "sideEffects": false
-}
diff --git a/packages/feedback-modal/rollup.bundle.config.mjs b/packages/feedback-modal/rollup.bundle.config.mjs
deleted file mode 100644
index 9fc71b68bc9d..000000000000
--- a/packages/feedback-modal/rollup.bundle.config.mjs
+++ /dev/null
@@ -1,15 +0,0 @@
-import { makeBaseBundleConfig, makeBundleConfigVariants } from '@sentry-internal/rollup-utils';
-
-export default makeBundleConfigVariants(
-  makeBaseBundleConfig({
-    bundleType: 'addon',
-    entrypoints: ['src/index.ts'],
-    jsVersion: 'es6',
-    licenseTitle: '@sentry-internal/feedback-modal',
-    outputFileBase: () => 'bundles/feedback-modal',
-    sucrase: {
-      jsxPragma: 'h',
-      jsxFragmentPragma: 'Fragment',
-    },
-  }),
-);
diff --git a/packages/feedback-modal/rollup.npm.config.mjs b/packages/feedback-modal/rollup.npm.config.mjs
deleted file mode 100644
index 3dc031c5ff82..000000000000
--- a/packages/feedback-modal/rollup.npm.config.mjs
+++ /dev/null
@@ -1,20 +0,0 @@
-import { makeBaseNPMConfig, makeNPMConfigVariants } from '@sentry-internal/rollup-utils';
-
-export default makeNPMConfigVariants(
-  makeBaseNPMConfig({
-    hasBundles: true,
-    packageSpecificConfig: {
-      output: {
-        // set exports to 'named' or 'auto' so that rollup doesn't warn
-        exports: 'named',
-        // set preserveModules to false because for feedback we actually want
-        // to bundle everything into one file.
-        preserveModules: false,
-      },
-    },
-    sucrase: {
-      jsxPragma: 'h',
-      jsxFragmentPragma: 'Fragment',
-    },
-  }),
-);
diff --git a/packages/feedback-modal/scripts/shim-preact-export.js b/packages/feedback-modal/scripts/shim-preact-export.js
deleted file mode 100644
index bd74e4da0a05..000000000000
--- a/packages/feedback-modal/scripts/shim-preact-export.js
+++ /dev/null
@@ -1,75 +0,0 @@
-// preact does not support more modern TypeScript versions, which breaks our users that depend on older
-// TypeScript versions. To fix this, we shim the types from preact to be any and remove the dependency on preact
-// for types directly. This script is meant to be run after the build/npm/types-ts3.8 directory is created.
-
-// Path: build/npm/types-ts3.8/global.d.ts
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * This regex looks for preact imports we can replace and shim out.
- *
- * Example:
- * import { ComponentChildren, VNode } from 'preact';
- */
-const preactImportRegex = /import\s*{\s*([\w\s,]+)\s*}\s*from\s*'preact'\s*;?/;
-
-function walk(dir) {
-  const files = fs.readdirSync(dir);
-  files.forEach(file => {
-    const filePath = path.join(dir, file);
-    const stat = fs.lstatSync(filePath);
-    if (stat.isDirectory()) {
-      walk(filePath);
-    } else {
-      if (filePath.endsWith('.d.ts')) {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const capture = preactImportRegex.exec(content);
-        if (capture) {
-          const groups = capture[1].split(',').map(s => s.trim());
-
-          // This generates a shim snippet to replace the type imports from preact
-          // It generates a snippet based on the capture groups of preactImportRegex.
-          //
-          // Example:
-          //
-          // import type { ComponentChildren, VNode } from 'preact';
-          // becomes
-          // type ComponentChildren: any;
-          // type VNode: any;
-          const snippet = groups.reduce((acc, curr) => {
-            const searchableValue = curr.includes(' as ') ? curr.split(' as ')[1] : curr;
-
-            // look to see if imported as value, then we have to use declare const
-            if (content.includes(`typeof ${searchableValue}`)) {
-              return `${acc}declare const ${searchableValue}: any;\n`;
-            }
-
-            // look to see if generic type like Foo<T>
-            if (content.includes(`${searchableValue}<`)) {
-              return `${acc}type ${searchableValue}<T> = any;\n`;
-            }
-
-            // otherwise we can just leave as type
-            return `${acc}type ${searchableValue} = any;\n`;
-          }, '');
-
-          // we then can remove the import from preact
-          const newContent = content.replace(preactImportRegex, '// replaced import from preact');
-
-          // and write the new content to the file
-          fs.writeFileSync(filePath, snippet + newContent, 'utf8');
-        }
-      }
-    }
-  });
-}
-
-function run() {
-  // recurse through build/npm/types-ts3.8 directory
-  const dir = path.join('build', 'npm', 'types-ts3.8');
-  walk(dir);
-}
-
-run();
diff --git a/packages/feedback-modal/src/index.ts b/packages/feedback-modal/src/index.ts
deleted file mode 100644
index eff7430a6050..000000000000
--- a/packages/feedback-modal/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { feedbackModalIntegration } from './modal/integration';
diff --git a/packages/feedback-modal/src/modal/integration.test.ts b/packages/feedback-modal/src/modal/integration.test.ts
deleted file mode 100644
index d9eedd59c0f3..000000000000
--- a/packages/feedback-modal/src/modal/integration.test.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { feedbackModalIntegration } from './integration';
-
-describe('feedbackModalIntegration', () => {
-  it('should have createDialog', () => {
-    const instance = feedbackModalIntegration();
-    expect(instance).toHaveProperty('createDialog');
-  });
-});
diff --git a/packages/feedback-modal/src/modal/integration.ts b/packages/feedback-modal/src/modal/integration.ts
deleted file mode 100644
index f9e8a9ad64be..000000000000
--- a/packages/feedback-modal/src/modal/integration.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { Integration, IntegrationFn } from '@sentry/types';
-
-export interface FeedbackModalIntegration extends Integration {
-  createDialog: unknown;
-}
-
-export const feedbackModalIntegration = ((): FeedbackModalIntegration => {
-  return {
-    name: 'FeedbackModal',
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setupOnce() {},
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    createDialog: () => {}, // TODO(ryan953): port this over from packages/feedback/src/modal
-  };
-}) satisfies IntegrationFn;
diff --git a/packages/feedback-modal/tsconfig.json b/packages/feedback-modal/tsconfig.json
deleted file mode 100644
index c1fc08578508..000000000000
--- a/packages/feedback-modal/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "module": "esnext",
-
-    /* Preact Config */
-    "jsx": "react-jsx",
-    "jsxImportSource": "preact",
-    "skipLibCheck": true,
-    "baseUrl": "./",
-    "paths": {
-      "react": ["./node_modules/preact/compat/"],
-      "react-dom": ["./node_modules/preact/compat/"]
-    }
-  },
-  "include": ["src/**/*.ts","src/**/*.tsx"]
-}
diff --git a/packages/feedback-modal/tsconfig.test.json b/packages/feedback-modal/tsconfig.test.json
deleted file mode 100644
index ad87caa06c48..000000000000
--- a/packages/feedback-modal/tsconfig.test.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-
-  "include": ["test/**/*.ts", "jest.config.ts", "jest.setup.ts"],
-
-  "compilerOptions": {
-    "types": ["node", "jest"],
-    "esModuleInterop": true,
-    "allowJs": true,
-    "noImplicitAny": true,
-    "noImplicitThis": false,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": false
-  }
-}
diff --git a/packages/feedback-modal/tsconfig.types.json b/packages/feedback-modal/tsconfig.types.json
deleted file mode 100644
index 374fd9bc9364..000000000000
--- a/packages/feedback-modal/tsconfig.types.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-
-  "compilerOptions": {
-    "declaration": true,
-    "declarationMap": true,
-    "emitDeclarationOnly": true,
-    "outDir": "build/npm/types"
-  }
-}
diff --git a/packages/feedback-screenshot/.eslintignore b/packages/feedback-screenshot/.eslintignore
deleted file mode 100644
index b38db2f296ff..000000000000
--- a/packages/feedback-screenshot/.eslintignore
+++ /dev/null
@@ -1,2 +0,0 @@
-node_modules/
-build/
diff --git a/packages/feedback-screenshot/.eslintrc.js b/packages/feedback-screenshot/.eslintrc.js
deleted file mode 100644
index 0b547ffc828c..000000000000
--- a/packages/feedback-screenshot/.eslintrc.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// Note: All paths are relative to the directory in which eslint is being run, rather than the directory where this file
-// lives
-
-// ESLint config docs: https://eslint.org/docs/user-guide/configuring/
-
-module.exports = {
-  extends: ['../../.eslintrc.js'],
-  overrides: [
-    {
-      files: ['jest.setup.ts', 'jest.config.ts'],
-      parserOptions: {
-        project: ['tsconfig.test.json'],
-      },
-    },
-  ],
-};
diff --git a/packages/feedback-screenshot/.gitignore b/packages/feedback-screenshot/.gitignore
deleted file mode 100644
index 363d3467c6fa..000000000000
--- a/packages/feedback-screenshot/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-node_modules
-/*.tgz
-.eslintcache
-build
diff --git a/packages/feedback-screenshot/LICENSE b/packages/feedback-screenshot/LICENSE
deleted file mode 100644
index ea5e82344f87..000000000000
--- a/packages/feedback-screenshot/LICENSE
+++ /dev/null
@@ -1,14 +0,0 @@
-Copyright (c) 2024 Sentry (https://sentry.io) and individual contributors. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/feedback-screenshot/README.md b/packages/feedback-screenshot/README.md
deleted file mode 100644
index f4949a12b0d1..000000000000
--- a/packages/feedback-screenshot/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-<p align="center">
-  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
-    <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84">
-  </a>
-</p>
-
-# Sentry Integration for Feedback
-
-This integration supports our browser feedback SDK allowing us to code-split heavy UI components as needed.
-
-For the primary Feedback Integration see
-[Sentry Feedback SDK](https://github.com/getsentry/sentry-javascript/tree/develop/packages/feedback)
-
-Note: This package is only meant to be used internally.
diff --git a/packages/feedback-screenshot/jest.config.js b/packages/feedback-screenshot/jest.config.js
deleted file mode 100644
index cd02790794a7..000000000000
--- a/packages/feedback-screenshot/jest.config.js
+++ /dev/null
@@ -1,6 +0,0 @@
-const baseConfig = require('../../jest/jest.config.js');
-
-module.exports = {
-  ...baseConfig,
-  testEnvironment: 'jsdom',
-};
diff --git a/packages/feedback-screenshot/package.json b/packages/feedback-screenshot/package.json
deleted file mode 100644
index e29be49cb539..000000000000
--- a/packages/feedback-screenshot/package.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
-  "name": "@sentry-internal/feedback-screenshot",
-  "version": "8.0.0-alpha.9",
-  "description": "Sentry SDK integration for user feedback",
-  "repository": "git://github.com/getsentry/sentry-javascript.git",
-  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/feedback-screenshot",
-  "author": "Sentry",
-  "license": "MIT",
-  "engines": {
-    "node": ">=14.18"
-  },
-  "files": [
-    "cjs",
-    "esm",
-    "types",
-    "types-ts3.8"
-  ],
-  "main": "build/npm/cjs/index.js",
-  "module": "build/npm/esm/index.js",
-  "types": "build/npm/types/index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": {
-        "types": "./build/npm/types/index.d.ts",
-        "default": "./build/npm/esm/index.js"
-      },
-      "require": {
-        "types": "./build/npm/types/index.d.ts",
-        "default": "./build/npm/cjs/index.js"
-      }
-    }
-  },
-  "typesVersions": {
-    "<4.9": {
-      "build/npm/types/index.d.ts": [
-        "build/npm/types-ts3.8/index.d.ts"
-      ]
-    }
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@sentry/core": "8.0.0-alpha.9",
-    "@sentry/types": "8.0.0-alpha.9",
-    "@sentry/utils": "8.0.0-alpha.9",
-    "preact": "^10.19.4"
-  },
-  "scripts": {
-    "build": "run-p build:transpile build:types build:bundle",
-    "build:transpile": "rollup -c rollup.npm.config.mjs",
-    "build:bundle": "rollup -c rollup.bundle.config.mjs",
-    "build:dev": "run-p build:transpile build:types",
-    "build:types": "run-s build:types:core build:types:downlevel",
-    "build:types:core": "tsc -p tsconfig.types.json",
-    "build:types:downlevel": "yarn downlevel-dts build/npm/types build/npm/types-ts3.8 --to ts3.8 && yarn node ./scripts/shim-preact-export.js",
-    "build:watch": "run-p build:transpile:watch build:bundle:watch build:types:watch",
-    "build:dev:watch": "run-p build:transpile:watch build:types:watch",
-    "build:transpile:watch": "yarn build:transpile --watch",
-    "build:bundle:watch": "yarn build:bundle --watch",
-    "build:types:watch": "tsc -p tsconfig.types.json --watch",
-    "build:tarball": "ts-node ../../scripts/prepack.ts --bundles && npm pack ./build/npm",
-    "circularDepCheck": "madge --circular src/index.ts",
-    "clean": "rimraf build sentry-feedback-screenshot-*.tgz",
-    "fix": "eslint . --format stylish --fix",
-    "lint": "eslint . --format stylish",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "yalc:publish": "ts-node ../../scripts/prepack.ts --bundles && yalc publish ./build/npm --push --sig"
-  },
-  "volta": {
-    "extends": "../../package.json"
-  },
-  "sideEffects": false
-}
diff --git a/packages/feedback-screenshot/rollup.bundle.config.mjs b/packages/feedback-screenshot/rollup.bundle.config.mjs
deleted file mode 100644
index 5e2422f0bcd0..000000000000
--- a/packages/feedback-screenshot/rollup.bundle.config.mjs
+++ /dev/null
@@ -1,15 +0,0 @@
-import { makeBaseBundleConfig, makeBundleConfigVariants } from '@sentry-internal/rollup-utils';
-
-export default makeBundleConfigVariants(
-  makeBaseBundleConfig({
-    bundleType: 'addon',
-    entrypoints: ['src/index.ts'],
-    jsVersion: 'es6',
-    licenseTitle: '@sentry-internal/feedback-screenshot',
-    outputFileBase: () => 'bundles/feedback-screenshot',
-    sucrase: {
-      jsxPragma: 'h',
-      jsxFragmentPragma: 'Fragment',
-    },
-  }),
-);
diff --git a/packages/feedback-screenshot/rollup.npm.config.mjs b/packages/feedback-screenshot/rollup.npm.config.mjs
deleted file mode 100644
index 3dc031c5ff82..000000000000
--- a/packages/feedback-screenshot/rollup.npm.config.mjs
+++ /dev/null
@@ -1,20 +0,0 @@
-import { makeBaseNPMConfig, makeNPMConfigVariants } from '@sentry-internal/rollup-utils';
-
-export default makeNPMConfigVariants(
-  makeBaseNPMConfig({
-    hasBundles: true,
-    packageSpecificConfig: {
-      output: {
-        // set exports to 'named' or 'auto' so that rollup doesn't warn
-        exports: 'named',
-        // set preserveModules to false because for feedback we actually want
-        // to bundle everything into one file.
-        preserveModules: false,
-      },
-    },
-    sucrase: {
-      jsxPragma: 'h',
-      jsxFragmentPragma: 'Fragment',
-    },
-  }),
-);
diff --git a/packages/feedback-screenshot/scripts/shim-preact-export.js b/packages/feedback-screenshot/scripts/shim-preact-export.js
deleted file mode 100644
index bd74e4da0a05..000000000000
--- a/packages/feedback-screenshot/scripts/shim-preact-export.js
+++ /dev/null
@@ -1,75 +0,0 @@
-// preact does not support more modern TypeScript versions, which breaks our users that depend on older
-// TypeScript versions. To fix this, we shim the types from preact to be any and remove the dependency on preact
-// for types directly. This script is meant to be run after the build/npm/types-ts3.8 directory is created.
-
-// Path: build/npm/types-ts3.8/global.d.ts
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * This regex looks for preact imports we can replace and shim out.
- *
- * Example:
- * import { ComponentChildren, VNode } from 'preact';
- */
-const preactImportRegex = /import\s*{\s*([\w\s,]+)\s*}\s*from\s*'preact'\s*;?/;
-
-function walk(dir) {
-  const files = fs.readdirSync(dir);
-  files.forEach(file => {
-    const filePath = path.join(dir, file);
-    const stat = fs.lstatSync(filePath);
-    if (stat.isDirectory()) {
-      walk(filePath);
-    } else {
-      if (filePath.endsWith('.d.ts')) {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const capture = preactImportRegex.exec(content);
-        if (capture) {
-          const groups = capture[1].split(',').map(s => s.trim());
-
-          // This generates a shim snippet to replace the type imports from preact
-          // It generates a snippet based on the capture groups of preactImportRegex.
-          //
-          // Example:
-          //
-          // import type { ComponentChildren, VNode } from 'preact';
-          // becomes
-          // type ComponentChildren: any;
-          // type VNode: any;
-          const snippet = groups.reduce((acc, curr) => {
-            const searchableValue = curr.includes(' as ') ? curr.split(' as ')[1] : curr;
-
-            // look to see if imported as value, then we have to use declare const
-            if (content.includes(`typeof ${searchableValue}`)) {
-              return `${acc}declare const ${searchableValue}: any;\n`;
-            }
-
-            // look to see if generic type like Foo<T>
-            if (content.includes(`${searchableValue}<`)) {
-              return `${acc}type ${searchableValue}<T> = any;\n`;
-            }
-
-            // otherwise we can just leave as type
-            return `${acc}type ${searchableValue} = any;\n`;
-          }, '');
-
-          // we then can remove the import from preact
-          const newContent = content.replace(preactImportRegex, '// replaced import from preact');
-
-          // and write the new content to the file
-          fs.writeFileSync(filePath, snippet + newContent, 'utf8');
-        }
-      }
-    }
-  });
-}
-
-function run() {
-  // recurse through build/npm/types-ts3.8 directory
-  const dir = path.join('build', 'npm', 'types-ts3.8');
-  walk(dir);
-}
-
-run();
diff --git a/packages/feedback-screenshot/src/index.ts b/packages/feedback-screenshot/src/index.ts
deleted file mode 100644
index 2582220645d1..000000000000
--- a/packages/feedback-screenshot/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { feedbackScreenshotIntegration } from './screenshot/integration';
diff --git a/packages/feedback-screenshot/src/screenshot/integration.test.ts b/packages/feedback-screenshot/src/screenshot/integration.test.ts
deleted file mode 100644
index 43acdd770670..000000000000
--- a/packages/feedback-screenshot/src/screenshot/integration.test.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { feedbackScreenshotIntegration } from './integration';
-
-describe('feedbackScreenshotIntegration', () => {
-  it('should have createInput', () => {
-    const instance = feedbackScreenshotIntegration();
-    expect(instance).toHaveProperty('createInput');
-  });
-});
diff --git a/packages/feedback-screenshot/src/screenshot/integration.ts b/packages/feedback-screenshot/src/screenshot/integration.ts
deleted file mode 100644
index ada4e7ec8b65..000000000000
--- a/packages/feedback-screenshot/src/screenshot/integration.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { Integration, IntegrationFn } from '@sentry/types';
-
-export interface FeedbackScreenshotIntegration extends Integration {
-  createInput: unknown;
-}
-
-export const feedbackScreenshotIntegration = (() => {
-  return {
-    name: 'FeedbackScreenshot',
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setupOnce() {},
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    createInput: () => {}, // TODO(ryan953): port this over from packages/feedback/src/screenshot
-  };
-}) satisfies IntegrationFn;
diff --git a/packages/feedback-screenshot/tsconfig.json b/packages/feedback-screenshot/tsconfig.json
deleted file mode 100644
index c1fc08578508..000000000000
--- a/packages/feedback-screenshot/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "module": "esnext",
-
-    /* Preact Config */
-    "jsx": "react-jsx",
-    "jsxImportSource": "preact",
-    "skipLibCheck": true,
-    "baseUrl": "./",
-    "paths": {
-      "react": ["./node_modules/preact/compat/"],
-      "react-dom": ["./node_modules/preact/compat/"]
-    }
-  },
-  "include": ["src/**/*.ts","src/**/*.tsx"]
-}
diff --git a/packages/feedback-screenshot/tsconfig.test.json b/packages/feedback-screenshot/tsconfig.test.json
deleted file mode 100644
index ad87caa06c48..000000000000
--- a/packages/feedback-screenshot/tsconfig.test.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-
-  "include": ["test/**/*.ts", "jest.config.ts", "jest.setup.ts"],
-
-  "compilerOptions": {
-    "types": ["node", "jest"],
-    "esModuleInterop": true,
-    "allowJs": true,
-    "noImplicitAny": true,
-    "noImplicitThis": false,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": false
-  }
-}
diff --git a/packages/feedback-screenshot/tsconfig.types.json b/packages/feedback-screenshot/tsconfig.types.json
deleted file mode 100644
index 374fd9bc9364..000000000000
--- a/packages/feedback-screenshot/tsconfig.types.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-
-  "compilerOptions": {
-    "declaration": true,
-    "declarationMap": true,
-    "emitDeclarationOnly": true,
-    "outDir": "build/npm/types"
-  }
-}
diff --git a/packages/feedback/package.json b/packages/feedback/package.json
index 5173a0b636b0..acb921f97324 100644
--- a/packages/feedback/package.json
+++ b/packages/feedback/package.json
@@ -62,7 +62,7 @@
     "build:types:watch": "tsc -p tsconfig.types.json --watch",
     "build:tarball": "ts-node ../../scripts/prepack.ts --bundles && npm pack ./build/npm",
     "circularDepCheck": "madge --circular src/index.ts",
-    "clean": "rimraf build sentry-feedback-*.tgz",
+    "clean": "rimraf build sentry-internal-feedback-*.tgz",
     "fix": "eslint . --format stylish --fix",
     "lint": "eslint . --format stylish",
     "test": "jest",
diff --git a/packages/feedback/rollup.bundle.config.mjs b/packages/feedback/rollup.bundle.config.mjs
index f5794d328409..6bdaefed8748 100644
--- a/packages/feedback/rollup.bundle.config.mjs
+++ b/packages/feedback/rollup.bundle.config.mjs
@@ -1,15 +1,43 @@
 import { makeBaseBundleConfig, makeBundleConfigVariants } from '@sentry-internal/rollup-utils';
 
-export default makeBundleConfigVariants(
-  makeBaseBundleConfig({
-    bundleType: 'addon',
-    entrypoints: ['src/index.ts'],
-    jsVersion: 'es6',
-    licenseTitle: '@sentry-internal/feedback',
-    outputFileBase: () => 'bundles/feedback',
-    sucrase: {
-      jsxPragma: 'h',
-      jsxFragmentPragma: 'Fragment',
-    },
-  }),
-);
+export default [
+  ...makeBundleConfigVariants(
+    makeBaseBundleConfig({
+      bundleType: 'addon',
+      entrypoints: ['src/index.bundle.ts'],
+      jsVersion: 'es6',
+      licenseTitle: '@sentry-internal/feedback',
+      outputFileBase: () => 'bundles/feedback',
+      sucrase: {
+        jsxPragma: 'h',
+        jsxFragmentPragma: 'Fragment',
+      },
+    }),
+  ),
+  ...makeBundleConfigVariants(
+    makeBaseBundleConfig({
+      bundleType: 'addon',
+      entrypoints: ['src/screenshot/integration.ts'],
+      jsVersion: 'es6',
+      licenseTitle: '@sentry-internal/feedback',
+      outputFileBase: () => 'bundles/feedback-screenshot',
+      sucrase: {
+        jsxPragma: 'h',
+        jsxFragmentPragma: 'Fragment',
+      },
+    }),
+  ),
+  ...makeBundleConfigVariants(
+    makeBaseBundleConfig({
+      bundleType: 'addon',
+      entrypoints: ['src/modal/integration.tsx'],
+      jsVersion: 'es6',
+      licenseTitle: '@sentry-internal/feedback',
+      outputFileBase: () => 'bundles/feedback-modal',
+      sucrase: {
+        jsxPragma: 'h',
+        jsxFragmentPragma: 'Fragment',
+      },
+    }),
+  ),
+];
diff --git a/packages/feedback/src/index.bundle.ts b/packages/feedback/src/index.bundle.ts
new file mode 100644
index 000000000000..a384487e935b
--- /dev/null
+++ b/packages/feedback/src/index.bundle.ts
@@ -0,0 +1,6 @@
+// This file is used as entry point to generate the integration CDN bundle for the core feedback integration
+// For now this includes the modal as well, but not feedback
+export { sendFeedback } from './core/sendFeedback';
+export { feedbackIntegration } from './core/integration';
+export { feedbackModalIntegration } from './modal/integration';
+export { getFeedback } from './core/getFeedback';
diff --git a/packages/feedback/src/modal/components/Form.tsx b/packages/feedback/src/modal/components/Form.tsx
index 5b5c5aa80dd4..f40693d8f2af 100644
--- a/packages/feedback/src/modal/components/Form.tsx
+++ b/packages/feedback/src/modal/components/Form.tsx
@@ -142,7 +142,7 @@ export function Form({
         <ScreenshotInputComponent onError={onScreenshotError} />
       ) : null}
 
-      <div class="form__right">
+      <div class="form__right" data-sentry-feedback={true}>
         <div class="form__top">
           {error ? <div class="form__error-container">{error}</div> : null}
 
diff --git a/packages/integration-shims/src/index.ts b/packages/integration-shims/src/index.ts
index f3c0937ff9d4..457761f0778e 100644
--- a/packages/integration-shims/src/index.ts
+++ b/packages/integration-shims/src/index.ts
@@ -1,4 +1,8 @@
-export { feedbackIntegrationShim, feedbackModalIntegrationShim, feedbackScreenshotIntegrationShim } from './Feedback';
+export {
+  feedbackIntegrationShim,
+  feedbackModalIntegrationShim,
+  feedbackScreenshotIntegrationShim,
+} from './Feedback';
 export { replayIntegrationShim } from './Replay';
 export {
   browserTracingIntegrationShim,
diff --git a/packages/nextjs/test/integration/package.json b/packages/nextjs/test/integration/package.json
index 0d17d6a049dc..f4c547b5b687 100644
--- a/packages/nextjs/test/integration/package.json
+++ b/packages/nextjs/test/integration/package.json
@@ -34,8 +34,6 @@
     "@sentry-internal/replay": "file:../../../replay-internal",
     "@sentry-internal/replay-canvas": "file:../../../replay-canvas",
     "@sentry-internal/feedback": "file:../../../feedback",
-    "@sentry-internal/feedback-modal": "file:../../../feedback-modal",
-    "@sentry-internal/feedback-screenshot": "file:../../../feedback-screenshot",
     "@sentry/types": "file:../../../types",
     "@sentry/utils": "file:../../../utils",
     "@sentry/vercel-edge": "file:../../../vercel-edge"
diff --git a/packages/remix/test/integration/package.json b/packages/remix/test/integration/package.json
index f0f2bb631553..63560ec64e8b 100644
--- a/packages/remix/test/integration/package.json
+++ b/packages/remix/test/integration/package.json
@@ -32,8 +32,6 @@
     "@sentry-internal/replay": "file:../../../replay-internal",
     "@sentry-internal/replay-canvas": "file:../../../replay-canvas",
     "@sentry-internal/feedback": "file:../../../feedback",
-    "@sentry-internal/feedback-modal": "file:../../../feedback-modal",
-    "@sentry-internal/feedback-screenshot": "file:../../../feedback-screenshot",
     "@sentry/types": "file:../../../types",
     "@sentry/utils": "file:../../../utils",
     "@vanilla-extract/css": "1.13.0",

From 3996e3a9cbce49eb618ced103469ef41386e7e22 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Thu, 11 Apr 2024 16:45:06 +0200
Subject: [PATCH 48/64] feat(core): Remove `getGlobalHub` export (#11565)

Just noticed we export this API from core but it's not used in packages
outside of `@sentry/core` (anymore?). Let's remove it while we can.
---
 packages/core/src/index.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 757d52f12201..9f69e91ef4d6 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -34,7 +34,6 @@ export {
   getCurrentHub,
   // eslint-disable-next-line deprecation/deprecation
   Hub,
-  getGlobalHub,
   getDefaultCurrentScope,
   getDefaultIsolationScope,
 } from './hub';

From dd41c2e0f7bc984f7e13e8588d1151ee2ae18574 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Thu, 11 Apr 2024 17:05:54 +0200
Subject: [PATCH 49/64] feat(core): Remove `Hub` class export (#11560)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the last public export of the `Hub` class. Now that it's
gone there are no more breaking changes (🤞). The class still remains in
the package because it's still used internally for now but we can remove
it (and shave off some well needed bytes) throught the v8 beta cycle.
---
 packages/core/src/index.ts                                      | 2 --
 .../replay-internal/test/unit/session/createSession.test.ts     | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 9f69e91ef4d6..e818ab1ffb01 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -32,8 +32,6 @@ export {
 export {
   // eslint-disable-next-line deprecation/deprecation
   getCurrentHub,
-  // eslint-disable-next-line deprecation/deprecation
-  Hub,
   getDefaultCurrentScope,
   getDefaultIsolationScope,
 } from './hub';
diff --git a/packages/replay-internal/test/unit/session/createSession.test.ts b/packages/replay-internal/test/unit/session/createSession.test.ts
index 5fb71c5eb70c..7713e821e74c 100644
--- a/packages/replay-internal/test/unit/session/createSession.test.ts
+++ b/packages/replay-internal/test/unit/session/createSession.test.ts
@@ -1,6 +1,6 @@
 import * as Sentry from '@sentry/core';
-import type { Hub } from '@sentry/core';
 
+import type { Hub } from '@sentry/types';
 import { WINDOW } from '../../../src/constants';
 import { createSession } from '../../../src/session/createSession';
 import { saveSession } from '../../../src/session/saveSession';

From f6a3e026ac7f04eec78495a14c0c68f9e553e22d Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Thu, 11 Apr 2024 12:18:53 -0400
Subject: [PATCH 50/64] ref(browser): Move browserTracing into browser pkg
 (#11484)

This PR moves `browserTracingIntegration` into the browser package,
leaving `browser-utils` only existing purely for utils/instrumentation
(and our vendored web vitals implementation).

resolves https://github.com/getsentry/sentry-javascript/issues/9885
---
 .../metrics/pageload-browser-spans/test.ts    |   5 +-
 packages/browser-utils/.eslintrc.js           |   3 +-
 packages/browser-utils/src/browser/index.ts   |  18 ---
 packages/browser-utils/src/index.ts           |  17 +-
 packages/browser-utils/src/instrument/dom.ts  |   2 +-
 .../browser-utils/src/instrument/history.ts   |   2 +-
 packages/browser-utils/src/instrument/xhr.ts  |   2 +-
 .../index.ts => metrics/browserMetrics.ts}    |  10 +-
 .../src/{browser => metrics}/instrument.ts    |   0
 .../src/{browser => metrics}/types.ts         |   0
 .../src/{browser => }/metrics/utils.ts        |   0
 .../{browser => metrics}/web-vitals/README.md |   0
 .../{browser => metrics}/web-vitals/getCLS.ts |   0
 .../{browser => metrics}/web-vitals/getFID.ts |   4 +-
 .../{browser => metrics}/web-vitals/getINP.ts |   0
 .../{browser => metrics}/web-vitals/getLCP.ts |   0
 .../web-vitals/lib/bindReporter.ts            |   0
 .../web-vitals/lib/generateUniqueID.ts        |   0
 .../web-vitals/lib/getActivationStart.ts      |   0
 .../web-vitals/lib/getNavigationEntry.ts      |   0
 .../web-vitals/lib/getVisibilityWatcher.ts    |   0
 .../web-vitals/lib/initMetric.ts              |   0
 .../web-vitals/lib/observe.ts                 |   0
 .../web-vitals/lib/onHidden.ts                |   0
 .../lib/polyfills/interactionCountPolyfill.ts |   0
 .../web-vitals/lib/runOnce.ts                 |   0
 .../web-vitals/lib/whenActivated.ts           |   0
 .../{browser => metrics}/web-vitals/onFCP.ts  |   0
 .../{browser => metrics}/web-vitals/onTTFB.ts |   0
 .../{browser => metrics}/web-vitals/types.ts  |   0
 .../web-vitals/types/base.ts                  |   0
 .../web-vitals/types/cls.ts                   |   0
 .../web-vitals/types/fcp.ts                   |   0
 .../web-vitals/types/fid.ts                   |   0
 .../web-vitals/types/inp.ts                   |   0
 .../web-vitals/types/lcp.ts                   |   0
 .../web-vitals/types/polyfills.ts             |   0
 .../web-vitals/types/ttfb.ts                  |   0
 .../test/browser/backgroundtab.test.ts        |  59 -------
 .../index.test.ts => browserMetrics.test.ts}  |   8 +-
 .../test/browser/{metrics => }/utils.test.ts  |   4 +-
 .../index.bundle.tracing.replay.feedback.ts   |   2 +-
 .../src/index.bundle.tracing.replay.ts        |   2 +-
 packages/browser/src/index.bundle.tracing.ts  |   2 +-
 packages/browser/src/index.ts                 |   6 +-
 .../src/tracing}/backgroundtab.ts             |   2 +-
 .../src/tracing}/browserTracingIntegration.ts |  24 ++-
 .../src/tracing}/request.ts                   |  10 +-
 .../unit/helper/browser-client-options.ts     |   1 +
 ...dex.bundle.tracing.replay.feedback.test.ts |   5 +-
 .../unit/index.bundle.tracing.replay.test.ts  |   3 +-
 .../test/unit/index.bundle.tracing.test.ts    |   2 +-
 .../test/unit/tracing/backgroundtab.test.ts   |  56 +++++++
 .../browserTracingIntegration.test.ts         | 149 ++++++++++--------
 .../test/unit/tracing}/request.test.ts        |  17 +-
 .../client/browserTracingIntegration.test.ts  |   5 +-
 56 files changed, 213 insertions(+), 207 deletions(-)
 delete mode 100644 packages/browser-utils/src/browser/index.ts
 rename packages/browser-utils/src/{browser/metrics/index.ts => metrics/browserMetrics.ts} (98%)
 rename packages/browser-utils/src/{browser => metrics}/instrument.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/types.ts (100%)
 rename packages/browser-utils/src/{browser => }/metrics/utils.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/README.md (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/getCLS.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/getFID.ts (96%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/getINP.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/getLCP.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/bindReporter.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/generateUniqueID.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/getActivationStart.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/getNavigationEntry.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/getVisibilityWatcher.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/initMetric.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/observe.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/onHidden.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/polyfills/interactionCountPolyfill.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/runOnce.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/lib/whenActivated.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/onFCP.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/onTTFB.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/base.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/cls.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/fcp.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/fid.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/inp.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/lcp.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/polyfills.ts (100%)
 rename packages/browser-utils/src/{browser => metrics}/web-vitals/types/ttfb.ts (100%)
 delete mode 100644 packages/browser-utils/test/browser/backgroundtab.test.ts
 rename packages/browser-utils/test/browser/{metrics/index.test.ts => browserMetrics.test.ts} (97%)
 rename packages/browser-utils/test/browser/{metrics => }/utils.test.ts (92%)
 rename packages/{browser-utils/src/browser => browser/src/tracing}/backgroundtab.ts (97%)
 rename packages/{browser-utils/src/browser => browser/src/tracing}/browserTracingIntegration.ts (97%)
 rename packages/{browser-utils/src/browser => browser/src/tracing}/request.ts (98%)
 create mode 100644 packages/browser/test/unit/tracing/backgroundtab.test.ts
 rename packages/{browser-utils/test/browser => browser/test/unit/tracing}/browserTracingIntegration.test.ts (89%)
 rename packages/{browser-utils/test/browser => browser/test/unit/tracing}/request.test.ts (96%)

diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts
index b60cdce9703b..2b2d5fa8bae5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts
@@ -14,10 +14,11 @@ sentryTest('should add browser-related spans to pageload transaction', async ({
   const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
   const browserSpans = eventData.spans?.filter(({ op }) => op === 'browser');
 
-  // Spans `connect`, `cache` and `DNS` are not always inside `pageload` transaction.
+  // Spans `domContentLoadedEvent`, `connect`, `cache` and `DNS` are not
+  // always inside `pageload` transaction.
   expect(browserSpans?.length).toBeGreaterThanOrEqual(4);
 
-  ['domContentLoadedEvent', 'loadEvent', 'request', 'response'].forEach(eventDesc =>
+  ['loadEvent', 'request', 'response'].forEach(eventDesc =>
     expect(browserSpans).toContainEqual(
       expect.objectContaining({
         description: eventDesc,
diff --git a/packages/browser-utils/.eslintrc.js b/packages/browser-utils/.eslintrc.js
index 7346008450be..9d8a86b13b96 100644
--- a/packages/browser-utils/.eslintrc.js
+++ b/packages/browser-utils/.eslintrc.js
@@ -11,9 +11,10 @@ module.exports = {
       },
     },
     {
-      files: ['src/browser/web-vitals/**'],
+      files: ['src/metrics/**'],
       rules: {
         '@typescript-eslint/explicit-function-return-type': 'off',
+        '@typescript-eslint/no-non-null-assertion': 'off',
       },
     },
   ],
diff --git a/packages/browser-utils/src/browser/index.ts b/packages/browser-utils/src/browser/index.ts
deleted file mode 100644
index 948a09c0dda4..000000000000
--- a/packages/browser-utils/src/browser/index.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-export type { RequestInstrumentationOptions } from './request';
-
-export {
-  BROWSER_TRACING_INTEGRATION_ID,
-  browserTracingIntegration,
-  startBrowserTracingNavigationSpan,
-  startBrowserTracingPageLoadSpan,
-} from './browserTracingIntegration';
-
-export { instrumentOutgoingRequests, defaultRequestInstrumentationOptions } from './request';
-
-export {
-  addPerformanceInstrumentationHandler,
-  addClsInstrumentationHandler,
-  addFidInstrumentationHandler,
-  addTtfbInstrumentationHandler,
-  addLcpInstrumentationHandler,
-} from './instrument';
diff --git a/packages/browser-utils/src/index.ts b/packages/browser-utils/src/index.ts
index 0824c9f50358..f65c78a6d3bf 100644
--- a/packages/browser-utils/src/index.ts
+++ b/packages/browser-utils/src/index.ts
@@ -1,16 +1,17 @@
 export {
-  browserTracingIntegration,
-  startBrowserTracingNavigationSpan,
-  startBrowserTracingPageLoadSpan,
-  BROWSER_TRACING_INTEGRATION_ID,
-  instrumentOutgoingRequests,
-  defaultRequestInstrumentationOptions,
   addPerformanceInstrumentationHandler,
   addClsInstrumentationHandler,
   addFidInstrumentationHandler,
   addTtfbInstrumentationHandler,
   addLcpInstrumentationHandler,
-} from './browser';
+} from './metrics/instrument';
+
+export {
+  addPerformanceEntries,
+  startTrackingInteractions,
+  startTrackingLongTasks,
+  startTrackingWebVitals,
+} from './metrics/browserMetrics';
 
 export { addClickKeypressInstrumentationHandler } from './instrument/dom';
 
@@ -20,5 +21,3 @@ export {
   addXhrInstrumentationHandler,
   SENTRY_XHR_DATA_KEY,
 } from './instrument/xhr';
-
-export type { RequestInstrumentationOptions } from './browser';
diff --git a/packages/browser-utils/src/instrument/dom.ts b/packages/browser-utils/src/instrument/dom.ts
index 4dfa5992aa07..5e813f23eb67 100644
--- a/packages/browser-utils/src/instrument/dom.ts
+++ b/packages/browser-utils/src/instrument/dom.ts
@@ -1,7 +1,7 @@
 import type { HandlerDataDom } from '@sentry/types';
 
 import { addHandler, addNonEnumerableProperty, fill, maybeInstrument, triggerHandlers, uuid4 } from '@sentry/utils';
-import { WINDOW } from '../browser/types';
+import { WINDOW } from '../metrics/types';
 
 type SentryWrappedTarget = HTMLElement & { _sentryId?: string };
 
diff --git a/packages/browser-utils/src/instrument/history.ts b/packages/browser-utils/src/instrument/history.ts
index c918cd4ce2dc..f791bcef5389 100644
--- a/packages/browser-utils/src/instrument/history.ts
+++ b/packages/browser-utils/src/instrument/history.ts
@@ -1,6 +1,6 @@
 import type { HandlerDataHistory } from '@sentry/types';
 import { addHandler, fill, maybeInstrument, supportsHistory, triggerHandlers } from '@sentry/utils';
-import { WINDOW } from '../browser/types';
+import { WINDOW } from '../metrics/types';
 
 let lastHref: string | undefined;
 
diff --git a/packages/browser-utils/src/instrument/xhr.ts b/packages/browser-utils/src/instrument/xhr.ts
index 05db402872ed..c504c8dce5f6 100644
--- a/packages/browser-utils/src/instrument/xhr.ts
+++ b/packages/browser-utils/src/instrument/xhr.ts
@@ -1,7 +1,7 @@
 import type { HandlerDataXhr, SentryWrappedXMLHttpRequest, WrappedFunction } from '@sentry/types';
 
 import { addHandler, fill, isString, maybeInstrument, triggerHandlers } from '@sentry/utils';
-import { WINDOW } from '../browser/types';
+import { WINDOW } from '../metrics/types';
 
 export const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';
 
diff --git a/packages/browser-utils/src/browser/metrics/index.ts b/packages/browser-utils/src/metrics/browserMetrics.ts
similarity index 98%
rename from packages/browser-utils/src/browser/metrics/index.ts
rename to packages/browser-utils/src/metrics/browserMetrics.ts
index ec3de991d593..7c6620ff7911 100644
--- a/packages/browser-utils/src/browser/metrics/index.ts
+++ b/packages/browser-utils/src/metrics/browserMetrics.ts
@@ -5,18 +5,18 @@ import type { Measurements, Span, SpanAttributes, StartSpanOptions } from '@sent
 import { browserPerformanceTimeOrigin, getComponentName, htmlTreeAsString, logger, parseUrl } from '@sentry/utils';
 
 import { spanToJSON } from '@sentry/core';
-import { DEBUG_BUILD } from '../../debug-build';
+import { DEBUG_BUILD } from '../debug-build';
 import {
   addClsInstrumentationHandler,
   addFidInstrumentationHandler,
   addLcpInstrumentationHandler,
   addPerformanceInstrumentationHandler,
   addTtfbInstrumentationHandler,
-} from '../instrument';
-import { WINDOW } from '../types';
-import { getNavigationEntry } from '../web-vitals/lib/getNavigationEntry';
-import { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher';
+} from './instrument';
+import { WINDOW } from './types';
 import { isMeasurementValue, startAndEndSpan } from './utils';
+import { getNavigationEntry } from './web-vitals/lib/getNavigationEntry';
+import { getVisibilityWatcher } from './web-vitals/lib/getVisibilityWatcher';
 
 interface NavigatorNetworkInformation {
   readonly connection?: NetworkInformation;
diff --git a/packages/browser-utils/src/browser/instrument.ts b/packages/browser-utils/src/metrics/instrument.ts
similarity index 100%
rename from packages/browser-utils/src/browser/instrument.ts
rename to packages/browser-utils/src/metrics/instrument.ts
diff --git a/packages/browser-utils/src/browser/types.ts b/packages/browser-utils/src/metrics/types.ts
similarity index 100%
rename from packages/browser-utils/src/browser/types.ts
rename to packages/browser-utils/src/metrics/types.ts
diff --git a/packages/browser-utils/src/browser/metrics/utils.ts b/packages/browser-utils/src/metrics/utils.ts
similarity index 100%
rename from packages/browser-utils/src/browser/metrics/utils.ts
rename to packages/browser-utils/src/metrics/utils.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/README.md b/packages/browser-utils/src/metrics/web-vitals/README.md
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/README.md
rename to packages/browser-utils/src/metrics/web-vitals/README.md
diff --git a/packages/browser-utils/src/browser/web-vitals/getCLS.ts b/packages/browser-utils/src/metrics/web-vitals/getCLS.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/getCLS.ts
rename to packages/browser-utils/src/metrics/web-vitals/getCLS.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/getFID.ts b/packages/browser-utils/src/metrics/web-vitals/getFID.ts
similarity index 96%
rename from packages/browser-utils/src/browser/web-vitals/getFID.ts
rename to packages/browser-utils/src/metrics/web-vitals/getFID.ts
index f79b388c042d..92543b89e170 100644
--- a/packages/browser-utils/src/browser/web-vitals/getFID.ts
+++ b/packages/browser-utils/src/metrics/web-vitals/getFID.ts
@@ -35,14 +35,14 @@ export const FIDThresholds: MetricRatingThresholds = [100, 300];
  * _**Important:** since FID is only reported after the user interacts with the
  * page, it's possible that it will not be reported for some page loads._
  */
-export const onFID = (onReport: FIDReportCallback, opts: ReportOpts = {}): void => {
+export const onFID = (onReport: FIDReportCallback, opts: ReportOpts = {}) => {
   whenActivated(() => {
     const visibilityWatcher = getVisibilityWatcher();
     const metric = initMetric('FID');
     // eslint-disable-next-line prefer-const
     let report: ReturnType<typeof bindReporter>;
 
-    const handleEntry = (entry: PerformanceEventTiming) => {
+    const handleEntry = (entry: PerformanceEventTiming): void => {
       // Only report if the page wasn't hidden prior to the first input.
       if (entry.startTime < visibilityWatcher.firstHiddenTime) {
         metric.value = entry.processingStart - entry.startTime;
diff --git a/packages/browser-utils/src/browser/web-vitals/getINP.ts b/packages/browser-utils/src/metrics/web-vitals/getINP.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/getINP.ts
rename to packages/browser-utils/src/metrics/web-vitals/getINP.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/getLCP.ts b/packages/browser-utils/src/metrics/web-vitals/getLCP.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/getLCP.ts
rename to packages/browser-utils/src/metrics/web-vitals/getLCP.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/bindReporter.ts b/packages/browser-utils/src/metrics/web-vitals/lib/bindReporter.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/bindReporter.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/bindReporter.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/generateUniqueID.ts b/packages/browser-utils/src/metrics/web-vitals/lib/generateUniqueID.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/generateUniqueID.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/generateUniqueID.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/getActivationStart.ts b/packages/browser-utils/src/metrics/web-vitals/lib/getActivationStart.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/getActivationStart.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/getActivationStart.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/getNavigationEntry.ts b/packages/browser-utils/src/metrics/web-vitals/lib/getNavigationEntry.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/getNavigationEntry.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/getNavigationEntry.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/getVisibilityWatcher.ts b/packages/browser-utils/src/metrics/web-vitals/lib/getVisibilityWatcher.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/getVisibilityWatcher.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/getVisibilityWatcher.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/initMetric.ts b/packages/browser-utils/src/metrics/web-vitals/lib/initMetric.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/initMetric.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/initMetric.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/observe.ts b/packages/browser-utils/src/metrics/web-vitals/lib/observe.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/observe.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/observe.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/onHidden.ts b/packages/browser-utils/src/metrics/web-vitals/lib/onHidden.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/onHidden.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/onHidden.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/polyfills/interactionCountPolyfill.ts b/packages/browser-utils/src/metrics/web-vitals/lib/polyfills/interactionCountPolyfill.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/polyfills/interactionCountPolyfill.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/polyfills/interactionCountPolyfill.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/runOnce.ts b/packages/browser-utils/src/metrics/web-vitals/lib/runOnce.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/runOnce.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/runOnce.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/lib/whenActivated.ts b/packages/browser-utils/src/metrics/web-vitals/lib/whenActivated.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/lib/whenActivated.ts
rename to packages/browser-utils/src/metrics/web-vitals/lib/whenActivated.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/onFCP.ts b/packages/browser-utils/src/metrics/web-vitals/onFCP.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/onFCP.ts
rename to packages/browser-utils/src/metrics/web-vitals/onFCP.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/onTTFB.ts b/packages/browser-utils/src/metrics/web-vitals/onTTFB.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/onTTFB.ts
rename to packages/browser-utils/src/metrics/web-vitals/onTTFB.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types.ts b/packages/browser-utils/src/metrics/web-vitals/types.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types.ts
rename to packages/browser-utils/src/metrics/web-vitals/types.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/base.ts b/packages/browser-utils/src/metrics/web-vitals/types/base.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/base.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/base.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/cls.ts b/packages/browser-utils/src/metrics/web-vitals/types/cls.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/cls.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/cls.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/fcp.ts b/packages/browser-utils/src/metrics/web-vitals/types/fcp.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/fcp.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/fcp.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/fid.ts b/packages/browser-utils/src/metrics/web-vitals/types/fid.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/fid.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/fid.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/inp.ts b/packages/browser-utils/src/metrics/web-vitals/types/inp.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/inp.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/inp.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/lcp.ts b/packages/browser-utils/src/metrics/web-vitals/types/lcp.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/lcp.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/lcp.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/polyfills.ts b/packages/browser-utils/src/metrics/web-vitals/types/polyfills.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/polyfills.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/polyfills.ts
diff --git a/packages/browser-utils/src/browser/web-vitals/types/ttfb.ts b/packages/browser-utils/src/metrics/web-vitals/types/ttfb.ts
similarity index 100%
rename from packages/browser-utils/src/browser/web-vitals/types/ttfb.ts
rename to packages/browser-utils/src/metrics/web-vitals/types/ttfb.ts
diff --git a/packages/browser-utils/test/browser/backgroundtab.test.ts b/packages/browser-utils/test/browser/backgroundtab.test.ts
deleted file mode 100644
index e25eaa168fd4..000000000000
--- a/packages/browser-utils/test/browser/backgroundtab.test.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { addTracingExtensions, getCurrentScope } from '@sentry/core';
-import { setCurrentClient, spanToJSON, startSpan } from '@sentry/core';
-import { JSDOM } from 'jsdom';
-
-import { registerBackgroundTabDetection } from '../../src/browser/backgroundtab';
-import { TestClient, getDefaultClientOptions } from '../utils/TestClient';
-
-describe('registerBackgroundTabDetection', () => {
-  let events: Record<string, any> = {};
-  beforeEach(() => {
-    const dom = new JSDOM();
-    global.document = dom.window.document;
-
-    const options = getDefaultClientOptions({ tracesSampleRate: 1 });
-    const client = new TestClient(options);
-    setCurrentClient(client);
-    client.init();
-
-    addTracingExtensions();
-
-    global.document.addEventListener = jest.fn((event, callback) => {
-      events[event] = callback;
-    });
-  });
-
-  afterEach(() => {
-    events = {};
-    getCurrentScope().clear();
-  });
-
-  it('does not create an event listener if global document is undefined', () => {
-    // @ts-expect-error need to override global document
-    global.document = undefined;
-    registerBackgroundTabDetection();
-    expect(events).toMatchObject({});
-  });
-
-  it('creates an event listener', () => {
-    registerBackgroundTabDetection();
-    expect(events).toMatchObject({ visibilitychange: expect.any(Function) });
-  });
-
-  it('finishes a transaction on visibility change', () => {
-    registerBackgroundTabDetection();
-    startSpan({ name: 'test' }, span => {
-      // Simulate document visibility hidden event
-      // @ts-expect-error need to override global document
-      global.document.hidden = true;
-      events.visibilitychange();
-
-      const { status, timestamp, data } = spanToJSON(span);
-
-      expect(status).toBe('cancelled');
-      expect(status).toBeDefined();
-      expect(data!['sentry.cancellation_reason']).toBe('document.hidden');
-      expect(timestamp).toBeDefined();
-    });
-  });
-});
diff --git a/packages/browser-utils/test/browser/metrics/index.test.ts b/packages/browser-utils/test/browser/browserMetrics.test.ts
similarity index 97%
rename from packages/browser-utils/test/browser/metrics/index.test.ts
rename to packages/browser-utils/test/browser/browserMetrics.test.ts
index 8c4476d4b6b2..b6d6aaa087aa 100644
--- a/packages/browser-utils/test/browser/metrics/index.test.ts
+++ b/packages/browser-utils/test/browser/browserMetrics.test.ts
@@ -9,10 +9,10 @@ import {
   spanToJSON,
 } from '@sentry/core';
 import type { Span } from '@sentry/types';
-import type { ResourceEntry } from '../../../src/browser/metrics';
-import { _addMeasureSpans, _addResourceSpans } from '../../../src/browser/metrics';
-import { WINDOW } from '../../../src/browser/types';
-import { TestClient, getDefaultClientOptions } from '../../utils/TestClient';
+import type { ResourceEntry } from '../../src/metrics/browserMetrics';
+import { _addMeasureSpans, _addResourceSpans } from '../../src/metrics/browserMetrics';
+import { WINDOW } from '../../src/metrics/types';
+import { TestClient, getDefaultClientOptions } from '../utils/TestClient';
 
 const mockWindowLocation = {
   ancestorOrigins: {},
diff --git a/packages/browser-utils/test/browser/metrics/utils.test.ts b/packages/browser-utils/test/browser/utils.test.ts
similarity index 92%
rename from packages/browser-utils/test/browser/metrics/utils.test.ts
rename to packages/browser-utils/test/browser/utils.test.ts
index 1ec79514af67..56f06f222366 100644
--- a/packages/browser-utils/test/browser/metrics/utils.test.ts
+++ b/packages/browser-utils/test/browser/utils.test.ts
@@ -6,8 +6,8 @@ import {
   setCurrentClient,
   spanToJSON,
 } from '@sentry/core';
-import { startAndEndSpan } from '../../../src/browser/metrics/utils';
-import { TestClient, getDefaultClientOptions } from '../../utils/TestClient';
+import { startAndEndSpan } from '../../src/metrics/utils';
+import { TestClient, getDefaultClientOptions } from '../utils/TestClient';
 
 describe('startAndEndSpan()', () => {
   beforeEach(() => {
diff --git a/packages/browser/src/index.bundle.tracing.replay.feedback.ts b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
index 7f178e87c789..feaedf21e8d4 100644
--- a/packages/browser/src/index.bundle.tracing.replay.feedback.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
@@ -28,6 +28,6 @@ export {
   browserTracingIntegration,
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
+} from './tracing/browserTracingIntegration';
 
 export { replayIntegration } from '@sentry-internal/replay';
diff --git a/packages/browser/src/index.bundle.tracing.replay.ts b/packages/browser/src/index.bundle.tracing.replay.ts
index 494932f6aef3..fbf0e24faa73 100644
--- a/packages/browser/src/index.bundle.tracing.replay.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.ts
@@ -26,7 +26,7 @@ export {
   browserTracingIntegration,
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
+} from './tracing/browserTracingIntegration';
 
 export {
   feedbackIntegrationShim as feedbackIntegration,
diff --git a/packages/browser/src/index.bundle.tracing.ts b/packages/browser/src/index.bundle.tracing.ts
index b020549f6968..66d1df7792fe 100644
--- a/packages/browser/src/index.bundle.tracing.ts
+++ b/packages/browser/src/index.bundle.tracing.ts
@@ -28,7 +28,7 @@ export {
   browserTracingIntegration,
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
+} from './tracing/browserTracingIntegration';
 
 export {
   feedbackIntegrationShim as feedbackIntegration,
diff --git a/packages/browser/src/index.ts b/packages/browser/src/index.ts
index bea2adda57ee..1bdee34b1c6a 100644
--- a/packages/browser/src/index.ts
+++ b/packages/browser/src/index.ts
@@ -41,11 +41,13 @@ export {
 export {
   defaultRequestInstrumentationOptions,
   instrumentOutgoingRequests,
+} from './tracing/request';
+export {
   browserTracingIntegration,
   startBrowserTracingNavigationSpan,
   startBrowserTracingPageLoadSpan,
-} from '@sentry-internal/browser-utils';
-export type { RequestInstrumentationOptions } from '@sentry-internal/browser-utils';
+} from './tracing/browserTracingIntegration';
+export type { RequestInstrumentationOptions } from './tracing/request';
 export {
   addTracingExtensions,
   getActiveSpan,
diff --git a/packages/browser-utils/src/browser/backgroundtab.ts b/packages/browser/src/tracing/backgroundtab.ts
similarity index 97%
rename from packages/browser-utils/src/browser/backgroundtab.ts
rename to packages/browser/src/tracing/backgroundtab.ts
index a3ed7d88bd3e..307892862649 100644
--- a/packages/browser-utils/src/browser/backgroundtab.ts
+++ b/packages/browser/src/tracing/backgroundtab.ts
@@ -3,7 +3,7 @@ import { spanToJSON } from '@sentry/core';
 import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
-import { WINDOW } from './types';
+import { WINDOW } from '../helpers';
 
 /**
  * Add a listener that cancels and finishes a transaction when the global
diff --git a/packages/browser-utils/src/browser/browserTracingIntegration.ts b/packages/browser/src/tracing/browserTracingIntegration.ts
similarity index 97%
rename from packages/browser-utils/src/browser/browserTracingIntegration.ts
rename to packages/browser/src/tracing/browserTracingIntegration.ts
index c0a786b600f9..d41073f46191 100644
--- a/packages/browser-utils/src/browser/browserTracingIntegration.ts
+++ b/packages/browser/src/tracing/browserTracingIntegration.ts
@@ -1,3 +1,10 @@
+import {
+  addHistoryInstrumentationHandler,
+  addPerformanceEntries,
+  startTrackingInteractions,
+  startTrackingLongTasks,
+  startTrackingWebVitals,
+} from '@sentry-internal/browser-utils';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
@@ -19,16 +26,9 @@ import type { Span } from '@sentry/types';
 import { browserPerformanceTimeOrigin, getDomElement, logger, uuid4 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
-import { addHistoryInstrumentationHandler } from '../instrument/history';
+import { WINDOW } from '../helpers';
 import { registerBackgroundTabDetection } from './backgroundtab';
-import {
-  addPerformanceEntries,
-  startTrackingInteractions,
-  startTrackingLongTasks,
-  startTrackingWebVitals,
-} from './metrics';
 import { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request';
-import { WINDOW } from './types';
 
 export const BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';
 
@@ -224,8 +224,6 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
 
   return {
     name: BROWSER_TRACING_INTEGRATION_ID,
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setupOnce: () => {},
     afterAllSetup(client) {
       const { markBackgroundSpan, traceFetch, traceXHR, shouldCreateSpanForRequest, enableHTTPTimings, _experiments } =
         options;
@@ -249,7 +247,7 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
         });
       });
 
-      client.on('startPageLoadSpan', (startSpanOptions, traceOptions) => {
+      client.on('startPageLoadSpan', (startSpanOptions, traceOptions = {}) => {
         if (getClient() !== client) {
           return;
         }
@@ -260,8 +258,8 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
           activeSpan.end();
         }
 
-        const sentryTrace = traceOptions?.sentryTrace || getMetaContent('sentry-trace');
-        const baggage = traceOptions?.baggage || getMetaContent('baggage');
+        const sentryTrace = traceOptions.sentryTrace || getMetaContent('sentry-trace');
+        const baggage = traceOptions.baggage || getMetaContent('baggage');
 
         // Continue trace updates the scope in the callback only, but we want to break out of it again...
         // This is a bit hacky, because we want to get the span to use both the correct scope _and_ the correct propagation context
diff --git a/packages/browser-utils/src/browser/request.ts b/packages/browser/src/tracing/request.ts
similarity index 98%
rename from packages/browser-utils/src/browser/request.ts
rename to packages/browser/src/tracing/request.ts
index 73038996d7c0..374dc4feaf13 100644
--- a/packages/browser-utils/src/browser/request.ts
+++ b/packages/browser/src/tracing/request.ts
@@ -1,3 +1,8 @@
+import {
+  SENTRY_XHR_DATA_KEY,
+  addPerformanceInstrumentationHandler,
+  addXhrInstrumentationHandler,
+} from '@sentry-internal/browser-utils';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SentryNonRecordingSpan,
@@ -22,10 +27,7 @@ import {
   generateSentryTraceHeader,
   stringMatchesSomePattern,
 } from '@sentry/utils';
-import { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler } from '../instrument/xhr';
-
-import { addPerformanceInstrumentationHandler } from './instrument';
-import { WINDOW } from './types';
+import { WINDOW } from '../helpers';
 
 /** Options for Request Instrumentation */
 export interface RequestInstrumentationOptions {
diff --git a/packages/browser/test/unit/helper/browser-client-options.ts b/packages/browser/test/unit/helper/browser-client-options.ts
index 8ca73faa2d23..867e6a9e6e6e 100644
--- a/packages/browser/test/unit/helper/browser-client-options.ts
+++ b/packages/browser/test/unit/helper/browser-client-options.ts
@@ -5,6 +5,7 @@ import type { BrowserClientOptions } from '../../../src/client';
 
 export function getDefaultBrowserClientOptions(options: Partial<BrowserClientOptions> = {}): BrowserClientOptions {
   return {
+    dsn: 'http://examplePublicKey@localhost/0',
     integrations: [],
     transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => resolvedSyncPromise({})),
     stackParser: () => [],
diff --git a/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts b/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts
index 873c41bfc769..847f610ca702 100644
--- a/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts
+++ b/packages/browser/test/unit/index.bundle.tracing.replay.feedback.test.ts
@@ -1,11 +1,10 @@
-import { browserTracingIntegration } from '@sentry-internal/browser-utils';
 import {
+  browserTracingIntegration,
   feedbackIntegration,
   feedbackModalIntegration,
   feedbackScreenshotIntegration,
   replayIntegration,
-} from '@sentry/browser';
-
+} from '../../src';
 import * as TracingReplayFeedbackBundle from '../../src/index.bundle.tracing.replay.feedback';
 
 describe('index.bundle.tracing.replay.feedback', () => {
diff --git a/packages/browser/test/unit/index.bundle.tracing.replay.test.ts b/packages/browser/test/unit/index.bundle.tracing.replay.test.ts
index 3e2a79e081a9..f0228e575e68 100644
--- a/packages/browser/test/unit/index.bundle.tracing.replay.test.ts
+++ b/packages/browser/test/unit/index.bundle.tracing.replay.test.ts
@@ -1,11 +1,10 @@
-import { browserTracingIntegration } from '@sentry-internal/browser-utils';
 import {
   feedbackIntegrationShim,
   feedbackModalIntegrationShim,
   feedbackScreenshotIntegrationShim,
 } from '@sentry-internal/integration-shims';
-import { replayIntegration } from '@sentry/browser';
 
+import { browserTracingIntegration, replayIntegration } from '../../src';
 import * as TracingReplayBundle from '../../src/index.bundle.tracing.replay';
 
 describe('index.bundle.tracing.replay', () => {
diff --git a/packages/browser/test/unit/index.bundle.tracing.test.ts b/packages/browser/test/unit/index.bundle.tracing.test.ts
index 10ec0c6f0fd2..67a530b0e376 100644
--- a/packages/browser/test/unit/index.bundle.tracing.test.ts
+++ b/packages/browser/test/unit/index.bundle.tracing.test.ts
@@ -1,4 +1,3 @@
-import { browserTracingIntegration } from '@sentry-internal/browser-utils';
 import {
   feedbackIntegrationShim,
   feedbackModalIntegrationShim,
@@ -6,6 +5,7 @@ import {
   replayIntegrationShim,
 } from '@sentry-internal/integration-shims';
 
+import { browserTracingIntegration } from '../../src';
 import * as TracingBundle from '../../src/index.bundle.tracing';
 
 describe('index.bundle.tracing', () => {
diff --git a/packages/browser/test/unit/tracing/backgroundtab.test.ts b/packages/browser/test/unit/tracing/backgroundtab.test.ts
new file mode 100644
index 000000000000..d31f53584521
--- /dev/null
+++ b/packages/browser/test/unit/tracing/backgroundtab.test.ts
@@ -0,0 +1,56 @@
+import { addTracingExtensions, getCurrentScope } from '@sentry/core';
+import { setCurrentClient } from '@sentry/core';
+
+import { TextDecoder, TextEncoder } from 'util';
+const patchedEncoder = (!global.window.TextEncoder && (global.window.TextEncoder = TextEncoder)) || true;
+// @ts-expect-error patch the encoder on the window, else importing JSDOM fails (deleted in afterAll)
+const patchedDecoder = (!global.window.TextDecoder && (global.window.TextDecoder = TextDecoder)) || true;
+
+import { JSDOM } from 'jsdom';
+
+import { BrowserClient } from '../../../src/client';
+import { registerBackgroundTabDetection } from '../../../src/tracing/backgroundtab';
+import { getDefaultBrowserClientOptions } from '../helper/browser-client-options';
+
+describe('registerBackgroundTabDetection', () => {
+  afterAll(() => {
+    // @ts-expect-error patch the encoder on the window, else importing JSDOM fails
+    patchedEncoder && delete global.window.TextEncoder;
+    // @ts-expect-error patch the encoder on the window, else importing JSDOM fails
+    patchedDecoder && delete global.window.TextDecoder;
+  });
+
+  let events: Record<string, any> = {};
+  beforeEach(() => {
+    const dom = new JSDOM();
+    global.document = dom.window.document;
+
+    const options = getDefaultBrowserClientOptions({ tracesSampleRate: 1 });
+    const client = new BrowserClient(options);
+    setCurrentClient(client);
+    client.init();
+
+    addTracingExtensions();
+
+    global.document.addEventListener = jest.fn((event, callback) => {
+      events[event] = callback;
+    });
+  });
+
+  afterEach(() => {
+    events = {};
+    getCurrentScope().clear();
+  });
+
+  it('does not create an event listener if global document is undefined', () => {
+    // @ts-expect-error need to override global document
+    global.document = undefined;
+    registerBackgroundTabDetection();
+    expect(events).toMatchObject({});
+  });
+
+  it('creates an event listener', () => {
+    registerBackgroundTabDetection();
+    expect(events).toMatchObject({ visibilitychange: expect.any(Function) });
+  });
+});
diff --git a/packages/browser-utils/test/browser/browserTracingIntegration.test.ts b/packages/browser/test/unit/tracing/browserTracingIntegration.test.ts
similarity index 89%
rename from packages/browser-utils/test/browser/browserTracingIntegration.test.ts
rename to packages/browser/test/unit/tracing/browserTracingIntegration.test.ts
index b537d684c8eb..30bf265cf20e 100644
--- a/packages/browser-utils/test/browser/browserTracingIntegration.test.ts
+++ b/packages/browser/test/unit/tracing/browserTracingIntegration.test.ts
@@ -1,3 +1,14 @@
+import { TextDecoder, TextEncoder } from 'util';
+const oldTextEncoder = global.window.TextEncoder;
+const oldTextDecoder = global.window.TextDecoder;
+// @ts-expect-error patch the encoder on the window, else importing JSDOM fails (deleted in afterAll)
+delete global.window.TextEncoder;
+// @ts-expect-error patch the encoder on the window, else importing JSDOM fails (deleted in afterAll)
+delete global.window.TextDecoder;
+global.window.TextEncoder = TextEncoder;
+// @ts-expect-error patch the encoder on the window, else importing JSDOM fails (deleted in afterAll)
+global.window.TextDecoder = TextDecoder;
+
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
@@ -16,9 +27,14 @@ import {
 import type { Span, StartSpanOptions } from '@sentry/types';
 import { timestampInSeconds } from '@sentry/utils';
 import { JSDOM } from 'jsdom';
-import { browserTracingIntegration, startBrowserTracingNavigationSpan, startBrowserTracingPageLoadSpan } from '../..';
-import { WINDOW } from '../../src/browser/types';
-import { TestClient, getDefaultClientOptions } from '../utils/TestClient';
+import { BrowserClient } from '../../../src/client';
+import { WINDOW } from '../../../src/helpers';
+import {
+  browserTracingIntegration,
+  startBrowserTracingNavigationSpan,
+  startBrowserTracingPageLoadSpan,
+} from '../../../src/tracing/browserTracingIntegration';
+import { getDefaultBrowserClientOptions } from '../helper/browser-client-options';
 
 // We're setting up JSDom here because the Next.js routing instrumentations requires a few things to be present on pageload:
 // 1. Access to window.document API for `window.document.getElementById`
@@ -51,9 +67,14 @@ describe('browserTracingIntegration', () => {
     getActiveSpan()?.end();
   });
 
+  afterAll(() => {
+    global.window.TextEncoder = oldTextEncoder;
+    global.window.TextDecoder = oldTextDecoder;
+  });
+
   it('works with tracing enabled', () => {
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         tracesSampleRate: 1,
         integrations: [browserTracingIntegration()],
       }),
@@ -81,8 +102,8 @@ describe('browserTracingIntegration', () => {
   });
 
   it('works with tracing disabled', () => {
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         integrations: [browserTracingIntegration()],
       }),
     );
@@ -94,8 +115,8 @@ describe('browserTracingIntegration', () => {
   });
 
   it("doesn't create a pageload span when instrumentPageLoad is false", () => {
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         integrations: [browserTracingIntegration({ instrumentPageLoad: false })],
       }),
     );
@@ -107,8 +128,8 @@ describe('browserTracingIntegration', () => {
   });
 
   it('works with tracing enabled but unsampled', () => {
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         tracesSampleRate: 0,
         integrations: [browserTracingIntegration()],
       }),
@@ -122,8 +143,8 @@ describe('browserTracingIntegration', () => {
   });
 
   it('starts navigation when URL changes', () => {
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         tracesSampleRate: 1,
         integrations: [browserTracingIntegration()],
       }),
@@ -206,8 +227,8 @@ describe('browserTracingIntegration', () => {
   });
 
   it("trims pageload transactions to the max duration of the transaction's children", async () => {
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         tracesSampleRate: 1,
         integrations: [browserTracingIntegration({ idleTimeout: 10 })],
       }),
@@ -230,8 +251,8 @@ describe('browserTracingIntegration', () => {
 
   describe('startBrowserTracingPageLoadSpan', () => {
     it('works without integration setup', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           integrations: [],
         }),
       );
@@ -244,8 +265,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('works with unsampled span', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [browserTracingIntegration({ instrumentPageLoad: false })],
         }),
@@ -260,8 +281,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('works with integration setup', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ instrumentPageLoad: false })],
         }),
@@ -290,8 +311,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('allows to overwrite properties', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ instrumentPageLoad: false })],
         }),
@@ -328,8 +349,8 @@ describe('browserTracingIntegration', () => {
     it('calls before beforeStartSpan', () => {
       const mockBeforeStartSpan = jest.fn((options: StartSpanOptions) => options);
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [
             browserTracingIntegration({ instrumentPageLoad: false, beforeStartSpan: mockBeforeStartSpan }),
@@ -355,8 +376,8 @@ describe('browserTracingIntegration', () => {
         op: 'test op',
       }));
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [
             browserTracingIntegration({
@@ -378,8 +399,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('sets the pageload span name on `scope.transactionName`', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           integrations: [browserTracingIntegration()],
         }),
       );
@@ -398,8 +419,8 @@ describe('browserTracingIntegration', () => {
       name: 'changed',
     }));
 
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         tracesSampleRate: 0,
         integrations: [
           browserTracingIntegration({
@@ -423,8 +444,8 @@ describe('browserTracingIntegration', () => {
 
   describe('startBrowserTracingNavigationSpan', () => {
     it('works without integration setup', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           integrations: [],
         }),
       );
@@ -437,8 +458,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('works with unsampled span', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [browserTracingIntegration({ instrumentNavigation: false })],
         }),
@@ -453,8 +474,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('works with integration setup', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ instrumentNavigation: false })],
         }),
@@ -483,8 +504,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('allows to overwrite properties', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ instrumentNavigation: false })],
         }),
@@ -521,8 +542,8 @@ describe('browserTracingIntegration', () => {
     it('calls before beforeStartSpan', () => {
       const mockBeforeStartSpan = jest.fn((options: StartSpanOptions) => options);
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [
             browserTracingIntegration({
@@ -552,8 +573,8 @@ describe('browserTracingIntegration', () => {
         op: 'test op',
       }));
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [
             browserTracingIntegration({
@@ -580,8 +601,8 @@ describe('browserTracingIntegration', () => {
         name: 'changed',
       }));
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 0,
           integrations: [
             browserTracingIntegration({
@@ -604,8 +625,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it('sets the navigation span name on `scope.transactionName`', () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           integrations: [browserTracingIntegration()],
         }),
       );
@@ -618,8 +639,8 @@ describe('browserTracingIntegration', () => {
     });
 
     it("resets the scopes' propagationContexts", () => {
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           integrations: [browserTracingIntegration()],
         }),
       );
@@ -663,8 +684,8 @@ describe('browserTracingIntegration', () => {
         '<meta name="sentry-trace" content="12312012123120121231201212312012-1121201211212012-0">' +
         '<meta name="baggage" content="sentry-release=2.1.14,foo=bar">';
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration()],
         }),
@@ -700,8 +721,8 @@ describe('browserTracingIntegration', () => {
         '<meta name="sentry-trace" content="12312012123120121231201212312012-1121201211212012-0">' +
         '<meta name="baggage" content="foo=bar">';
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration()],
         }),
@@ -736,8 +757,8 @@ describe('browserTracingIntegration', () => {
         '<meta name="sentry-trace" content="12312012123120121231201212312012-1121201211212012-0">' +
         '<meta name="baggage" content="sentry-release=2.1.14">';
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ instrumentPageLoad: false })],
         }),
@@ -768,7 +789,7 @@ describe('browserTracingIntegration', () => {
       expect(dynamicSamplingContext).toBeDefined();
       expect(dynamicSamplingContext).toStrictEqual({
         environment: 'production',
-        public_key: 'username',
+        public_key: 'examplePublicKey',
         sample_rate: '1',
         sampled: 'true',
         trace_id: expect.not.stringContaining('12312012123120121231201212312012'),
@@ -785,8 +806,8 @@ describe('browserTracingIntegration', () => {
         '<meta name="sentry-trace" content="12312012123120121231201212312012-1121201211212012-1">' +
         '<meta name="baggage" content="sentry-release=2.1.14,foo=bar">';
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ instrumentPageLoad: false })],
         }),
@@ -831,8 +852,8 @@ describe('browserTracingIntegration', () => {
   describe('idleTimeout', () => {
     it('is created by default', () => {
       jest.useFakeTimers();
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration()],
         }),
@@ -866,8 +887,8 @@ describe('browserTracingIntegration', () => {
     it('can be a custom value', () => {
       jest.useFakeTimers();
 
-      const client = new TestClient(
-        getDefaultClientOptions({
+      const client = new BrowserClient(
+        getDefaultBrowserClientOptions({
           tracesSampleRate: 1,
           integrations: [browserTracingIntegration({ idleTimeout: 2000 })],
         }),
@@ -906,8 +927,8 @@ describe('browserTracingIntegration', () => {
 
     const interval = 200;
 
-    const client = new TestClient(
-      getDefaultClientOptions({
+    const client = new BrowserClient(
+      getDefaultBrowserClientOptions({
         tracesSampleRate: 1,
         integrations: [browserTracingIntegration({ heartbeatInterval: interval })],
       }),
diff --git a/packages/browser-utils/test/browser/request.test.ts b/packages/browser/test/unit/tracing/request.test.ts
similarity index 96%
rename from packages/browser-utils/test/browser/request.test.ts
rename to packages/browser/test/unit/tracing/request.test.ts
index 0671e8d5805c..521ff1327b01 100644
--- a/packages/browser-utils/test/browser/request.test.ts
+++ b/packages/browser/test/unit/tracing/request.test.ts
@@ -1,9 +1,8 @@
+import * as browserUtils from '@sentry-internal/browser-utils';
 import * as utils from '@sentry/utils';
+import { WINDOW } from '../../../src/helpers';
 
-import * as xhrInstrumentation from '../../src/instrument/xhr';
-
-import { extractNetworkProtocol, instrumentOutgoingRequests, shouldAttachHeaders } from '../../src/browser/request';
-import { WINDOW } from '../../src/browser/types';
+import { extractNetworkProtocol, instrumentOutgoingRequests, shouldAttachHeaders } from '../../../src/tracing/request';
 
 beforeAll(() => {
   // @ts-expect-error need to override global Request because it's not in the jest environment (even with an
@@ -18,7 +17,7 @@ describe('instrumentOutgoingRequests', () => {
 
   it('instruments fetch and xhr requests', () => {
     const addFetchSpy = jest.spyOn(utils, 'addFetchInstrumentationHandler');
-    const addXhrSpy = jest.spyOn(xhrInstrumentation, 'addXhrInstrumentationHandler');
+    const addXhrSpy = jest.spyOn(browserUtils, 'addXhrInstrumentationHandler');
 
     instrumentOutgoingRequests();
 
@@ -35,7 +34,7 @@ describe('instrumentOutgoingRequests', () => {
   });
 
   it('does not instrument xhr requests if traceXHR is false', () => {
-    const addXhrSpy = jest.spyOn(xhrInstrumentation, 'addXhrInstrumentationHandler');
+    const addXhrSpy = jest.spyOn(browserUtils, 'addXhrInstrumentationHandler');
 
     instrumentOutgoingRequests({ traceXHR: false });
 
@@ -114,6 +113,8 @@ describe('shouldAttachHeaders', () => {
 
     beforeAll(() => {
       originalWindowLocation = WINDOW.location;
+      // @ts-expect-error Override delete
+      delete WINDOW.location;
       // @ts-expect-error We are missing some fields of the Origin interface but it doesn't matter for these tests.
       WINDOW.location = new URL('https://my-origin.com');
     });
@@ -154,6 +155,8 @@ describe('shouldAttachHeaders', () => {
 
     beforeAll(() => {
       originalWindowLocation = WINDOW.location;
+      // @ts-expect-error Override delete
+      delete WINDOW.location;
       // @ts-expect-error We are missing some fields of the Origin interface but it doesn't matter for these tests.
       WINDOW.location = new URL('https://my-origin.com/api/my-route');
     });
@@ -277,6 +280,8 @@ describe('shouldAttachHeaders', () => {
 
     beforeAll(() => {
       originalWindowLocation = WINDOW.location;
+      // @ts-expect-error Override delete
+      delete WINDOW.location;
       // @ts-expect-error We need to simulate an edge-case
       WINDOW.location = undefined;
     });
diff --git a/packages/sveltekit/test/client/browserTracingIntegration.test.ts b/packages/sveltekit/test/client/browserTracingIntegration.test.ts
index cdbe093e201b..a76f0e187c35 100644
--- a/packages/sveltekit/test/client/browserTracingIntegration.test.ts
+++ b/packages/sveltekit/test/client/browserTracingIntegration.test.ts
@@ -41,7 +41,7 @@ describe('browserTracingIntegration', () => {
         updateName: vi.fn(),
         setAttribute: vi.fn(),
       };
-      return createdRootSpan;
+      return createdRootSpan as Span;
     });
 
   const startBrowserTracingNavigationSpanSpy = vi
@@ -52,7 +52,7 @@ describe('browserTracingIntegration', () => {
         updateName: vi.fn(),
         setAttribute: vi.fn(),
       };
-      return createdRootSpan;
+      return createdRootSpan as Span;
     });
 
   const fakeClient = { getOptions: () => ({}), on: () => {} };
@@ -75,7 +75,6 @@ describe('browserTracingIntegration', () => {
   it('implements required hooks', () => {
     const integration = browserTracingIntegration();
     expect(integration.name).toEqual('BrowserTracing');
-    expect(integration.setupOnce).toBeDefined();
     expect(integration.afterAllSetup).toBeDefined();
   });
 

From 35e464d32f15986b2f534068fffbad60bbb9037a Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Fri, 12 Apr 2024 10:14:48 +0200
Subject: [PATCH 51/64] feat(core): Extract errors from props in unkown inputs
 (#11526)

This changes the handling of unknown inputs for e.g.
`captureException()`, to check if there is a property that holds an
`Error` and use this.

So e.g. this:

```js
const error = new Error('Some error');
Sentry.captureException({ message: 'something happened!', err: error });
```

Will use `Some error` as the error message, and also take the stacktrace
from the error instead of the syntethic one.

There is of course the chance that this leads to false positives, if
something is captured and contains a reference to an unrelated error
instance. But I'd say this is not so likely, and we still keep the
serialised object as `extra` on the event.

Should fix e.g.
https://peated.sentry.io/issues/5166150355/?project=4505138086019073
---
 packages/browser/src/eventbuilder.ts          |  59 ++++++---
 .../browser/test/unit/eventbuilder.test.ts    | 124 ++++++++++++++----
 packages/utils/src/eventbuilder.ts            | 106 +++++++++++----
 packages/utils/test/eventbuilder.test.ts      | 124 +++++++++++++++++-
 4 files changed, 341 insertions(+), 72 deletions(-)

diff --git a/packages/browser/src/eventbuilder.ts b/packages/browser/src/eventbuilder.ts
index b39baee2a3fe..fcb7808178f2 100644
--- a/packages/browser/src/eventbuilder.ts
+++ b/packages/browser/src/eventbuilder.ts
@@ -48,10 +48,7 @@ export function exceptionFromError(stackParser: StackParser, ex: Error): Excepti
   return exception;
 }
 
-/**
- * @hidden
- */
-export function eventFromPlainObject(
+function eventFromPlainObject(
   stackParser: StackParser,
   exception: Record<string, unknown>,
   syntheticException?: Error,
@@ -60,35 +57,46 @@ export function eventFromPlainObject(
   const client = getClient();
   const normalizeDepth = client && client.getOptions().normalizeDepth;
 
-  const event: Event = {
+  // If we can, we extract an exception from the object properties
+  const errorFromProp = getErrorPropertyFromObject(exception);
+
+  const extra = {
+    __serialized__: normalizeToSize(exception, normalizeDepth),
+  };
+
+  if (errorFromProp) {
+    return {
+      exception: {
+        values: [exceptionFromError(stackParser, errorFromProp)],
+      },
+      extra,
+    };
+  }
+
+  const event = {
     exception: {
       values: [
         {
           type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
           value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),
-        },
+        } as Exception,
       ],
     },
-    extra: {
-      __serialized__: normalizeToSize(exception, normalizeDepth),
-    },
-  };
+    extra,
+  } satisfies Event;
 
   if (syntheticException) {
     const frames = parseStackFrames(stackParser, syntheticException);
     if (frames.length) {
       // event.exception.values[0] has been set above
-      (event.exception as { values: Exception[] }).values[0].stacktrace = { frames };
+      event.exception.values[0].stacktrace = { frames };
     }
   }
 
   return event;
 }
 
-/**
- * @hidden
- */
-export function eventFromError(stackParser: StackParser, ex: Error): Event {
+function eventFromError(stackParser: StackParser, ex: Error): Event {
   return {
     exception: {
       values: [exceptionFromError(stackParser, ex)],
@@ -97,7 +105,7 @@ export function eventFromError(stackParser: StackParser, ex: Error): Event {
 }
 
 /** Parses stack frames from an error */
-export function parseStackFrames(
+function parseStackFrames(
   stackParser: StackParser,
   ex: Error & { framesToPop?: number; stacktrace?: string },
 ): StackFrame[] {
@@ -283,10 +291,7 @@ export function eventFromUnknownInput(
   return event;
 }
 
-/**
- * @hidden
- */
-export function eventFromString(
+function eventFromString(
   stackParser: StackParser,
   message: ParameterizedString,
   syntheticException?: Error,
@@ -346,3 +351,17 @@ function getObjectClassName(obj: unknown): string | undefined | void {
     // ignore errors here
   }
 }
+
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {
+  for (const prop in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (value instanceof Error) {
+        return value;
+      }
+    }
+  }
+
+  return undefined;
+}
diff --git a/packages/browser/test/unit/eventbuilder.test.ts b/packages/browser/test/unit/eventbuilder.test.ts
index 0a5a7911ea08..d941c792aeff 100644
--- a/packages/browser/test/unit/eventbuilder.test.ts
+++ b/packages/browser/test/unit/eventbuilder.test.ts
@@ -1,5 +1,5 @@
 import { defaultStackParser } from '../../src';
-import { eventFromPlainObject } from '../../src/eventbuilder';
+import { eventFromUnknownInput } from '../../src/eventbuilder';
 
 jest.mock('@sentry/core', () => {
   const original = jest.requireActual('@sentry/core');
@@ -12,17 +12,6 @@ jest.mock('@sentry/core', () => {
         },
       };
     },
-    getCurrentHub() {
-      return {
-        getClient(): any {
-          return {
-            getOptions(): any {
-              return { normalizeDepth: 6 };
-            },
-          };
-        },
-      };
-    },
   };
 });
 
@@ -35,7 +24,7 @@ afterEach(() => {
   jest.resetAllMocks();
 });
 
-describe('eventFromPlainObject', () => {
+describe('eventFromUnknownInput', () => {
   it('should use normalizeDepth from init options', () => {
     const deepObject = {
       a: {
@@ -53,7 +42,7 @@ describe('eventFromPlainObject', () => {
       },
     };
 
-    const event = eventFromPlainObject(defaultStackParser, deepObject);
+    const event = eventFromUnknownInput(defaultStackParser, deepObject);
 
     expect(event?.extra?.__serialized__).toEqual({
       a: {
@@ -71,16 +60,107 @@ describe('eventFromPlainObject', () => {
   });
 
   it.each([
-    ['empty object', {}, 'Object captured as exception with keys: [object has no keys]'],
-    ['pojo', { prop1: 'hello', prop2: 2 }, 'Object captured as exception with keys: prop1, prop2'],
-    ['Custom Class', new MyTestClass(), 'Object captured as exception with keys: prop1, prop2'],
-    ['Event', new Event('custom'), 'Event `Event` (type=custom) captured as exception'],
-    ['MouseEvent', new MouseEvent('click'), 'Event `MouseEvent` (type=click) captured as exception'],
-  ] as [string, Record<string, unknown>, string][])(
+    ['empty object', {}, {}, 'Object captured as exception with keys: [object has no keys]'],
+    [
+      'pojo',
+      { prop1: 'hello', prop2: 2 },
+      { prop1: 'hello', prop2: 2 },
+      'Object captured as exception with keys: prop1, prop2',
+    ],
+    [
+      'Custom Class',
+      new MyTestClass(),
+      { prop1: 'hello', prop2: 2 },
+      'Object captured as exception with keys: prop1, prop2',
+    ],
+    [
+      'Event',
+      new Event('custom'),
+      {
+        currentTarget: '[object Null]',
+        isTrusted: false,
+        target: '[object Null]',
+        type: 'custom',
+      },
+      'Event `Event` (type=custom) captured as exception',
+    ],
+    [
+      'MouseEvent',
+      new MouseEvent('click'),
+      {
+        currentTarget: '[object Null]',
+        isTrusted: false,
+        target: '[object Null]',
+        type: 'click',
+      },
+      'Event `MouseEvent` (type=click) captured as exception',
+    ],
+  ] as [string, Record<string, unknown>, Record<string, unknown>, string][])(
     'has correct exception value for %s',
-    (_name, exception, expected) => {
-      const actual = eventFromPlainObject(defaultStackParser, exception);
+    (_name, exception, serializedException, expected) => {
+      const actual = eventFromUnknownInput(defaultStackParser, exception);
       expect(actual.exception?.values?.[0]?.value).toEqual(expected);
+
+      expect(actual.extra).toEqual({
+        __serialized__: serializedException,
+      });
     },
   );
+
+  it('handles object with error prop', () => {
+    const error = new Error('Some error');
+    const event = eventFromUnknownInput(defaultStackParser, {
+      foo: { bar: 'baz' },
+      name: 'BadType',
+      err: error,
+    });
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some error',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: {
+        foo: { bar: 'baz' },
+        name: 'BadType',
+        err: {
+          message: 'Some error',
+          name: 'Error',
+          stack: expect.stringContaining('Error: Some error'),
+        },
+      },
+    });
+  });
+
+  it('handles class with error prop', () => {
+    const error = new Error('Some error');
+
+    class MyTestClass {
+      prop1 = 'hello';
+      prop2 = error;
+    }
+
+    const event = eventFromUnknownInput(defaultStackParser, new MyTestClass());
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some error',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: {
+        prop1: 'hello',
+        prop2: {
+          message: 'Some error',
+          name: 'Error',
+          stack: expect.stringContaining('Error: Some error'),
+        },
+      },
+    });
+  });
 });
diff --git a/packages/utils/src/eventbuilder.ts b/packages/utils/src/eventbuilder.ts
index af1bb60cd09c..ecfb98e80783 100644
--- a/packages/utils/src/eventbuilder.ts
+++ b/packages/utils/src/eventbuilder.ts
@@ -11,7 +11,7 @@ import type {
   StackParser,
 } from '@sentry/types';
 
-import { isError, isParameterizedString, isPlainObject } from './is';
+import { isError, isErrorEvent, isParameterizedString, isPlainObject } from './is';
 import { addExceptionMechanism, addExceptionTypeValue } from './misc';
 import { normalizeToSize } from './normalize';
 import { extractExceptionKeysForMessage } from './object';
@@ -40,7 +40,21 @@ export function exceptionFromError(stackParser: StackParser, error: Error): Exce
   return exception;
 }
 
-function getMessageForObject(exception: object): string {
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {
+  for (const prop in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (value instanceof Error) {
+        return value;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function getMessageForObject(exception: Record<string, unknown>): string {
   if ('name' in exception && typeof exception.name === 'string') {
     let message = `'${exception.name}' captured as exception`;
 
@@ -51,13 +65,67 @@ function getMessageForObject(exception: object): string {
     return message;
   } else if ('message' in exception && typeof exception.message === 'string') {
     return exception.message;
-  } else {
-    // This will allow us to group events based on top-level keys
-    // which is much better than creating new group when any key/value change
-    return `Object captured as exception with keys: ${extractExceptionKeysForMessage(
-      exception as Record<string, unknown>,
-    )}`;
   }
+
+  const keys = extractExceptionKeysForMessage(exception);
+
+  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before
+  // We still want to try to get a decent message for these cases
+  if (isErrorEvent(exception)) {
+    return `Event \`ErrorEvent\` captured as exception with message \`${exception.message}\``;
+  }
+
+  const className = getObjectClassName(exception);
+
+  return `${
+    className && className !== 'Object' ? `'${className}'` : 'Object'
+  } captured as exception with keys: ${keys}`;
+}
+
+function getObjectClassName(obj: unknown): string | undefined | void {
+  try {
+    const prototype: unknown | null = Object.getPrototypeOf(obj);
+    return prototype ? prototype.constructor.name : undefined;
+  } catch (e) {
+    // ignore errors here
+  }
+}
+
+function getException(
+  client: Client,
+  mechanism: Mechanism,
+  exception: unknown,
+  hint?: EventHint,
+): [Error, Extras | undefined] {
+  if (isError(exception)) {
+    return [exception, undefined];
+  }
+
+  // Mutate this!
+  mechanism.synthetic = true;
+
+  if (isPlainObject(exception)) {
+    const normalizeDepth = client && client.getOptions().normalizeDepth;
+    const extras = { ['__serialized__']: normalizeToSize(exception as Record<string, unknown>, normalizeDepth) };
+
+    const errorFromProp = getErrorPropertyFromObject(exception);
+    if (errorFromProp) {
+      return [errorFromProp, extras];
+    }
+
+    const message = getMessageForObject(exception);
+    const ex = (hint && hint.syntheticException) || new Error(message);
+    ex.message = message;
+
+    return [ex, extras];
+  }
+
+  // This handles when someone does: `throw "something awesome";`
+  // We use synthesized Error here so we can extract a (rough) stack trace.
+  const ex = (hint && hint.syntheticException) || new Error(exception as string);
+  ex.message = `${exception}`;
+
+  return [ex, undefined];
 }
 
 /**
@@ -70,7 +138,6 @@ export function eventFromUnknownInput(
   exception: unknown,
   hint?: EventHint,
 ): Event {
-  let ex: unknown = exception;
   const providedMechanism: Mechanism | undefined =
     hint && hint.data && (hint.data as { mechanism: Mechanism }).mechanism;
   const mechanism: Mechanism = providedMechanism || {
@@ -78,28 +145,11 @@ export function eventFromUnknownInput(
     type: 'generic',
   };
 
-  let extras: Extras | undefined;
-
-  if (!isError(exception)) {
-    if (isPlainObject(exception)) {
-      const normalizeDepth = client && client.getOptions().normalizeDepth;
-      extras = { ['__serialized__']: normalizeToSize(exception as Record<string, unknown>, normalizeDepth) };
-
-      const message = getMessageForObject(exception);
-      ex = (hint && hint.syntheticException) || new Error(message);
-      (ex as Error).message = message;
-    } else {
-      // This handles when someone does: `throw "something awesome";`
-      // We use synthesized Error here so we can extract a (rough) stack trace.
-      ex = (hint && hint.syntheticException) || new Error(exception as string);
-      (ex as Error).message = exception as string;
-    }
-    mechanism.synthetic = true;
-  }
+  const [ex, extras] = getException(client, mechanism, exception, hint);
 
   const event: Event = {
     exception: {
-      values: [exceptionFromError(stackParser, ex as Error)],
+      values: [exceptionFromError(stackParser, ex)],
     },
   };
 
diff --git a/packages/utils/test/eventbuilder.test.ts b/packages/utils/test/eventbuilder.test.ts
index 3f3f5c479c98..c09697366b6f 100644
--- a/packages/utils/test/eventbuilder.test.ts
+++ b/packages/utils/test/eventbuilder.test.ts
@@ -4,30 +4,150 @@ import { createStackParser, eventFromUnknownInput, nodeStackLineParser } from '.
 
 const stackParser = createStackParser(nodeStackLineParser());
 
+class MyTestClass {
+  prop1 = 'hello';
+  prop2 = 2;
+}
+
 describe('eventFromUnknownInput', () => {
   const fakeClient = {
     getOptions: () => ({}),
   } as Client;
   test('object with useless props', () => {
     const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, prop: 1 });
-    expect(event.exception?.values?.[0].value).toBe('Object captured as exception with keys: foo, prop');
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Object captured as exception with keys: foo, prop',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: { foo: { bar: 'baz' }, prop: 1 },
+    });
   });
 
   test('object with name prop', () => {
     const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, name: 'BadType' });
     expect(event.exception?.values?.[0].value).toBe("'BadType' captured as exception");
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: "'BadType' captured as exception",
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: { foo: { bar: 'baz' }, name: 'BadType' },
+    });
   });
 
   test('object with name and message props', () => {
     const event = eventFromUnknownInput(fakeClient, stackParser, { message: 'went wrong', name: 'BadType' });
     expect(event.exception?.values?.[0].value).toBe("'BadType' captured as exception with message 'went wrong'");
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: "'BadType' captured as exception with message 'went wrong'",
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: { message: 'went wrong', name: 'BadType' },
+    });
   });
 
   test('object with message prop', () => {
     const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, message: 'Some message' });
-    expect(event.exception?.values?.[0].value).toBe('Some message');
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some message',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: { foo: { bar: 'baz' }, message: 'Some message' },
+    });
+  });
+
+  test('object with error prop', () => {
+    const error = new Error('Some error');
+    const event = eventFromUnknownInput(fakeClient, stackParser, {
+      foo: { bar: 'baz' },
+      name: 'BadType',
+      err: error,
+    });
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some error',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: {
+        foo: { bar: 'baz' },
+        name: 'BadType',
+        err: {
+          message: 'Some error',
+          name: 'Error',
+          stack: expect.stringContaining('Error: Some error'),
+        },
+      },
+    });
+  });
+
+  it('handles class with error prop', () => {
+    const error = new Error('Some error');
+
+    class MyTestClass {
+      prop1 = 'hello';
+      prop2 = error;
+    }
+
+    const event = eventFromUnknownInput(fakeClient, stackParser, new MyTestClass());
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some error',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: {
+        prop1: 'hello',
+        prop2: {
+          message: 'Some error',
+          name: 'Error',
+          stack: expect.stringContaining('Error: Some error'),
+        },
+      },
+    });
   });
 
+  it.each([
+    ['empty object', {}, 'Object captured as exception with keys: [object has no keys]'],
+    ['pojo', { prop1: 'hello', prop2: 2 }, 'Object captured as exception with keys: prop1, prop2'],
+    ['Custom Class', new MyTestClass(), "'MyTestClass' captured as exception with keys: prop1, prop2"],
+  ] as [string, Record<string, unknown>, string][])(
+    'has correct exception value for %s',
+    (_name, exception, expected) => {
+      const actual = eventFromUnknownInput(fakeClient, stackParser, exception);
+      expect(actual.exception?.values?.[0]?.value).toEqual(expected);
+
+      expect(actual.extra).toEqual({
+        __serialized__: exception,
+      });
+    },
+  );
+
   test('passing client directly', () => {
     const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, prop: 1 });
     expect(event.exception?.values?.[0].value).toBe('Object captured as exception with keys: foo, prop');

From ce959cdedf15f5990d2bd805a2ffbd4f31c838cb Mon Sep 17 00:00:00 2001
From: Luca Forstner <luca.forstner@sentry.io>
Date: Fri, 12 Apr 2024 15:14:35 +0200
Subject: [PATCH 52/64] fix(nextjs): Fix `tunnelRoute` matching logic for
 hybrid cloud (#11576)

---
 packages/nextjs/src/config/withSentryConfig.ts | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/packages/nextjs/src/config/withSentryConfig.ts b/packages/nextjs/src/config/withSentryConfig.ts
index 0d68448f81ba..f9c815fe6efb 100644
--- a/packages/nextjs/src/config/withSentryConfig.ts
+++ b/packages/nextjs/src/config/withSentryConfig.ts
@@ -137,25 +137,28 @@ function setUpTunnelRewriteRules(userNextConfig: NextConfigObject, tunnelPath: s
         {
           type: 'query',
           key: 'r', // short for region - we keep it short so matching is harder for ad-blockers
-          value: '(?<region>\\[a-z\\]{2})',
+          value: '(?<region>[a-z]{2})',
         },
       ],
       destination: 'https://o:orgid.ingest.:region.sentry.io/api/:projectid/envelope/?hsts=0',
     };
 
+    // Order of these is important, they get applied first to last.
+    const newRewrites = [tunnelRouteRewriteWithRegion, tunnelRouteRewrite];
+
     if (typeof originalRewrites !== 'function') {
-      return [tunnelRouteRewriteWithRegion, tunnelRouteRewrite];
+      return newRewrites;
     }
 
     // @ts-expect-error Expected 0 arguments but got 1 - this is from the future-proofing mentioned above, so we don't care about it
     const originalRewritesResult = await originalRewrites(...args);
 
     if (Array.isArray(originalRewritesResult)) {
-      return [tunnelRouteRewriteWithRegion, tunnelRouteRewrite, ...originalRewritesResult];
+      return [...newRewrites, ...originalRewritesResult];
     } else {
       return {
         ...originalRewritesResult,
-        beforeFiles: [tunnelRouteRewriteWithRegion, tunnelRouteRewrite, ...(originalRewritesResult.beforeFiles || [])],
+        beforeFiles: [...newRewrites, ...(originalRewritesResult.beforeFiles || [])],
       };
     }
   };

From 20706b85760ea17ce38dabaa4fe1dc0df45ed427 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Fri, 12 Apr 2024 09:42:16 -0400
Subject: [PATCH 53/64] fix(node): Make fastify types more broad (#11544)

As per
https://github.com/getsentry/sentry-javascript/issues/4784#issuecomment-2048423563

make sure fastify types use any is that we don't collide with what
fastify types expect.

Also convert e2e tests to use typescript to validate build.
---
 .../node-fastify-app/package.json             |  5 ++-
 .../node-fastify-app/src/{app.js => app.ts}   | 37 +++++++++++++------
 .../node-fastify-app/src/tracing.js           | 10 -----
 .../node/src/integrations/tracing/fastify.ts  |  8 ++--
 4 files changed, 33 insertions(+), 27 deletions(-)
 rename dev-packages/e2e-tests/test-applications/node-fastify-app/src/{app.js => app.ts} (71%)
 delete mode 100644 dev-packages/e2e-tests/test-applications/node-fastify-app/src/tracing.js

diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-app/package.json b/dev-packages/e2e-tests/test-applications/node-fastify-app/package.json
index 9e8779cf9bdd..56c8818933af 100644
--- a/dev-packages/e2e-tests/test-applications/node-fastify-app/package.json
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-app/package.json
@@ -3,10 +3,11 @@
   "version": "1.0.0",
   "private": true,
   "scripts": {
-    "start": "node src/app.js",
+    "start": "ts-node src/app.ts",
     "test": "playwright test",
     "clean": "npx rimraf node_modules pnpm-lock.yaml",
-    "test:build": "pnpm install",
+    "typecheck": "tsc",
+    "test:build": "pnpm install && pnpm run typecheck",
     "test:assert": "pnpm test"
   },
   "dependencies": {
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js b/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.ts
similarity index 71%
rename from dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js
rename to dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.ts
index dbb239a4e340..187d259b1f5b 100644
--- a/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.js
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-app/src/app.ts
@@ -1,8 +1,21 @@
-require('./tracing');
+import type * as S from '@sentry/node';
+const Sentry = require('@sentry/node') as typeof S;
+
+Sentry.init({
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: process.env.E2E_TEST_DSN,
+  integrations: [],
+  tracesSampleRate: 1,
+  tunnel: 'http://localhost:3031/', // proxy server
+  tracePropagationTargets: ['http://localhost:3030', '/external-allowed'],
+});
+
+import type * as H from 'http';
+import type * as F from 'fastify';
 
-const Sentry = require('@sentry/node');
-const { fastify } = require('fastify');
-const http = require('http');
+// Make sure fastify is imported after Sentry is initialized
+const { fastify } = require('fastify') as typeof F;
+const http = require('http') as typeof H;
 
 const app = fastify();
 const port = 3030;
@@ -10,28 +23,28 @@ const port2 = 3040;
 
 Sentry.setupFastifyErrorHandler(app);
 
-app.get('/test-success', function (req, res) {
+app.get('/test-success', function (_req, res) {
   res.send({ version: 'v1' });
 });
 
-app.get('/test-param/:param', function (req, res) {
+app.get<{ Params: { param: string } }>('/test-param/:param', function (req, res) {
   res.send({ paramWas: req.params.param });
 });
 
-app.get('/test-inbound-headers/:id', function (req, res) {
+app.get<{ Params: { id: string } }>('/test-inbound-headers/:id', function (req, res) {
   const headers = req.headers;
 
   res.send({ headers, id: req.params.id });
 });
 
-app.get('/test-outgoing-http/:id', async function (req, res) {
+app.get<{ Params: { id: string } }>('/test-outgoing-http/:id', async function (req, res) {
   const id = req.params.id;
   const data = await makeHttpRequest(`http://localhost:3030/test-inbound-headers/${id}`);
 
   res.send(data);
 });
 
-app.get('/test-outgoing-fetch/:id', async function (req, res) {
+app.get<{ Params: { id: string } }>('/test-outgoing-fetch/:id', async function (req, res) {
   const id = req.params.id;
   const response = await fetch(`http://localhost:3030/test-inbound-headers/${id}`);
   const data = await response.json();
@@ -55,7 +68,7 @@ app.get('/test-error', async function (req, res) {
   res.send({ exceptionId });
 });
 
-app.get('/test-exception/:id', async function (req, res) {
+app.get<{ Params: { id: string } }>('/test-exception/:id', async function (req, res) {
   throw new Error(`This is an exception with id ${req.params.id}`);
 });
 
@@ -101,9 +114,9 @@ app2.get('/external-disallowed', function (req, res) {
 
 app2.listen({ port: port2 });
 
-function makeHttpRequest(url) {
+function makeHttpRequest(url: string) {
   return new Promise(resolve => {
-    const data = [];
+    const data: any[] = [];
 
     http
       .request(url, httpRes => {
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-app/src/tracing.js b/dev-packages/e2e-tests/test-applications/node-fastify-app/src/tracing.js
deleted file mode 100644
index 136b401cbd73..000000000000
--- a/dev-packages/e2e-tests/test-applications/node-fastify-app/src/tracing.js
+++ /dev/null
@@ -1,10 +0,0 @@
-const Sentry = require('@sentry/node');
-
-Sentry.init({
-  environment: 'qa', // dynamic sampling bias to keep transactions
-  dsn: process.env.E2E_TEST_DSN,
-  integrations: [],
-  tracesSampleRate: 1,
-  tunnel: 'http://localhost:3031/', // proxy server
-  tracePropagationTargets: ['http://localhost:3030', '/external-allowed'],
-});
diff --git a/packages/node/src/integrations/tracing/fastify.ts b/packages/node/src/integrations/tracing/fastify.ts
index 87a820bd238e..aa2b2f275525 100644
--- a/packages/node/src/integrations/tracing/fastify.ts
+++ b/packages/node/src/integrations/tracing/fastify.ts
@@ -31,8 +31,10 @@ export const fastifyIntegration = defineIntegration(_fastifyIntegration);
 
 // We inline the types we care about here
 interface Fastify {
-  register: (plugin: unknown) => void;
-  addHook: (hook: string, handler: (request: unknown, reply: unknown, error: Error) => void) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  register: (plugin: any) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  addHook: (hook: string, handler: (request: any, reply: any, error: Error) => void) => void;
 }
 
 /**
@@ -53,7 +55,7 @@ interface FastifyRequestRouteInfo {
  */
 export function setupFastifyErrorHandler(fastify: Fastify): void {
   const plugin = Object.assign(
-    function (fastify: Fastify, options: unknown, done: () => void): void {
+    function (fastify: Fastify, _options: unknown, done: () => void): void {
       fastify.addHook('onError', async (_request, _reply, error) => {
         captureException(error);
       });

From 07ca78e6d63d8e6e00fa2b74fb792ead6f161282 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Fri, 12 Apr 2024 15:58:07 +0200
Subject: [PATCH 54/64] feat(core): Deprecate `addTracingExtensions` (#11579)

Instead, users can use `registerSpanErrorInstrumentation` which is now
does much less things than before.

I opted to not fully remove this yet because I guess the chance that
somebody may have been using this is somewhat high, and we can easily
continue to have it with no bundle size hit for those who don't need it.
We also couldn't really deprecate this in v7 so I think it's OK to leave
this in for now.
---
 MIGRATION.md                                  | 11 +++++----
 .../suites/public-api/startSpan/init.js       |  2 --
 .../browser-utils/test/browser/utils.test.ts  | 11 +--------
 packages/browser/src/index.bundle.feedback.ts | 13 ++--------
 packages/browser/src/index.bundle.replay.ts   |  3 ---
 .../index.bundle.tracing.replay.feedback.ts   |  6 ++---
 .../src/index.bundle.tracing.replay.ts        |  6 ++---
 packages/browser/src/index.bundle.tracing.ts  |  7 ++----
 packages/browser/src/index.bundle.ts          |  3 ---
 packages/browser/src/index.ts                 |  2 ++
 .../src/tracing/browserTracingIntegration.ts  |  4 ++--
 .../test/unit/tracing/backgroundtab.test.ts   |  4 +---
 packages/core/src/server-runtime-client.ts    |  4 ++--
 packages/core/src/tracing/errors.ts           |  4 ++--
 packages/core/src/tracing/hubextensions.ts    |  7 +++---
 packages/core/src/tracing/index.ts            |  2 ++
 .../tracing/dynamicSamplingContext.test.ts    |  8 +------
 packages/core/test/lib/tracing/errors.test.ts | 16 +++++--------
 .../core/test/lib/tracing/idleSpan.test.ts    |  2 --
 packages/core/test/lib/tracing/trace.test.ts  | 24 ++++---------------
 .../core/test/lib/utils/spanUtils.test.ts     |  2 --
 .../integration-shims/src/BrowserTracing.ts   |  5 ----
 packages/integration-shims/src/index.ts       |  5 +---
 .../src/common/utils/edgeWrapperUtils.ts      |  2 --
 .../common/withServerActionInstrumentation.ts | 10 +-------
 .../src/common/wrapApiHandlerWithSentry.ts    |  3 ---
 .../wrapApiHandlerWithSentryVercelCrons.ts    |  3 +--
 .../wrapAppGetInitialPropsWithSentry.ts       | 10 +-------
 .../wrapDocumentGetInitialPropsWithSentry.ts  |  3 ---
 .../wrapErrorGetInitialPropsWithSentry.ts     | 10 +-------
 .../wrapGenerationFunctionWithSentry.ts       |  2 --
 .../common/wrapGetInitialPropsWithSentry.ts   | 10 +-------
 .../wrapGetServerSidePropsWithSentry.ts       | 10 +-------
 .../common/wrapGetStaticPropsWithSentry.ts    |  3 ---
 .../src/common/wrapPageComponentWithSentry.ts |  3 +--
 .../src/common/wrapRouteHandlerWithSentry.ts  |  3 ---
 .../common/wrapServerComponentWithSentry.ts   |  2 --
 packages/nextjs/src/edge/index.ts             |  4 ++--
 packages/nextjs/src/server/index.ts           |  4 +---
 .../nextjs/test/config/withSentry.test.ts     |  6 +----
 packages/nextjs/test/config/wrappers.test.ts  |  6 +----
 .../opentelemetry/test/propagator.test.ts     |  6 +----
 packages/svelte/test/performance.test.ts      |  4 +---
 packages/sveltekit/test/client/load.test.ts   |  4 ----
 packages/sveltekit/test/server/handle.test.ts |  5 ----
 packages/sveltekit/test/server/load.test.ts   |  5 ----
 46 files changed, 55 insertions(+), 214 deletions(-)

diff --git a/MIGRATION.md b/MIGRATION.md
index 046906b2f0fd..d64f3fe03374 100644
--- a/MIGRATION.md
+++ b/MIGRATION.md
@@ -65,7 +65,7 @@ We've removed the following packages:
 `@sentry/tracing` has been removed and will no longer be published. See
 [below](./MIGRATION.md/#3-removal-of-deprecated-apis) for more details.
 
-For Browser SDKs you can import `BrowserTracing` from the SDK directly:
+For Browser SDKs you can import `browserTracingIntegration` from the SDK directly:
 
 ```js
 // v7
@@ -86,12 +86,13 @@ import * as Sentry from '@sentry/browser';
 Sentry.init({
   dsn: '__DSN__',
   tracesSampleRate: 1.0,
-  integrations: [new Sentry.BrowserTracing()],
+  integrations: [Sentry.browserTracingIntegration()],
 });
 ```
 
-If you were importing `@sentry/tracing` for the side effect, you can now use `Sentry.addTracingExtensions()` to add the
-tracing extensions to the SDK. `addTracingExtensions` replaces the `addExtensionMethods` method from `@sentry/tracing`.
+If you don't want to use `browserTracingIntegration` but still manually start spans, you can now use
+`Sentry.registerSpanErrorInstrumentation()` to setup handlers for span instrumentation.
+`registerSpanErrorInstrumentation` replaces the `addExtensionMethods` method from `@sentry/tracing`.
 
 ```js
 // v7
@@ -108,7 +109,7 @@ Sentry.init({
 // v8
 import * as Sentry from '@sentry/browser';
 
-Sentry.addTracingExtensions();
+Sentry.registerSpanErrorInstrumentation();
 
 Sentry.init({
   dsn: '__DSN__',
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js
index 3fb0df7a75d4..3364667c960c 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js
@@ -2,8 +2,6 @@ import * as Sentry from '@sentry/browser';
 
 window.Sentry = Sentry;
 
-Sentry.addTracingExtensions();
-
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
diff --git a/packages/browser-utils/test/browser/utils.test.ts b/packages/browser-utils/test/browser/utils.test.ts
index 56f06f222366..bb7a757e4b6a 100644
--- a/packages/browser-utils/test/browser/utils.test.ts
+++ b/packages/browser-utils/test/browser/utils.test.ts
@@ -1,18 +1,9 @@
-import {
-  SentrySpan,
-  addTracingExtensions,
-  getCurrentScope,
-  getIsolationScope,
-  setCurrentClient,
-  spanToJSON,
-} from '@sentry/core';
+import { SentrySpan, getCurrentScope, getIsolationScope, setCurrentClient, spanToJSON } from '@sentry/core';
 import { startAndEndSpan } from '../../src/metrics/utils';
 import { TestClient, getDefaultClientOptions } from '../utils/TestClient';
 
 describe('startAndEndSpan()', () => {
   beforeEach(() => {
-    addTracingExtensions();
-
     getCurrentScope().clear();
     getIsolationScope().clear();
 
diff --git a/packages/browser/src/index.bundle.feedback.ts b/packages/browser/src/index.bundle.feedback.ts
index 649011bd82ed..850da7bf1e26 100644
--- a/packages/browser/src/index.bundle.feedback.ts
+++ b/packages/browser/src/index.bundle.feedback.ts
@@ -1,9 +1,4 @@
-// This is exported so the loader does not fail when switching off Replay/Tracing
-import {
-  addTracingExtensionsShim,
-  browserTracingIntegrationShim,
-  replayIntegrationShim,
-} from '@sentry-internal/integration-shims';
+import { browserTracingIntegrationShim, replayIntegrationShim } from '@sentry-internal/integration-shims';
 
 export * from './index.bundle.base';
 
@@ -14,8 +9,4 @@ export {
   getFeedback,
 } from '@sentry-internal/feedback';
 
-export {
-  browserTracingIntegrationShim as browserTracingIntegration,
-  addTracingExtensionsShim as addTracingExtensions,
-  replayIntegrationShim as replayIntegration,
-};
+export { browserTracingIntegrationShim as browserTracingIntegration, replayIntegrationShim as replayIntegration };
diff --git a/packages/browser/src/index.bundle.replay.ts b/packages/browser/src/index.bundle.replay.ts
index bdc776374398..3a26a2db77ac 100644
--- a/packages/browser/src/index.bundle.replay.ts
+++ b/packages/browser/src/index.bundle.replay.ts
@@ -1,6 +1,4 @@
-// This is exported so the loader does not fail when switching off Replay/Tracing
 import {
-  addTracingExtensionsShim,
   browserTracingIntegrationShim,
   feedbackIntegrationShim,
   feedbackModalIntegrationShim,
@@ -13,7 +11,6 @@ export { replayIntegration } from '@sentry-internal/replay';
 
 export {
   browserTracingIntegrationShim as browserTracingIntegration,
-  addTracingExtensionsShim as addTracingExtensions,
   feedbackIntegrationShim as feedbackIntegration,
   feedbackModalIntegrationShim as feedbackModalIntegration,
   feedbackScreenshotIntegrationShim as feedbackScreenshotIntegration,
diff --git a/packages/browser/src/index.bundle.tracing.replay.feedback.ts b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
index feaedf21e8d4..4c9c1e716534 100644
--- a/packages/browser/src/index.bundle.tracing.replay.feedback.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.feedback.ts
@@ -1,7 +1,6 @@
-import { addTracingExtensions } from '@sentry/core';
+import { registerSpanErrorInstrumentation } from '@sentry/core';
 
-// We are patching the global object with our hub extension methods
-addTracingExtensions();
+registerSpanErrorInstrumentation();
 
 export * from './index.bundle.base';
 
@@ -14,7 +13,6 @@ export {
   withActiveSpan,
   getSpanDescendants,
   setMeasurement,
-  addTracingExtensions,
 } from '@sentry/core';
 
 export {
diff --git a/packages/browser/src/index.bundle.tracing.replay.ts b/packages/browser/src/index.bundle.tracing.replay.ts
index fbf0e24faa73..1b986f9e794a 100644
--- a/packages/browser/src/index.bundle.tracing.replay.ts
+++ b/packages/browser/src/index.bundle.tracing.replay.ts
@@ -3,10 +3,9 @@ import {
   feedbackModalIntegrationShim,
   feedbackScreenshotIntegrationShim,
 } from '@sentry-internal/integration-shims';
-import { addTracingExtensions } from '@sentry/core';
+import { registerSpanErrorInstrumentation } from '@sentry/core';
 
-// We are patching the global object with our hub extension methods
-addTracingExtensions();
+registerSpanErrorInstrumentation();
 
 export * from './index.bundle.base';
 
@@ -19,7 +18,6 @@ export {
   withActiveSpan,
   getSpanDescendants,
   setMeasurement,
-  addTracingExtensions,
 } from '@sentry/core';
 
 export {
diff --git a/packages/browser/src/index.bundle.tracing.ts b/packages/browser/src/index.bundle.tracing.ts
index 66d1df7792fe..f956bc4db1f6 100644
--- a/packages/browser/src/index.bundle.tracing.ts
+++ b/packages/browser/src/index.bundle.tracing.ts
@@ -1,14 +1,12 @@
-// This is exported so the loader does not fail when switching off Replay
 import {
   feedbackIntegrationShim,
   feedbackModalIntegrationShim,
   feedbackScreenshotIntegrationShim,
   replayIntegrationShim,
 } from '@sentry-internal/integration-shims';
-import { addTracingExtensions } from '@sentry/core';
+import { registerSpanErrorInstrumentation } from '@sentry/core';
 
-// We are patching the global object with our hub extension methods
-addTracingExtensions();
+registerSpanErrorInstrumentation();
 
 export * from './index.bundle.base';
 
@@ -21,7 +19,6 @@ export {
   withActiveSpan,
   getSpanDescendants,
   setMeasurement,
-  addTracingExtensions,
 } from '@sentry/core';
 
 export {
diff --git a/packages/browser/src/index.bundle.ts b/packages/browser/src/index.bundle.ts
index ce04413b4053..9433e3605c3b 100644
--- a/packages/browser/src/index.bundle.ts
+++ b/packages/browser/src/index.bundle.ts
@@ -1,6 +1,4 @@
-// This is exported so the loader does not fail when switching off Replay/Tracing
 import {
-  addTracingExtensionsShim,
   browserTracingIntegrationShim,
   feedbackIntegrationShim,
   feedbackModalIntegrationShim,
@@ -11,7 +9,6 @@ import {
 export * from './index.bundle.base';
 
 export {
-  addTracingExtensionsShim as addTracingExtensions,
   browserTracingIntegrationShim as browserTracingIntegration,
   feedbackIntegrationShim as feedbackIntegration,
   feedbackModalIntegrationShim as feedbackModalIntegration,
diff --git a/packages/browser/src/index.ts b/packages/browser/src/index.ts
index 1bdee34b1c6a..455214f60816 100644
--- a/packages/browser/src/index.ts
+++ b/packages/browser/src/index.ts
@@ -49,7 +49,9 @@ export {
 } from './tracing/browserTracingIntegration';
 export type { RequestInstrumentationOptions } from './tracing/request';
 export {
+  // eslint-disable-next-line deprecation/deprecation
   addTracingExtensions,
+  registerSpanErrorInstrumentation,
   getActiveSpan,
   getRootSpan,
   startSpan,
diff --git a/packages/browser/src/tracing/browserTracingIntegration.ts b/packages/browser/src/tracing/browserTracingIntegration.ts
index d41073f46191..d1b4a90d6f97 100644
--- a/packages/browser/src/tracing/browserTracingIntegration.ts
+++ b/packages/browser/src/tracing/browserTracingIntegration.ts
@@ -10,13 +10,13 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   TRACING_DEFAULTS,
-  addTracingExtensions,
   continueTrace,
   getActiveSpan,
   getClient,
   getCurrentScope,
   getIsolationScope,
   getRootSpan,
+  registerSpanErrorInstrumentation,
   spanToJSON,
   startIdleSpan,
   withScope,
@@ -153,7 +153,7 @@ const DEFAULT_BROWSER_TRACING_OPTIONS: BrowserTracingOptions = {
  * We explicitly export the proper type here, as this has to be extended in some cases.
  */
 export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptions> = {}) => {
-  addTracingExtensions();
+  registerSpanErrorInstrumentation();
 
   const options = {
     ...DEFAULT_BROWSER_TRACING_OPTIONS,
diff --git a/packages/browser/test/unit/tracing/backgroundtab.test.ts b/packages/browser/test/unit/tracing/backgroundtab.test.ts
index d31f53584521..2c998744a723 100644
--- a/packages/browser/test/unit/tracing/backgroundtab.test.ts
+++ b/packages/browser/test/unit/tracing/backgroundtab.test.ts
@@ -1,4 +1,4 @@
-import { addTracingExtensions, getCurrentScope } from '@sentry/core';
+import { getCurrentScope } from '@sentry/core';
 import { setCurrentClient } from '@sentry/core';
 
 import { TextDecoder, TextEncoder } from 'util';
@@ -30,8 +30,6 @@ describe('registerBackgroundTabDetection', () => {
     setCurrentClient(client);
     client.init();
 
-    addTracingExtensions();
-
     global.document.addEventListener = jest.fn((event, callback) => {
       events[event] = callback;
     });
diff --git a/packages/core/src/server-runtime-client.ts b/packages/core/src/server-runtime-client.ts
index 9cd05374ddd3..396e805e7fb5 100644
--- a/packages/core/src/server-runtime-client.ts
+++ b/packages/core/src/server-runtime-client.ts
@@ -20,9 +20,9 @@ import { DEBUG_BUILD } from './debug-build';
 import type { Scope } from './scope';
 import { SessionFlusher } from './sessionflusher';
 import {
-  addTracingExtensions,
   getDynamicSamplingContextFromClient,
   getDynamicSamplingContextFromSpan,
+  registerSpanErrorInstrumentation,
 } from './tracing';
 import { _getSpanForScope } from './utils/spanOnScope';
 import { getRootSpan, spanToTraceContext } from './utils/spanUtils';
@@ -47,7 +47,7 @@ export class ServerRuntimeClient<
    */
   public constructor(options: O) {
     // Server clients always support tracing
-    addTracingExtensions();
+    registerSpanErrorInstrumentation();
 
     super(options);
   }
diff --git a/packages/core/src/tracing/errors.ts b/packages/core/src/tracing/errors.ts
index de184c01391f..835038175331 100644
--- a/packages/core/src/tracing/errors.ts
+++ b/packages/core/src/tracing/errors.ts
@@ -16,9 +16,9 @@ export function _resetErrorsInstrumented(): void {
 }
 
 /**
- * Configures global error listeners
+ * Ensure that global errors automatically set the active span status.
  */
-export function registerErrorInstrumentation(): void {
+export function registerSpanErrorInstrumentation(): void {
   if (errorsInstrumented) {
     return;
   }
diff --git a/packages/core/src/tracing/hubextensions.ts b/packages/core/src/tracing/hubextensions.ts
index 394a2be026fe..3b08bc16a319 100644
--- a/packages/core/src/tracing/hubextensions.ts
+++ b/packages/core/src/tracing/hubextensions.ts
@@ -1,9 +1,8 @@
-import { registerErrorInstrumentation } from './errors';
+import { registerSpanErrorInstrumentation } from './errors';
 
 /**
- * Adds tracing extensions.
- * TODO (v8): Do we still need this?? Can we solve this differently?
+ * @deprecated Use `registerSpanErrorInstrumentation()` instead. In v9, this function will be removed. Note that you don't need to call this in Node-based SDKs or when using `browserTracingIntegration`.
  */
 export function addTracingExtensions(): void {
-  registerErrorInstrumentation();
+  registerSpanErrorInstrumentation();
 }
diff --git a/packages/core/src/tracing/index.ts b/packages/core/src/tracing/index.ts
index a01fca60316a..e1925c4b16d5 100644
--- a/packages/core/src/tracing/index.ts
+++ b/packages/core/src/tracing/index.ts
@@ -1,4 +1,6 @@
+export { registerSpanErrorInstrumentation } from './errors';
 export { setCapturedScopesOnSpan, getCapturedScopesOnSpan } from './utils';
+// eslint-disable-next-line deprecation/deprecation
 export { addTracingExtensions } from './hubextensions';
 export { startIdleSpan, TRACING_DEFAULTS } from './idleSpan';
 export { SentrySpan } from './sentrySpan';
diff --git a/packages/core/test/lib/tracing/dynamicSamplingContext.test.ts b/packages/core/test/lib/tracing/dynamicSamplingContext.test.ts
index 329d13c769af..107c039f948c 100644
--- a/packages/core/test/lib/tracing/dynamicSamplingContext.test.ts
+++ b/packages/core/test/lib/tracing/dynamicSamplingContext.test.ts
@@ -4,12 +4,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   setCurrentClient,
 } from '../../../src';
-import {
-  SentrySpan,
-  addTracingExtensions,
-  getDynamicSamplingContextFromSpan,
-  startInactiveSpan,
-} from '../../../src/tracing';
+import { SentrySpan, getDynamicSamplingContextFromSpan, startInactiveSpan } from '../../../src/tracing';
 import { freezeDscOnSpan } from '../../../src/tracing/dynamicSamplingContext';
 import { TestClient, getDefaultTestClientOptions } from '../../mocks/client';
 
@@ -19,7 +14,6 @@ describe('getDynamicSamplingContextFromSpan', () => {
     const client = new TestClient(options);
     setCurrentClient(client);
     client.init();
-    addTracingExtensions();
   });
 
   afterEach(() => {
diff --git a/packages/core/test/lib/tracing/errors.test.ts b/packages/core/test/lib/tracing/errors.test.ts
index 76c4aa9609f2..3e3f85ef73b7 100644
--- a/packages/core/test/lib/tracing/errors.test.ts
+++ b/packages/core/test/lib/tracing/errors.test.ts
@@ -1,7 +1,7 @@
 import type { HandlerDataError, HandlerDataUnhandledRejection } from '@sentry/types';
-import { addTracingExtensions, setCurrentClient, spanToJSON, startInactiveSpan, startSpan } from '../../../src';
+import { setCurrentClient, spanToJSON, startInactiveSpan, startSpan } from '../../../src';
 
-import { _resetErrorsInstrumented, registerErrorInstrumentation } from '../../../src/tracing/errors';
+import { _resetErrorsInstrumented, registerSpanErrorInstrumentation } from '../../../src/tracing/errors';
 import { TestClient, getDefaultTestClientOptions } from '../../mocks/client';
 
 const mockAddGlobalErrorInstrumentationHandler = jest.fn();
@@ -25,10 +25,6 @@ jest.mock('@sentry/utils', () => {
   };
 });
 
-beforeAll(() => {
-  addTracingExtensions();
-});
-
 describe('registerErrorHandlers()', () => {
   beforeEach(() => {
     mockAddGlobalErrorInstrumentationHandler.mockClear();
@@ -41,7 +37,7 @@ describe('registerErrorHandlers()', () => {
   });
 
   it('registers error instrumentation', () => {
-    registerErrorInstrumentation();
+    registerSpanErrorInstrumentation();
     expect(mockAddGlobalErrorInstrumentationHandler).toHaveBeenCalledTimes(1);
     expect(mockAddGlobalUnhandledRejectionInstrumentationHandler).toHaveBeenCalledTimes(1);
     expect(mockAddGlobalErrorInstrumentationHandler).toHaveBeenCalledWith(expect.any(Function));
@@ -49,7 +45,7 @@ describe('registerErrorHandlers()', () => {
   });
 
   it('does not set status if transaction is not on scope', () => {
-    registerErrorInstrumentation();
+    registerSpanErrorInstrumentation();
 
     const transaction = startInactiveSpan({ name: 'test' })!;
     expect(spanToJSON(transaction).status).toBe(undefined);
@@ -64,7 +60,7 @@ describe('registerErrorHandlers()', () => {
   });
 
   it('sets status for transaction on scope on error', () => {
-    registerErrorInstrumentation();
+    registerSpanErrorInstrumentation();
 
     startSpan({ name: 'test' }, span => {
       mockErrorCallback({} as HandlerDataError);
@@ -73,7 +69,7 @@ describe('registerErrorHandlers()', () => {
   });
 
   it('sets status for transaction on scope on unhandledrejection', () => {
-    registerErrorInstrumentation();
+    registerSpanErrorInstrumentation();
 
     startSpan({ name: 'test' }, span => {
       mockUnhandledRejectionCallback({});
diff --git a/packages/core/test/lib/tracing/idleSpan.test.ts b/packages/core/test/lib/tracing/idleSpan.test.ts
index a0d5b5bf3123..5896e80654e5 100644
--- a/packages/core/test/lib/tracing/idleSpan.test.ts
+++ b/packages/core/test/lib/tracing/idleSpan.test.ts
@@ -5,7 +5,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON,
   SentryNonRecordingSpan,
   SentrySpan,
-  addTracingExtensions,
   getActiveSpan,
   getClient,
   getCurrentScope,
@@ -24,7 +23,6 @@ const dsn = 'https://123@sentry.io/42';
 describe('startIdleSpan', () => {
   beforeEach(() => {
     jest.useFakeTimers();
-    addTracingExtensions();
 
     getCurrentScope().clear();
     getIsolationScope().clear();
diff --git a/packages/core/test/lib/tracing/trace.test.ts b/packages/core/test/lib/tracing/trace.test.ts
index 8fe6de43f219..b4b73307e174 100644
--- a/packages/core/test/lib/tracing/trace.test.ts
+++ b/packages/core/test/lib/tracing/trace.test.ts
@@ -3,7 +3,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   Scope,
-  addTracingExtensions,
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
@@ -17,6 +16,7 @@ import { getAsyncContextStrategy } from '../../../src/hub';
 import {
   SentrySpan,
   continueTrace,
+  registerSpanErrorInstrumentation,
   startInactiveSpan,
   startSpan,
   startSpanManual,
@@ -28,10 +28,6 @@ import { _setSpanForScope } from '../../../src/utils/spanOnScope';
 import { getActiveSpan, getRootSpan, getSpanDescendants, spanIsSampled } from '../../../src/utils/spanUtils';
 import { TestClient, getDefaultTestClientOptions } from '../../mocks/client';
 
-beforeAll(() => {
-  addTracingExtensions();
-});
-
 const enum Type {
   Sync = 'sync',
   Async = 'async',
@@ -41,7 +37,7 @@ let client: TestClient;
 
 describe('startSpan', () => {
   beforeEach(() => {
-    addTracingExtensions();
+    registerSpanErrorInstrumentation();
 
     getCurrentScope().clear();
     getIsolationScope().clear();
@@ -559,7 +555,7 @@ describe('startSpan', () => {
 
 describe('startSpanManual', () => {
   beforeEach(() => {
-    addTracingExtensions();
+    registerSpanErrorInstrumentation();
 
     getCurrentScope().clear();
     getIsolationScope().clear();
@@ -878,7 +874,7 @@ describe('startSpanManual', () => {
 
 describe('startInactiveSpan', () => {
   beforeEach(() => {
-    addTracingExtensions();
+    registerSpanErrorInstrumentation();
 
     getCurrentScope().clear();
     getIsolationScope().clear();
@@ -1218,8 +1214,6 @@ describe('startInactiveSpan', () => {
 
 describe('continueTrace', () => {
   beforeEach(() => {
-    addTracingExtensions();
-
     getCurrentScope().clear();
     getIsolationScope().clear();
     getGlobalScope().clear();
@@ -1335,8 +1329,6 @@ describe('continueTrace', () => {
 
 describe('getActiveSpan', () => {
   beforeEach(() => {
-    addTracingExtensions();
-
     getCurrentScope().clear();
     getIsolationScope().clear();
     getGlobalScope().clear();
@@ -1384,10 +1376,6 @@ describe('getActiveSpan', () => {
 });
 
 describe('withActiveSpan()', () => {
-  beforeAll(() => {
-    addTracingExtensions();
-  });
-
   beforeEach(() => {
     getCurrentScope().clear();
     getIsolationScope().clear();
@@ -1460,8 +1448,6 @@ describe('withActiveSpan()', () => {
 
 describe('span hooks', () => {
   beforeEach(() => {
-    addTracingExtensions();
-
     getCurrentScope().clear();
     getIsolationScope().clear();
     getGlobalScope().clear();
@@ -1511,8 +1497,6 @@ describe('span hooks', () => {
 
 describe('suppressTracing', () => {
   beforeEach(() => {
-    addTracingExtensions();
-
     getCurrentScope().clear();
     getIsolationScope().clear();
     getGlobalScope().clear();
diff --git a/packages/core/test/lib/utils/spanUtils.test.ts b/packages/core/test/lib/utils/spanUtils.test.ts
index 9020a6e59229..2a4850947e80 100644
--- a/packages/core/test/lib/utils/spanUtils.test.ts
+++ b/packages/core/test/lib/utils/spanUtils.test.ts
@@ -7,7 +7,6 @@ import {
   SPAN_STATUS_OK,
   SPAN_STATUS_UNSET,
   SentrySpan,
-  addTracingExtensions,
   setCurrentClient,
   spanToTraceHeader,
   startInactiveSpan,
@@ -224,7 +223,6 @@ describe('getRootSpan', () => {
   beforeEach(() => {
     const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1 }));
     setCurrentClient(client);
-    addTracingExtensions();
   });
 
   it('returns the root span of a span that is a root span', () => {
diff --git a/packages/integration-shims/src/BrowserTracing.ts b/packages/integration-shims/src/BrowserTracing.ts
index 7fa357dffabf..cd6ed88060a6 100644
--- a/packages/integration-shims/src/BrowserTracing.ts
+++ b/packages/integration-shims/src/BrowserTracing.ts
@@ -16,8 +16,3 @@ export const browserTracingIntegrationShim = defineIntegration((_options?: unkno
     name: 'BrowserTracing',
   };
 });
-
-/** Shim function */
-export function addTracingExtensionsShim(): void {
-  // noop
-}
diff --git a/packages/integration-shims/src/index.ts b/packages/integration-shims/src/index.ts
index 457761f0778e..2d1186017d4e 100644
--- a/packages/integration-shims/src/index.ts
+++ b/packages/integration-shims/src/index.ts
@@ -4,7 +4,4 @@ export {
   feedbackScreenshotIntegrationShim,
 } from './Feedback';
 export { replayIntegrationShim } from './Replay';
-export {
-  browserTracingIntegrationShim,
-  addTracingExtensionsShim,
-} from './BrowserTracing';
+export { browserTracingIntegrationShim } from './BrowserTracing';
diff --git a/packages/nextjs/src/common/utils/edgeWrapperUtils.ts b/packages/nextjs/src/common/utils/edgeWrapperUtils.ts
index dc2f6628f18e..272889fa76db 100644
--- a/packages/nextjs/src/common/utils/edgeWrapperUtils.ts
+++ b/packages/nextjs/src/common/utils/edgeWrapperUtils.ts
@@ -2,7 +2,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_OK,
-  addTracingExtensions,
   captureException,
   continueTrace,
   getIsolationScope,
@@ -23,7 +22,6 @@ export function withEdgeWrapping<H extends EdgeRouteHandler>(
   options: { spanDescription: string; spanOp: string; mechanismFunctionName: string },
 ): (...params: Parameters<H>) => Promise<ReturnType<H>> {
   return async function (this: unknown, ...args) {
-    addTracingExtensions();
     const req: unknown = args[0];
 
     let sentryTrace;
diff --git a/packages/nextjs/src/common/withServerActionInstrumentation.ts b/packages/nextjs/src/common/withServerActionInstrumentation.ts
index a3e95575217a..83bdc9b7bbd3 100644
--- a/packages/nextjs/src/common/withServerActionInstrumentation.ts
+++ b/packages/nextjs/src/common/withServerActionInstrumentation.ts
@@ -1,12 +1,5 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SPAN_STATUS_ERROR, getIsolationScope } from '@sentry/core';
-import {
-  addTracingExtensions,
-  captureException,
-  continueTrace,
-  getClient,
-  handleCallbackErrors,
-  startSpan,
-} from '@sentry/core';
+import { captureException, continueTrace, getClient, handleCallbackErrors, startSpan } from '@sentry/core';
 import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from './debug-build';
@@ -57,7 +50,6 @@ async function withServerActionInstrumentationImplementation<A extends (...args:
   options: Options,
   callback: A,
 ): Promise<ReturnType<A>> {
-  addTracingExtensions();
   return withIsolationScopeOrReuseFromRootSpan(isolationScope => {
     const sendDefaultPii = getClient()?.getOptions().sendDefaultPii;
 
diff --git a/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts
index 1519667a7abd..37d0b83c7c5b 100644
--- a/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapApiHandlerWithSentry.ts
@@ -1,6 +1,5 @@
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  addTracingExtensions,
   captureException,
   continueTrace,
   setHttpStatus,
@@ -52,8 +51,6 @@ export function wrapApiHandlerWithSentry(apiHandler: NextApiHandler, parameteriz
       }
       req.__withSentry_applied__ = true;
 
-      addTracingExtensions();
-
       return withIsolationScopeOrReuseFromRootSpan(isolationScope => {
         return continueTrace(
           {
diff --git a/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts b/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts
index 83f5b4aded98..637f602b52ec 100644
--- a/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts
+++ b/packages/nextjs/src/common/wrapApiHandlerWithSentryVercelCrons.ts
@@ -1,4 +1,4 @@
-import { addTracingExtensions, captureCheckIn } from '@sentry/core';
+import { captureCheckIn } from '@sentry/core';
 import type { NextApiRequest } from 'next';
 
 import type { VercelCronsConfig } from './types';
@@ -25,7 +25,6 @@ export function wrapApiHandlerWithSentryVercelCrons<F extends (...args: any[]) =
           return originalFunction.apply(thisArg, args);
         }
 
-        addTracingExtensions();
         const [req] = args as [NextApiRequest | EdgeRequest];
 
         let maybePromiseResult;
diff --git a/packages/nextjs/src/common/wrapAppGetInitialPropsWithSentry.ts b/packages/nextjs/src/common/wrapAppGetInitialPropsWithSentry.ts
index 50bbd346fcd2..312e1b319fdb 100644
--- a/packages/nextjs/src/common/wrapAppGetInitialPropsWithSentry.ts
+++ b/packages/nextjs/src/common/wrapAppGetInitialPropsWithSentry.ts
@@ -1,10 +1,4 @@
-import {
-  addTracingExtensions,
-  getActiveSpan,
-  getDynamicSamplingContextFromSpan,
-  getRootSpan,
-  spanToTraceHeader,
-} from '@sentry/core';
+import { getActiveSpan, getDynamicSamplingContextFromSpan, getRootSpan, spanToTraceHeader } from '@sentry/core';
 import { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/utils';
 import type App from 'next/app';
 
@@ -28,8 +22,6 @@ export function wrapAppGetInitialPropsWithSentry(origAppGetInitialProps: AppGetI
         return wrappingTarget.apply(thisArg, args);
       }
 
-      addTracingExtensions();
-
       const [context] = args;
       const { req, res } = context.ctx;
 
diff --git a/packages/nextjs/src/common/wrapDocumentGetInitialPropsWithSentry.ts b/packages/nextjs/src/common/wrapDocumentGetInitialPropsWithSentry.ts
index 9c903a1fa795..162081accb05 100644
--- a/packages/nextjs/src/common/wrapDocumentGetInitialPropsWithSentry.ts
+++ b/packages/nextjs/src/common/wrapDocumentGetInitialPropsWithSentry.ts
@@ -1,4 +1,3 @@
-import { addTracingExtensions } from '@sentry/core';
 import type Document from 'next/document';
 
 import { isBuild } from './utils/isBuild';
@@ -23,8 +22,6 @@ export function wrapDocumentGetInitialPropsWithSentry(
         return wrappingTarget.apply(thisArg, args);
       }
 
-      addTracingExtensions();
-
       const [context] = args;
       const { req, res } = context;
 
diff --git a/packages/nextjs/src/common/wrapErrorGetInitialPropsWithSentry.ts b/packages/nextjs/src/common/wrapErrorGetInitialPropsWithSentry.ts
index aeeccd332213..71c8cf9806a5 100644
--- a/packages/nextjs/src/common/wrapErrorGetInitialPropsWithSentry.ts
+++ b/packages/nextjs/src/common/wrapErrorGetInitialPropsWithSentry.ts
@@ -1,10 +1,4 @@
-import {
-  addTracingExtensions,
-  getActiveSpan,
-  getDynamicSamplingContextFromSpan,
-  getRootSpan,
-  spanToTraceHeader,
-} from '@sentry/core';
+import { getActiveSpan, getDynamicSamplingContextFromSpan, getRootSpan, spanToTraceHeader } from '@sentry/core';
 import { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/utils';
 import type { NextPageContext } from 'next';
 import type { ErrorProps } from 'next/error';
@@ -31,8 +25,6 @@ export function wrapErrorGetInitialPropsWithSentry(
         return wrappingTarget.apply(thisArg, args);
       }
 
-      addTracingExtensions();
-
       const [context] = args;
       const { req, res } = context;
 
diff --git a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
index e6dd1072a16b..9931e856e12f 100644
--- a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
+++ b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
@@ -2,7 +2,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   SPAN_STATUS_OK,
-  addTracingExtensions,
   captureException,
   getClient,
   getCurrentScope,
@@ -26,7 +25,6 @@ export function wrapGenerationFunctionWithSentry<F extends (...args: any[]) => a
   generationFunction: F,
   context: GenerationFunctionContext,
 ): F {
-  addTracingExtensions();
   const { requestAsyncStorage, componentRoute, componentType, generationFunctionIdentifier } = context;
   return new Proxy(generationFunction, {
     apply: (originalFunction, thisArg, args) => {
diff --git a/packages/nextjs/src/common/wrapGetInitialPropsWithSentry.ts b/packages/nextjs/src/common/wrapGetInitialPropsWithSentry.ts
index c78ce497e394..0b5425417913 100644
--- a/packages/nextjs/src/common/wrapGetInitialPropsWithSentry.ts
+++ b/packages/nextjs/src/common/wrapGetInitialPropsWithSentry.ts
@@ -1,10 +1,4 @@
-import {
-  addTracingExtensions,
-  getActiveSpan,
-  getDynamicSamplingContextFromSpan,
-  getRootSpan,
-  spanToTraceHeader,
-} from '@sentry/core';
+import { getActiveSpan, getDynamicSamplingContextFromSpan, getRootSpan, spanToTraceHeader } from '@sentry/core';
 import { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/utils';
 import type { NextPage } from 'next';
 
@@ -27,8 +21,6 @@ export function wrapGetInitialPropsWithSentry(origGetInitialProps: GetInitialPro
         return wrappingTarget.apply(thisArg, args);
       }
 
-      addTracingExtensions();
-
       const [context] = args;
       const { req, res } = context;
 
diff --git a/packages/nextjs/src/common/wrapGetServerSidePropsWithSentry.ts b/packages/nextjs/src/common/wrapGetServerSidePropsWithSentry.ts
index 782bc523f935..d8a14b392462 100644
--- a/packages/nextjs/src/common/wrapGetServerSidePropsWithSentry.ts
+++ b/packages/nextjs/src/common/wrapGetServerSidePropsWithSentry.ts
@@ -1,10 +1,4 @@
-import {
-  addTracingExtensions,
-  getActiveSpan,
-  getDynamicSamplingContextFromSpan,
-  getRootSpan,
-  spanToTraceHeader,
-} from '@sentry/core';
+import { getActiveSpan, getDynamicSamplingContextFromSpan, getRootSpan, spanToTraceHeader } from '@sentry/core';
 import { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/utils';
 import type { GetServerSideProps } from 'next';
 
@@ -28,8 +22,6 @@ export function wrapGetServerSidePropsWithSentry(
         return wrappingTarget.apply(thisArg, args);
       }
 
-      addTracingExtensions();
-
       const [context] = args;
       const { req, res } = context;
 
diff --git a/packages/nextjs/src/common/wrapGetStaticPropsWithSentry.ts b/packages/nextjs/src/common/wrapGetStaticPropsWithSentry.ts
index 67ac97daac5c..a50c25ac616b 100644
--- a/packages/nextjs/src/common/wrapGetStaticPropsWithSentry.ts
+++ b/packages/nextjs/src/common/wrapGetStaticPropsWithSentry.ts
@@ -1,4 +1,3 @@
-import { addTracingExtensions } from '@sentry/core';
 import type { GetStaticProps } from 'next';
 
 import { isBuild } from './utils/isBuild';
@@ -23,8 +22,6 @@ export function wrapGetStaticPropsWithSentry(
         return wrappingTarget.apply(thisArg, args);
       }
 
-      addTracingExtensions();
-
       const errorWrappedGetStaticProps = withErrorInstrumentation(wrappingTarget);
       return callDataFetcherTraced(errorWrappedGetStaticProps, args, {
         parameterizedRoute,
diff --git a/packages/nextjs/src/common/wrapPageComponentWithSentry.ts b/packages/nextjs/src/common/wrapPageComponentWithSentry.ts
index b14b5cff2e07..b6ab022afb21 100644
--- a/packages/nextjs/src/common/wrapPageComponentWithSentry.ts
+++ b/packages/nextjs/src/common/wrapPageComponentWithSentry.ts
@@ -1,4 +1,4 @@
-import { addTracingExtensions, captureException, getCurrentScope } from '@sentry/core';
+import { captureException, getCurrentScope } from '@sentry/core';
 import { extractTraceparentData } from '@sentry/utils';
 import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
@@ -22,7 +22,6 @@ function isReactClassComponent(target: unknown): target is ClassComponent {
  * Wraps a page component with Sentry error instrumentation.
  */
 export function wrapPageComponentWithSentry(pageComponent: FunctionComponent | ClassComponent): unknown {
-  addTracingExtensions();
   if (isReactClassComponent(pageComponent)) {
     return class SentryWrappedPageComponent extends pageComponent {
       public render(...args: unknown[]): unknown {
diff --git a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
index e82b4a3b4bdd..06e969a737ce 100644
--- a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
@@ -3,7 +3,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
-  addTracingExtensions,
   captureException,
   getActiveSpan,
   getRootSpan,
@@ -61,8 +60,6 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
   routeHandler: F,
   context: RouteHandlerContext,
 ): (...args: Parameters<F>) => ReturnType<F> extends Promise<unknown> ? ReturnType<F> : Promise<ReturnType<F>> {
-  addTracingExtensions();
-
   const { method, parameterizedRoute, headers } = context;
 
   return new Proxy(routeHandler, {
diff --git a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
index 76521b71e0d1..a41cfd2fb052 100644
--- a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
+++ b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
@@ -2,7 +2,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   SPAN_STATUS_OK,
-  addTracingExtensions,
   captureException,
   getCurrentScope,
   handleCallbackErrors,
@@ -25,7 +24,6 @@ export function wrapServerComponentWithSentry<F extends (...args: any[]) => any>
   appDirComponent: F,
   context: ServerComponentContext,
 ): F {
-  addTracingExtensions();
   const { componentRoute, componentType } = context;
 
   // Even though users may define server components as async functions, for the client bundles
diff --git a/packages/nextjs/src/edge/index.ts b/packages/nextjs/src/edge/index.ts
index 7c4874d051ad..7034873f665e 100644
--- a/packages/nextjs/src/edge/index.ts
+++ b/packages/nextjs/src/edge/index.ts
@@ -1,4 +1,4 @@
-import { addTracingExtensions, applySdkMetadata } from '@sentry/core';
+import { applySdkMetadata, registerSpanErrorInstrumentation } from '@sentry/core';
 import { GLOBAL_OBJ } from '@sentry/utils';
 import type { VercelEdgeOptions } from '@sentry/vercel-edge';
 import { getDefaultIntegrations, init as vercelEdgeInit } from '@sentry/vercel-edge';
@@ -14,7 +14,7 @@ const globalWithInjectedValues = GLOBAL_OBJ as typeof GLOBAL_OBJ & {
 
 /** Inits the Sentry NextJS SDK on the Edge Runtime. */
 export function init(options: VercelEdgeOptions = {}): void {
-  addTracingExtensions();
+  registerSpanErrorInstrumentation();
 
   if (isBuild()) {
     return;
diff --git a/packages/nextjs/src/server/index.ts b/packages/nextjs/src/server/index.ts
index d961d6717e4c..7d8f9a7a7d94 100644
--- a/packages/nextjs/src/server/index.ts
+++ b/packages/nextjs/src/server/index.ts
@@ -1,4 +1,4 @@
-import { addEventProcessor, addTracingExtensions, applySdkMetadata, getClient } from '@sentry/core';
+import { addEventProcessor, applySdkMetadata, getClient } from '@sentry/core';
 import { getDefaultIntegrations, init as nodeInit } from '@sentry/node';
 import type { NodeOptions } from '@sentry/node';
 import { GLOBAL_OBJ, logger } from '@sentry/utils';
@@ -64,8 +64,6 @@ export function showReportDialog(): void {
 
 /** Inits the Sentry NextJS SDK on node. */
 export function init(options: NodeOptions): void {
-  addTracingExtensions();
-
   if (isBuild()) {
     return;
   }
diff --git a/packages/nextjs/test/config/withSentry.test.ts b/packages/nextjs/test/config/withSentry.test.ts
index 6de52dbc1989..7a29ab80afb7 100644
--- a/packages/nextjs/test/config/withSentry.test.ts
+++ b/packages/nextjs/test/config/withSentry.test.ts
@@ -1,14 +1,10 @@
 import * as SentryCore from '@sentry/core';
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, addTracingExtensions } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
 import type { NextApiRequest, NextApiResponse } from 'next';
 
 import type { AugmentedNextApiResponse, NextApiHandler } from '../../src/common/types';
 import { wrapApiHandlerWithSentry } from '../../src/server';
 
-// The wrap* functions require the hub to have tracing extensions. This is normally called by the NodeClient
-// constructor but the client isn't used in these tests.
-addTracingExtensions();
-
 const startSpanManualSpy = jest.spyOn(SentryCore, 'startSpanManual');
 
 describe('withSentry', () => {
diff --git a/packages/nextjs/test/config/wrappers.test.ts b/packages/nextjs/test/config/wrappers.test.ts
index 47162b638533..284737f4335d 100644
--- a/packages/nextjs/test/config/wrappers.test.ts
+++ b/packages/nextjs/test/config/wrappers.test.ts
@@ -1,16 +1,12 @@
 import type { IncomingMessage, ServerResponse } from 'http';
 import * as SentryCore from '@sentry/core';
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, addTracingExtensions } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
 
 import type { Client } from '@sentry/types';
 import { wrapGetInitialPropsWithSentry, wrapGetServerSidePropsWithSentry } from '../../src/common';
 
 const startSpanManualSpy = jest.spyOn(SentryCore, 'startSpanManual');
 
-// The wrap* functions require the hub to have tracing extensions. This is normally called by the NodeClient
-// constructor but the client isn't used in these tests.
-addTracingExtensions();
-
 describe('data-fetching function wrappers should create spans', () => {
   const route = '/tricks/[trickName]';
   let req: IncomingMessage;
diff --git a/packages/opentelemetry/test/propagator.test.ts b/packages/opentelemetry/test/propagator.test.ts
index 244b0aa93d2b..da9f2d30fc98 100644
--- a/packages/opentelemetry/test/propagator.test.ts
+++ b/packages/opentelemetry/test/propagator.test.ts
@@ -8,7 +8,7 @@ import {
   trace,
 } from '@opentelemetry/api';
 import { suppressTracing } from '@opentelemetry/core';
-import { addTracingExtensions, withScope } from '@sentry/core';
+import { withScope } from '@sentry/core';
 
 import { SENTRY_BAGGAGE_HEADER, SENTRY_SCOPES_CONTEXT_KEY, SENTRY_TRACE_HEADER } from '../src/constants';
 import { SentryPropagator, makeTraceState } from '../src/propagator';
@@ -16,10 +16,6 @@ import { getScopesFromContext } from '../src/utils/contextData';
 import { getSamplingDecision } from '../src/utils/getSamplingDecision';
 import { cleanupOtel, mockSdkInit } from './helpers/mockSdkInit';
 
-beforeAll(() => {
-  addTracingExtensions();
-});
-
 describe('SentryPropagator', () => {
   const propagator = new SentryPropagator();
   let carrier: { [key: string]: unknown };
diff --git a/packages/svelte/test/performance.test.ts b/packages/svelte/test/performance.test.ts
index 735a732f981a..53cf80d04d17 100644
--- a/packages/svelte/test/performance.test.ts
+++ b/packages/svelte/test/performance.test.ts
@@ -1,5 +1,5 @@
 import { act, render } from '@testing-library/svelte';
-import { addTracingExtensions, getClient, getCurrentScope, getIsolationScope, init, startSpan } from '../src';
+import { getClient, getCurrentScope, getIsolationScope, init, startSpan } from '../src';
 
 import type { TransactionEvent } from '@sentry/types';
 import { vi } from 'vitest';
@@ -19,8 +19,6 @@ describe('Sentry.trackComponent()', () => {
     getCurrentScope().clear();
     getIsolationScope().clear();
 
-    addTracingExtensions();
-
     const beforeSendTransaction = vi.fn(event => {
       transactions.push(event);
       return null;
diff --git a/packages/sveltekit/test/client/load.test.ts b/packages/sveltekit/test/client/load.test.ts
index 34d1606174de..087eada60b47 100644
--- a/packages/sveltekit/test/client/load.test.ts
+++ b/packages/sveltekit/test/client/load.test.ts
@@ -33,10 +33,6 @@ const MOCK_LOAD_ARGS: any = {
   url: new URL('http://localhost:3000/users/123'),
 };
 
-beforeAll(() => {
-  SentrySvelte.addTracingExtensions();
-});
-
 describe('wrapLoadWithSentry', () => {
   beforeEach(() => {
     mockCaptureException.mockClear();
diff --git a/packages/sveltekit/test/server/handle.test.ts b/packages/sveltekit/test/server/handle.test.ts
index 2c3d1a9333f1..e029a118b411 100644
--- a/packages/sveltekit/test/server/handle.test.ts
+++ b/packages/sveltekit/test/server/handle.test.ts
@@ -1,6 +1,5 @@
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  addTracingExtensions,
   getRootSpan,
   getSpanDescendants,
   spanIsSampled,
@@ -90,10 +89,6 @@ function resolve(
 
 let client: NodeClient;
 
-beforeAll(() => {
-  addTracingExtensions();
-});
-
 beforeEach(() => {
   const options = getDefaultNodeClientOptions({ tracesSampleRate: 1.0 });
   client = new NodeClient(options);
diff --git a/packages/sveltekit/test/server/load.test.ts b/packages/sveltekit/test/server/load.test.ts
index 699fcf034232..28e7fc342308 100644
--- a/packages/sveltekit/test/server/load.test.ts
+++ b/packages/sveltekit/test/server/load.test.ts
@@ -2,7 +2,6 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  addTracingExtensions,
 } from '@sentry/core';
 import { NodeClient, getCurrentScope, getIsolationScope, setCurrentClient } from '@sentry/node';
 import * as SentryNode from '@sentry/node';
@@ -76,10 +75,6 @@ function getServerOnlyArgs() {
   };
 }
 
-beforeAll(() => {
-  addTracingExtensions();
-});
-
 afterEach(() => {
   mockCaptureException.mockClear();
   mockStartSpan.mockClear();

From a1f3a11d9be9afbf1f4e4151469cec36eaa04b55 Mon Sep 17 00:00:00 2001
From: Tim Fish <tim@timfish.uk>
Date: Fri, 12 Apr 2024 16:22:25 +0200
Subject: [PATCH 55/64] fix(node): Send ANR events without scope if event loop
 blocked indefinitely (#11578)

When experimenting for #11525 I found that `Runtime.evaluate` only
returns when the event loop becomes unblocked. This means that we are
not sending ANR events if the event loop is blocked indefinitely.

This PR adds a timeout that sends the ANR event if we have not been able
to evaluate the scope within 5 seconds.
---
 .../suites/anr/indefinite.mjs                 | 31 ++++++++++++++
 .../node-integration-tests/suites/anr/test.ts | 40 +++++++++++--------
 packages/node/src/integrations/anr/worker.ts  | 10 +++++
 3 files changed, 65 insertions(+), 16 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/anr/indefinite.mjs

diff --git a/dev-packages/node-integration-tests/suites/anr/indefinite.mjs b/dev-packages/node-integration-tests/suites/anr/indefinite.mjs
new file mode 100644
index 000000000000..d37f041b8c23
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/anr/indefinite.mjs
@@ -0,0 +1,31 @@
+import * as assert from 'assert';
+import * as crypto from 'crypto';
+
+import * as Sentry from '@sentry/node';
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  autoSessionTracking: false,
+  integrations: [Sentry.anrIntegration({ captureStackTrace: true, anrThreshold: 100 })],
+});
+
+Sentry.setUser({ email: 'person@home.com' });
+Sentry.addBreadcrumb({ message: 'important message!' });
+
+function longWork() {
+  // This loop will run almost indefinitely
+  for (let i = 0; i < 2000000000; i++) {
+    const salt = crypto.randomBytes(128).toString('base64');
+    const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');
+    assert.ok(hash);
+  }
+}
+
+setTimeout(() => {
+  longWork();
+}, 1000);
diff --git a/dev-packages/node-integration-tests/suites/anr/test.ts b/dev-packages/node-integration-tests/suites/anr/test.ts
index 6af5d46bfb50..fcd9f121ed34 100644
--- a/dev-packages/node-integration-tests/suites/anr/test.ts
+++ b/dev-packages/node-integration-tests/suites/anr/test.ts
@@ -1,7 +1,7 @@
 import { conditionalTest } from '../../utils';
 import { cleanupChildProcesses, createRunner } from '../../utils/runner';
 
-const EXPECTED_ANR_EVENT = {
+const ANR_EVENT = {
   // Ensure we have context
   contexts: {
     trace: {
@@ -21,15 +21,6 @@ const EXPECTED_ANR_EVENT = {
       timezone: expect.any(String),
     },
   },
-  user: {
-    email: 'person@home.com',
-  },
-  breadcrumbs: [
-    {
-      timestamp: expect.any(Number),
-      message: 'important message!',
-    },
-  ],
   // and an exception that is our ANR
   exception: {
     values: [
@@ -60,24 +51,41 @@ const EXPECTED_ANR_EVENT = {
   },
 };
 
+const ANR_EVENT_WITH_SCOPE = {
+  ...ANR_EVENT,
+  user: {
+    email: 'person@home.com',
+  },
+  breadcrumbs: [
+    {
+      timestamp: expect.any(Number),
+      message: 'important message!',
+    },
+  ],
+};
+
 conditionalTest({ min: 16 })('should report ANR when event loop blocked', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
 
   test('CJS', done => {
-    createRunner(__dirname, 'basic.js').withMockSentryServer().expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'basic.js').withMockSentryServer().expect({ event: ANR_EVENT_WITH_SCOPE }).start(done);
   });
 
   test('ESM', done => {
-    createRunner(__dirname, 'basic.mjs').withMockSentryServer().expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'basic.mjs').withMockSentryServer().expect({ event: ANR_EVENT_WITH_SCOPE }).start(done);
+  });
+
+  test('blocked indefinitely', done => {
+    createRunner(__dirname, 'indefinite.mjs').withMockSentryServer().expect({ event: ANR_EVENT }).start(done);
   });
 
   test('With --inspect', done => {
     createRunner(__dirname, 'basic.mjs')
       .withMockSentryServer()
       .withFlags('--inspect')
-      .expect({ event: EXPECTED_ANR_EVENT })
+      .expect({ event: ANR_EVENT_WITH_SCOPE })
       .start(done);
   });
 
@@ -108,16 +116,16 @@ conditionalTest({ min: 16 })('should report ANR when event loop blocked', () =>
           abnormal_mechanism: 'anr_foreground',
         },
       })
-      .expect({ event: EXPECTED_ANR_EVENT })
+      .expect({ event: ANR_EVENT_WITH_SCOPE })
       .start(done);
   });
 
   test('from forked process', done => {
-    createRunner(__dirname, 'forker.js').expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'forker.js').expect({ event: ANR_EVENT_WITH_SCOPE }).start(done);
   });
 
   test('worker can be stopped and restarted', done => {
-    createRunner(__dirname, 'stop-and-start.js').expect({ event: EXPECTED_ANR_EVENT }).start(done);
+    createRunner(__dirname, 'stop-and-start.js').expect({ event: ANR_EVENT_WITH_SCOPE }).start(done);
   });
 
   const EXPECTED_ISOLATED_EVENT = {
diff --git a/packages/node/src/integrations/anr/worker.ts b/packages/node/src/integrations/anr/worker.ts
index 21bdcbbb0631..6acbbe507b01 100644
--- a/packages/node/src/integrations/anr/worker.ts
+++ b/packages/node/src/integrations/anr/worker.ts
@@ -187,6 +187,14 @@ if (options.captureStackTrace) {
         callFrameToStackFrame(frame, scripts.get(frame.location.scriptId), getModuleName),
       );
 
+      // Runtime.evaluate may never return if the event loop is blocked indefinitely
+      // In that case, we want to send the event anyway
+      const getScopeTimeout = setTimeout(() => {
+        sendAnrEvent(stackFrames).then(null, () => {
+          log('Sending ANR event failed.');
+        });
+      }, 5_000);
+
       // Evaluate a script in the currently paused context
       session.post(
         'Runtime.evaluate',
@@ -203,6 +211,8 @@ if (options.captureStackTrace) {
             log(`Error executing script: '${err.message}'`);
           }
 
+          clearTimeout(getScopeTimeout);
+
           const scopes = param && param.result ? (param.result.value as ScopeData) : undefined;
 
           session.post('Debugger.resume');

From 478f80568db48db982c133399a265e4f8461ee68 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 09:53:36 +0200
Subject: [PATCH 56/64] fix(browser): Ensure tracing without performance (TWP)
 works (#11561)

This also forward-ports the tests from
https://github.com/getsentry/sentry-javascript/pull/11555, and adds some
more tests.

Node is a different story, will tackle it separately.
---
 .../tracing/request/fetch-no-tracing/init.js  |  8 ++
 .../request/fetch-no-tracing/subject.js       |  5 ++
 .../tracing/request/fetch-no-tracing/test.ts  | 30 ++++++++
 .../request/fetch-tracing-unsampled/init.js   | 10 +++
 .../fetch-tracing-unsampled/subject.js        |  5 ++
 .../request/fetch-tracing-unsampled/test.ts   | 43 +++++++++++
 .../fetch-tracing-without-performance/init.js | 10 +++
 .../subject.js                                |  5 ++
 .../fetch-tracing-without-performance/test.ts | 46 ++++++++++++
 .../request/fetch-with-no-active-span/init.js | 16 +++-
 .../request/fetch-with-no-active-span/test.ts | 48 ++++++------
 .../suites/tracing/request/fetch/subject.js   |  6 +-
 .../suites/tracing/request/fetch/test.ts      | 31 ++++++--
 .../tracing/request/xhr-no-tracing/init.js    |  8 ++
 .../tracing/request/xhr-no-tracing/subject.js | 12 +++
 .../tracing/request/xhr-no-tracing/test.ts    | 30 ++++++++
 .../request/xhr-tracing-unsampled/init.js     | 10 +++
 .../request/xhr-tracing-unsampled/subject.js  | 12 +++
 .../request/xhr-tracing-unsampled/test.ts     | 43 +++++++++++
 .../xhr-tracing-without-performance/init.js   |  9 +++
 .../subject.js                                | 12 +++
 .../xhr-tracing-without-performance/test.ts   | 46 ++++++++++++
 .../request/xhr-with-no-active-span/init.js   | 16 +++-
 .../request/xhr-with-no-active-span/test.ts   | 48 ++++++------
 .../suites/tracing/request/xhr/subject.js     |  1 +
 .../suites/tracing/request/xhr/test.ts        | 31 ++++++--
 packages/browser/src/tracing/request.ts       | 75 +++++++++++--------
 packages/core/src/fetch.ts                    | 46 +++++++-----
 packages/core/src/tracing/trace.ts            |  2 +-
 .../vercel-edge/test/wintercg-fetch.test.ts   |  7 +-
 30 files changed, 559 insertions(+), 112 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/test.ts

diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js
new file mode 100644
index 000000000000..5cfae0864821
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js
@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracePropagationTargets: ['http://example.com'],
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/subject.js
new file mode 100644
index 000000000000..eef6d917a2d8
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/subject.js
@@ -0,0 +1,5 @@
+fetch('http://example.com/0').then(
+  fetch('http://example.com/1', { headers: { 'X-Test-Header': 'existing-header' } }).then(
+    fetch('http://example.com/2'),
+  ),
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/test.ts
new file mode 100644
index 000000000000..95c7b3052732
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/test.ts
@@ -0,0 +1,30 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should not attach `sentry-trace` header to fetch requests without tracing',
+  async ({ getLocalTestPath, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const requests = (
+      await Promise.all([
+        page.goto(url),
+        Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))),
+      ])
+    )[1];
+
+    expect(requests).toHaveLength(3);
+
+    for (const request of requests) {
+      const requestHeaders = request.headers();
+      expect(requestHeaders['sentry-trace']).toBeUndefined();
+      expect(requestHeaders['baggage']).toBeUndefined();
+    }
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js
new file mode 100644
index 000000000000..203a32557f21
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://example.com'],
+  tracesSampleRate: 0,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/subject.js
new file mode 100644
index 000000000000..eef6d917a2d8
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/subject.js
@@ -0,0 +1,5 @@
+fetch('http://example.com/0').then(
+  fetch('http://example.com/1', { headers: { 'X-Test-Header': 'existing-header' } }).then(
+    fetch('http://example.com/2'),
+  ),
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/test.ts
new file mode 100644
index 000000000000..44911665af7c
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/test.ts
@@ -0,0 +1,43 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should attach `sentry-trace` header to unsampled fetch requests', async ({ getLocalTestPath, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const requests = (
+    await Promise.all([
+      page.goto(url),
+      Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))),
+    ])
+  )[1];
+
+  expect(requests).toHaveLength(3);
+
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/),
+    baggage: expect.any(String),
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js
new file mode 100644
index 000000000000..89854ab72450
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://example.com'],
+  // no tracesSampleRate defined means TWP mode
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/subject.js
new file mode 100644
index 000000000000..eef6d917a2d8
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/subject.js
@@ -0,0 +1,5 @@
+fetch('http://example.com/0').then(
+  fetch('http://example.com/1', { headers: { 'X-Test-Header': 'existing-header' } }).then(
+    fetch('http://example.com/2'),
+  ),
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/test.ts
new file mode 100644
index 000000000000..8c5c626731df
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/test.ts
@@ -0,0 +1,46 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should attach `sentry-trace` header to tracing without performance (TWP) fetch requests',
+  async ({ getLocalTestPath, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const requests = (
+      await Promise.all([
+        page.goto(url),
+        Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))),
+      ])
+    )[1];
+
+    expect(requests).toHaveLength(3);
+
+    const request1 = requests[0];
+    const requestHeaders1 = request1.headers();
+    expect(requestHeaders1).toMatchObject({
+      'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      baggage: expect.any(String),
+    });
+
+    const request2 = requests[1];
+    const requestHeaders2 = request2.headers();
+    expect(requestHeaders2).toMatchObject({
+      'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      baggage: expect.any(String),
+      'x-test-header': 'existing-header',
+    });
+
+    const request3 = requests[2];
+    const requestHeaders3 = request3.headers();
+    expect(requestHeaders3).toMatchObject({
+      'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      baggage: expect.any(String),
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/init.js
index a8d8c03d1f25..e94191654e74 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/init.js
@@ -2,10 +2,22 @@ import * as Sentry from '@sentry/browser';
 
 window.Sentry = Sentry;
 
+window._sentryTransactionsCount = 0;
+
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  // disable pageload transaction
-  integrations: [Sentry.browserTracingIntegration({ instrumentPageLoad: false })],
+  // disable auto span creation
+  integrations: [
+    Sentry.browserTracingIntegration({
+      instrumentPageLoad: false,
+      instrumentNavigation: false,
+    }),
+  ],
   tracePropagationTargets: ['http://example.com'],
   tracesSampleRate: 1,
+  autoSessionTracking: false,
+  beforeSendTransaction() {
+    window._sentryTransactionsCount++;
+    return null;
+  },
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/test.ts
index 4dc5a0ac4e0a..acaf0e98d693 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-no-active-span/test.ts
@@ -1,35 +1,41 @@
 import { expect } from '@playwright/test';
 
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeUrlRegex, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
 
 sentryTest(
-  'there should be no span created for fetch requests with no active span',
-  async ({ getLocalTestPath, page }) => {
+  'should not create span for fetch requests with no active span but should attach sentry-trace header',
+  async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
     }
 
-    const url = await getLocalTestPath({ testDir: __dirname });
+    const sentryTraceHeaders: string[] = [];
 
-    let requestCount = 0;
-    page.on('request', request => {
-      expect(envelopeUrlRegex.test(request.url())).toBe(false);
-      requestCount++;
+    await page.route('http://example.com/**', route => {
+      const sentryTraceHeader = route.request().headers()['sentry-trace'];
+      if (sentryTraceHeader) {
+        sentryTraceHeaders.push(sentryTraceHeader);
+      }
+
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
     });
 
-    await page.goto(url);
-
-    // Here are the requests that should exist:
-    // 1. HTML page
-    // 2. Init JS bundle
-    // 3. Subject JS bundle
-    // 4 [OPTIONAl] CDN JS bundle
-    // and then 3 fetch requests
-    if (process.env.PW_BUNDLE && process.env.PW_BUNDLE.startsWith('bundle_')) {
-      expect(requestCount).toBe(7);
-    } else {
-      expect(requestCount).toBe(6);
-    }
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await Promise.all([page.goto(url), ...[0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))]);
+
+    expect(await page.evaluate('window._sentryTransactionsCount')).toBe(0);
+
+    expect(sentryTraceHeaders).toHaveLength(3);
+    expect(sentryTraceHeaders).toEqual([
+      expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+    ]);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/subject.js
index f62499b1e9c5..eef6d917a2d8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/subject.js
@@ -1 +1,5 @@
-fetch('http://example.com/0').then(fetch('http://example.com/1').then(fetch('http://example.com/2')));
+fetch('http://example.com/0').then(
+  fetch('http://example.com/1', { headers: { 'X-Test-Header': 'existing-header' } }).then(
+    fetch('http://example.com/2'),
+  ),
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts
index 4308491f2d7f..00cf0baafc6a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts
@@ -4,7 +4,7 @@ import type { Event } from '@sentry/types';
 import { sentryTest } from '../../../../utils/fixtures';
 import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
 
-sentryTest('should create spans for multiple fetch requests', async ({ getLocalTestPath, page }) => {
+sentryTest('should create spans for fetch requests', async ({ getLocalTestPath, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
@@ -40,7 +40,7 @@ sentryTest('should create spans for multiple fetch requests', async ({ getLocalT
   );
 });
 
-sentryTest('should attach `sentry-trace` header to multiple fetch requests', async ({ getLocalTestPath, page }) => {
+sentryTest('should attach `sentry-trace` header to fetch requests', async ({ getLocalTestPath, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
@@ -56,10 +56,25 @@ sentryTest('should attach `sentry-trace` header to multiple fetch requests', asy
 
   expect(requests).toHaveLength(3);
 
-  for (const request of requests) {
-    const requestHeaders = request.headers();
-    expect(requestHeaders).toMatchObject({
-      'sentry-trace': expect.any(String),
-    });
-  }
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/),
+    baggage: expect.any(String),
+  });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js
new file mode 100644
index 000000000000..5cfae0864821
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js
@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracePropagationTargets: ['http://example.com'],
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/subject.js
new file mode 100644
index 000000000000..cb5f05dad5c1
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/subject.js
@@ -0,0 +1,12 @@
+const xhr_1 = new XMLHttpRequest();
+xhr_1.open('GET', 'http://example.com/0');
+xhr_1.send();
+
+const xhr_2 = new XMLHttpRequest();
+xhr_2.open('GET', 'http://example.com/1');
+xhr_2.setRequestHeader('X-Test-Header', 'existing-header');
+xhr_2.send();
+
+const xhr_3 = new XMLHttpRequest();
+xhr_3.open('GET', 'http://example.com/2');
+xhr_3.send();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/test.ts
new file mode 100644
index 000000000000..95c7b3052732
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/test.ts
@@ -0,0 +1,30 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should not attach `sentry-trace` header to fetch requests without tracing',
+  async ({ getLocalTestPath, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const requests = (
+      await Promise.all([
+        page.goto(url),
+        Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))),
+      ])
+    )[1];
+
+    expect(requests).toHaveLength(3);
+
+    for (const request of requests) {
+      const requestHeaders = request.headers();
+      expect(requestHeaders['sentry-trace']).toBeUndefined();
+      expect(requestHeaders['baggage']).toBeUndefined();
+    }
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js
new file mode 100644
index 000000000000..203a32557f21
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://example.com'],
+  tracesSampleRate: 0,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/subject.js
new file mode 100644
index 000000000000..cb5f05dad5c1
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/subject.js
@@ -0,0 +1,12 @@
+const xhr_1 = new XMLHttpRequest();
+xhr_1.open('GET', 'http://example.com/0');
+xhr_1.send();
+
+const xhr_2 = new XMLHttpRequest();
+xhr_2.open('GET', 'http://example.com/1');
+xhr_2.setRequestHeader('X-Test-Header', 'existing-header');
+xhr_2.send();
+
+const xhr_3 = new XMLHttpRequest();
+xhr_3.open('GET', 'http://example.com/2');
+xhr_3.send();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/test.ts
new file mode 100644
index 000000000000..954628873383
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/test.ts
@@ -0,0 +1,43 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should attach `sentry-trace` header to unsampled xhr requests', async ({ getLocalTestPath, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const requests = (
+    await Promise.all([
+      page.goto(url),
+      Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))),
+    ])
+  )[1];
+
+  expect(requests).toHaveLength(3);
+
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/),
+    baggage: expect.any(String),
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js
new file mode 100644
index 000000000000..e7db5efdc388
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://example.com'],
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/subject.js
new file mode 100644
index 000000000000..cb5f05dad5c1
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/subject.js
@@ -0,0 +1,12 @@
+const xhr_1 = new XMLHttpRequest();
+xhr_1.open('GET', 'http://example.com/0');
+xhr_1.send();
+
+const xhr_2 = new XMLHttpRequest();
+xhr_2.open('GET', 'http://example.com/1');
+xhr_2.setRequestHeader('X-Test-Header', 'existing-header');
+xhr_2.send();
+
+const xhr_3 = new XMLHttpRequest();
+xhr_3.open('GET', 'http://example.com/2');
+xhr_3.send();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/test.ts
new file mode 100644
index 000000000000..2e1a8ee36277
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/test.ts
@@ -0,0 +1,46 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should attach `sentry-trace` header to tracing without performance (TWP) xhr requests',
+  async ({ getLocalTestPath, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const requests = (
+      await Promise.all([
+        page.goto(url),
+        Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))),
+      ])
+    )[1];
+
+    expect(requests).toHaveLength(3);
+
+    const request1 = requests[0];
+    const requestHeaders1 = request1.headers();
+    expect(requestHeaders1).toMatchObject({
+      'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      baggage: expect.any(String),
+    });
+
+    const request2 = requests[1];
+    const requestHeaders2 = request2.headers();
+    expect(requestHeaders2).toMatchObject({
+      'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      baggage: expect.any(String),
+      'x-test-header': 'existing-header',
+    });
+
+    const request3 = requests[2];
+    const requestHeaders3 = request3.headers();
+    expect(requestHeaders3).toMatchObject({
+      'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      baggage: expect.any(String),
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/init.js
index a8d8c03d1f25..e94191654e74 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/init.js
@@ -2,10 +2,22 @@ import * as Sentry from '@sentry/browser';
 
 window.Sentry = Sentry;
 
+window._sentryTransactionsCount = 0;
+
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  // disable pageload transaction
-  integrations: [Sentry.browserTracingIntegration({ instrumentPageLoad: false })],
+  // disable auto span creation
+  integrations: [
+    Sentry.browserTracingIntegration({
+      instrumentPageLoad: false,
+      instrumentNavigation: false,
+    }),
+  ],
   tracePropagationTargets: ['http://example.com'],
   tracesSampleRate: 1,
+  autoSessionTracking: false,
+  beforeSendTransaction() {
+    window._sentryTransactionsCount++;
+    return null;
+  },
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/test.ts
index 19c1f5891a39..d3c5f91362c9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-no-active-span/test.ts
@@ -1,35 +1,41 @@
 import { expect } from '@playwright/test';
 
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeUrlRegex, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
 
 sentryTest(
-  'there should be no span created for xhr requests with no active span',
-  async ({ getLocalTestPath, page }) => {
+  'should not create span for xhr requests with no active span but should attach sentry-trace header',
+  async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
     }
 
-    const url = await getLocalTestPath({ testDir: __dirname });
+    const sentryTraceHeaders: string[] = [];
 
-    let requestCount = 0;
-    page.on('request', request => {
-      expect(envelopeUrlRegex.test(request.url())).toBe(false);
-      requestCount++;
+    await page.route('http://example.com/**', route => {
+      const sentryTraceHeader = route.request().headers()['sentry-trace'];
+      if (sentryTraceHeader) {
+        sentryTraceHeaders.push(sentryTraceHeader);
+      }
+
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
     });
 
-    await page.goto(url);
-
-    // Here are the requests that should exist:
-    // 1. HTML page
-    // 2. Init JS bundle
-    // 3. Subject JS bundle
-    // 4 [OPTIONAl] CDN JS bundle
-    // and then 3 fetch requests
-    if (process.env.PW_BUNDLE && process.env.PW_BUNDLE.startsWith('bundle_')) {
-      expect(requestCount).toBe(7);
-    } else {
-      expect(requestCount).toBe(6);
-    }
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await Promise.all([page.goto(url), ...[0, 1, 2].map(idx => page.waitForRequest(`http://example.com/${idx}`))]);
+
+    expect(await page.evaluate('window._sentryTransactionsCount')).toBe(0);
+
+    expect(sentryTraceHeaders).toHaveLength(3);
+    expect(sentryTraceHeaders).toEqual([
+      expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+      expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/),
+    ]);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/subject.js
index 5790c230aa66..cb5f05dad5c1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/subject.js
@@ -4,6 +4,7 @@ xhr_1.send();
 
 const xhr_2 = new XMLHttpRequest();
 xhr_2.open('GET', 'http://example.com/1');
+xhr_2.setRequestHeader('X-Test-Header', 'existing-header');
 xhr_2.send();
 
 const xhr_3 = new XMLHttpRequest();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts
index 3d329c9c5c6d..13646a34826e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts
@@ -4,7 +4,7 @@ import type { Event } from '@sentry/types';
 import { sentryTest } from '../../../../utils/fixtures';
 import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
 
-sentryTest('should create spans for multiple XHR requests', async ({ getLocalTestPath, page }) => {
+sentryTest('should create spans for XHR requests', async ({ getLocalTestPath, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
@@ -28,7 +28,7 @@ sentryTest('should create spans for multiple XHR requests', async ({ getLocalTes
   );
 });
 
-sentryTest('should attach `sentry-trace` header to multiple XHR requests', async ({ getLocalTestPath, page }) => {
+sentryTest('should attach `sentry-trace` header to XHR requests', async ({ getLocalTestPath, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
@@ -44,10 +44,25 @@ sentryTest('should attach `sentry-trace` header to multiple XHR requests', async
 
   expect(requests).toHaveLength(3);
 
-  for (const request of requests) {
-    const requestHeaders = request.headers();
-    expect(requestHeaders).toMatchObject({
-      'sentry-trace': expect.any(String),
-    });
-  }
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/),
+    baggage: expect.any(String),
+  });
 });
diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts
index 374dc4feaf13..2c013fe27232 100644
--- a/packages/browser/src/tracing/request.ts
+++ b/packages/browser/src/tracing/request.ts
@@ -6,6 +6,7 @@ import {
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SentryNonRecordingSpan,
+  getActiveSpan,
   getClient,
   getCurrentScope,
   getDynamicSamplingContextFromClient,
@@ -18,7 +19,7 @@ import {
   spanToTraceHeader,
   startInactiveSpan,
 } from '@sentry/core';
-import type { HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/types';
+import type { Client, HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/types';
 import {
   BAGGAGE_HEADER_NAME,
   addFetchInstrumentationHandler,
@@ -285,11 +286,11 @@ export function xhrCallback(
   const xhr = handlerData.xhr;
   const sentryXhrData = xhr && xhr[SENTRY_XHR_DATA_KEY];
 
-  if (!hasTracingEnabled() || !xhr || xhr.__sentry_own_request__ || !sentryXhrData) {
+  if (!xhr || xhr.__sentry_own_request__ || !sentryXhrData) {
     return undefined;
   }
 
-  const shouldCreateSpanResult = shouldCreateSpan(sentryXhrData.url);
+  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(sentryXhrData.url);
 
   // check first if the request has finished and is tracked by an existing span which should now end
   if (handlerData.endTimestamp && shouldCreateSpanResult) {
@@ -307,22 +308,21 @@ export function xhrCallback(
     return undefined;
   }
 
-  const scope = getCurrentScope();
-  const isolationScope = getIsolationScope();
-
-  const span = shouldCreateSpanResult
-    ? startInactiveSpan({
-        name: `${sentryXhrData.method} ${sentryXhrData.url}`,
-        onlyIfParent: true,
-        attributes: {
-          type: 'xhr',
-          'http.method': sentryXhrData.method,
-          url: sentryXhrData.url,
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser',
-        },
-        op: 'http.client',
-      })
-    : new SentryNonRecordingSpan();
+  const hasParent = !!getActiveSpan();
+
+  const span =
+    shouldCreateSpanResult && hasParent
+      ? startInactiveSpan({
+          name: `${sentryXhrData.method} ${sentryXhrData.url}`,
+          attributes: {
+            type: 'xhr',
+            'http.method': sentryXhrData.method,
+            url: sentryXhrData.url,
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser',
+          },
+          op: 'http.client',
+        })
+      : new SentryNonRecordingSpan();
 
   xhr.__sentry_xhr_span_id__ = span.spanContext().spanId;
   spans[xhr.__sentry_xhr_span_id__] = span;
@@ -330,23 +330,38 @@ export function xhrCallback(
   const client = getClient();
 
   if (xhr.setRequestHeader && shouldAttachHeaders(sentryXhrData.url) && client) {
-    const { traceId, spanId, sampled, dsc } = {
-      ...isolationScope.getPropagationContext(),
-      ...scope.getPropagationContext(),
-    };
-
-    const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
-
-    const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
-      dsc || (span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromClient(traceId, client)),
+    addTracingHeadersToXhrRequest(
+      xhr,
+      client,
+      // In the following cases, we do not want to use the span as base for the trace headers,
+      // which means that the headers will be generated from the scope:
+      // - If tracing is disabled (TWP)
+      // - If the span has no parent span - which means we ran into `onlyIfParent` check
+      hasTracingEnabled() && hasParent ? span : undefined,
     );
-
-    setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);
   }
 
   return span;
 }
 
+function addTracingHeadersToXhrRequest(xhr: SentryWrappedXMLHttpRequest, client: Client, span?: Span): void {
+  const scope = getCurrentScope();
+  const isolationScope = getIsolationScope();
+  const { traceId, spanId, sampled, dsc } = {
+    ...isolationScope.getPropagationContext(),
+    ...scope.getPropagationContext(),
+  };
+
+  const sentryTraceHeader =
+    span && hasTracingEnabled() ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
+
+  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
+    dsc || (span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromClient(traceId, client)),
+  );
+
+  setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);
+}
+
 function setHeaderOnXhr(
   xhr: SentryWrappedXMLHttpRequest,
   sentryTraceHeader: string,
diff --git a/packages/core/src/fetch.ts b/packages/core/src/fetch.ts
index 8002d9280297..f9069b6b6efa 100644
--- a/packages/core/src/fetch.ts
+++ b/packages/core/src/fetch.ts
@@ -16,7 +16,7 @@ import {
 } from './tracing';
 import { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan';
 import { hasTracingEnabled } from './utils/hasTracingEnabled';
-import { spanToTraceHeader } from './utils/spanUtils';
+import { getActiveSpan, spanToTraceHeader } from './utils/spanUtils';
 
 type PolymorphicRequestHeaders =
   | Record<string, string | undefined>
@@ -41,11 +41,11 @@ export function instrumentFetchRequest(
   spans: Record<string, Span>,
   spanOrigin: SpanOrigin = 'auto.http.browser',
 ): Span | undefined {
-  if (!hasTracingEnabled() || !handlerData.fetchData) {
+  if (!handlerData.fetchData) {
     return undefined;
   }
 
-  const shouldCreateSpanResult = shouldCreateSpan(handlerData.fetchData.url);
+  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(handlerData.fetchData.url);
 
   if (handlerData.endTimestamp && shouldCreateSpanResult) {
     const spanId = handlerData.fetchData.__span;
@@ -81,19 +81,21 @@ export function instrumentFetchRequest(
 
   const { method, url } = handlerData.fetchData;
 
-  const span = shouldCreateSpanResult
-    ? startInactiveSpan({
-        name: `${method} ${url}`,
-        onlyIfParent: true,
-        attributes: {
-          url,
-          type: 'fetch',
-          'http.method': method,
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanOrigin,
-        },
-        op: 'http.client',
-      })
-    : new SentryNonRecordingSpan();
+  const hasParent = !!getActiveSpan();
+
+  const span =
+    shouldCreateSpanResult && hasParent
+      ? startInactiveSpan({
+          name: `${method} ${url}`,
+          attributes: {
+            url,
+            type: 'fetch',
+            'http.method': method,
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanOrigin,
+          },
+          op: 'http.client',
+        })
+      : new SentryNonRecordingSpan();
 
   handlerData.fetchData.__span = span.spanContext().spanId;
   spans[span.spanContext().spanId] = span;
@@ -107,7 +109,17 @@ export function instrumentFetchRequest(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const options: { [key: string]: any } = handlerData.args[1];
 
-    options.headers = addTracingHeadersToFetchRequest(request, client, scope, options, span);
+    options.headers = addTracingHeadersToFetchRequest(
+      request,
+      client,
+      scope,
+      options,
+      // In the following cases, we do not want to use the span as base for the trace headers,
+      // which means that the headers will be generated from the scope:
+      // - If tracing is disabled (TWP)
+      // - If the span has no parent span - which means we ran into `onlyIfParent` check
+      hasTracingEnabled() && hasParent ? span : undefined,
+    );
   }
 
   return span;
diff --git a/packages/core/src/tracing/trace.ts b/packages/core/src/tracing/trace.ts
index 4b6fe024fd88..791cae88a573 100644
--- a/packages/core/src/tracing/trace.ts
+++ b/packages/core/src/tracing/trace.ts
@@ -357,7 +357,7 @@ function _startChildSpan(parentSpan: Span, scope: Scope, spanArguments: SentrySp
         traceId,
         sampled,
       })
-    : new SentryNonRecordingSpan();
+    : new SentryNonRecordingSpan({ traceId });
 
   addChildSpanToSpan(parentSpan, childSpan);
 
diff --git a/packages/vercel-edge/test/wintercg-fetch.test.ts b/packages/vercel-edge/test/wintercg-fetch.test.ts
index bdcb9bedd36f..79678046d02d 100644
--- a/packages/vercel-edge/test/wintercg-fetch.test.ts
+++ b/packages/vercel-edge/test/wintercg-fetch.test.ts
@@ -165,7 +165,12 @@ describe('WinterCGFetch instrumentation', () => {
     expect(addBreadcrumbSpy).toBeCalledWith(
       {
         category: 'fetch',
-        data: { method: 'POST', status_code: 201, url: 'http://my-website.com/' },
+        data: {
+          method: 'POST',
+          status_code: 201,
+          url: 'http://my-website.com/',
+          __span: expect.any(String),
+        },
         type: 'http',
       },
       {

From 49e095ff41f80608786690ca84715077170e3c56 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 10:59:33 +0200
Subject: [PATCH 57/64] test(node): Add test for console.log & isolation scope
 (#11593)

Adds a test to ensure isolation scope is correctly applied to express
spans, and also that console.log is correctly instrumented.

We have related tests in E2E tests and in other places, but it doesn't
hurt to have this explicitly here I guess...
---
 .../express/span-isolationScope/server.ts     | 29 ++++++++++++++
 .../express/span-isolationScope/test.ts       | 39 +++++++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 dev-packages/node-integration-tests/suites/express/span-isolationScope/server.ts
 create mode 100644 dev-packages/node-integration-tests/suites/express/span-isolationScope/test.ts

diff --git a/dev-packages/node-integration-tests/suites/express/span-isolationScope/server.ts b/dev-packages/node-integration-tests/suites/express/span-isolationScope/server.ts
new file mode 100644
index 000000000000..99a9c53e932e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/span-isolationScope/server.ts
@@ -0,0 +1,29 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+
+Sentry.setTag('global', 'tag');
+
+app.get('/test/isolationScope', (_req, res) => {
+  // eslint-disable-next-line no-console
+  console.log('This is a test log.');
+  Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+  Sentry.setTag('isolation-scope', 'tag');
+
+  res.send({});
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/span-isolationScope/test.ts b/dev-packages/node-integration-tests/suites/express/span-isolationScope/test.ts
new file mode 100644
index 000000000000..b6954e426a1d
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/span-isolationScope/test.ts
@@ -0,0 +1,39 @@
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('correctly applies isolation scope to span', done => {
+  createRunner(__dirname, 'server.ts')
+    .ignore('session', 'sessions')
+    .expect({
+      transaction: {
+        transaction: 'GET /test/isolationScope',
+        breadcrumbs: [
+          {
+            category: 'console',
+            level: 'log',
+            message: expect.stringMatching(/\{"port":(\d+)\}/),
+            timestamp: expect.any(Number),
+          },
+          {
+            category: 'console',
+            level: 'log',
+            message: 'This is a test log.',
+            timestamp: expect.any(Number),
+          },
+          {
+            message: 'manual breadcrumb',
+            timestamp: expect.any(Number),
+          },
+        ],
+        tags: {
+          global: 'tag',
+          'isolation-scope': 'tag',
+        },
+      },
+    })
+    .start(done)
+    .makeRequest('get', '/test/isolationScope');
+});

From 409624b9899218fcdebdb14f002d0b56c157f865 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 15 Apr 2024 11:42:24 +0200
Subject: [PATCH 58/64] feat(core): Remove `getCurrentHub` from
 `AsyncContextStrategy` (#11581)

Removes the `getCurrentHub` property from the
`AsyncContextStrategy` interface and consequently also the property in
the interface implementers.
---
 packages/core/src/asyncContext.ts             |  8 +----
 packages/core/src/getCurrentHubShim.ts        | 12 ++++++++
 packages/core/src/hub.ts                      | 19 ------------
 packages/core/src/index.ts                    |  4 +--
 packages/core/src/sdk.ts                      | 29 ++++++++++---------
 packages/core/src/trpc.ts                     | 11 +++----
 .../opentelemetry/src/asyncContextStrategy.ts | 27 ++---------------
 packages/vercel-edge/src/async.ts             | 27 ++---------------
 8 files changed, 38 insertions(+), 99 deletions(-)

diff --git a/packages/core/src/asyncContext.ts b/packages/core/src/asyncContext.ts
index 4e8fc5ac917e..82d336ded509 100644
--- a/packages/core/src/asyncContext.ts
+++ b/packages/core/src/asyncContext.ts
@@ -1,4 +1,4 @@
-import type { Hub, Integration } from '@sentry/types';
+import type { Integration } from '@sentry/types';
 import type { Scope } from '@sentry/types';
 import { GLOBAL_OBJ } from '@sentry/utils';
 import type { startInactiveSpan, startSpan, startSpanManual, suppressTracing, withActiveSpan } from './tracing/trace';
@@ -10,12 +10,6 @@ import type { getActiveSpan } from './utils/spanUtils';
  * Strategy used to track async context.
  */
 export interface AsyncContextStrategy {
-  /**
-   * Gets the currently active hub.
-   */
-  // eslint-disable-next-line deprecation/deprecation
-  getCurrentHub: () => Hub;
-
   /**
    * Fork the isolation scope inside of the provided callback.
    */
diff --git a/packages/core/src/getCurrentHubShim.ts b/packages/core/src/getCurrentHubShim.ts
index dd5df3e479e6..3da344fcba1a 100644
--- a/packages/core/src/getCurrentHubShim.ts
+++ b/packages/core/src/getCurrentHubShim.ts
@@ -70,6 +70,18 @@ export function getCurrentHubShim(): Hub {
   };
 }
 
+/**
+ * Returns the default hub instance.
+ *
+ * If a hub is already registered in the global carrier but this module
+ * contains a more recent version, it replaces the registered version.
+ * Otherwise, the currently registered hub will be returned.
+ *
+ * @deprecated Use the respective replacement method directly instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+export const getCurrentHub = getCurrentHubShim;
+
 /**
  * Sends the current Session on the scope
  */
diff --git a/packages/core/src/hub.ts b/packages/core/src/hub.ts
index e68ff4cafc53..1bd3ec7c64b6 100644
--- a/packages/core/src/hub.ts
+++ b/packages/core/src/hub.ts
@@ -496,24 +496,6 @@ export class Hub implements HubInterface {
   }
 }
 
-/**
- * Returns the default hub instance.
- *
- * If a hub is already registered in the global carrier but this module
- * contains a more recent version, it replaces the registered version.
- * Otherwise, the currently registered hub will be returned.
- *
- * @deprecated Use the respective replacement method directly instead.
- */
-// eslint-disable-next-line deprecation/deprecation
-export function getCurrentHub(): HubInterface {
-  // Get main carrier (global for every environment)
-  const carrier = getMainCarrier();
-
-  const acs = getAsyncContextStrategy(carrier);
-  return acs.getCurrentHub() || getGlobalHub();
-}
-
 /** Get the default current scope. */
 export function getDefaultCurrentScope(): Scope {
   return getGlobalSingleton('defaultCurrentScope', () => new Scope());
@@ -586,7 +568,6 @@ function withIsolationScope<T>(callback: (isolationScope: ScopeInterface) => T):
 /* eslint-disable deprecation/deprecation */
 function getHubStackAsyncContextStrategy(): AsyncContextStrategy {
   return {
-    getCurrentHub: getGlobalHub,
     withIsolationScope,
     withScope,
     withSetScope,
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index e818ab1ffb01..cf3415302314 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -30,8 +30,6 @@ export {
   addEventProcessor,
 } from './exports';
 export {
-  // eslint-disable-next-line deprecation/deprecation
-  getCurrentHub,
   getDefaultCurrentScope,
   getDefaultIsolationScope,
 } from './hub';
@@ -107,4 +105,4 @@ export { addTracingHeadersToFetchRequest, instrumentFetchRequest } from './fetch
 export { trpcMiddleware } from './trpc';
 
 // eslint-disable-next-line deprecation/deprecation
-export { getCurrentHubShim } from './getCurrentHubShim';
+export { getCurrentHubShim, getCurrentHub } from './getCurrentHubShim';
diff --git a/packages/core/src/sdk.ts b/packages/core/src/sdk.ts
index d4e4dafa5db7..ebe8f9a6ca22 100644
--- a/packages/core/src/sdk.ts
+++ b/packages/core/src/sdk.ts
@@ -1,10 +1,10 @@
-import type { Client, ClientOptions, Hub as HubInterface } from '@sentry/types';
+import type { Client, ClientOptions } from '@sentry/types';
 import { consoleSandbox, logger } from '@sentry/utils';
 import { getCurrentScope } from './currentScopes';
 
+import { getMainCarrier, getSentryCarrier } from './asyncContext';
 import { DEBUG_BUILD } from './debug-build';
 import type { Hub } from './hub';
-import { getCurrentHub } from './hub';
 
 /** A class object that can instantiate Client objects. */
 export type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;
@@ -44,19 +44,22 @@ export function initAndBind<F extends Client, O extends ClientOptions>(
  */
 export function setCurrentClient(client: Client): void {
   getCurrentScope().setClient(client);
+  registerClientOnGlobalHub(client);
+}
 
-  // is there a hub too?
+/**
+ * Unfortunately, we still have to manually bind the client to the "hub" set on the global
+ * Sentry carrier object. This is because certain scripts (e.g. our loader script) obtain
+ * the client via `window.__SENTRY__.hub.getClient()`.
+ *
+ * @see {@link hub.ts getGlobalHub}
+ */
+function registerClientOnGlobalHub(client: Client): void {
   // eslint-disable-next-line deprecation/deprecation
-  const hub = getCurrentHub();
-  if (isHubClass(hub)) {
+  const sentryGlobal = getSentryCarrier(getMainCarrier()) as { hub?: Hub };
+  // eslint-disable-next-line deprecation/deprecation
+  if (sentryGlobal.hub && typeof sentryGlobal.hub.getStackTop === 'function') {
     // eslint-disable-next-line deprecation/deprecation
-    const top = hub.getStackTop();
-    top.client = client;
+    sentryGlobal.hub.getStackTop().client = client;
   }
 }
-
-// eslint-disable-next-line deprecation/deprecation
-function isHubClass(hub: HubInterface): hub is Hub {
-  // eslint-disable-next-line deprecation/deprecation
-  return !!(hub as Hub).getStackTop;
-}
diff --git a/packages/core/src/trpc.ts b/packages/core/src/trpc.ts
index f36722b34594..f2cc6656d62d 100644
--- a/packages/core/src/trpc.ts
+++ b/packages/core/src/trpc.ts
@@ -1,12 +1,9 @@
 import { isThenable, normalize } from '@sentry/utils';
-import {
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  captureException,
-  setContext,
-  startSpanManual,
-} from '.';
+
 import { getClient } from './currentScopes';
+import { captureException, setContext } from './exports';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from './semanticAttributes';
+import { startSpanManual } from './tracing';
 
 interface SentryTrpcMiddlewareOptions {
   /** Whether to include procedure inputs in reported events. Defaults to `false`. */
diff --git a/packages/opentelemetry/src/asyncContextStrategy.ts b/packages/opentelemetry/src/asyncContextStrategy.ts
index 3ef7bf9ba2f2..69878d27b252 100644
--- a/packages/opentelemetry/src/asyncContextStrategy.ts
+++ b/packages/opentelemetry/src/asyncContextStrategy.ts
@@ -1,12 +1,7 @@
 import * as api from '@opentelemetry/api';
-import {
-  getCurrentHubShim,
-  getDefaultCurrentScope,
-  getDefaultIsolationScope,
-  setAsyncContextStrategy,
-} from '@sentry/core';
+import { getDefaultCurrentScope, getDefaultIsolationScope, setAsyncContextStrategy } from '@sentry/core';
 import type { withActiveSpan as defaultWithActiveSpan } from '@sentry/core';
-import type { Hub, Scope } from '@sentry/types';
+import type { Scope } from '@sentry/types';
 
 import {
   SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY,
@@ -40,23 +35,6 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
     };
   }
 
-  // eslint-disable-next-line deprecation/deprecation
-  function getCurrentHub(): Hub {
-    // eslint-disable-next-line deprecation/deprecation
-    const hub = getCurrentHubShim();
-    return {
-      ...hub,
-      getScope: () => {
-        const scopes = getScopes();
-        return scopes.scope;
-      },
-      getIsolationScope: () => {
-        const scopes = getScopes();
-        return scopes.isolationScope;
-      },
-    };
-  }
-
   function withScope<T>(callback: (scope: Scope) => T): T {
     const ctx = api.context.active();
 
@@ -114,7 +92,6 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
   }
 
   setAsyncContextStrategy({
-    getCurrentHub,
     withScope,
     withSetScope,
     withSetIsolationScope,
diff --git a/packages/vercel-edge/src/async.ts b/packages/vercel-edge/src/async.ts
index 8fbc8306492e..dd7432c8e959 100644
--- a/packages/vercel-edge/src/async.ts
+++ b/packages/vercel-edge/src/async.ts
@@ -1,10 +1,5 @@
-import {
-  getCurrentHubShim,
-  getDefaultCurrentScope,
-  getDefaultIsolationScope,
-  setAsyncContextStrategy,
-} from '@sentry/core';
-import type { Hub, Scope } from '@sentry/types';
+import { getDefaultCurrentScope, getDefaultIsolationScope, setAsyncContextStrategy } from '@sentry/core';
+import type { Scope } from '@sentry/types';
 import { GLOBAL_OBJ, logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from './debug-build';
@@ -51,23 +46,6 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
     };
   }
 
-  // eslint-disable-next-line deprecation/deprecation
-  function getCurrentHub(): Hub {
-    // eslint-disable-next-line deprecation/deprecation
-    const hub = getCurrentHubShim();
-    return {
-      ...hub,
-      getScope: () => {
-        const scopes = getScopes();
-        return scopes.scope;
-      },
-      getIsolationScope: () => {
-        const scopes = getScopes();
-        return scopes.isolationScope;
-      },
-    };
-  }
-
   function withScope<T>(callback: (scope: Scope) => T): T {
     const scope = getScopes().scope.clone();
     const isolationScope = getScopes().isolationScope;
@@ -99,7 +77,6 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
   }
 
   setAsyncContextStrategy({
-    getCurrentHub,
     withScope,
     withSetScope,
     withIsolationScope,

From 832a7bf70ec1d559274c894af3be2e5b0169ea3b Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 11:48:27 +0200
Subject: [PATCH 59/64] feat(node): Ensure tracing without performance (TWP)
 works (#11564)

This fixes the node SDK to make tracing without performance work as
expected.

This has three aspects:

1. Ensure we always have an url to check against
`tracePropagationTargets`, even if the span is not sampled.
2. Ensure we use the correct propagation context always
3. Ensure we actually consistently handle ougoing http.client spans
without an active transaction

The fix for 2. was to have a fallback behavior if we don't have a scope
linked to a context yet (we'll just use the current scope then). This is
needed because we won't necessarily have an assigned scope yet at the
time this is called, because at this point in time this is still a
floating context. This also meant removing the fallback code to look at
the remote span context (because we'll always have a scope now).

The fix for 3. was to move this out of the http integration and do this
in the sampler instead.

The fix for 1. was a bit more elaborate, because we require different
things to solve the http instrumentation and the fetch instrumentation.

For fetch, we leverage our sampler, which can attach trace state that
even unsampled spans will have. We attach the URL as trace state which
we can read in the propagator, ensuring this works even for unsampled
spans.

Sadly, for http this is not sufficient, because our usage of
`onlyIfParentForOutgoingRequest` lead to some spans being created
outside of the sampler. By removing this option (see 3) and doing stuff
in the sampler instead, we can ensure that all spans for http are
handled properly.

This also bumps our node-fetch otel instrumentation to
[1.2.0](https://github.com/gas-buddy/opentelemetry-instrumentation-fetch-node/releases/tag/v1.2.0)
which fixes headers for Node 21 (tests were actually failing without
this!).
---
 .../trace-header-assign/server.ts             |  35 ++++
 .../sentry-trace/trace-header-assign/test.ts  |   2 +-
 .../requests/fetch-noSampleRate/scenario.ts   |  24 +++
 .../requests/fetch-noSampleRate/test.ts       |  53 ++++++
 .../fetch-sampled-no-active-span/scenario.ts  |  25 +++
 .../fetch-sampled-no-active-span/test.ts      |  48 ++++++
 .../requests/fetch-sampled/scenario.ts        |  25 +++
 .../tracing/requests/fetch-sampled/test.ts    |  40 +++++
 .../requests/fetch-unsampled/scenario.ts      |  28 ++++
 .../tracing/requests/fetch-unsampled/test.ts  |  48 ++++++
 .../requests/http-noSampleRate/scenario.ts    |  39 +++++
 .../requests/http-noSampleRate/test.ts        |  50 ++++++
 .../http-sampled-no-active-span/scenario.ts   |  40 +++++
 .../http-sampled-no-active-span/test.ts       |  49 ++++++
 .../tracing/requests/http-sampled/scenario.ts |  20 +++
 .../tracing/requests/http-sampled/test.ts     |  41 +++++
 .../requests/http-unsampled/scenario.ts       |  43 +++++
 .../tracing/requests/http-unsampled/test.ts   |  49 ++++++
 .../tracing/tracePropagationTargets/test.ts   |  12 +-
 .../unit/utils/lazyLoadIntegration.test.ts    |   2 +-
 packages/node/package.json                    |   2 +-
 packages/node/src/integrations/http.ts        |   4 +-
 packages/opentelemetry/src/constants.ts       |   1 +
 packages/opentelemetry/src/propagator.ts      |  79 +++++----
 packages/opentelemetry/src/sampler.ts         |  31 +++-
 .../opentelemetry/test/propagator.test.ts     | 151 +++---------------
 yarn.lock                                     |   8 +-
 27 files changed, 761 insertions(+), 188 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/server.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts

diff --git a/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/server.ts b/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/server.ts
new file mode 100644
index 000000000000..f1393c3cfc5b
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/server.ts
@@ -0,0 +1,35 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+export type TestAPIResponse = { test_data: { host: string; 'sentry-trace': string; baggage: string } };
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  environment: 'prod',
+  integrations: [
+    // TODO: This used to use the Express integration
+  ],
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+import http from 'http';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import cors from 'cors';
+import express from 'express';
+
+const app = express();
+
+app.use(cors());
+
+app.get('/test/express', (_req, res) => {
+  const headers = http.get('http://somewhere.not.sentry/').getHeaders();
+
+  // Responding with the headers outgoing request headers back to the assertions.
+  res.send({ test_data: headers });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/test.ts b/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/test.ts
index 2870f0a8b51c..071f02f83647 100644
--- a/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/test.ts
+++ b/dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/test.ts
@@ -7,7 +7,7 @@ afterAll(() => {
 });
 
 test('Should assign `sentry-trace` header which sets parent trace id of an outgoing request.', async () => {
-  const runner = createRunner(__dirname, '..', 'server.ts').start();
+  const runner = createRunner(__dirname, 'server.ts').start();
 
   const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express', {
     'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/scenario.ts
new file mode 100644
index 000000000000..55b0a04c6784
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/scenario.ts
@@ -0,0 +1,24 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+  await new Promise(resolve => setTimeout(resolve, 100));
+  await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/test.ts
new file mode 100644
index 000000000000..2de3dcfea66b
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/test.ts
@@ -0,0 +1,53 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing fetch requests are correctly instrumented without tracesSampleRate', done => {
+    expect.assertions(15);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .get('/api/v1', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .ensureNoErrorOutput()
+          .ignore('session', 'sessions')
+          .expect({
+            event: {
+              exception: {
+                values: [
+                  {
+                    type: 'Error',
+                    value: 'foo',
+                  },
+                ],
+              },
+            },
+          })
+          .start(done);
+      });
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/scenario.ts
new file mode 100644
index 000000000000..191797a10c15
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/scenario.ts
@@ -0,0 +1,25 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  tracesSampleRate: 1.0,
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+  await new Promise(resolve => setTimeout(resolve, 100));
+  await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts
new file mode 100644
index 000000000000..40e14fe648f8
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts
@@ -0,0 +1,48 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing sampled fetch requests without active span are correctly instrumented', done => {
+    expect.assertions(11);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      })
+      .get('/api/v1', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .ignore('session', 'sessions')
+          .expect({
+            event: {
+              exception: {
+                values: [
+                  {
+                    type: 'Error',
+                    value: 'foo',
+                  },
+                ],
+              },
+            },
+          })
+          .start(done);
+      });
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/scenario.ts
new file mode 100644
index 000000000000..4d47e16fd42f
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/scenario.ts
@@ -0,0 +1,25 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  await Sentry.startSpan({ name: 'test_span' }, async () => {
+    // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+    await new Promise(resolve => setTimeout(resolve, 100));
+    await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/test.ts
new file mode 100644
index 000000000000..40d05d2131eb
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/test.ts
@@ -0,0 +1,40 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing sampled fetch requests are correctly instrumented', done => {
+    expect.assertions(11);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+        expect(headers['baggage']).toEqual(expect.any(String));
+      })
+      .get('/api/v1', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+        expect(headers['baggage']).toEqual(expect.any(String));
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .expect({
+            transaction: {
+              // we're not too concerned with the actual transaction here since this is tested elsewhere
+            },
+          })
+          .start(done);
+      });
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/scenario.ts
new file mode 100644
index 000000000000..91c38bf2b23a
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/scenario.ts
@@ -0,0 +1,28 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  tracesSampleRate: 0,
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  // Wrap in span that is not sampled
+  await Sentry.startSpan({ name: 'outer' }, async () => {
+    // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+    await new Promise(resolve => setTimeout(resolve, 100));
+    await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+  });
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/test.ts
new file mode 100644
index 000000000000..0b0ceeaa499c
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/test.ts
@@ -0,0 +1,48 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing fetch requests are correctly instrumented when not sampled', done => {
+    expect.assertions(11);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      })
+      .get('/api/v1', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .ignore('session', 'sessions')
+          .expect({
+            event: {
+              exception: {
+                values: [
+                  {
+                    type: 'Error',
+                    value: 'foo',
+                  },
+                ],
+              },
+            },
+          })
+          .start(done);
+      });
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/scenario.ts
new file mode 100644
index 000000000000..8213ddf7034e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/scenario.ts
@@ -0,0 +1,39 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+import * as http from 'http';
+
+async function run(): Promise<void> {
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v0`);
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v1`);
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v2`);
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v3`);
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
+
+function makeHttpRequest(url: string): Promise<void> {
+  return new Promise<void>(resolve => {
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', () => {
+          // we don't care about data
+        });
+        httpRes.on('end', () => {
+          resolve();
+        });
+      })
+      .end();
+  });
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/test.ts
new file mode 100644
index 000000000000..570d9f4865a6
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-noSampleRate/test.ts
@@ -0,0 +1,50 @@
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+test('outgoing http requests are correctly instrumented without tracesSampleRate', done => {
+  expect.assertions(15);
+
+  createTestServer(done)
+    .get('/api/v0', headers => {
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v1', headers => {
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v2', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v3', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .start()
+    .then(SERVER_URL => {
+      createRunner(__dirname, 'scenario.ts')
+        .withEnv({ SERVER_URL })
+        .ensureNoErrorOutput()
+        .ignore('session', 'sessions')
+        .expect({
+          event: {
+            exception: {
+              values: [
+                {
+                  type: 'Error',
+                  value: 'foo',
+                },
+              ],
+            },
+          },
+        })
+        .start(done);
+    });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/scenario.ts
new file mode 100644
index 000000000000..e98a9e9aea80
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/scenario.ts
@@ -0,0 +1,40 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+import * as http from 'http';
+
+async function run(): Promise<void> {
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v0`);
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v1`);
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v2`);
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/v3`);
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
+
+function makeHttpRequest(url: string): Promise<void> {
+  return new Promise<void>(resolve => {
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', () => {
+          // we don't care about data
+        });
+        httpRes.on('end', () => {
+          resolve();
+        });
+      })
+      .end();
+  });
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts
new file mode 100644
index 000000000000..ee0151cd6297
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts
@@ -0,0 +1,49 @@
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+test('outgoing sampled http requests without active span are correctly instrumented', done => {
+  expect.assertions(15);
+
+  createTestServer(done)
+    .get('/api/v0', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v1', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v2', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v3', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .start()
+    .then(SERVER_URL => {
+      createRunner(__dirname, 'scenario.ts')
+        .withEnv({ SERVER_URL })
+        .ignore('session', 'sessions')
+        .expect({
+          event: {
+            exception: {
+              values: [
+                {
+                  type: 'Error',
+                  value: 'foo',
+                },
+              ],
+            },
+          },
+        })
+        .start(done);
+    });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/scenario.ts
new file mode 100644
index 000000000000..c346b617b9e6
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/scenario.ts
@@ -0,0 +1,20 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+import * as http from 'http';
+
+Sentry.startSpan({ name: 'test_span' }, () => {
+  http.get(`${process.env.SERVER_URL}/api/v0`);
+  http.get(`${process.env.SERVER_URL}/api/v1`);
+  http.get(`${process.env.SERVER_URL}/api/v2`);
+  http.get(`${process.env.SERVER_URL}/api/v3`);
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
new file mode 100644
index 000000000000..f3ad8bc5728e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
@@ -0,0 +1,41 @@
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+test('outgoing sampled http requests are correctly instrumented', done => {
+  expect.assertions(15);
+
+  createTestServer(done)
+    .get('/api/v0', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v1', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v2', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v3', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .start()
+    .then(SERVER_URL => {
+      createRunner(__dirname, 'scenario.ts')
+        .withEnv({ SERVER_URL })
+        .expect({
+          transaction: {
+            // we're not too concerned with the actual transaction here since this is tested elsewhere
+          },
+        })
+        .start(done);
+    });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/scenario.ts
new file mode 100644
index 000000000000..6b66b11b8ffb
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/scenario.ts
@@ -0,0 +1,43 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  tracesSampleRate: 0,
+  integrations: [],
+  transport: loggingTransport,
+});
+
+import * as http from 'http';
+
+async function run(): Promise<void> {
+  // Wrap in span that is not sampled
+  await Sentry.startSpan({ name: 'outer' }, async () => {
+    await makeHttpRequest(`${process.env.SERVER_URL}/api/v0`);
+    await makeHttpRequest(`${process.env.SERVER_URL}/api/v1`);
+    await makeHttpRequest(`${process.env.SERVER_URL}/api/v2`);
+    await makeHttpRequest(`${process.env.SERVER_URL}/api/v3`);
+  });
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();
+
+function makeHttpRequest(url: string): Promise<void> {
+  return new Promise<void>(resolve => {
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', () => {
+          // we don't care about data
+        });
+        httpRes.on('end', () => {
+          resolve();
+        });
+      })
+      .end();
+  });
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts
new file mode 100644
index 000000000000..c860958622fa
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts
@@ -0,0 +1,49 @@
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+test('outgoing http requests are correctly instrumented when not sampled', done => {
+  expect.assertions(15);
+
+  createTestServer(done)
+    .get('/api/v0', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v1', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v2', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .get('/api/v3', headers => {
+      expect(headers['baggage']).toBeUndefined();
+      expect(headers['sentry-trace']).toBeUndefined();
+      expect(headers['__requestUrl']).toBeUndefined();
+    })
+    .start()
+    .then(SERVER_URL => {
+      createRunner(__dirname, 'scenario.ts')
+        .withEnv({ SERVER_URL })
+        .ignore('session', 'sessions')
+        .expect({
+          event: {
+            exception: {
+              values: [
+                {
+                  type: 'Error',
+                  value: 'foo',
+                },
+              ],
+            },
+          },
+        })
+        .start(done);
+    });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
index e87e9f3df1bc..c43b5607ef52 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
@@ -2,16 +2,18 @@ import { createRunner } from '../../../utils/runner';
 import { createTestServer } from '../../../utils/server';
 
 test('HttpIntegration should instrument correct requests when tracePropagationTargets option is provided', done => {
-  expect.assertions(9);
+  expect.assertions(11);
 
   createTestServer(done)
     .get('/api/v0', headers => {
-      expect(typeof headers['baggage']).toBe('string');
-      expect(typeof headers['sentry-trace']).toBe('string');
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
     })
     .get('/api/v1', headers => {
-      expect(typeof headers['baggage']).toBe('string');
-      expect(typeof headers['sentry-trace']).toBe('string');
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
     })
     .get('/api/v2', headers => {
       expect(headers['baggage']).toBeUndefined();
diff --git a/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts b/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts
index a9a86cbf4374..f2afefcbe9a2 100644
--- a/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts
+++ b/packages/browser/test/unit/utils/lazyLoadIntegration.test.ts
@@ -64,7 +64,7 @@ describe('lazyLoadIntegration', () => {
     expect(global.document.querySelectorAll('script')).toHaveLength(0);
   });
 
-  test('it injects a script tag if integration is not yet loaded xxx', async () => {
+  test('it injects a script tag if integration is not yet loaded', async () => {
     // @ts-expect-error For testing sake
     global.Sentry = {
       ...Sentry,
diff --git a/packages/node/package.json b/packages/node/package.json
index c711fc35b620..e4019a00e6e5 100644
--- a/packages/node/package.json
+++ b/packages/node/package.json
@@ -82,7 +82,7 @@
     "@types/node": "^14.18.0"
   },
   "optionalDependencies": {
-    "opentelemetry-instrumentation-fetch-node": "1.1.2"
+    "opentelemetry-instrumentation-fetch-node": "1.2.0"
   },
   "scripts": {
     "build": "run-p build:transpile build:types",
diff --git a/packages/node/src/integrations/http.ts b/packages/node/src/integrations/http.ts
index 633f27c7b64c..89aa8d90b997 100644
--- a/packages/node/src/integrations/http.ts
+++ b/packages/node/src/integrations/http.ts
@@ -88,7 +88,7 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
             return false;
           },
 
-          requireParentforOutgoingSpans: true,
+          requireParentforOutgoingSpans: false,
           requireParentforIncomingSpans: false,
           requestHook: (span, req) => {
             addOriginToSpan(span, 'auto.http.otel.http');
@@ -101,10 +101,10 @@ const _httpIntegration = ((options: HttpOptions = {}) => {
 
             const scopes = getCapturedScopesOnSpan(span);
 
-            // Update the isolation scope, isolate this request
             const isolationScope = (scopes.isolationScope || getIsolationScope()).clone();
             const scope = scopes.scope || getCurrentScope();
 
+            // Update the isolation scope, isolate this request
             isolationScope.setSDKProcessingMetadata({ request: req });
 
             const client = getClient<NodeClient>();
diff --git a/packages/opentelemetry/src/constants.ts b/packages/opentelemetry/src/constants.ts
index e153d50b0180..0f056d09a4ea 100644
--- a/packages/opentelemetry/src/constants.ts
+++ b/packages/opentelemetry/src/constants.ts
@@ -6,6 +6,7 @@ export const SENTRY_BAGGAGE_HEADER = 'baggage';
 export const SENTRY_TRACE_STATE_DSC = 'sentry.dsc';
 export const SENTRY_TRACE_STATE_PARENT_SPAN_ID = 'sentry.parent_span_id';
 export const SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING = 'sentry.sampled_not_recording';
+export const SENTRY_TRACE_STATE_URL = 'sentry.url';
 
 export const SENTRY_SCOPES_CONTEXT_KEY = createContextKey('sentry_scopes');
 
diff --git a/packages/opentelemetry/src/propagator.ts b/packages/opentelemetry/src/propagator.ts
index d96f19c16b7c..6640a0f4e0f1 100644
--- a/packages/opentelemetry/src/propagator.ts
+++ b/packages/opentelemetry/src/propagator.ts
@@ -4,6 +4,7 @@ import { TraceFlags, propagation, trace } from '@opentelemetry/api';
 import { TraceState, W3CBaggagePropagator, isTracingSuppressed } from '@opentelemetry/core';
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
 import type { continueTrace } from '@sentry/core';
+import { hasTracingEnabled } from '@sentry/core';
 import { getRootSpan } from '@sentry/core';
 import { spanToJSON } from '@sentry/core';
 import { getClient, getCurrentScope, getDynamicSamplingContextFromClient, getIsolationScope } from '@sentry/core';
@@ -26,6 +27,7 @@ import {
   SENTRY_TRACE_STATE_DSC,
   SENTRY_TRACE_STATE_PARENT_SPAN_ID,
   SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING,
+  SENTRY_TRACE_STATE_URL,
 } from './constants';
 import { DEBUG_BUILD } from './debug-build';
 import { getScopesFromContext, setScopesOnContext } from './utils/contextData';
@@ -84,7 +86,8 @@ export class SentryPropagator extends W3CBaggagePropagator {
     }
 
     const activeSpan = trace.getSpan(context);
-    const url = activeSpan && spanToJSON(activeSpan).data?.[SemanticAttributes.HTTP_URL];
+    const url = activeSpan && getCurrentURL(activeSpan);
+
     const tracePropagationTargets = getClient()?.getOptions()?.tracePropagationTargets;
     if (
       typeof url === 'string' &&
@@ -92,7 +95,10 @@ export class SentryPropagator extends W3CBaggagePropagator {
       !this._shouldInjectTraceData(tracePropagationTargets, url)
     ) {
       DEBUG_BUILD &&
-        logger.log('[Tracing] Not injecting trace data for url because it does not matchTracePropagationTargets:', url);
+        logger.log(
+          '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:',
+          url,
+        );
       return;
     }
 
@@ -120,7 +126,10 @@ export class SentryPropagator extends W3CBaggagePropagator {
       }, baggage);
     }
 
-    setter.set(carrier, SENTRY_TRACE_HEADER, generateSentryTraceHeader(traceId, spanId, sampled));
+    // We also want to avoid setting the default OTEL trace ID, if we get that for whatever reason
+    if (traceId && traceId !== '00000000000000000000000000000000') {
+      setter.set(carrier, SENTRY_TRACE_HEADER, generateSentryTraceHeader(traceId, spanId, sampled));
+    }
 
     super.inject(propagation.setBaggage(context, baggage), carrier, setter);
   }
@@ -212,7 +221,7 @@ function getInjectionData(context: Context): {
   spanId: string | undefined;
   sampled: boolean | undefined;
 } {
-  const span = trace.getSpan(context);
+  const span = hasTracingEnabled() ? trace.getSpan(context) : undefined;
   const spanIsRemote = span?.spanContext().isRemote;
 
   // If we have a local span, we can just pick everything from it
@@ -230,39 +239,15 @@ function getInjectionData(context: Context): {
   }
 
   // Else we try to use the propagation context from the scope
-  const scope = getScopesFromContext(context)?.scope;
-  if (scope) {
-    const propagationContext = scope.getPropagationContext();
-    const dynamicSamplingContext = getDynamicSamplingContext(propagationContext, propagationContext.traceId);
-    return {
-      dynamicSamplingContext,
-      traceId: propagationContext.traceId,
-      spanId: propagationContext.spanId,
-      sampled: propagationContext.sampled,
-    };
-  }
+  const scope = getScopesFromContext(context)?.scope || getCurrentScope();
 
-  // Else, we look at the remote span context
-  if (span) {
-    const spanContext = span.spanContext();
-    const propagationContext = getPropagationContextFromSpan(span);
-    const dynamicSamplingContext = getDynamicSamplingContext(propagationContext, spanContext.traceId);
-
-    return {
-      dynamicSamplingContext,
-      traceId: spanContext.traceId,
-      spanId: spanContext.spanId,
-      sampled: getSamplingDecision(spanContext),
-    };
-  }
-
-  // If we have neither, there is nothing much we can do, but that should not happen usually
-  // Unless there is a detached OTEL context being passed around
+  const propagationContext = scope.getPropagationContext();
+  const dynamicSamplingContext = getDynamicSamplingContext(propagationContext, propagationContext.traceId);
   return {
-    dynamicSamplingContext: undefined,
-    traceId: undefined,
-    spanId: undefined,
-    sampled: undefined,
+    dynamicSamplingContext,
+    traceId: propagationContext.traceId,
+    spanId: propagationContext.spanId,
+    sampled: propagationContext.sampled,
   };
 }
 
@@ -333,3 +318,27 @@ function getExistingBaggage(carrier: unknown): string | undefined {
     return undefined;
   }
 }
+
+/**
+ * It is pretty tricky to get access to the outgoing request URL of a request in the propagator.
+ * As we only have access to the context of the span to be sent and the carrier (=headers),
+ * but the span may be unsampled and thus have no attributes.
+ *
+ * So we use the following logic:
+ * 1. If we have an active span, we check if it has a URL attribute.
+ * 2. Else, if the active span has no URL attribute (e.g. it is unsampled), we check a special trace state (which we set in our sampler).
+ */
+function getCurrentURL(span: Span): string | undefined {
+  const urlAttribute = spanToJSON(span).data?.[SemanticAttributes.HTTP_URL];
+  if (urlAttribute) {
+    return urlAttribute;
+  }
+
+  // Also look at the traceState, which we may set in the sampler even for unsampled spans
+  const urlTraceState = span.spanContext().traceState?.get(SENTRY_TRACE_STATE_URL);
+  if (urlTraceState) {
+    return urlTraceState;
+  }
+
+  return undefined;
+}
diff --git a/packages/opentelemetry/src/sampler.ts b/packages/opentelemetry/src/sampler.ts
index e611d6a43395..024f802c5ae6 100644
--- a/packages/opentelemetry/src/sampler.ts
+++ b/packages/opentelemetry/src/sampler.ts
@@ -1,4 +1,5 @@
 import type { Attributes, Context, Span } from '@opentelemetry/api';
+import { SpanKind } from '@opentelemetry/api';
 import { isSpanContextValid, trace } from '@opentelemetry/api';
 import { TraceState } from '@opentelemetry/core';
 import type { Sampler, SamplingResult } from '@opentelemetry/sdk-trace-base';
@@ -6,7 +7,7 @@ import { SamplingDecision } from '@opentelemetry/sdk-trace-base';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, hasTracingEnabled, sampleSpan } from '@sentry/core';
 import type { Client, SpanAttributes } from '@sentry/types';
 import { logger } from '@sentry/utils';
-import { SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING } from './constants';
+import { SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING, SENTRY_TRACE_STATE_URL } from './constants';
 
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
 import { DEBUG_BUILD } from './debug-build';
@@ -30,19 +31,36 @@ export class SentrySampler implements Sampler {
     context: Context,
     traceId: string,
     spanName: string,
-    _spanKind: unknown,
+    spanKind: SpanKind,
     spanAttributes: SpanAttributes,
     _links: unknown,
   ): SamplingResult {
     const options = this._client.getOptions();
 
+    const parentSpan = trace.getSpan(context);
+    const parentContext = parentSpan?.spanContext();
+
+    let traceState = parentContext?.traceState || new TraceState();
+
+    // We always keep the URL on the trace state, so we can access it in the propagator
+    const url = spanAttributes[SemanticAttributes.HTTP_URL];
+    if (url && typeof url === 'string') {
+      traceState = traceState.set(SENTRY_TRACE_STATE_URL, url);
+    }
+
     if (!hasTracingEnabled(options)) {
-      return { decision: SamplingDecision.NOT_RECORD };
+      return { decision: SamplingDecision.NOT_RECORD, traceState };
     }
 
-    const parentSpan = trace.getSpan(context);
-    const parentContext = parentSpan?.spanContext();
-    const traceState = parentContext?.traceState || new TraceState();
+    // If we have a http.client span that has no local parent, we never want to sample it
+    // but we want to leave downstream sampling decisions up to the server
+    if (
+      spanKind === SpanKind.CLIENT &&
+      spanAttributes[SemanticAttributes.HTTP_METHOD] &&
+      (!parentSpan || parentContext?.isRemote)
+    ) {
+      return { decision: SamplingDecision.NOT_RECORD, traceState };
+    }
 
     let parentSampled: boolean | undefined = undefined;
 
@@ -94,6 +112,7 @@ export class SentrySampler implements Sampler {
     return {
       decision: SamplingDecision.RECORD_AND_SAMPLED,
       attributes,
+      traceState,
     };
   }
 
diff --git a/packages/opentelemetry/test/propagator.test.ts b/packages/opentelemetry/test/propagator.test.ts
index da9f2d30fc98..0d84da98e4f6 100644
--- a/packages/opentelemetry/test/propagator.test.ts
+++ b/packages/opentelemetry/test/propagator.test.ts
@@ -8,7 +8,7 @@ import {
   trace,
 } from '@opentelemetry/api';
 import { suppressTracing } from '@opentelemetry/core';
-import { withScope } from '@sentry/core';
+import { getCurrentScope, withScope } from '@sentry/core';
 
 import { SENTRY_BAGGAGE_HEADER, SENTRY_SCOPES_CONTEXT_KEY, SENTRY_TRACE_HEADER } from '../src/constants';
 import { SentryPropagator, makeTraceState } from '../src/propagator';
@@ -40,134 +40,6 @@ describe('SentryPropagator', () => {
 
   describe('inject', () => {
     describe('without active local span', () => {
-      it.each([
-        [
-          'uses remote spanContext without DSC for sampled remote span',
-          {
-            traceId: 'd4cda95b652f4a1592b449d5929fda1b',
-            spanId: '6e0c63257de34c92',
-            traceFlags: TraceFlags.SAMPLED,
-            isRemote: true,
-          },
-          [
-            'sentry-environment=production',
-            'sentry-release=1.0.0',
-            'sentry-public_key=abc',
-            'sentry-sampled=true',
-            'sentry-trace_id=d4cda95b652f4a1592b449d5929fda1b',
-          ],
-          'd4cda95b652f4a1592b449d5929fda1b-6e0c63257de34c92-1',
-        ],
-        [
-          'uses remote spanContext without DSC for unsampled remote span',
-          {
-            traceId: 'd4cda95b652f4a1592b449d5929fda1b',
-            spanId: '6e0c63257de34c92',
-            traceFlags: TraceFlags.NONE,
-            isRemote: true,
-          },
-          [
-            'sentry-environment=production',
-            'sentry-release=1.0.0',
-            'sentry-public_key=abc',
-            'sentry-trace_id=d4cda95b652f4a1592b449d5929fda1b',
-          ],
-          'd4cda95b652f4a1592b449d5929fda1b-6e0c63257de34c92',
-        ],
-        [
-          'uses remote spanContext with trace state & without DSC for unsampled remote span',
-          {
-            traceId: 'd4cda95b652f4a1592b449d5929fda1b',
-            spanId: '6e0c63257de34c92',
-            traceFlags: TraceFlags.NONE,
-            isRemote: true,
-            traceState: makeTraceState({
-              sampled: false,
-            }),
-          },
-          [
-            'sentry-environment=production',
-            'sentry-release=1.0.0',
-            'sentry-public_key=abc',
-            'sentry-sampled=false',
-            'sentry-trace_id=d4cda95b652f4a1592b449d5929fda1b',
-          ],
-          'd4cda95b652f4a1592b449d5929fda1b-6e0c63257de34c92-0',
-        ],
-        [
-          'uses remote spanContext with DSC for sampled remote span',
-          {
-            traceId: 'd4cda95b652f4a1592b449d5929fda1b',
-            spanId: '6e0c63257de34c92',
-            traceFlags: TraceFlags.SAMPLED,
-            traceState: makeTraceState({
-              parentSpanId: '6e0c63257de34c92',
-              dsc: {
-                transaction: 'sampled-transaction',
-                sampled: 'true',
-                trace_id: 'dsc_trace_id',
-                public_key: 'dsc_public_key',
-                environment: 'dsc_environment',
-                release: 'dsc_release',
-                sample_rate: '0.5',
-                replay_id: 'dsc_replay_id',
-              },
-            }),
-            isRemote: true,
-          },
-          [
-            'sentry-environment=dsc_environment',
-            'sentry-release=dsc_release',
-            'sentry-public_key=dsc_public_key',
-            'sentry-trace_id=dsc_trace_id',
-            'sentry-transaction=sampled-transaction',
-            'sentry-sampled=true',
-            'sentry-sample_rate=0.5',
-            'sentry-replay_id=dsc_replay_id',
-          ],
-          'd4cda95b652f4a1592b449d5929fda1b-6e0c63257de34c92-1',
-        ],
-        [
-          'uses remote spanContext with DSC for unsampled remote span',
-          {
-            traceId: 'd4cda95b652f4a1592b449d5929fda1b',
-            spanId: '6e0c63257de34c92',
-            traceFlags: TraceFlags.NONE,
-            traceState: makeTraceState({
-              parentSpanId: '6e0c63257de34c92',
-              dsc: {
-                transaction: 'sampled-transaction',
-                sampled: 'false',
-                trace_id: 'dsc_trace_id',
-                public_key: 'dsc_public_key',
-                environment: 'dsc_environment',
-                release: 'dsc_release',
-                sample_rate: '0.5',
-                replay_id: 'dsc_replay_id',
-              },
-            }),
-            isRemote: true,
-          },
-          [
-            'sentry-environment=dsc_environment',
-            'sentry-release=dsc_release',
-            'sentry-public_key=dsc_public_key',
-            'sentry-trace_id=dsc_trace_id',
-            'sentry-transaction=sampled-transaction',
-            'sentry-sampled=false',
-            'sentry-sample_rate=0.5',
-            'sentry-replay_id=dsc_replay_id',
-          ],
-          'd4cda95b652f4a1592b449d5929fda1b-6e0c63257de34c92-0',
-        ],
-      ])('%s', (_name, spanContext, baggage, sentryTrace) => {
-        const ctx = trace.setSpanContext(ROOT_CONTEXT, spanContext);
-        propagator.inject(ctx, carrier, defaultTextMapSetter);
-
-        expect(baggageToArray(carrier[SENTRY_BAGGAGE_HEADER])).toEqual(baggage.sort());
-        expect(carrier[SENTRY_TRACE_HEADER]).toBe(sentryTrace);
-      });
-
       it('uses scope propagation context without DSC if no span is found', () => {
         withScope(scope => {
           scope.setPropagationContext({
@@ -261,12 +133,20 @@ describe('SentryPropagator', () => {
         );
       });
 
-      it('creates random traceId & spanId if no scope & span is found', () => {
+      it('uses propagation data from current scope if no scope & span is found', () => {
+        const scope = getCurrentScope();
+        const traceId = scope.getPropagationContext().traceId;
+
         const ctx = trace.deleteSpan(ROOT_CONTEXT).deleteValue(SENTRY_SCOPES_CONTEXT_KEY);
         propagator.inject(ctx, carrier, defaultTextMapSetter);
 
-        expect(baggageToArray(carrier[SENTRY_BAGGAGE_HEADER])).toEqual([]);
-        expect(carrier[SENTRY_TRACE_HEADER]).toMatch(/^\w{32}-\w{16}$/);
+        expect(baggageToArray(carrier[SENTRY_BAGGAGE_HEADER])).toEqual([
+          'sentry-environment=production',
+          'sentry-public_key=abc',
+          'sentry-release=1.0.0',
+          `sentry-trace_id=${traceId}`,
+        ]);
+        expect(carrier[SENTRY_TRACE_HEADER]).toMatch(traceId);
       });
     });
 
@@ -641,10 +521,15 @@ describe('SentryPropagator', () => {
     });
 
     it('should create baggage without propagation context', () => {
+      const scope = getCurrentScope();
+      const traceId = scope.getPropagationContext().traceId;
+
       const context = ROOT_CONTEXT;
       const baggage = propagation.createBaggage({ foo: { value: 'bar' } });
       propagator.inject(propagation.setBaggage(context, baggage), carrier, defaultTextMapSetter);
-      expect(carrier[SENTRY_BAGGAGE_HEADER]).toBe('foo=bar');
+      expect(carrier[SENTRY_BAGGAGE_HEADER]).toBe(
+        `foo=bar,sentry-environment=production,sentry-release=1.0.0,sentry-public_key=abc,sentry-trace_id=${traceId}`,
+      );
     });
 
     it('should NOT set baggage and sentry-trace header if instrumentation is supressed', () => {
diff --git a/yarn.lock b/yarn.lock
index 64bc3a06b8bb..2db9b7009ea8 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -23178,10 +23178,10 @@ opener@^1.5.2:
   resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
-opentelemetry-instrumentation-fetch-node@1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/opentelemetry-instrumentation-fetch-node/-/opentelemetry-instrumentation-fetch-node-1.1.2.tgz#ba18648b8e1273c5e801a1d9d7a5e4c6f1daf6df"
-  integrity sha512-w5KYAw/X/F0smj1v67VQUhnWusS6+0y/v7W/H5iY6s1Zf7uOCCm0fiffY8t2H+4wXui2AOjcfEM77S6AvSTAJg==
+opentelemetry-instrumentation-fetch-node@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/opentelemetry-instrumentation-fetch-node/-/opentelemetry-instrumentation-fetch-node-1.2.0.tgz#5beaad33b622f7021c61733af864fb505cd35626"
+  integrity sha512-aiSt/4ubOTyb1N5C2ZbGrBvaJOXIZhZvpRPYuUVxQJe27wJZqf/o65iPrqgLcgfeOLaQ8cS2Q+762jrYvniTrA==
   dependencies:
     "@opentelemetry/api" "^1.6.0"
     "@opentelemetry/instrumentation" "^0.43.0"

From b2aa3924e0e5c187a391809f7faaded9056f5401 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 14:24:15 +0200
Subject: [PATCH 60/64] feat(nextjs): Remove webpack 4 support (#11605)

This is not supported since next 12, so we are good to remove this too:
https://nextjs.org/docs/messages/webpack5
---
 packages/nextjs/package.json |  3 +--
 yarn.lock                    | 40 +-----------------------------------
 2 files changed, 2 insertions(+), 41 deletions(-)

diff --git a/packages/nextjs/package.json b/packages/nextjs/package.json
index fec1a30a244a..882cc027797f 100644
--- a/packages/nextjs/package.json
+++ b/packages/nextjs/package.json
@@ -82,14 +82,13 @@
   },
   "devDependencies": {
     "@types/resolve": "1.20.3",
-    "@types/webpack": "^4.41.31",
     "eslint-plugin-react": "^7.31.11",
     "next": "13.2.0"
   },
   "peerDependencies": {
     "next": "^13.2.0 || ^14.0",
     "react": "16.x || 17.x || 18.x",
-    "webpack": ">= 4.0.0"
+    "webpack": ">= 5.0.0"
   },
   "peerDependenciesMeta": {
     "webpack": {
diff --git a/yarn.lock b/yarn.lock
index 2db9b7009ea8..05ba0338c571 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7175,11 +7175,6 @@
   dependencies:
     "@types/node" "*"
 
-"@types/source-list-map@*":
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/@types/source-list-map/-/source-list-map-0.1.2.tgz#0078836063ffaf17412349bba364087e0ac02ec9"
-  integrity sha512-K5K+yml8LTo9bWJI/rECfIPrGgxdpeNbj+d53lwN4QjW1MCwlkhUms+gtdzigTeUyBr09+u8BwOIY3MXvHdcsA==
-
 "@types/stack-utils@^2.0.0":
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.1.tgz#20f18294f797f2209b5f65c8e3b5c8e8261d127c"
@@ -7190,11 +7185,6 @@
   resolved "https://registry.yarnpkg.com/@types/symlink-or-copy/-/symlink-or-copy-1.2.0.tgz#4151a81b4052c80bc2becbae09f3a9ec010a9c7a"
   integrity sha512-Lja2xYuuf2B3knEsga8ShbOdsfNOtzT73GyJmZyY7eGl2+ajOqrs8yM5ze0fsSoYwvA6bw7/Qr7OZ7PEEmYwWg==
 
-"@types/tapable@^1":
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/@types/tapable/-/tapable-1.0.8.tgz#b94a4391c85666c7b73299fd3ad79d4faa435310"
-  integrity sha512-ipixuVrh2OdNmauvtT51o3d8z12p6LtFW9in7U79der/kwejjdNchQC5UMn5u/KxNoM7VHHOs/l8KS8uHxhODQ==
-
 "@types/tmp@^0.2.2":
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/@types/tmp/-/tmp-0.2.3.tgz#908bfb113419fd6a42273674c00994d40902c165"
@@ -7210,13 +7200,6 @@
   resolved "https://registry.yarnpkg.com/@types/triple-beam/-/triple-beam-1.3.2.tgz#38ecb64f01aa0d02b7c8f4222d7c38af6316fef8"
   integrity sha512-txGIh+0eDFzKGC25zORnswy+br1Ha7hj5cMVwKIU7+s0U2AxxJru/jZSMU6OC9MJWP6+pc/hc6ZjyZShpsyY2g==
 
-"@types/uglify-js@*":
-  version "3.13.1"
-  resolved "https://registry.yarnpkg.com/@types/uglify-js/-/uglify-js-3.13.1.tgz#5e889e9e81e94245c75b6450600e1c5ea2878aea"
-  integrity sha512-O3MmRAk6ZuAKa9CHgg0Pr0+lUOqoMLpc9AS4R8ano2auvsg7IE8syF3Xh/NPr26TWklxYcqoEEFdzLLs1fV9PQ==
-  dependencies:
-    source-map "^0.6.1"
-
 "@types/unist@*", "@types/unist@^3.0.0":
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/@types/unist/-/unist-3.0.0.tgz#988ae8af1e5239e89f9fbb1ade4c935f4eeedf9a"
@@ -7227,27 +7210,6 @@
   resolved "https://registry.yarnpkg.com/@types/unist/-/unist-2.0.8.tgz#bb197b9639aa1a04cf464a617fe800cccd92ad5c"
   integrity sha512-d0XxK3YTObnWVp6rZuev3c49+j4Lo8g4L1ZRm9z5L0xpoZycUPshHgczK5gsUMaZOstjVYYi09p5gYvUtfChYw==
 
-"@types/webpack-sources@*":
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/@types/webpack-sources/-/webpack-sources-3.2.0.tgz#16d759ba096c289034b26553d2df1bf45248d38b"
-  integrity sha512-Ft7YH3lEVRQ6ls8k4Ff1oB4jN6oy/XmU6tQISKdhfh+1mR+viZFphS6WL0IrtDOzvefmJg5a0s7ZQoRXwqTEFg==
-  dependencies:
-    "@types/node" "*"
-    "@types/source-list-map" "*"
-    source-map "^0.7.3"
-
-"@types/webpack@^4.41.31":
-  version "4.41.31"
-  resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-4.41.31.tgz#c35f252a3559ddf9c85c0d8b0b42019025e581aa"
-  integrity sha512-/i0J7sepXFIp1ZT7FjUGi1eXMCg8HCCzLJEQkKsOtbJFontsJLolBcDC+3qxn5pPwiCt1G0ZdRmYRzNBtvpuGQ==
-  dependencies:
-    "@types/node" "*"
-    "@types/tapable" "^1"
-    "@types/uglify-js" "*"
-    "@types/webpack-sources" "*"
-    anymatch "^3.0.0"
-    source-map "^0.6.0"
-
 "@types/ws@^8.5.1":
   version "8.5.10"
   resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.10.tgz#4acfb517970853fa6574a3a6886791d04a396787"
@@ -8555,7 +8517,7 @@ anymatch@^2.0.0:
     micromatch "^3.1.4"
     normalize-path "^2.1.1"
 
-anymatch@^3.0.0, anymatch@^3.0.3, anymatch@^3.1.1, anymatch@~3.1.2:
+anymatch@^3.0.3, anymatch@^3.1.1, anymatch@~3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716"
   integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==

From dc5aafc23e95ad417463f082b79ab176cbddbbe9 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 14:24:58 +0200
Subject: [PATCH 61/64] feat(opentelemetry): Remove `otel.attributes` in
 context (#11604)

This is duplicated from the trace data, no need to send this anymore.
---
 .../test/integration/transactions.test.ts     | 37 -------------------
 packages/opentelemetry/src/spanExporter.ts    |  2 -
 .../test/integration/transactions.test.ts     | 27 --------------
 3 files changed, 66 deletions(-)

diff --git a/packages/node/test/integration/transactions.test.ts b/packages/node/test/integration/transactions.test.ts
index e9d45294d1e3..d2a55e129cb9 100644
--- a/packages/node/test/integration/transactions.test.ts
+++ b/packages/node/test/integration/transactions.test.ts
@@ -75,12 +75,6 @@ describe('Integration | Transactions', () => {
     ]);
 
     expect(transaction.contexts?.otel).toEqual({
-      attributes: {
-        'test.outer': 'test value',
-        'sentry.op': 'test op',
-        'sentry.origin': 'auto.test',
-        'sentry.source': 'task',
-      },
       resource: {
         'service.name': 'node',
         'service.namespace': 'sentry',
@@ -245,14 +239,6 @@ describe('Integration | Transactions', () => {
           { message: 'test breadcrumb 3', timestamp: 123456 },
         ],
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'test.outer': 'test value',
-              'sentry.op': 'test op',
-              'sentry.origin': 'auto.test',
-              'sentry.source': 'task',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
@@ -294,12 +280,6 @@ describe('Integration | Transactions', () => {
           { message: 'test breadcrumb 3b', timestamp: 123456 },
         ],
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'test.outer': 'test value b',
-              'sentry.op': 'test op b',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
@@ -408,11 +388,6 @@ describe('Integration | Transactions', () => {
           { message: 'test breadcrumb 3', timestamp: 123456 },
         ],
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'test.outer': 'test value',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
@@ -449,11 +424,6 @@ describe('Integration | Transactions', () => {
           { message: 'test breadcrumb 3b', timestamp: 123456 },
         ],
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'test.outer': 'test value b',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
@@ -527,13 +497,6 @@ describe('Integration | Transactions', () => {
     expect(beforeSendTransaction).toHaveBeenLastCalledWith(
       expect.objectContaining({
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'sentry.op': 'test op',
-              'sentry.origin': 'auto.test',
-              'sentry.source': 'task',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
diff --git a/packages/opentelemetry/src/spanExporter.ts b/packages/opentelemetry/src/spanExporter.ts
index bdebb8e2f6e0..3ff88742db64 100644
--- a/packages/opentelemetry/src/spanExporter.ts
+++ b/packages/opentelemetry/src/spanExporter.ts
@@ -212,8 +212,6 @@ function createTransactionForOtelSpan(span: ReadableSpan): TransactionEvent {
     contexts: {
       trace: traceContext,
       otel: {
-        // TODO: remove the attributes here?
-        attributes: removeSentryAttributes(span.attributes),
         resource: span.resource.attributes,
       },
     },
diff --git a/packages/opentelemetry/test/integration/transactions.test.ts b/packages/opentelemetry/test/integration/transactions.test.ts
index ca73eb21fc02..63020fb2edd4 100644
--- a/packages/opentelemetry/test/integration/transactions.test.ts
+++ b/packages/opentelemetry/test/integration/transactions.test.ts
@@ -89,12 +89,6 @@ describe('Integration | Transactions', () => {
     ]);
 
     expect(transaction.contexts?.otel).toEqual({
-      attributes: {
-        'test.outer': 'test value',
-        'sentry.op': 'test op',
-        'sentry.origin': 'auto.test',
-        'sentry.source': 'task',
-      },
       resource: {
         'service.name': 'opentelemetry-test',
         'service.namespace': 'sentry',
@@ -259,14 +253,6 @@ describe('Integration | Transactions', () => {
           { message: 'test breadcrumb 3', timestamp: 123456 },
         ],
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'test.outer': 'test value',
-              'sentry.op': 'test op',
-              'sentry.origin': 'auto.test',
-              'sentry.source': 'task',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
@@ -308,12 +294,6 @@ describe('Integration | Transactions', () => {
           { message: 'test breadcrumb 3b', timestamp: 123456 },
         ],
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'test.outer': 'test value b',
-              'sentry.op': 'test op b',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',
@@ -391,13 +371,6 @@ describe('Integration | Transactions', () => {
     expect(beforeSendTransaction).toHaveBeenLastCalledWith(
       expect.objectContaining({
         contexts: expect.objectContaining({
-          otel: expect.objectContaining({
-            attributes: {
-              'sentry.op': 'test op',
-              'sentry.origin': 'auto.test',
-              'sentry.source': 'task',
-            },
-          }),
           trace: {
             data: {
               'otel.kind': 'INTERNAL',

From d7d43598c48a19bee79f00fd96ab92a6ef5723f3 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 14:47:57 +0200
Subject: [PATCH 62/64] build: Remove unnecessary yarn resolutions (#11603)

We don't actually need them anymore, as we've updated stuff I guess.
This also finally fixes the problem that yarn always seemed to do some
work even with the lockfile "up to date".
---
 package.json |   6 +--
 yarn.lock    | 102 ++++++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 97 insertions(+), 11 deletions(-)

diff --git a/package.json b/package.json
index 00945d179e72..05eb47e40591 100644
--- a/package.json
+++ b/package.json
@@ -136,11 +136,7 @@
     "vitest": "^0.29.2",
     "yalc": "^1.0.0-pre.53"
   },
-  "resolutions": {
-    "wrap-ansi": "7.0.0",
-    "string-width": "4.1.0",
-    "**/terser/source-map": "0.7.4"
-  },
+  "resolutions": {},
   "version": "0.0.0",
   "name": "sentry-javascript",
   "prettier": {
diff --git a/yarn.lock b/yarn.lock
index 05ba0338c571..b6c340ac1d3f 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -8463,7 +8463,7 @@ ansi-styles@^2.2.1:
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
   integrity sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=
 
-ansi-styles@^3.0.0, ansi-styles@^3.2.1:
+ansi-styles@^3.0.0, ansi-styles@^3.2.0, ansi-styles@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
   integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
@@ -8482,7 +8482,7 @@ ansi-styles@^5.0.0:
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
   integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
 
-ansi-styles@^6.0.0:
+ansi-styles@^6.0.0, ansi-styles@^6.1.0:
   version "6.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5"
   integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
@@ -13234,6 +13234,11 @@ duplexify@^4.0.0, duplexify@^4.1.1:
     readable-stream "^3.1.1"
     stream-shift "^1.0.0"
 
+eastasianwidth@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
+  integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
+
 ecdsa-sig-formatter@1.0.11, ecdsa-sig-formatter@^1.0.11:
   version "1.0.11"
   resolved "https://registry.yarnpkg.com/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz#ae0f0fa2d85045ef14a817daa3ce9acd0489e5bf"
@@ -13980,11 +13985,26 @@ emittery@^0.8.1:
   resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.8.1.tgz#bb23cc86d03b30aa75a7f734819dee2e1ba70860"
   integrity sha512-uDfvUjVrfGJJhymx/kz6prltenw1u7WrCg1oa94zYY8xxVpLLUu045LAT0dhDZdXG58/EpPL/5kA180fQ/qudg==
 
+emoji-regex@^10.2.1:
+  version "10.3.0"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-10.3.0.tgz#76998b9268409eb3dae3de989254d456e70cfe23"
+  integrity sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==
+
+emoji-regex@^7.0.1:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-7.0.3.tgz#933a04052860c85e83c122479c4748a8e4c72156"
+  integrity sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==
+
 emoji-regex@^8.0.0:
   version "8.0.0"
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
+emoji-regex@^9.2.2:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
+  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
+
 emojis-list@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
@@ -18148,6 +18168,11 @@ is-finite@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.1.0.tgz#904135c77fb42c0641d6aa1bcdbc4daa8da082f3"
   integrity sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==
 
+is-fullwidth-code-point@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
+  integrity sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==
+
 is-fullwidth-code-point@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
@@ -27625,7 +27650,8 @@ string-template@~0.2.1:
   resolved "https://registry.yarnpkg.com/string-template/-/string-template-0.2.1.tgz#42932e598a352d01fc22ec3367d9d84eec6c9add"
   integrity sha1-QpMuWYo1LQH8IuwzZ9nYTuxsmt0=
 
-"string-width-cjs@npm:string-width@^4.2.0":
+"string-width-cjs@npm:string-width@^4.2.0", string-width@^4.2.0, string-width@^4.2.2, string-width@^4.2.3:
+  name string-width-cjs
   version "4.2.3"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
@@ -27634,7 +27660,15 @@ string-template@~0.2.1:
     is-fullwidth-code-point "^3.0.0"
     strip-ansi "^6.0.1"
 
-string-width@4.1.0, "string-width@^1.0.2 || 2", "string-width@^1.0.2 || 2 || 3 || 4", string-width@^2.1.0, string-width@^3.0.0, string-width@^3.1.0, string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.2, string-width@^4.2.3, string-width@^5.0.0, string-width@^5.0.1, string-width@^5.1.2, string-width@^6.1.0:
+"string-width@^1.0.2 || 2", string-width@^2.1.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
+  integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
+  dependencies:
+    is-fullwidth-code-point "^2.0.0"
+    strip-ansi "^4.0.0"
+
+"string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.0.0, string-width@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.1.0.tgz#ba846d1daa97c3c596155308063e075ed1c99aff"
   integrity sha512-NrX+1dVVh+6Y9dnQ19pR0pP4FiEIlUvdTGn8pw6CKTNq5sgib2nIhmUNT5TAmhWmvKr3WcxBcP3E8nWezuipuQ==
@@ -27643,6 +27677,33 @@ string-width@4.1.0, "string-width@^1.0.2 || 2", "string-width@^1.0.2 || 2 || 3 |
     is-fullwidth-code-point "^3.0.0"
     strip-ansi "^5.2.0"
 
+string-width@^3.0.0, string-width@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-3.1.0.tgz#22767be21b62af1081574306f69ac51b62203961"
+  integrity sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==
+  dependencies:
+    emoji-regex "^7.0.1"
+    is-fullwidth-code-point "^2.0.0"
+    strip-ansi "^5.1.0"
+
+string-width@^5.0.0, string-width@^5.0.1, string-width@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
+  integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
+  dependencies:
+    eastasianwidth "^0.2.0"
+    emoji-regex "^9.2.2"
+    strip-ansi "^7.0.1"
+
+string-width@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-6.1.0.tgz#96488d6ed23f9ad5d82d13522af9e4c4c3fd7518"
+  integrity sha512-k01swCJAgQmuADB0YIc+7TuatfNvTBVOoaUWJjTB9R4VJzR5vNWzf5t42ESVZFPS8xTySF7CAdV4t/aaIm3UnQ==
+  dependencies:
+    eastasianwidth "^0.2.0"
+    emoji-regex "^10.2.1"
+    strip-ansi "^7.0.1"
+
 string.prototype.matchall@^4.0.5, string.prototype.matchall@^4.0.6, string.prototype.matchall@^4.0.8:
   version "4.0.8"
   resolved "https://registry.yarnpkg.com/string.prototype.matchall/-/string.prototype.matchall-4.0.8.tgz#3bf85722021816dcd1bf38bb714915887ca79fd3"
@@ -27721,6 +27782,7 @@ stringify-object@^3.2.1:
     is-regexp "^1.0.0"
 
 "strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+  name strip-ansi-cjs
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
@@ -27741,7 +27803,7 @@ strip-ansi@^4.0.0:
   dependencies:
     ansi-regex "^3.0.0"
 
-strip-ansi@^5.1.0, strip-ansi@^5.2.0:
+strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae"
   integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==
@@ -30436,7 +30498,8 @@ workerpool@^6.4.0:
   resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.4.0.tgz#f8d5cfb45fde32fa3b7af72ad617c3369567a462"
   integrity sha512-i3KR1mQMNwY2wx20ozq2EjISGtQWDIfV56We+yGJ5yDs8jTwQiLLaqHlkBHITlCuJnYlVRmXegxFxZg7gqI++A==
 
-"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@7.0.0, wrap-ansi@^5.1.0, wrap-ansi@^6.0.1, wrap-ansi@^6.2.0, wrap-ansi@^7.0.0, wrap-ansi@^8.1.0:
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0:
+  name wrap-ansi-cjs
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
@@ -30445,6 +30508,33 @@ workerpool@^6.4.0:
     string-width "^4.1.0"
     strip-ansi "^6.0.0"
 
+wrap-ansi@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-5.1.0.tgz#1fd1f67235d5b6d0fee781056001bfb694c03b09"
+  integrity sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==
+  dependencies:
+    ansi-styles "^3.2.0"
+    string-width "^3.0.0"
+    strip-ansi "^5.0.0"
+
+wrap-ansi@^6.0.1, wrap-ansi@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
+  integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
+wrap-ansi@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"
+  integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==
+  dependencies:
+    ansi-styles "^6.1.0"
+    string-width "^5.0.1"
+    strip-ansi "^7.0.1"
+
 wrappy@1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"

From 3d347527a95b0c795effc2bd84b52be8cb65d976 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 15 Apr 2024 14:51:09 +0200
Subject: [PATCH 63/64] fix(browser): Ensure pageload trace remains active
 after pageload span finished (#11600)

Remove the now incorrect propagationContext resetting logic for
pageload spans and add tests to cover this scenario.
---
 .../navigation/test.ts                        | 22 --------
 .../suites/tracing/trace-lifetime/init.js     |  9 ++++
 .../tracing/trace-lifetime/navigation/test.ts | 26 ++++++++++
 .../tracing/trace-lifetime/pageload/test.ts   | 50 +++++++++++++++++++
 .../suites/tracing/trace-lifetime/subject.js  |  4 ++
 .../tracing/trace-lifetime/template.html      |  9 ++++
 .../src/tracing/browserTracingIntegration.ts  |  8 ++-
 .../tracing/browserTracingIntegration.test.ts | 18 +++----
 8 files changed, 110 insertions(+), 36 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/template.html

diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts
index f7dc01ca7f54..5a46a65a4392 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts
@@ -49,25 +49,3 @@ sentryTest('should create a navigation transaction on page navigation', async ({
 
   expect(pageloadSpanId).not.toEqual(navigationSpanId);
 });
-
-sentryTest('should create a new trace for for multiple navigations', async ({ getLocalTestPath, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
-
-  const url = await getLocalTestPath({ testDir: __dirname });
-
-  await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const navigationEvent1 = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
-  const navigationEvent2 = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#bar`);
-
-  expect(navigationEvent1.contexts?.trace?.op).toBe('navigation');
-  expect(navigationEvent2.contexts?.trace?.op).toBe('navigation');
-
-  const navigation1TraceId = navigationEvent1.contexts?.trace?.trace_id;
-  const navigation2TraceId = navigationEvent2.contexts?.trace?.trace_id;
-
-  expect(navigation1TraceId).toBeDefined();
-  expect(navigation2TraceId).toBeDefined();
-  expect(navigation1TraceId).not.toEqual(navigation2TraceId);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js
new file mode 100644
index 000000000000..83076460599f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts
new file mode 100644
index 000000000000..cb8dc17812c7
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts
@@ -0,0 +1,26 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/types';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should create a new trace on each navigation', async ({ getLocalTestPath, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const navigationEvent1 = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
+  const navigationEvent2 = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#bar`);
+
+  expect(navigationEvent1.contexts?.trace?.op).toBe('navigation');
+  expect(navigationEvent2.contexts?.trace?.op).toBe('navigation');
+
+  const navigation1TraceId = navigationEvent1.contexts?.trace?.trace_id;
+  const navigation2TraceId = navigationEvent2.contexts?.trace?.trace_id;
+
+  expect(navigation1TraceId).toMatch(/^[0-9a-f]{32}$/);
+  expect(navigation2TraceId).toMatch(/^[0-9a-f]{32}$/);
+  expect(navigation1TraceId).not.toEqual(navigation2TraceId);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts
new file mode 100644
index 000000000000..16659f013dd0
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts
@@ -0,0 +1,50 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/types';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should create a new trace for a navigation after the initial pageload',
+  async ({ getLocalTestPath, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const pageloadEvent = await getFirstSentryEnvelopeRequest<Event>(page, url);
+    const navigationEvent1 = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
+
+    expect(pageloadEvent.contexts?.trace?.op).toBe('pageload');
+    expect(navigationEvent1.contexts?.trace?.op).toBe('navigation');
+
+    const pageloadTraceId = pageloadEvent.contexts?.trace?.trace_id;
+    const navigation1TraceId = navigationEvent1.contexts?.trace?.trace_id;
+
+    expect(pageloadTraceId).toMatch(/^[0-9a-f]{32}$/);
+    expect(navigation1TraceId).toMatch(/^[0-9a-f]{32}$/);
+    expect(pageloadTraceId).not.toEqual(navigation1TraceId);
+  },
+);
+
+sentryTest('error after pageload has pageload traceId', async ({ getLocalTestPath, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const pageloadEvent = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  expect(pageloadEvent.contexts?.trace?.op).toBe('pageload');
+
+  const pageloadTraceId = pageloadEvent.contexts?.trace?.trace_id;
+  expect(pageloadTraceId).toMatch(/^[0-9a-f]{32}$/);
+
+  const [, errorEvent] = await Promise.all([
+    page.locator('#errorBtn').click(),
+    getFirstSentryEnvelopeRequest<Event>(page),
+  ]);
+
+  const errorTraceId = errorEvent.contexts?.trace?.trace_id;
+  expect(errorTraceId).toBe(pageloadTraceId);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/subject.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/subject.js
new file mode 100644
index 000000000000..5131ea7631e9
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/subject.js
@@ -0,0 +1,4 @@
+const errorBtn = document.getElementById('errorBtn');
+errorBtn.addEventListener('click', () => {
+  throw new Error('Sentry Test Error');
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/template.html b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/template.html
new file mode 100644
index 000000000000..a29ad2056a45
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/template.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <button id="errorBtn">Throw Error</button>
+  </body>
+</html>
diff --git a/packages/browser/src/tracing/browserTracingIntegration.ts b/packages/browser/src/tracing/browserTracingIntegration.ts
index d1b4a90d6f97..16e715b15ad2 100644
--- a/packages/browser/src/tracing/browserTracingIntegration.ts
+++ b/packages/browser/src/tracing/browserTracingIntegration.ts
@@ -265,10 +265,11 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
         // This is a bit hacky, because we want to get the span to use both the correct scope _and_ the correct propagation context
         // but afterwards, we want to reset it to avoid this also applying to other spans
         const scope = getCurrentScope();
-        const propagationContextBefore = scope.getPropagationContext();
 
         activeSpan = continueTrace({ sentryTrace, baggage }, () => {
-          // We update the outer current scope to have the correct propagation context...
+          // We update the outer current scope to have the correct propagation context
+          // this means, the scope active when the pageload span is created will continue to hold the
+          // propagationContext from the incoming trace, even after the pageload span ended.
           scope.setPropagationContext(getCurrentScope().getPropagationContext());
 
           // Ensure we are on the original current scope again, so the span is set as active on it
@@ -279,9 +280,6 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
             });
           });
         });
-
-        // Reset this back to what it was before
-        scope.setPropagationContext(propagationContextBefore);
       });
 
       if (options.instrumentPageLoad && WINDOW.location) {
diff --git a/packages/browser/test/unit/tracing/browserTracingIntegration.test.ts b/packages/browser/test/unit/tracing/browserTracingIntegration.test.ts
index 30bf265cf20e..7fde92ab764e 100644
--- a/packages/browser/test/unit/tracing/browserTracingIntegration.test.ts
+++ b/packages/browser/test/unit/tracing/browserTracingIntegration.test.ts
@@ -710,9 +710,9 @@ describe('browserTracingIntegration', () => {
       expect(dynamicSamplingContext).toBeDefined();
       expect(dynamicSamplingContext).toStrictEqual({ release: '2.1.14' });
 
-      // Propagation context is reset and does not contain the meta tag data
-      expect(propagationContext.traceId).not.toEqual('12312012123120121231201212312012');
-      expect(propagationContext.parentSpanId).not.toEqual('1121201211212012');
+      // Propagation context keeps the meta tag trace data for later events on the same route to add them to the trace
+      expect(propagationContext.traceId).toEqual('12312012123120121231201212312012');
+      expect(propagationContext.parentSpanId).toEqual('1121201211212012');
     });
 
     it('puts frozen Dynamic Sampling Context on pageload span if sentry-trace data and only 3rd party baggage is present', () => {
@@ -747,9 +747,9 @@ describe('browserTracingIntegration', () => {
       expect(dynamicSamplingContext).toBeDefined();
       expect(dynamicSamplingContext).toStrictEqual({});
 
-      // Propagation context is reset and does not contain the meta tag data
-      expect(propagationContext.traceId).not.toEqual('12312012123120121231201212312012');
-      expect(propagationContext.parentSpanId).not.toEqual('1121201211212012');
+      // Propagation context keeps the meta tag trace data for later events on the same route to add them to the trace
+      expect(propagationContext.traceId).toEqual('12312012123120121231201212312012');
+      expect(propagationContext.parentSpanId).toEqual('1121201211212012');
     });
 
     it('ignores the meta tag data for navigation spans', () => {
@@ -843,9 +843,9 @@ describe('browserTracingIntegration', () => {
       expect(dynamicSamplingContext).toBeDefined();
       expect(dynamicSamplingContext).toStrictEqual({ release: '2.2.14' });
 
-      // Propagation context is reset and does not contain the meta tag data
-      expect(propagationContext.traceId).not.toEqual('12312012123120121231201212312012');
-      expect(propagationContext.parentSpanId).not.toEqual('1121201211212012');
+      // Propagation context keeps the custom trace data for later events on the same route to add them to the trace
+      expect(propagationContext.traceId).toEqual('12312012123120121231201212312011');
+      expect(propagationContext.parentSpanId).toEqual('1121201211212011');
     });
   });
 

From a1b65e82f3f19abede2dd40bd4a272db5d5aec99 Mon Sep 17 00:00:00 2001
From: Francesco Novy <francesco.novy@sentry.io>
Date: Mon, 15 Apr 2024 14:38:38 +0200
Subject: [PATCH 64/64] meta(changelog): Add changelog for v8.0.0-beta.0

---
 CHANGELOG.md | 140 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 140 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8bafd44c9c78..aa4c9807c79d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,146 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 8.0.0-beta.0
+
+This is the first beta release of Sentry JavaScript SDK v8. With this release, there are no more planned breaking
+changes for the v8 cycle.
+
+Read the [in-depth migration guide](./MIGRATION.md) to find out how to address any breaking changes in your code. All
+deprecations from the v7 cycle, with the exception of `getCurrentHub()`, have been removed and can no longer be used in
+v8.
+
+### Version Support
+
+The Sentry JavaScript SDK v8 now supports Node.js 14.8.0 or higher. This applies to `@sentry/node` and all of our
+node-based server-side sdks (`@sentry/nextjs`, `@sentry/remix`, etc.).
+
+The browser SDKs now require
+[ES2018+](https://caniuse.com/?feats=mdn-javascript_builtins_regexp_dotall,js-regexp-lookbehind,mdn-javascript_builtins_regexp_named_capture_groups,mdn-javascript_builtins_regexp_property_escapes,mdn-javascript_builtins_symbol_asynciterator,mdn-javascript_functions_method_definitions_async_generator_methods,mdn-javascript_grammar_template_literals_template_literal_revision,mdn-javascript_operators_destructuring_rest_in_objects,mdn-javascript_operators_destructuring_rest_in_arrays,promise-finally)
+compatible browsers. New minimum browser versions:
+
+- Chrome 63
+- Edge 79
+- Safari/iOS Safari 12
+- Firefox 58
+- Opera 50
+- Samsung Internet 8.2
+
+For more details, please see the [version support section in migration guide](./MIGRATION.md#1-version-support-changes).
+
+### Package removal
+
+The following packages will no longer be published
+
+- [@sentry/hub](./MIGRATION.md#sentryhub)
+- [@sentry/tracing](./MIGRATION.md#sentrytracing)
+- [@sentry/integrations](./MIGRATION.md#sentryintegrations)
+- [@sentry/serverless](./MIGRATION.md#sentryserverless)
+- [@sentry/replay](./MIGRATION.md#sentryreplay)
+
+### Initializing Server-side SDKs (Node, Bun, Next.js, SvelteKit, Astro, Remix):
+
+Initializing the SDKs on the server-side has been simplified. See more details in our migration docs about
+[initializing the SDK in v8](./MIGRATION.md/#initializing-the-node-sdk).
+
+### Performance Monitoring Changes
+
+The API around performance monitoring and tracing has been vastly improved, and we've added support for more
+integrations out of the box.
+
+- [Performance Monitoring API](./MIGRATION.md#performance-monitoring-api)
+- [Performance Monitoring Integrations](./MIGRATION.md#performance-monitoring-integrations)
+
+### Important Changes since v8.0.0-alpha.9
+
+- **feat(browser): Create spans as children of root span by default (#10986)**
+
+Because execution context isolation in browser environments does not work reliably, we deciced to keep a flat span
+hierarchy by default in v8.
+
+- **feat(core): Deprecate `addTracingExtensions` (#11579)**
+
+Instead of calling `Sentry.addTracingExtensions()` if you want to use performance in a browser SDK without using
+`browserTracingIntegration()`, you should now call `Sentry.registerSpanErrorInstrumentation()`.
+
+- **feat(core): Implement `suppressTracing` (#11468)**
+
+You can use the new `suppressTracing` API to ensure a given callback will not generate any spans:
+
+```js
+return Sentry.suppressTracing(() => {
+  // Ensure this fetch call does not generate a span
+  return fetch('/my-url');
+});
+```
+
+- **feat: Rename ESM loader hooks to `import` and `loader` (#11498)**
+
+We renamed the loader hooks for better clarity:
+
+```sh
+# For Node.js <= 18.18.2
+node --loader=@sentry/node/loader app.js
+
+# For Node.js >= 18.19.0
+node --import=@sentry/node/import app.js
+```
+
+- **feat(node): Do not exit process by default when other `onUncaughtException` handlers are registered in
+  `onUncaughtExceptionIntegration` (#11532)**
+
+In v8, we will no longer exit the node process by default if other uncaught exception handlers have been registered by
+the user.
+
+- **Better handling of transaction name for errors**
+
+We improved the way we keep the transaction name for error events, even when spans are not sampled or performance is
+disabled.
+
+- feat(fastify): Update scope `transactionName` when handling request (#11447)
+- feat(hapi): Update scope `transactionName` when handling request (#11448)
+- feat(koa): Update scope `transactionName` when creating router span (#11476)
+- feat(sveltekit): Update scope transactionName when handling server-side request (#11511)
+- feat(nestjs): Update scope transaction name with parameterized route (#11510)
+
+### Removal/Refactoring of deprecated functionality
+
+- feat(core): Remove `getCurrentHub` from `AsyncContextStrategy` (#11581)
+- feat(core): Remove `getGlobalHub` export (#11565)
+- feat(core): Remove `Hub` class export (#11560)
+- feat(core): Remove most Hub class exports (#11536)
+- feat(nextjs): Remove webpack 4 support (#11605)
+- feat(vercel-edge): Stop using hub (#11539)
+
+### Other Changes
+
+- feat: Hoist `getCurrentHub` shim to core as `getCurrentHubShim` (#11537)
+- feat(core): Add default behaviour for `rewriteFramesIntegration` in browser (#11535)
+- feat(core): Ensure replay envelopes are sent in order when offline (#11413)
+- feat(core): Extract errors from props in unkown inputs (#11526)
+- feat(core): Update metric normalization (#11518)
+- feat(feedback): Customize feedback placeholder text color (#11417)
+- feat(feedback): Maintain v7 compat in the @sentry-internal/feedback package (#11461)
+- feat(next): Handle existing root spans for isolation scope (#11479)
+- feat(node): Ensure tracing without performance (TWP) works (#11564)
+- feat(opentelemetry): Export `getRequestSpanData` (#11508)
+- feat(opentelemetry): Remove otel.attributes in context (#11604)
+- feat(ratelimit): Add metrics rate limit (#11538)
+- feat(remix): Skip span creation for `OPTIONS` and `HEAD` requests. (#11149)
+- feat(replay): Merge packages together & ensure bundles are built (#11552)
+- feat(tracing): Adds span envelope and datacategory (#11534)
+- fix(browser): Ensure pageload trace remains active after pageload span finished (#11600)
+- fix(browser): Ensure tracing without performance (TWP) works (#11561)
+- fix(nextjs): Fix `tunnelRoute` matching logic for hybrid cloud (#11576)
+- fix(nextjs): Remove Http integration from Next.js (#11304)
+- fix(node): Ensure isolation scope is correctly cloned for non-recording spans (#11503)
+- fix(node): Make fastify types more broad (#11544)
+- fix(node): Send ANR events without scope if event loop blocked indefinitely (#11578)
+- fix(tracing): Fixes latest route name and source not updating correctly (#11533)
+- ref(browser): Move browserTracing into browser pkg (#11484)
+- ref(feedback): Configure font size (#11437)
+- ref(feedback): Refactor Feedback types into @sentry/types and reduce the exported surface area (#11355)
+
 ## 8.0.0-alpha.9
 
 This is the eighth alpha release of Sentry JavaScript SDK v8, which includes a variety of breaking changes.