diff --git a/.github/workflows/external-contributors.yml b/.github/workflows/external-contributors.yml
index 076645f22773..782d95d60269 100644
--- a/.github/workflows/external-contributors.yml
+++ b/.github/workflows/external-contributors.yml
@@ -36,7 +36,7 @@ jobs:
           author_association: ${{ github.event.pull_request.author_association }}
 
       - name: Create PR with changes
-        uses: peter-evans/create-pull-request@dd2324fc52d5d43c699a5636bcf19fceaa70c284
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e
         with:
           # This token is scoped to Daniel Griesser
           # If we used the default GITHUB_TOKEN, the resulting PR would not trigger CI :(
diff --git a/.size-limit.js b/.size-limit.js
index eed705e16da6..ca26288b07b3 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -139,7 +139,7 @@ module.exports = [
     path: 'packages/vue/build/esm/index.js',
     import: createImport('init', 'browserTracingIntegration'),
     gzip: true,
-    limit: '39.5 KB',
+    limit: '40 KB',
   },
   // Svelte SDK (ESM)
   {
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 266092c9064e..a90046b67055 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,11 +10,64 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 9.12.0
+
+### Important Changes
+
+- **feat(feedback): Implement highlighting and hiding controls for screenshots ([#15951](https://github.com/getsentry/sentry-javascript/pull/15951))**
+
+  The Sentry SDK now supports highlighting and hiding controls for screenshots in [user feedback reports](https://docs.sentry.io/platforms/javascript/user-feedback/). This functionality is enabled by default.
+
+- **feat(node): Add `ignoreIncomingRequestBody` callback to `httpIntegration` ([#15959](https://github.com/getsentry/sentry-javascript/pull/15959))**
+
+  The `httpIntegration` now supports an optional `ignoreIncomingRequestBody` callback that can be used to skip capturing the body of incoming requests.
+
+  ```ts
+  Sentry.init({
+    integrations: [
+      Sentry.httpIntegration({
+        ignoreIncomingRequestBody: (url, request) => {
+          return request.method === 'GET' && url.includes('/api/large-payload');
+        },
+      }),
+    ],
+  });
+  ```
+
+  The `ignoreIncomingRequestBody` callback receives the URL of the request and should return `true` if the body should be ignored.
+
+- **Logging Improvements**
+
+  Sentry is adding support for [structured logging](https://github.com/getsentry/sentry-javascript/discussions/15916). In this release we've made a variety of improvements to logging functionality in the Sentry SDKs.
+
+  - feat(node): Add server.address to nodejs logs ([#16006](https://github.com/getsentry/sentry-javascript/pull/16006))
+  - feat(core): Add sdk name and version to logs ([#16005](https://github.com/getsentry/sentry-javascript/pull/16005))
+  - feat(core): Add sentry origin attribute to console logs integration ([#15998](https://github.com/getsentry/sentry-javascript/pull/15998))
+  - fix(core): Do not abbreviate message parameter attribute ([#15987](https://github.com/getsentry/sentry-javascript/pull/15987))
+  - fix(core): Prefix release and environment correctly ([#15999](https://github.com/getsentry/sentry-javascript/pull/15999))
+  - fix(node): Make log flushing logic more robust ([#15991](https://github.com/getsentry/sentry-javascript/pull/15991))
+
+### Other Changes
+
+- build(aws-serverless): Include debug logs in lambda layer SDK bundle ([#15974](https://github.com/getsentry/sentry-javascript/pull/15974))
+- feat(astro): Add tracking of errors during HTML streaming ([#15995](https://github.com/getsentry/sentry-javascript/pull/15995))
+- feat(browser): Add `onRequestSpanStart` hook to browser tracing integration ([#15979](https://github.com/getsentry/sentry-javascript/pull/15979))
+- feat(deps): Bump @sentry/cli from 2.42.3 to 2.43.0 ([#16001](https://github.com/getsentry/sentry-javascript/pull/16001))
+- feat(nextjs): Add `captureRouterTransitionStart` hook for capturing navigations ([#15981](https://github.com/getsentry/sentry-javascript/pull/15981))
+- feat(nextjs): Mark clientside prefetch request spans with `http.request.prefetch: true` attribute ([#15980](https://github.com/getsentry/sentry-javascript/pull/15980))
+- feat(nextjs): Un experimentify `clientInstrumentationHook` ([#15992](https://github.com/getsentry/sentry-javascript/pull/15992))
+- feat(nextjs): Warn when client was initialized more than once ([#15971](https://github.com/getsentry/sentry-javascript/pull/15971))
+- feat(node): Add support for `SENTRY_DEBUG` env variable ([#15972](https://github.com/getsentry/sentry-javascript/pull/15972))
+- fix(tss-react): Change `authToken` type to `string` ([#15985](https://github.com/getsentry/sentry-javascript/pull/15985))
+
+Work in this release was contributed by @Page- and @Fryuni. Thank you for your contributions!
+
 ## 9.11.0
 
 - feat(browser): Add `http.redirect_count` attribute to `browser.redirect` span ([#15943](https://github.com/getsentry/sentry-javascript/pull/15943))
 - feat(core): Add `consoleLoggingIntegration` for logs ([#15955](https://github.com/getsentry/sentry-javascript/pull/15955))
 - feat(core): Don't truncate error messages ([#15818](https://github.com/getsentry/sentry-javascript/pull/15818))
+- feat(core): Emit debug log when transport execution fails ([#16009](https://github.com/getsentry/sentry-javascript/pull/16009))
 - feat(nextjs): Add release injection in Turbopack ([#15958](https://github.com/getsentry/sentry-javascript/pull/15958))
 - feat(nextjs): Record `turbopack` as tag ([#15928](https://github.com/getsentry/sentry-javascript/pull/15928))
 - feat(nuxt): Base decision on source maps upload only on Nuxt source map settings ([#15859](https://github.com/getsentry/sentry-javascript/pull/15859))
@@ -117,7 +170,7 @@
 
 - **feat(nextjs): Support `instrumentation-client.ts` ([#15705](https://github.com/getsentry/sentry-javascript/pull/15705))**
 
-  Next.js recently added a feature to support [client-side (browser) instrumentation via the `experimental.clientInstrumentationHook` flag and the `instrumentation-client.ts` file](https://nextjs.org/docs/app/api-reference/config/next-config-js/clientInstrumentationHook).
+  Next.js recently added a feature to support [client-side (browser) instrumentation via a `instrumentation-client.ts` file](https://nextjs.org/docs/app/api-reference/file-conventions/instrumentation-client).
 
   To be forwards compatible, the Sentry Next.js SDK will now pick up `instrumentation-client.ts` files even on older Next.js versions and add them to your client bundles.
   It is suggested that you either rename your `sentry.client.config.ts` file to `instrumentation-client.ts`, or if you already happen to have a `instrumentation-client.ts` file move the contents of `sentry.client.config.ts` to `instrumentation-client.ts`.
diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/integration/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/integration/test.ts
index 00e918ce9719..e255a6afda23 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/integration/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/integration/test.ts
@@ -23,7 +23,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'trace',
       body: { stringValue: 'console.trace 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 1,
@@ -37,7 +56,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'debug',
       body: { stringValue: 'console.debug 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 5,
@@ -51,7 +89,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'info',
       body: { stringValue: 'console.log 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 10,
@@ -65,7 +122,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'info',
       body: { stringValue: 'console.info 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 9,
@@ -79,7 +155,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'warn',
       body: { stringValue: 'console.warn 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 13,
@@ -93,7 +188,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'error',
       body: { stringValue: 'console.error 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 17,
@@ -107,7 +221,26 @@ sentryTest('should capture console object calls', async ({ getLocalTestUrl, page
     {
       severityText: 'error',
       body: { stringValue: 'Assertion failed: console.assert 123 false' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.origin',
+          value: {
+            stringValue: 'auto.console.logging',
+          },
+        },
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 17,
diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/simple/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/simple/test.ts
index 84f2a34e8fe5..5995058867a0 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/simple/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/simple/test.ts
@@ -23,7 +23,20 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
     {
       severityText: 'trace',
       body: { stringValue: 'test trace' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 1,
@@ -37,7 +50,20 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
     {
       severityText: 'debug',
       body: { stringValue: 'test debug' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 5,
@@ -51,7 +77,20 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
     {
       severityText: 'info',
       body: { stringValue: 'test info' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 9,
@@ -65,7 +104,20 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
     {
       severityText: 'warn',
       body: { stringValue: 'test warn' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 13,
@@ -79,7 +131,20 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
     {
       severityText: 'error',
       body: { stringValue: 'test error' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 17,
@@ -93,7 +158,20 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
     {
       severityText: 'fatal',
       body: { stringValue: 'test fatal' },
-      attributes: [],
+      attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 21,
@@ -108,6 +186,18 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       severityText: 'trace',
       body: { stringValue: 'test trace stringArg false 123' },
       attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
         {
           key: 'sentry.message.template',
           value: {
@@ -115,25 +205,25 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
           },
         },
         {
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: {
             stringValue: 'trace',
           },
         },
         {
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.param.2',
+          key: 'sentry.message.parameter.2',
           value: {
             boolValue: false,
           },
         },
         {
-          key: 'sentry.message.param.3',
+          key: 'sentry.message.parameter.3',
           value: {
             doubleValue: 123,
           },
@@ -153,6 +243,18 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       severityText: 'debug',
       body: { stringValue: 'test debug stringArg false 123' },
       attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
         {
           key: 'sentry.message.template',
           value: {
@@ -160,25 +262,25 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
           },
         },
         {
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: {
             stringValue: 'debug',
           },
         },
         {
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.param.2',
+          key: 'sentry.message.parameter.2',
           value: {
             boolValue: false,
           },
         },
         {
-          key: 'sentry.message.param.3',
+          key: 'sentry.message.parameter.3',
           value: {
             doubleValue: 123,
           },
@@ -198,6 +300,18 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       severityText: 'info',
       body: { stringValue: 'test info stringArg false 123' },
       attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
         {
           key: 'sentry.message.template',
           value: {
@@ -205,25 +319,25 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
           },
         },
         {
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: {
             stringValue: 'info',
           },
         },
         {
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.param.2',
+          key: 'sentry.message.parameter.2',
           value: {
             boolValue: false,
           },
         },
         {
-          key: 'sentry.message.param.3',
+          key: 'sentry.message.parameter.3',
           value: {
             doubleValue: 123,
           },
@@ -243,6 +357,18 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       severityText: 'warn',
       body: { stringValue: 'test warn stringArg false 123' },
       attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
         {
           key: 'sentry.message.template',
           value: {
@@ -250,25 +376,25 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
           },
         },
         {
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: {
             stringValue: 'warn',
           },
         },
         {
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.param.2',
+          key: 'sentry.message.parameter.2',
           value: {
             boolValue: false,
           },
         },
         {
-          key: 'sentry.message.param.3',
+          key: 'sentry.message.parameter.3',
           value: {
             doubleValue: 123,
           },
@@ -288,6 +414,18 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       severityText: 'error',
       body: { stringValue: 'test error stringArg false 123' },
       attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
         {
           key: 'sentry.message.template',
           value: {
@@ -295,25 +433,25 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
           },
         },
         {
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: {
             stringValue: 'error',
           },
         },
         {
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.param.2',
+          key: 'sentry.message.parameter.2',
           value: {
             boolValue: false,
           },
         },
         {
-          key: 'sentry.message.param.3',
+          key: 'sentry.message.parameter.3',
           value: {
             doubleValue: 123,
           },
@@ -333,6 +471,18 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       severityText: 'fatal',
       body: { stringValue: 'test fatal stringArg false 123' },
       attributes: [
+        {
+          key: 'sentry.sdk.name',
+          value: {
+            stringValue: 'sentry.javascript.browser',
+          },
+        },
+        {
+          key: 'sentry.sdk.version',
+          value: {
+            stringValue: expect.any(String),
+          },
+        },
         {
           key: 'sentry.message.template',
           value: {
@@ -340,25 +490,25 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
           },
         },
         {
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: {
             stringValue: 'fatal',
           },
         },
         {
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.param.2',
+          key: 'sentry.message.parameter.2',
           value: {
             boolValue: false,
           },
         },
         {
-          key: 'sentry.message.param.3',
+          key: 'sentry.message.parameter.3',
           value: {
             doubleValue: 123,
           },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js
new file mode 100644
index 000000000000..2c85bd05b765
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js
@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [
+    Sentry.browserTracingIntegration({
+      idleTimeout: 1000,
+      onRequestSpanStart(span, { headers }) {
+        if (headers) {
+          span.setAttribute('hook.called.headers', headers.get('foo'));
+        }
+      },
+    }),
+  ],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/subject.js
new file mode 100644
index 000000000000..494ce7d23a05
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/subject.js
@@ -0,0 +1,11 @@
+fetch('http://sentry-test-site-fetch.example/', {
+  headers: {
+    foo: 'fetch',
+  },
+});
+
+const xhr = new XMLHttpRequest();
+
+xhr.open('GET', 'http://sentry-test-site-xhr.example/');
+xhr.setRequestHeader('foo', 'xhr');
+xhr.send();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts
new file mode 100644
index 000000000000..91b0c1333298
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts
@@ -0,0 +1,52 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should call onRequestSpanStart hook', async ({ browserName, getLocalTestUrl, page }) => {
+  const supportedBrowsers = ['chromium', 'firefox'];
+
+  if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
+    sentryTest.skip();
+  }
+
+  await page.route('http://sentry-test-site-fetch.example/', async route => {
+    await route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: '',
+    });
+  });
+  await page.route('http://sentry-test-site-xhr.example/', async route => {
+    await route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: '',
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const envelopes = await getMultipleSentryEnvelopeRequests<Event>(page, 2, { url, timeout: 10000 });
+
+  const tracingEvent = envelopes[envelopes.length - 1]; // last envelope contains tracing data on all browsers
+
+  expect(tracingEvent.spans).toContainEqual(
+    expect.objectContaining({
+      op: 'http.client',
+      data: expect.objectContaining({
+        'hook.called.headers': 'xhr',
+      }),
+    }),
+  );
+
+  expect(tracingEvent.spans).toContainEqual(
+    expect.objectContaining({
+      op: 'http.client',
+      data: expect.objectContaining({
+        'hook.called.headers': 'fetch',
+      }),
+    }),
+  );
+});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-13/sentry.client.config.ts b/dev-packages/e2e-tests/test-applications/nextjs-13/instrumentation-client.ts
similarity index 78%
rename from dev-packages/e2e-tests/test-applications/nextjs-13/sentry.client.config.ts
rename to dev-packages/e2e-tests/test-applications/nextjs-13/instrumentation-client.ts
index f2c7e4aef94d..4870c64e7959 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-13/sentry.client.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-13/instrumentation-client.ts
@@ -1,5 +1,3 @@
-'use client';
-
 import * as Sentry from '@sentry/nextjs';
 
 Sentry.init({
@@ -9,3 +7,5 @@ Sentry.init({
   tracesSampleRate: 1.0,
   sendDefaultPii: true,
 });
+
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-14/sentry.client.config.ts b/dev-packages/e2e-tests/test-applications/nextjs-14/instrumentation-client.ts
similarity index 78%
rename from dev-packages/e2e-tests/test-applications/nextjs-14/sentry.client.config.ts
rename to dev-packages/e2e-tests/test-applications/nextjs-14/instrumentation-client.ts
index f2c7e4aef94d..4870c64e7959 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-14/sentry.client.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-14/instrumentation-client.ts
@@ -1,5 +1,3 @@
-'use client';
-
 import * as Sentry from '@sentry/nextjs';
 
 Sentry.init({
@@ -9,3 +7,5 @@ Sentry.init({
   tracesSampleRate: 1.0,
   sendDefaultPii: true,
 });
+
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-15/app/prefetching/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-15/app/prefetching/page.tsx
new file mode 100644
index 000000000000..4cb811ecf1b4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-15/app/prefetching/page.tsx
@@ -0,0 +1,9 @@
+import Link from 'next/link';
+
+export default function Page() {
+  return (
+    <Link id="prefetch-link" href="/prefetching/to-be-prefetched">
+      link
+    </Link>
+  );
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-15/app/prefetching/to-be-prefetched/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-15/app/prefetching/to-be-prefetched/page.tsx
new file mode 100644
index 000000000000..83aac90d65cf
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-15/app/prefetching/to-be-prefetched/page.tsx
@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export default function Page() {
+  return <p>Hello</p>;
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-15/sentry.client.config.ts b/dev-packages/e2e-tests/test-applications/nextjs-15/instrumentation-client.ts
similarity index 78%
rename from dev-packages/e2e-tests/test-applications/nextjs-15/sentry.client.config.ts
rename to dev-packages/e2e-tests/test-applications/nextjs-15/instrumentation-client.ts
index f2c7e4aef94d..4870c64e7959 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-15/sentry.client.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-15/instrumentation-client.ts
@@ -1,5 +1,3 @@
-'use client';
-
 import * as Sentry from '@sentry/nextjs';
 
 Sentry.init({
@@ -9,3 +7,5 @@ Sentry.init({
   tracesSampleRate: 1.0,
   sendDefaultPii: true,
 });
+
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-15/next-env.d.ts b/dev-packages/e2e-tests/test-applications/nextjs-15/next-env.d.ts
index 40c3d68096c2..1b3be0840f3f 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-15/next-env.d.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-15/next-env.d.ts
@@ -2,4 +2,4 @@
 /// <reference types="next/image-types/global" />
 
 // NOTE: This file should not be edited
-// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-15/package.json b/dev-packages/e2e-tests/test-applications/nextjs-15/package.json
index 66b38e2e5cc0..a79d34746ee4 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-15/package.json
+++ b/dev-packages/e2e-tests/test-applications/nextjs-15/package.json
@@ -18,7 +18,7 @@
     "@types/node": "^18.19.1",
     "@types/react": "18.0.26",
     "@types/react-dom": "18.0.9",
-    "next": "15.0.0-canary.182",
+    "next": "15.3.0-canary.33",
     "react": "beta",
     "react-dom": "beta",
     "typescript": "~5.0.0"
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-15/tests/prefetch-spans.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-15/tests/prefetch-spans.test.ts
new file mode 100644
index 000000000000..b59a45f31f8b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-15/tests/prefetch-spans.test.ts
@@ -0,0 +1,24 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('Prefetch client spans should have a http.request.prefetch attribute', async ({ page }) => {
+  test.skip(process.env.TEST_ENV === 'development', "Prefetch requests don't have the prefetch header in dev mode");
+
+  const pageloadTransactionPromise = waitForTransaction('nextjs-15', async transactionEvent => {
+    return transactionEvent?.transaction === '/prefetching';
+  });
+
+  await page.goto(`/prefetching`);
+
+  // Make it more likely that nextjs prefetches
+  await page.hover('#prefetch-link');
+
+  expect((await pageloadTransactionPromise).spans).toContainEqual(
+    expect.objectContaining({
+      op: 'http.client',
+      data: expect.objectContaining({
+        'http.request.prefetch': true,
+      }),
+    }),
+  );
+});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/sentry.client.config.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/instrumentation-client.ts
similarity index 78%
rename from dev-packages/e2e-tests/test-applications/nextjs-app-dir/sentry.client.config.ts
rename to dev-packages/e2e-tests/test-applications/nextjs-app-dir/instrumentation-client.ts
index f2c7e4aef94d..4870c64e7959 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/sentry.client.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/instrumentation-client.ts
@@ -1,5 +1,3 @@
-'use client';
-
 import * as Sentry from '@sentry/nextjs';
 
 Sentry.init({
@@ -9,3 +7,5 @@ Sentry.init({
   tracesSampleRate: 1.0,
   sendDefaultPii: true,
 });
+
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/next-env.d.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/next-env.d.ts
index fd36f9494e2c..725dd6f24515 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/next-env.d.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/next-env.d.ts
@@ -3,4 +3,4 @@
 /// <reference types="next/navigation-types/compat/navigation" />
 
 // NOTE: This file should not be edited
-// see https://nextjs.org/docs/basic-features/typescript for more information.
+// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/client-app-routing-instrumentation.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/client-app-routing-instrumentation.test.ts
index abfe9b323d0f..8069a1d1395b 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/client-app-routing-instrumentation.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/client-app-routing-instrumentation.test.ts
@@ -106,7 +106,7 @@ test('Creates a navigation transaction for `router.back()`', async ({ page }) =>
     contexts: {
       trace: {
         data: {
-          'navigation.type': 'router.back',
+          'navigation.type': expect.stringMatching(/router\.(back|traverse)/), // back is Next.js < 15.3.0, traverse >= 15.3.0
         },
       },
     },
@@ -118,7 +118,8 @@ test('Creates a navigation transaction for `router.forward()`', async ({ page })
     return (
       transactionEvent?.transaction === `/navigation/42/router-push` &&
       transactionEvent.contexts?.trace?.op === 'navigation' &&
-      transactionEvent.contexts.trace.data?.['navigation.type'] === 'router.forward'
+      (transactionEvent.contexts.trace.data?.['navigation.type'] === 'router.forward' ||
+        transactionEvent.contexts.trace.data?.['navigation.type'] === 'router.traverse')
     );
   });
 
@@ -169,7 +170,8 @@ test('Creates a navigation transaction for browser-back', async ({ page }) => {
     return (
       transactionEvent?.transaction === `/navigation/42/browser-back` &&
       transactionEvent.contexts?.trace?.op === 'navigation' &&
-      transactionEvent.contexts.trace.data?.['navigation.type'] === 'browser.popstate'
+      (transactionEvent.contexts.trace.data?.['navigation.type'] === 'browser.popstate' ||
+        transactionEvent.contexts.trace.data?.['navigation.type'] === 'router.traverse')
     );
   });
 
@@ -187,7 +189,8 @@ test('Creates a navigation transaction for browser-forward', async ({ page }) =>
     return (
       transactionEvent?.transaction === `/navigation/42/router-push` &&
       transactionEvent.contexts?.trace?.op === 'navigation' &&
-      transactionEvent.contexts.trace.data?.['navigation.type'] === 'browser.popstate'
+      (transactionEvent.contexts.trace.data?.['navigation.type'] === 'browser.popstate' ||
+        transactionEvent.contexts.trace.data?.['navigation.type'] === 'router.traverse')
     );
   });
 
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-turbo/instrumentation-client.ts b/dev-packages/e2e-tests/test-applications/nextjs-turbo/instrumentation-client.ts
index 85bd765c9c44..4870c64e7959 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-turbo/instrumentation-client.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-turbo/instrumentation-client.ts
@@ -7,3 +7,5 @@ Sentry.init({
   tracesSampleRate: 1.0,
   sendDefaultPii: true,
 });
+
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-turbo/package.json b/dev-packages/e2e-tests/test-applications/nextjs-turbo/package.json
index 94e762a859a9..99679ba13deb 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-turbo/package.json
+++ b/dev-packages/e2e-tests/test-applications/nextjs-turbo/package.json
@@ -17,7 +17,7 @@
     "@types/node": "^18.19.1",
     "@types/react": "18.0.26",
     "@types/react-dom": "18.0.9",
-    "next": "15.3.0-canary.26",
+    "next": "15.3.0-canary.40",
     "react": "rc",
     "react-dom": "rc",
     "typescript": "~5.0.0"
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/server.js b/dev-packages/node-integration-tests/suites/express/tracing/server.js
index f9b4ae24b339..0291ee656995 100644
--- a/dev-packages/node-integration-tests/suites/express/tracing/server.js
+++ b/dev-packages/node-integration-tests/suites/express/tracing/server.js
@@ -8,6 +8,16 @@ Sentry.init({
   tracePropagationTargets: [/^(?!.*test).*$/],
   tracesSampleRate: 1.0,
   transport: loggingTransport,
+  integrations: [
+    Sentry.httpIntegration({
+      ignoreIncomingRequestBody: (url) => {
+        if (url.includes('/test-post-ignore-body')) {
+          return true;
+        }
+        return false;
+      },
+    }),
+  ],
 });
 
 // express must be required after Sentry is initialized
@@ -43,6 +53,10 @@ app.post('/test-post', function (req, res) {
   res.send({ status: 'ok', body: req.body });
 });
 
+app.post('/test-post-ignore-body', function (req, res) {
+  res.send({ status: 'ok', body: req.body });
+});
+
 Sentry.setupExpressErrorHandler(app);
 
 startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/test.ts b/dev-packages/node-integration-tests/suites/express/tracing/test.ts
index ebf9977e722b..ebe710bdc0d0 100644
--- a/dev-packages/node-integration-tests/suites/express/tracing/test.ts
+++ b/dev-packages/node-integration-tests/suites/express/tracing/test.ts
@@ -1,5 +1,6 @@
 import { afterAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+import { assertSentryTransaction } from '../../../utils/assertions';
 
 describe('express tracing', () => {
   afterAll(() => {
@@ -244,6 +245,34 @@ describe('express tracing', () => {
         });
         await runner.completed();
       });
+
+      test('correctly ignores request data', async () => {
+        const runner = createRunner(__dirname, 'server.js')
+          .expect({
+            transaction: e => {
+              assertSentryTransaction(e, {
+                transaction: 'POST /test-post-ignore-body',
+                request: {
+                  url: expect.stringMatching(/^http:\/\/localhost:(\d+)\/test-post-ignore-body$/),
+                  method: 'POST',
+                  headers: {
+                    'user-agent': expect.stringContaining(''),
+                    'content-type': 'application/octet-stream',
+                  },
+                },
+              });
+              // Ensure the request body has been ignored
+              expect(e).have.property('request').that.does.not.have.property('data');
+            },
+          })
+          .start();
+
+        runner.makeRequest('post', '/test-post-ignore-body', {
+          headers: { 'Content-Type': 'application/octet-stream' },
+          data: Buffer.from('some plain text in buffer'),
+        });
+        await runner.completed();
+      });
     });
   });
 });
diff --git a/packages/astro/src/server/middleware.ts b/packages/astro/src/server/middleware.ts
index 6b55dbd8a976..692a8a7256a3 100644
--- a/packages/astro/src/server/middleware.ts
+++ b/packages/astro/src/server/middleware.ts
@@ -184,12 +184,18 @@ async function instrumentRequest(
 
               const newResponseStream = new ReadableStream({
                 start: async controller => {
-                  for await (const chunk of originalBody) {
-                    const html = typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
-                    const modifiedHtml = addMetaTagToHead(html);
-                    controller.enqueue(new TextEncoder().encode(modifiedHtml));
+                  try {
+                    for await (const chunk of originalBody) {
+                      const html = typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+                      const modifiedHtml = addMetaTagToHead(html);
+                      controller.enqueue(new TextEncoder().encode(modifiedHtml));
+                    }
+                  } catch (e) {
+                    sendErrorToSentry(e);
+                    controller.error(e);
+                  } finally {
+                    controller.close();
                   }
-                  controller.close();
                 },
               });
 
diff --git a/packages/astro/test/server/middleware.test.ts b/packages/astro/test/server/middleware.test.ts
index eff473d4401f..08dcb6112421 100644
--- a/packages/astro/test/server/middleware.test.ts
+++ b/packages/astro/test/server/middleware.test.ts
@@ -149,6 +149,49 @@ describe('sentryMiddleware', () => {
     });
   });
 
+  it('throws and sends an error to sentry if response streaming throws', async () => {
+    const captureExceptionSpy = vi.spyOn(SentryNode, 'captureException');
+
+    const middleware = handleRequest();
+    const ctx = {
+      request: {
+        method: 'GET',
+        url: '/users',
+        headers: new Headers(),
+      },
+      url: new URL('https://myDomain.io/users/'),
+      params: {},
+    };
+
+    const error = new Error('Something went wrong');
+
+    const faultyStream = new ReadableStream({
+      pull: controller => {
+        controller.error(error);
+        controller.close();
+      },
+    });
+
+    const next = vi.fn(() =>
+      Promise.resolve(
+        new Response(faultyStream, {
+          headers: new Headers({ 'content-type': 'text/html' }),
+        }),
+      ),
+    );
+
+    // @ts-expect-error, a partial ctx object is fine here
+    const resultFromNext = await middleware(ctx, next);
+
+    expect(resultFromNext?.headers.get('content-type')).toEqual('text/html');
+
+    await expect(() => resultFromNext!.text()).rejects.toThrowError();
+
+    expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+      mechanism: { handled: false, type: 'astro', data: { function: 'astroMiddleware' } },
+    });
+  });
+
   describe('track client IP address', () => {
     it('attaches client IP if `trackClientIp=true` when handling dynamic page requests', async () => {
       const middleware = handleRequest({ trackClientIp: true });
diff --git a/packages/aws-serverless/rollup.aws.config.mjs b/packages/aws-serverless/rollup.aws.config.mjs
index 6348d3b1ae74..d9f0720886ef 100644
--- a/packages/aws-serverless/rollup.aws.config.mjs
+++ b/packages/aws-serverless/rollup.aws.config.mjs
@@ -19,7 +19,7 @@ export default [
     // We only need one copy of the SDK, and we pick the minified one because there's a cap on how big a lambda function
     // plus its dependencies can be, and we might as well take up as little of that space as is necessary. We'll rename
     // it to be `index.js` in the build script, since it's standing in for the index file of the npm package.
-    { variants: ['.min.js'] },
+    { variants: ['.debug.min.js'] },
   ),
   makeBaseNPMConfig({
     entrypoints: ['src/awslambda-auto.ts'],
diff --git a/packages/aws-serverless/scripts/buildLambdaLayer.ts b/packages/aws-serverless/scripts/buildLambdaLayer.ts
index 6062db947ceb..7ce98ca64a5c 100644
--- a/packages/aws-serverless/scripts/buildLambdaLayer.ts
+++ b/packages/aws-serverless/scripts/buildLambdaLayer.ts
@@ -19,7 +19,7 @@ async function buildLambdaLayer(): Promise<void> {
   // We build a minified bundle, but it's standing in for the regular `index.js` file listed in `package.json`'s `main`
   // property, so we have to rename it so it's findable.
   fs.renameSync(
-    'build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/cjs/index.min.js',
+    'build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/cjs/index.debug.min.js',
     'build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/cjs/index.js',
   );
 
diff --git a/packages/browser/src/tracing/browserTracingIntegration.ts b/packages/browser/src/tracing/browserTracingIntegration.ts
index 062b308527d6..fab45cd1ed4f 100644
--- a/packages/browser/src/tracing/browserTracingIntegration.ts
+++ b/packages/browser/src/tracing/browserTracingIntegration.ts
@@ -9,7 +9,7 @@ import {
   startTrackingLongTasks,
   startTrackingWebVitals,
 } from '@sentry-internal/browser-utils';
-import type { Client, IntegrationFn, Span, StartSpanOptions, TransactionSource } from '@sentry/core';
+import type { Client, IntegrationFn, Span, StartSpanOptions, TransactionSource, WebFetchHeaders } from '@sentry/core';
 import {
   GLOBAL_OBJ,
   SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON,
@@ -195,6 +195,13 @@ export interface BrowserTracingOptions {
    * Default: (url: string) => true
    */
   shouldCreateSpanForRequest?(this: void, url: string): boolean;
+
+  /**
+   * This callback is invoked directly after a span is started for an outgoing fetch or XHR request.
+   * You can use it to annotate the span with additional data or attributes, for example by setting
+   * attributes based on the passed request headers.
+   */
+  onRequestSpanStart?(span: Span, requestInformation: { headers?: WebFetchHeaders }): void;
 }
 
 const DEFAULT_BROWSER_TRACING_OPTIONS: BrowserTracingOptions = {
@@ -246,6 +253,7 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
     instrumentPageLoad,
     instrumentNavigation,
     linkPreviousTrace,
+    onRequestSpanStart,
   } = {
     ...DEFAULT_BROWSER_TRACING_OPTIONS,
     ..._options,
@@ -468,6 +476,7 @@ export const browserTracingIntegration = ((_options: Partial<BrowserTracingOptio
         tracePropagationTargets: client.getOptions().tracePropagationTargets,
         shouldCreateSpanForRequest,
         enableHTTPTimings,
+        onRequestSpanStart,
       });
     },
   };
diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts
index 17dd71f0abba..0a8e42547341 100644
--- a/packages/browser/src/tracing/request.ts
+++ b/packages/browser/src/tracing/request.ts
@@ -5,7 +5,7 @@ import {
   extractNetworkProtocol,
 } from '@sentry-internal/browser-utils';
 import type { XhrHint } from '@sentry-internal/browser-utils';
-import type { Client, HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/core';
+import type { Client, HandlerDataXhr, SentryWrappedXMLHttpRequest, Span, WebFetchHeaders } from '@sentry/core';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
@@ -98,6 +98,11 @@ export interface RequestInstrumentationOptions {
    * Default: (url: string) => true
    */
   shouldCreateSpanForRequest?(this: void, url: string): boolean;
+
+  /**
+   * Is called when spans are started for outgoing requests.
+   */
+  onRequestSpanStart?(span: Span, requestInformation: { headers?: WebFetchHeaders }): void;
 }
 
 const responseToSpanId = new WeakMap<object, string>();
@@ -119,10 +124,9 @@ export function instrumentOutgoingRequests(client: Client, _options?: Partial<Re
     shouldCreateSpanForRequest,
     enableHTTPTimings,
     tracePropagationTargets,
+    onRequestSpanStart,
   } = {
-    traceFetch: defaultRequestInstrumentationOptions.traceFetch,
-    traceXHR: defaultRequestInstrumentationOptions.traceXHR,
-    trackFetchStreamPerformance: defaultRequestInstrumentationOptions.trackFetchStreamPerformance,
+    ...defaultRequestInstrumentationOptions,
     ..._options,
   };
 
@@ -179,10 +183,12 @@ export function instrumentOutgoingRequests(client: Client, _options?: Partial<Re
           'http.url': fullUrl,
           'server.address': host,
         });
-      }
 
-      if (enableHTTPTimings && createdSpan) {
-        addHTTPTimings(createdSpan);
+        if (enableHTTPTimings) {
+          addHTTPTimings(createdSpan);
+        }
+
+        onRequestSpanStart?.(createdSpan, { headers: handlerData.headers });
       }
     });
   }
@@ -190,8 +196,18 @@ export function instrumentOutgoingRequests(client: Client, _options?: Partial<Re
   if (traceXHR) {
     addXhrInstrumentationHandler(handlerData => {
       const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);
-      if (enableHTTPTimings && createdSpan) {
-        addHTTPTimings(createdSpan);
+      if (createdSpan) {
+        if (enableHTTPTimings) {
+          addHTTPTimings(createdSpan);
+        }
+
+        let headers;
+        try {
+          headers = new Headers(handlerData.xhr.__sentry_xhr_v3__?.request_headers);
+        } catch {
+          // noop
+        }
+        onRequestSpanStart?.(createdSpan, { headers });
       }
     });
   }
diff --git a/packages/cloudflare/README.md b/packages/cloudflare/README.md
index de54f5351332..99e2a91b8cf0 100644
--- a/packages/cloudflare/README.md
+++ b/packages/cloudflare/README.md
@@ -22,16 +22,21 @@ To get started, first install the `@sentry/cloudflare` package:
 npm install @sentry/cloudflare
 ```
 
-Then set either the `nodejs_compat` or `nodejs_als` compatibility flags in your `wrangler.toml`. This is because the SDK
-needs access to the `AsyncLocalStorage` API to work correctly.
-
-```toml
-compatibility_flags = ["nodejs_compat"]
-# compatibility_flags = ["nodejs_als"]
+Then either set the `nodejs_als` or `nodejs_compat` compatibility flags in your `wrangler.jsonc`/`wrangler.toml` config. This is because the SDK needs access to the `AsyncLocalStorage` API to work correctly.
+
+```jsonc {tabTitle:JSON} {filename:wrangler.jsonc}
+{
+  "compatibility_flags": [
+    "nodejs_als"
+    // "nodejs_compat"
+  ]
+}
 ```
 
-Then you can either setup up the SDK for [Cloudflare Pages](#setup-cloudflare-pages) or
-[Cloudflare Workers](#setup-cloudflare-workers).
+```toml {tabTitle:Toml} {filename:wrangler.toml}
+compatibility_flags = ["nodejs_als"]
+# compatibility_flags = ["nodejs_compat"]
+```
 
 ## Setup (Cloudflare Pages)
 
diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
index 6deea6ac38ce..3599448abf4c 100644
--- a/packages/core/src/client.ts
+++ b/packages/core/src/client.ts
@@ -670,6 +670,13 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public on(hook: 'afterCaptureLog', callback: (log: Log) => void): () => void;
 
+  /**
+   * A hook that is called when the client is flushing logs
+   *
+   * @returns {() => void} A function that, when executed, removes the registered callback.
+   */
+  public on(hook: 'flushLogs', callback: () => void): () => void;
+
   /**
    * Register a hook on this client.
    */
@@ -827,6 +834,11 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public emit(hook: 'afterCaptureLog', log: Log): void;
 
+  /**
+   * Emit a hook event for client flush logs
+   */
+  public emit(hook: 'flushLogs'): void;
+
   /**
    * Emit a hook that was previously registered via `on()`.
    */
diff --git a/packages/core/src/fetch.ts b/packages/core/src/fetch.ts
index 5f0c9cc30b56..379097936ef4 100644
--- a/packages/core/src/fetch.ts
+++ b/packages/core/src/fetch.ts
@@ -4,7 +4,7 @@ import { SPAN_STATUS_ERROR, setHttpStatus, startInactiveSpan } from './tracing';
 import { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan';
 import type { FetchBreadcrumbHint, HandlerDataFetch, Span, SpanAttributes, SpanOrigin } from './types-hoist';
 import { SENTRY_BAGGAGE_KEY_PREFIX } from './utils-hoist/baggage';
-import { isInstanceOf } from './utils-hoist/is';
+import { isInstanceOf, isRequest } from './utils-hoist/is';
 import { getSanitizedUrlStringFromUrlObject, isURLObjectRelative, parseStringToURLObject } from './utils-hoist/url';
 import { hasSpansEnabled } from './utils/hasSpansEnabled';
 import { getActiveSpan } from './utils/spanUtils';
@@ -227,10 +227,6 @@ function stripBaggageHeaderOfSentryBaggageValues(baggageHeader: string): string
   );
 }
 
-function isRequest(request: unknown): request is Request {
-  return typeof Request !== 'undefined' && isInstanceOf(request, Request);
-}
-
 function isHeaders(headers: unknown): headers is Headers {
   return typeof Headers !== 'undefined' && isInstanceOf(headers, Headers);
 }
diff --git a/packages/core/src/logs/console-integration.ts b/packages/core/src/logs/console-integration.ts
index 6dbb829db5a6..d0fe2a639738 100644
--- a/packages/core/src/logs/console-integration.ts
+++ b/packages/core/src/logs/console-integration.ts
@@ -1,6 +1,7 @@
 import { getClient } from '../currentScopes';
 import { DEBUG_BUILD } from '../debug-build';
 import { defineIntegration } from '../integration';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../semanticAttributes';
 import type { ConsoleLevel, IntegrationFn } from '../types-hoist';
 import { CONSOLE_LEVELS, GLOBAL_OBJ, addConsoleInstrumentationHandler, logger, safeJoin } from '../utils-hoist';
 import { _INTERNAL_captureLog } from './exports';
@@ -17,6 +18,10 @@ type GlobalObjectWithUtil = typeof GLOBAL_OBJ & {
 
 const INTEGRATION_NAME = 'ConsoleLogs';
 
+const DEFAULT_ATTRIBUTES = {
+  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.console.logging',
+};
+
 const _consoleLoggingIntegration = ((options: Partial<CaptureConsoleOptions> = {}) => {
   const levels = options.levels || CONSOLE_LEVELS;
 
@@ -38,7 +43,7 @@ const _consoleLoggingIntegration = ((options: Partial<CaptureConsoleOptions> = {
             const followingArgs = args.slice(1);
             const message =
               followingArgs.length > 0 ? `Assertion failed: ${formatConsoleArgs(followingArgs)}` : 'Assertion failed';
-            _INTERNAL_captureLog({ level: 'error', message });
+            _INTERNAL_captureLog({ level: 'error', message, attributes: DEFAULT_ATTRIBUTES });
           }
           return;
         }
@@ -48,6 +53,7 @@ const _consoleLoggingIntegration = ((options: Partial<CaptureConsoleOptions> = {
           level: isLevelLog ? 'info' : level,
           message: formatConsoleArgs(args),
           severityNumber: isLevelLog ? 10 : undefined,
+          attributes: DEFAULT_ATTRIBUTES,
         });
       });
     },
diff --git a/packages/core/src/logs/exports.ts b/packages/core/src/logs/exports.ts
index 5e12f5739729..8b5f0c76bc17 100644
--- a/packages/core/src/logs/exports.ts
+++ b/packages/core/src/logs/exports.ts
@@ -97,18 +97,24 @@ export function _INTERNAL_captureLog(
   };
 
   if (release) {
-    logAttributes.release = release;
+    logAttributes['sentry.release'] = release;
   }
 
   if (environment) {
-    logAttributes.environment = environment;
+    logAttributes['sentry.environment'] = environment;
+  }
+
+  const { sdk } = client.getSdkMetadata() ?? {};
+  if (sdk) {
+    logAttributes['sentry.sdk.name'] = sdk.name;
+    logAttributes['sentry.sdk.version'] = sdk.version;
   }
 
   if (isParameterizedString(message)) {
     const { __sentry_template_string__, __sentry_template_values__ = [] } = message;
     logAttributes['sentry.message.template'] = __sentry_template_string__;
     __sentry_template_values__.forEach((param, index) => {
-      logAttributes[`sentry.message.param.${index}`] = param;
+      logAttributes[`sentry.message.parameter.${index}`] = param;
     });
   }
 
@@ -163,6 +169,8 @@ export function _INTERNAL_flushLogsBuffer(client: Client, maybeLogBuffer?: Array
   // Clear the log buffer after envelopes have been constructed.
   logBuffer.length = 0;
 
+  client.emit('flushLogs');
+
   // sendEnvelope should not throw
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
   client.sendEnvelope(envelope);
diff --git a/packages/core/src/server-runtime-client.ts b/packages/core/src/server-runtime-client.ts
index dfada209fcfd..b7910ed23d0a 100644
--- a/packages/core/src/server-runtime-client.ts
+++ b/packages/core/src/server-runtime-client.ts
@@ -25,6 +25,9 @@ import { resolvedSyncPromise } from './utils-hoist/syncpromise';
 import { _INTERNAL_flushLogsBuffer } from './logs/exports';
 import { isPrimitive } from './utils-hoist';
 
+// TODO: Make this configurable
+const DEFAULT_LOG_FLUSH_INTERVAL = 5000;
+
 export interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportOptions> {
   platform?: string;
   runtime?: { name: string; version?: string };
@@ -37,6 +40,7 @@ export interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportO
 export class ServerRuntimeClient<
   O extends ClientOptions & ServerRuntimeClientOptions = ServerRuntimeClientOptions,
 > extends Client<O> {
+  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
   private _logWeight: number;
 
   /**
@@ -54,9 +58,9 @@ export class ServerRuntimeClient<
     if (this._options._experiments?.enableLogs) {
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       const client = this;
-      client.on('flush', () => {
-        _INTERNAL_flushLogsBuffer(client);
+      client.on('flushLogs', () => {
         client._logWeight = 0;
+        clearTimeout(client._logFlushIdleTimeout);
       });
 
       client.on('afterCaptureLog', log => {
@@ -67,7 +71,11 @@ export class ServerRuntimeClient<
         // the payload gets too big.
         if (client._logWeight >= 800_000) {
           _INTERNAL_flushLogsBuffer(client);
-          client._logWeight = 0;
+        } else {
+          // start an idle timeout to flush the logs buffer if no logs are captured for a while
+          client._logFlushIdleTimeout = setTimeout(() => {
+            _INTERNAL_flushLogsBuffer(client);
+          }, DEFAULT_LOG_FLUSH_INTERVAL);
         }
       });
     }
diff --git a/packages/core/src/transports/base.ts b/packages/core/src/transports/base.ts
index 2b7de82ba4e1..e928e5d856ce 100644
--- a/packages/core/src/transports/base.ts
+++ b/packages/core/src/transports/base.ts
@@ -77,6 +77,7 @@ export function createTransport(
         },
         error => {
           recordEnvelopeLoss('network_error');
+          DEBUG_BUILD && logger.error('Encountered error running transport request:', error);
           throw error;
         },
       );
diff --git a/packages/core/src/types-hoist/feedback/config.ts b/packages/core/src/types-hoist/feedback/config.ts
index d7b3d78995bb..4ec846c7d98d 100644
--- a/packages/core/src/types-hoist/feedback/config.ts
+++ b/packages/core/src/types-hoist/feedback/config.ts
@@ -57,15 +57,6 @@ export interface FeedbackGeneralConfiguration {
     name: string;
   };
 
-  /**
-   * _experiments allows users to enable experimental or internal features.
-   * We don't consider such features as part of the public API and hence we don't guarantee semver for them.
-   * Experimental features can be added, changed or removed at any time.
-   *
-   * Default: undefined
-   */
-  _experiments: Partial<{ annotations: boolean }>;
-
   /**
    * Set an object that will be merged sent as tags data with the event.
    */
diff --git a/packages/core/src/types-hoist/instrument.ts b/packages/core/src/types-hoist/instrument.ts
index 420482579dd9..5eba6066432a 100644
--- a/packages/core/src/types-hoist/instrument.ts
+++ b/packages/core/src/types-hoist/instrument.ts
@@ -61,6 +61,8 @@ export interface HandlerDataFetch {
   error?: unknown;
   // This is to be consumed by the HttpClient integration
   virtualError?: unknown;
+  /** Headers that the user passed to the fetch request. */
+  headers?: WebFetchHeaders;
 }
 
 export interface HandlerDataDom {
diff --git a/packages/core/src/utils-hoist/instrument/fetch.ts b/packages/core/src/utils-hoist/instrument/fetch.ts
index 71c5148fae9c..7d6185d00639 100644
--- a/packages/core/src/utils-hoist/instrument/fetch.ts
+++ b/packages/core/src/utils-hoist/instrument/fetch.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { HandlerDataFetch } from '../../types-hoist';
+import type { HandlerDataFetch, WebFetchHeaders } from '../../types-hoist';
 
-import { isError } from '../is';
+import { isError, isRequest } from '../is';
 import { addNonEnumerableProperty, fill } from '../object';
 import { supportsNativeFetch } from '../supports';
 import { timestampInSeconds } from '../time';
@@ -67,6 +67,7 @@ function instrumentFetch(onFetchResolved?: (response: Response) => void, skipNat
         startTimestamp: timestampInSeconds() * 1000,
         // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation
         virtualError,
+        headers: getHeadersFromFetchArgs(args),
       };
 
       // if there is no callback, fetch is instrumented directly
@@ -253,3 +254,26 @@ export function parseFetchArgs(fetchArgs: unknown[]): { method: string; url: str
     method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',
   };
 }
+
+function getHeadersFromFetchArgs(fetchArgs: unknown[]): WebFetchHeaders | undefined {
+  const [requestArgument, optionsArgument] = fetchArgs;
+
+  try {
+    if (
+      typeof optionsArgument === 'object' &&
+      optionsArgument !== null &&
+      'headers' in optionsArgument &&
+      optionsArgument.headers
+    ) {
+      return new Headers(optionsArgument.headers as any);
+    }
+
+    if (isRequest(requestArgument)) {
+      return new Headers(requestArgument.headers);
+    }
+  } catch {
+    // noop
+  }
+
+  return;
+}
diff --git a/packages/core/src/utils-hoist/is.ts b/packages/core/src/utils-hoist/is.ts
index cfa9bc141e20..ab5e150e2394 100644
--- a/packages/core/src/utils-hoist/is.ts
+++ b/packages/core/src/utils-hoist/is.ts
@@ -201,3 +201,12 @@ export function isVueViewModel(wat: unknown): boolean {
   // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.
   return !!(typeof wat === 'object' && wat !== null && ((wat as VueViewModel).__isVue || (wat as VueViewModel)._isVue));
 }
+
+/**
+ * Checks whether the given parameter is a Standard Web API Request instance.
+ *
+ * Returns false if Request is not available in the current runtime.
+ */
+export function isRequest(request: unknown): request is Request {
+  return typeof Request !== 'undefined' && isInstanceOf(request, Request);
+}
diff --git a/packages/core/test/lib/logs/exports.test.ts b/packages/core/test/lib/logs/exports.test.ts
index acc40ba0c361..c672373df947 100644
--- a/packages/core/test/lib/logs/exports.test.ts
+++ b/packages/core/test/lib/logs/exports.test.ts
@@ -136,8 +136,53 @@ describe('_INTERNAL_captureLog', () => {
     const logAttributes = _INTERNAL_getLogBuffer(client)?.[0]?.attributes;
     expect(logAttributes).toEqual(
       expect.arrayContaining([
-        expect.objectContaining({ key: 'release', value: { stringValue: '1.0.0' } }),
-        expect.objectContaining({ key: 'environment', value: { stringValue: 'test' } }),
+        expect.objectContaining({ key: 'sentry.release', value: { stringValue: '1.0.0' } }),
+        expect.objectContaining({ key: 'sentry.environment', value: { stringValue: 'test' } }),
+      ]),
+    );
+  });
+
+  it('includes SDK metadata in log attributes when available', () => {
+    const options = getDefaultTestClientOptions({
+      dsn: PUBLIC_DSN,
+      _experiments: { enableLogs: true },
+    });
+    const client = new TestClient(options);
+    // Mock getSdkMetadata to return SDK info
+    vi.spyOn(client, 'getSdkMetadata').mockReturnValue({
+      sdk: {
+        name: 'sentry.javascript.node',
+        version: '7.0.0',
+      },
+    });
+
+    _INTERNAL_captureLog({ level: 'info', message: 'test log with SDK metadata' }, client, undefined);
+
+    const logAttributes = _INTERNAL_getLogBuffer(client)?.[0]?.attributes;
+    expect(logAttributes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: 'sentry.sdk.name', value: { stringValue: 'sentry.javascript.node' } }),
+        expect.objectContaining({ key: 'sentry.sdk.version', value: { stringValue: '7.0.0' } }),
+      ]),
+    );
+  });
+
+  it('does not include SDK metadata in log attributes when not available', () => {
+    const options = getDefaultTestClientOptions({
+      dsn: PUBLIC_DSN,
+      _experiments: { enableLogs: true },
+    });
+    const client = new TestClient(options);
+    // Mock getSdkMetadata to return no SDK info
+    vi.spyOn(client, 'getSdkMetadata').mockReturnValue({});
+
+    _INTERNAL_captureLog({ level: 'info', message: 'test log without SDK metadata' }, client, undefined);
+
+    const logAttributes = _INTERNAL_getLogBuffer(client)?.[0]?.attributes;
+    expect(logAttributes).not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: 'sentry.sdk.name' }),
+        expect.objectContaining({ key: 'sentry.sdk.version' }),
       ]),
     );
   });
@@ -206,11 +251,11 @@ describe('_INTERNAL_captureLog', () => {
           value: { stringValue: 'Hello %s, welcome to %s' },
         }),
         expect.objectContaining({
-          key: 'sentry.message.param.0',
+          key: 'sentry.message.parameter.0',
           value: { stringValue: 'John' },
         }),
         expect.objectContaining({
-          key: 'sentry.message.param.1',
+          key: 'sentry.message.parameter.1',
           value: { stringValue: 'Sentry' },
         }),
       ]),
diff --git a/packages/core/test/lib/server-runtime-client.test.ts b/packages/core/test/lib/server-runtime-client.test.ts
index 87c62b1567d4..4aaf77a06fb2 100644
--- a/packages/core/test/lib/server-runtime-client.test.ts
+++ b/packages/core/test/lib/server-runtime-client.test.ts
@@ -4,7 +4,7 @@ import { describe, expect, it, test, vi } from 'vitest';
 import { Scope, createTransport } from '../../src';
 import type { ServerRuntimeClientOptions } from '../../src/server-runtime-client';
 import { ServerRuntimeClient } from '../../src/server-runtime-client';
-import { _INTERNAL_captureLog } from '../../src/logs/exports';
+import { _INTERNAL_captureLog, _INTERNAL_flushLogsBuffer } from '../../src/logs/exports';
 
 const PUBLIC_DSN = 'https://username@domain/123';
 
@@ -256,8 +256,8 @@ describe('ServerRuntimeClient', () => {
       _INTERNAL_captureLog({ message: 'test1', level: 'info' }, client);
       _INTERNAL_captureLog({ message: 'test2', level: 'info' }, client);
 
-      // Trigger flush event
-      client.emit('flush');
+      // Trigger flush directly
+      _INTERNAL_flushLogsBuffer(client);
 
       expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
       expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
diff --git a/packages/feedback/src/core/integration.ts b/packages/feedback/src/core/integration.ts
index 8b312b902258..e5f1092856f1 100644
--- a/packages/feedback/src/core/integration.ts
+++ b/packages/feedback/src/core/integration.ts
@@ -84,7 +84,6 @@ export const buildFeedbackIntegration = ({
       email: 'email',
       name: 'username',
     },
-    _experiments = {},
     tags,
     styleNonce,
     scriptNonce,
@@ -159,8 +158,6 @@ export const buildFeedbackIntegration = ({
       onSubmitError,
       onSubmitSuccess,
       onFormSubmitted,
-
-      _experiments,
     };
 
     let _shadow: ShadowRoot | null = null;
diff --git a/packages/feedback/src/screenshot/components/Annotations.tsx b/packages/feedback/src/screenshot/components/Annotations.tsx
deleted file mode 100644
index eb897b40f166..000000000000
--- a/packages/feedback/src/screenshot/components/Annotations.tsx
+++ /dev/null
@@ -1,91 +0,0 @@
-import type { VNode, h as hType } from 'preact';
-import type * as Hooks from 'preact/hooks';
-import { DOCUMENT } from '../../constants';
-
-interface FactoryParams {
-  h: typeof hType;
-}
-
-export default function AnnotationsFactory({
-  h, // eslint-disable-line @typescript-eslint/no-unused-vars
-}: FactoryParams) {
-  return function Annotations({
-    action,
-    imageBuffer,
-    annotatingRef,
-  }: {
-    action: 'crop' | 'annotate' | '';
-    imageBuffer: HTMLCanvasElement;
-    annotatingRef: Hooks.Ref<HTMLCanvasElement>;
-  }): VNode {
-    const onAnnotateStart = (): void => {
-      if (action !== 'annotate') {
-        return;
-      }
-
-      const handleMouseMove = (moveEvent: MouseEvent): void => {
-        const annotateCanvas = annotatingRef.current;
-        if (annotateCanvas) {
-          const rect = annotateCanvas.getBoundingClientRect();
-          const x = moveEvent.clientX - rect.x;
-          const y = moveEvent.clientY - rect.y;
-
-          const ctx = annotateCanvas.getContext('2d');
-          if (ctx) {
-            ctx.lineTo(x, y);
-            ctx.stroke();
-            ctx.beginPath();
-            ctx.moveTo(x, y);
-          }
-        }
-      };
-
-      const handleMouseUp = (): void => {
-        const ctx = annotatingRef.current?.getContext('2d');
-        if (ctx) {
-          ctx.beginPath();
-        }
-
-        // Add your apply annotation logic here
-        applyAnnotation();
-
-        DOCUMENT.removeEventListener('mousemove', handleMouseMove);
-        DOCUMENT.removeEventListener('mouseup', handleMouseUp);
-      };
-
-      DOCUMENT.addEventListener('mousemove', handleMouseMove);
-      DOCUMENT.addEventListener('mouseup', handleMouseUp);
-    };
-
-    const applyAnnotation = (): void => {
-      // Logic to apply the annotation
-      const imageCtx = imageBuffer.getContext('2d');
-      const annotateCanvas = annotatingRef.current;
-      if (imageCtx && annotateCanvas) {
-        imageCtx.drawImage(
-          annotateCanvas,
-          0,
-          0,
-          annotateCanvas.width,
-          annotateCanvas.height,
-          0,
-          0,
-          imageBuffer.width,
-          imageBuffer.height,
-        );
-
-        const annotateCtx = annotateCanvas.getContext('2d');
-        if (annotateCtx) {
-          annotateCtx.clearRect(0, 0, annotateCanvas.width, annotateCanvas.height);
-        }
-      }
-    };
-    return (
-      <canvas
-        class={`editor__annotation ${action === 'annotate' ? 'editor__annotation--active' : ''}`}
-        onMouseDown={onAnnotateStart}
-        ref={annotatingRef}
-      ></canvas>
-    );
-  };
-}
diff --git a/packages/feedback/src/screenshot/components/Crop.tsx b/packages/feedback/src/screenshot/components/Crop.tsx
deleted file mode 100644
index 3b31ee71573c..000000000000
--- a/packages/feedback/src/screenshot/components/Crop.tsx
+++ /dev/null
@@ -1,338 +0,0 @@
-import type { FeedbackInternalOptions } from '@sentry/core';
-import type { VNode, h as hType } from 'preact';
-import type * as Hooks from 'preact/hooks';
-import { DOCUMENT, WINDOW } from '../../constants';
-import CropCornerFactory from './CropCorner';
-
-const CROP_BUTTON_SIZE = 30;
-const CROP_BUTTON_BORDER = 3;
-const CROP_BUTTON_OFFSET = CROP_BUTTON_SIZE + CROP_BUTTON_BORDER;
-const DPI = WINDOW.devicePixelRatio;
-
-interface Box {
-  startX: number;
-  startY: number;
-  endX: number;
-  endY: number;
-}
-
-interface Rect {
-  x: number;
-  y: number;
-  height: number;
-  width: number;
-}
-
-const constructRect = (box: Box): Rect => ({
-  x: Math.min(box.startX, box.endX),
-  y: Math.min(box.startY, box.endY),
-  width: Math.abs(box.startX - box.endX),
-  height: Math.abs(box.startY - box.endY),
-});
-
-const getContainedSize = (img: HTMLCanvasElement): Rect => {
-  const imgClientHeight = img.clientHeight;
-  const imgClientWidth = img.clientWidth;
-  const ratio = img.width / img.height;
-  let width = imgClientHeight * ratio;
-  let height = imgClientHeight;
-  if (width > imgClientWidth) {
-    width = imgClientWidth;
-    height = imgClientWidth / ratio;
-  }
-  const x = (imgClientWidth - width) / 2;
-  const y = (imgClientHeight - height) / 2;
-  return { x: x, y: y, width: width, height: height };
-};
-
-interface FactoryParams {
-  h: typeof hType;
-  hooks: typeof Hooks;
-  options: FeedbackInternalOptions;
-}
-
-export default function CropFactory({
-  h,
-  hooks,
-  options,
-}: FactoryParams): (props: {
-  action: 'crop' | 'annotate' | '';
-  imageBuffer: HTMLCanvasElement;
-  croppingRef: Hooks.Ref<HTMLCanvasElement>;
-  cropContainerRef: Hooks.Ref<HTMLDivElement>;
-  croppingRect: Box;
-  setCroppingRect: Hooks.StateUpdater<Box>;
-  resize: () => void;
-}) => VNode {
-  const CropCorner = CropCornerFactory({ h });
-  return function Crop({
-    action,
-    imageBuffer,
-    croppingRef,
-    cropContainerRef,
-    croppingRect,
-    setCroppingRect,
-    resize,
-  }: {
-    action: 'crop' | 'annotate' | '';
-    imageBuffer: HTMLCanvasElement;
-    croppingRef: Hooks.Ref<HTMLCanvasElement>;
-    cropContainerRef: Hooks.Ref<HTMLDivElement>;
-    croppingRect: Box;
-    setCroppingRect: Hooks.StateUpdater<Box>;
-    resize: () => void;
-  }): VNode {
-    const initialPositionRef = hooks.useRef({ initialX: 0, initialY: 0 });
-
-    const [isResizing, setIsResizing] = hooks.useState(false);
-    const [confirmCrop, setConfirmCrop] = hooks.useState(false);
-
-    hooks.useEffect(() => {
-      const cropper = croppingRef.current;
-      if (!cropper) {
-        return;
-      }
-
-      const ctx = cropper.getContext('2d');
-      if (!ctx) {
-        return;
-      }
-
-      const imageDimensions = getContainedSize(imageBuffer);
-      const croppingBox = constructRect(croppingRect);
-      ctx.clearRect(0, 0, imageDimensions.width, imageDimensions.height);
-
-      if (action !== 'crop') {
-        return;
-      }
-
-      // draw gray overlay around the selection
-      ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
-      ctx.fillRect(0, 0, imageDimensions.width, imageDimensions.height);
-      ctx.clearRect(croppingBox.x, croppingBox.y, croppingBox.width, croppingBox.height);
-
-      // draw selection border
-      ctx.strokeStyle = '#ffffff';
-      ctx.lineWidth = 3;
-      ctx.strokeRect(croppingBox.x + 1, croppingBox.y + 1, croppingBox.width - 2, croppingBox.height - 2);
-      ctx.strokeStyle = '#000000';
-      ctx.lineWidth = 1;
-      ctx.strokeRect(croppingBox.x + 3, croppingBox.y + 3, croppingBox.width - 6, croppingBox.height - 6);
-    }, [croppingRect, action]);
-
-    // Resizing logic
-    const makeHandleMouseMove = hooks.useCallback((corner: string) => {
-      return (e: MouseEvent) => {
-        if (!croppingRef.current) {
-          return;
-        }
-
-        const cropCanvas = croppingRef.current;
-        const cropBoundingRect = cropCanvas.getBoundingClientRect();
-        const mouseX = e.clientX - cropBoundingRect.x;
-        const mouseY = e.clientY - cropBoundingRect.y;
-
-        switch (corner) {
-          case 'top-left':
-            setCroppingRect(prev => ({
-              ...prev,
-              startX: Math.min(Math.max(0, mouseX), prev.endX - CROP_BUTTON_OFFSET),
-              startY: Math.min(Math.max(0, mouseY), prev.endY - CROP_BUTTON_OFFSET),
-            }));
-            break;
-          case 'top-right':
-            setCroppingRect(prev => ({
-              ...prev,
-              endX: Math.max(Math.min(mouseX, cropCanvas.width / DPI), prev.startX + CROP_BUTTON_OFFSET),
-              startY: Math.min(Math.max(0, mouseY), prev.endY - CROP_BUTTON_OFFSET),
-            }));
-            break;
-          case 'bottom-left':
-            setCroppingRect(prev => ({
-              ...prev,
-              startX: Math.min(Math.max(0, mouseX), prev.endX - CROP_BUTTON_OFFSET),
-              endY: Math.max(Math.min(mouseY, cropCanvas.height / DPI), prev.startY + CROP_BUTTON_OFFSET),
-            }));
-            break;
-          case 'bottom-right':
-            setCroppingRect(prev => ({
-              ...prev,
-              endX: Math.max(Math.min(mouseX, cropCanvas.width / DPI), prev.startX + CROP_BUTTON_OFFSET),
-              endY: Math.max(Math.min(mouseY, cropCanvas.height / DPI), prev.startY + CROP_BUTTON_OFFSET),
-            }));
-            break;
-        }
-      };
-    }, []);
-
-    // Dragging logic
-    const onDragStart = (e: MouseEvent): void => {
-      if (isResizing) {
-        return;
-      }
-
-      initialPositionRef.current = { initialX: e.clientX, initialY: e.clientY };
-
-      const handleMouseMove = (moveEvent: MouseEvent): void => {
-        const cropCanvas = croppingRef.current;
-        if (!cropCanvas) {
-          return;
-        }
-
-        const deltaX = moveEvent.clientX - initialPositionRef.current.initialX;
-        const deltaY = moveEvent.clientY - initialPositionRef.current.initialY;
-
-        setCroppingRect(prev => {
-          const newStartX = Math.max(
-            0,
-            Math.min(prev.startX + deltaX, cropCanvas.width / DPI - (prev.endX - prev.startX)),
-          );
-          const newStartY = Math.max(
-            0,
-            Math.min(prev.startY + deltaY, cropCanvas.height / DPI - (prev.endY - prev.startY)),
-          );
-
-          const newEndX = newStartX + (prev.endX - prev.startX);
-          const newEndY = newStartY + (prev.endY - prev.startY);
-
-          initialPositionRef.current.initialX = moveEvent.clientX;
-          initialPositionRef.current.initialY = moveEvent.clientY;
-
-          return { startX: newStartX, startY: newStartY, endX: newEndX, endY: newEndY };
-        });
-      };
-
-      const handleMouseUp = (): void => {
-        DOCUMENT.removeEventListener('mousemove', handleMouseMove);
-        DOCUMENT.removeEventListener('mouseup', handleMouseUp);
-      };
-
-      DOCUMENT.addEventListener('mousemove', handleMouseMove);
-      DOCUMENT.addEventListener('mouseup', handleMouseUp);
-    };
-
-    const onGrabButton = (e: Event, corner: string): void => {
-      setIsResizing(true);
-      const handleMouseMove = makeHandleMouseMove(corner);
-      const handleMouseUp = (): void => {
-        DOCUMENT.removeEventListener('mousemove', handleMouseMove);
-        DOCUMENT.removeEventListener('mouseup', handleMouseUp);
-        setConfirmCrop(true);
-        setIsResizing(false);
-      };
-
-      DOCUMENT.addEventListener('mouseup', handleMouseUp);
-      DOCUMENT.addEventListener('mousemove', handleMouseMove);
-    };
-
-    function applyCrop(): void {
-      const cutoutCanvas = DOCUMENT.createElement('canvas');
-      const imageBox = getContainedSize(imageBuffer);
-      const croppingBox = constructRect(croppingRect);
-      cutoutCanvas.width = croppingBox.width * DPI;
-      cutoutCanvas.height = croppingBox.height * DPI;
-
-      const cutoutCtx = cutoutCanvas.getContext('2d');
-      if (cutoutCtx && imageBuffer) {
-        cutoutCtx.drawImage(
-          imageBuffer,
-          (croppingBox.x / imageBox.width) * imageBuffer.width,
-          (croppingBox.y / imageBox.height) * imageBuffer.height,
-          (croppingBox.width / imageBox.width) * imageBuffer.width,
-          (croppingBox.height / imageBox.height) * imageBuffer.height,
-          0,
-          0,
-          cutoutCanvas.width,
-          cutoutCanvas.height,
-        );
-      }
-
-      const ctx = imageBuffer.getContext('2d');
-      if (ctx) {
-        ctx.clearRect(0, 0, imageBuffer.width, imageBuffer.height);
-        imageBuffer.width = cutoutCanvas.width;
-        imageBuffer.height = cutoutCanvas.height;
-        imageBuffer.style.width = `${croppingBox.width}px`;
-        imageBuffer.style.height = `${croppingBox.height}px`;
-        ctx.drawImage(cutoutCanvas, 0, 0);
-
-        resize();
-      }
-    }
-
-    return (
-      <div
-        class={`editor__crop-container ${action === 'crop' ? '' : 'editor__crop-container--inactive'}
-              ${confirmCrop ? 'editor__crop-container--move' : ''}`}
-        ref={cropContainerRef}
-      >
-        <canvas onMouseDown={onDragStart} ref={croppingRef}></canvas>
-        {action === 'crop' && (
-          <div>
-            <CropCorner
-              left={croppingRect.startX - CROP_BUTTON_BORDER}
-              top={croppingRect.startY - CROP_BUTTON_BORDER}
-              onGrabButton={onGrabButton}
-              corner="top-left"
-            />
-            <CropCorner
-              left={croppingRect.endX - CROP_BUTTON_SIZE + CROP_BUTTON_BORDER}
-              top={croppingRect.startY - CROP_BUTTON_BORDER}
-              onGrabButton={onGrabButton}
-              corner="top-right"
-            />
-            <CropCorner
-              left={croppingRect.startX - CROP_BUTTON_BORDER}
-              top={croppingRect.endY - CROP_BUTTON_SIZE + CROP_BUTTON_BORDER}
-              onGrabButton={onGrabButton}
-              corner="bottom-left"
-            />
-            <CropCorner
-              left={croppingRect.endX - CROP_BUTTON_SIZE + CROP_BUTTON_BORDER}
-              top={croppingRect.endY - CROP_BUTTON_SIZE + CROP_BUTTON_BORDER}
-              onGrabButton={onGrabButton}
-              corner="bottom-right"
-            />
-          </div>
-        )}
-        {action === 'crop' && (
-          <div
-            style={{
-              left: Math.max(0, croppingRect.endX - 191),
-              top: Math.max(0, croppingRect.endY + 8),
-            }}
-            class={`editor__crop-btn-group ${confirmCrop ? 'editor__crop-btn-group--active' : ''}`}
-          >
-            <button
-              onClick={e => {
-                e.preventDefault();
-                if (croppingRef.current) {
-                  setCroppingRect({
-                    startX: 0,
-                    startY: 0,
-                    endX: croppingRef.current.width / DPI,
-                    endY: croppingRef.current.height / DPI,
-                  });
-                }
-                setConfirmCrop(false);
-              }}
-              class="btn btn--default"
-            >
-              {options.cancelButtonLabel}
-            </button>
-            <button
-              onClick={e => {
-                e.preventDefault();
-                applyCrop();
-                setConfirmCrop(false);
-              }}
-              class="btn btn--primary"
-            >
-              {options.confirmButtonLabel}
-            </button>
-          </div>
-        )}
-      </div>
-    );
-  };
-}
diff --git a/packages/feedback/src/screenshot/components/CropCorner.tsx b/packages/feedback/src/screenshot/components/CropCorner.tsx
deleted file mode 100644
index de3b6e506e71..000000000000
--- a/packages/feedback/src/screenshot/components/CropCorner.tsx
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { VNode, h as hType } from 'preact';
-
-interface FactoryParams {
-  h: typeof hType;
-}
-
-export default function CropCornerFactory({
-  h, // eslint-disable-line @typescript-eslint/no-unused-vars
-}: FactoryParams) {
-  return function CropCorner({
-    top,
-    left,
-    corner,
-    onGrabButton,
-  }: {
-    top: number;
-    left: number;
-    corner: string;
-    onGrabButton: (e: Event, corner: string) => void;
-  }): VNode {
-    return (
-      <button
-        class={`editor__crop-corner editor__crop-corner--${corner} `}
-        style={{
-          top: top,
-          left: left,
-        }}
-        onMouseDown={e => {
-          e.preventDefault();
-          onGrabButton(e, corner);
-        }}
-        onClick={e => {
-          e.preventDefault();
-        }}
-      ></button>
-    );
-  };
-}
diff --git a/packages/feedback/src/screenshot/components/CropIcon.tsx b/packages/feedback/src/screenshot/components/CropIcon.tsx
deleted file mode 100644
index 091179d86004..000000000000
--- a/packages/feedback/src/screenshot/components/CropIcon.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import type { VNode, h as hType } from 'preact';
-
-interface FactoryParams {
-  h: typeof hType;
-}
-
-export default function CropIconFactory({
-  h, // eslint-disable-line @typescript-eslint/no-unused-vars
-}: FactoryParams) {
-  return function CropIcon(): VNode {
-    return (
-      <svg width="20" height="20" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-        <path
-          d="M15.25 12.5H12.5M12.5 12.5H4.50001C3.94773 12.5 3.50001 12.0523 3.50001 11.5V3.50002M12.5 12.5L12.5 4.50002C12.5 3.94773 12.0523 3.50002 11.5 3.50002H3.50001M12.5 12.5L12.5 15.25M3.50001 3.50002V0.750031M3.50001 3.50002H0.75"
-          stroke="currentColor"
-          strokeWidth="1.5"
-          strokeLinecap="round"
-          strokeLinejoin="round"
-        />
-      </svg>
-    );
-  };
-}
diff --git a/packages/feedback/src/screenshot/components/IconClose.tsx b/packages/feedback/src/screenshot/components/IconClose.tsx
new file mode 100644
index 000000000000..dea383a61839
--- /dev/null
+++ b/packages/feedback/src/screenshot/components/IconClose.tsx
@@ -0,0 +1,29 @@
+import type { VNode, h as hType } from 'preact';
+
+interface FactoryParams {
+  h: typeof hType;
+}
+
+export default function IconCloseFactory({
+  h, // eslint-disable-line @typescript-eslint/no-unused-vars
+}: FactoryParams) {
+  return function IconClose(): VNode {
+    return (
+      <svg data-test-id="icon-close" viewBox="0 0 16 16" fill="#2B2233" height="25px" width="25px">
+        <circle r="7" cx="8" cy="8" fill="white" />
+        <path
+          strokeWidth="1.5"
+          d="M8,16a8,8,0,1,1,8-8A8,8,0,0,1,8,16ZM8,1.53A6.47,6.47,0,1,0,14.47,8,6.47,6.47,0,0,0,8,1.53Z"
+        ></path>
+        <path
+          strokeWidth="1.5"
+          d="M5.34,11.41a.71.71,0,0,1-.53-.22.74.74,0,0,1,0-1.06l5.32-5.32a.75.75,0,0,1,1.06,1.06L5.87,11.19A.74.74,0,0,1,5.34,11.41Z"
+        ></path>
+        <path
+          strokeWidth="1.5"
+          d="M10.66,11.41a.74.74,0,0,1-.53-.22L4.81,5.87A.75.75,0,0,1,5.87,4.81l5.32,5.32a.74.74,0,0,1,0,1.06A.71.71,0,0,1,10.66,11.41Z"
+        ></path>
+      </svg>
+    );
+  };
+}
diff --git a/packages/feedback/src/screenshot/components/PenIcon.tsx b/packages/feedback/src/screenshot/components/PenIcon.tsx
deleted file mode 100644
index 75a0faedf480..000000000000
--- a/packages/feedback/src/screenshot/components/PenIcon.tsx
+++ /dev/null
@@ -1,31 +0,0 @@
-import type { VNode, h as hType } from 'preact';
-
-interface FactoryParams {
-  h: typeof hType;
-}
-
-export default function PenIconFactory({
-  h, // eslint-disable-line @typescript-eslint/no-unused-vars
-}: FactoryParams) {
-  return function PenIcon(): VNode {
-    return (
-      <svg width="20" height="20" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-        <path
-          d="M8.5 12L12 8.5L14 11L11 14L8.5 12Z"
-          stroke="currentColor"
-          strokeWidth="1.5"
-          strokeLinecap="round"
-          strokeLinejoin="round"
-        />
-        <path
-          d="M12 8.5L11 3.5L2 2L3.5 11L8.5 12L12 8.5Z"
-          stroke="currentColor"
-          strokeWidth="1.5"
-          strokeLinecap="round"
-          strokeLinejoin="round"
-        />
-        <path d="M2 2L7.5 7.5" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" />
-      </svg>
-    );
-  };
-}
diff --git a/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx b/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx
index 9e8e708ec580..ef76eac7f42a 100644
--- a/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx
+++ b/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx
@@ -2,20 +2,32 @@ import type { FeedbackInternalOptions, FeedbackModalIntegration } from '@sentry/
 import type { ComponentType, VNode, h as hType } from 'preact';
 import { h } from 'preact'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import type * as Hooks from 'preact/hooks';
-import { WINDOW } from '../../constants';
-import AnnotationsFactory from './Annotations';
-import CropFactory from './Crop';
+import { DOCUMENT, WINDOW } from '../../constants';
+import IconCloseFactory from './IconClose';
 import { createScreenshotInputStyles } from './ScreenshotInput.css';
 import ToolbarFactory from './Toolbar';
 import { useTakeScreenshotFactory } from './useTakeScreenshot';
 
-const DPI = WINDOW.devicePixelRatio;
-
 interface FactoryParams {
   h: typeof hType;
   hooks: typeof Hooks;
-  imageBuffer: HTMLCanvasElement;
+
+  /**
+   * A ref to a Canvas Element that serves as our "value" or image output.
+   */
+  outputBuffer: HTMLCanvasElement;
+
+  /**
+   * A reference to the whole dialog (the parent of this component) so that we
+   * can show/hide it and take a clean screenshot of the webpage.
+   */
   dialog: ReturnType<FeedbackModalIntegration['createDialog']>;
+
+  /**
+   * The whole options object.
+   *
+   * Needed to set nonce and id values for editor specific styles
+   */
   options: FeedbackInternalOptions;
 }
 
@@ -23,150 +35,329 @@ interface Props {
   onError: (error: Error) => void;
 }
 
-interface Box {
-  startX: number;
-  startY: number;
-  endX: number;
-  endY: number;
-}
+type MaybeCanvas = HTMLCanvasElement | null;
+type Screenshot = { canvas: HTMLCanvasElement; dpi: number };
 
-interface Rect {
+type DrawType = 'highlight' | 'hide' | '';
+interface DrawCommand {
+  type: DrawType;
   x: number;
   y: number;
-  height: number;
-  width: number;
+  h: number;
+  w: number;
+}
+
+function drawRect(command: DrawCommand, ctx: CanvasRenderingContext2D, color: string): void {
+  switch (command.type) {
+    case 'highlight': {
+      // creates a shadow around
+      ctx.shadowColor = 'rgba(0, 0, 0, 0.7)';
+      ctx.shadowBlur = 50;
+
+      // draws a rectangle first with a shadow
+      ctx.fillStyle = color;
+      ctx.fillRect(command.x - 1, command.y - 1, command.w + 2, command.h + 2);
+
+      // cut out the inside of the rectangle
+      ctx.clearRect(command.x, command.y, command.w, command.h);
+
+      break;
+    }
+    case 'hide':
+      ctx.fillStyle = 'rgb(0, 0, 0)';
+      ctx.fillRect(command.x, command.y, command.w, command.h);
+
+      break;
+    default:
+      break;
+  }
 }
 
-const getContainedSize = (img: HTMLCanvasElement): Rect => {
-  const imgClientHeight = img.clientHeight;
-  const imgClientWidth = img.clientWidth;
-  const ratio = img.width / img.height;
-  let width = imgClientHeight * ratio;
-  let height = imgClientHeight;
-  if (width > imgClientWidth) {
-    width = imgClientWidth;
-    height = imgClientWidth / ratio;
+function with2dContext(
+  canvas: MaybeCanvas,
+  options: CanvasRenderingContext2DSettings,
+  callback: (canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => void,
+): void {
+  if (!canvas) {
+    return;
   }
-  const x = (imgClientWidth - width) / 2;
-  const y = (imgClientHeight - height) / 2;
-  return { x: x, y: y, width: width, height: height };
-};
+  const ctx = canvas.getContext('2d', options);
+  if (!ctx) {
+    return;
+  }
+  callback(canvas, ctx);
+}
+
+function paintImage(maybeDest: MaybeCanvas, source: HTMLCanvasElement): void {
+  with2dContext(maybeDest, { alpha: true }, (destCanvas, destCtx) => {
+    destCtx.drawImage(source, 0, 0, source.width, source.height, 0, 0, destCanvas.width, destCanvas.height);
+  });
+}
+
+// Paint the array of drawCommands into a canvas.
+// Assuming this is the canvas foreground, and the background is cleaned.
+function paintForeground(maybeCanvas: MaybeCanvas, strokeColor: string, drawCommands: DrawCommand[]): void {
+  with2dContext(maybeCanvas, { alpha: true }, (canvas, ctx) => {
+    // If there's anything to draw, then we'll first clear the canvas with
+    // a transparent grey background
+    if (drawCommands.length) {
+      ctx.fillStyle = 'rgba(0, 0, 0, 0.25)';
+      ctx.fillRect(0, 0, canvas.width, canvas.height);
+    }
+
+    drawCommands.forEach(command => {
+      drawRect(command, ctx, strokeColor);
+    });
+  });
+}
 
 export function ScreenshotEditorFactory({
   h,
   hooks,
-  imageBuffer,
+  outputBuffer,
   dialog,
   options,
 }: FactoryParams): ComponentType<Props> {
   const useTakeScreenshot = useTakeScreenshotFactory({ hooks });
   const Toolbar = ToolbarFactory({ h });
-  const Annotations = AnnotationsFactory({ h });
-  const Crop = CropFactory({ h, hooks, options });
-
-  return function ScreenshotEditor({ onError }: Props): VNode {
-    const styles = hooks.useMemo(() => ({ __html: createScreenshotInputStyles(options.styleNonce).innerText }), []);
-
-    const canvasContainerRef = hooks.useRef<HTMLDivElement>(null);
-    const cropContainerRef = hooks.useRef<HTMLDivElement>(null);
-    const annotatingRef = hooks.useRef<HTMLCanvasElement>(null);
-    const croppingRef = hooks.useRef<HTMLCanvasElement>(null);
-    const [action, setAction] = hooks.useState<'annotate' | 'crop' | ''>('crop');
-    const [croppingRect, setCroppingRect] = hooks.useState<Box>({
-      startX: 0,
-      startY: 0,
-      endX: 0,
-      endY: 0,
-    });
+  const IconClose = IconCloseFactory({ h });
+  const editorStyleInnerText = { __html: createScreenshotInputStyles(options.styleNonce).innerText };
 
-    hooks.useEffect(() => {
-      WINDOW.addEventListener('resize', resize);
+  const dialogStyle = (dialog.el as HTMLElement).style;
+
+  const ScreenshotEditor = ({ screenshot }: { screenshot: Screenshot }): VNode => {
+    // Data for rendering:
+    const [action, setAction] = hooks.useState<DrawType>('highlight');
+    const [drawCommands, setDrawCommands] = hooks.useState<DrawCommand[]>([]);
+
+    // Refs to our html components:
+    const measurementRef = hooks.useRef<HTMLDivElement | null>(null);
+    const backgroundRef = hooks.useRef<MaybeCanvas>(null);
+    const foregroundRef = hooks.useRef<MaybeCanvas>(null);
+    const mouseRef = hooks.useRef<HTMLDivElement | null>(null);
+
+    // The size of our window, relative to the imageSource
+    const [scaleFactor, setScaleFactor] = hooks.useState<number>(1);
+
+    const strokeColor = hooks.useMemo((): string => {
+      const sentryFeedback = DOCUMENT.getElementById(options.id);
+      if (!sentryFeedback) {
+        return 'white';
+      }
+      const computedStyle = getComputedStyle(sentryFeedback);
+      return (
+        computedStyle.getPropertyValue('--button-primary-background') ||
+        computedStyle.getPropertyValue('--accent-background')
+      );
+    }, [options.id]);
+
+    // The initial resize, to measure the area and set the children to the correct size
+    hooks.useLayoutEffect(() => {
+      const handleResize = (): void => {
+        const measurementDiv = measurementRef.current;
+        if (!measurementDiv) {
+          return;
+        }
 
+        with2dContext(screenshot.canvas, { alpha: false }, canvas => {
+          const scale = Math.min(
+            measurementDiv.clientWidth / canvas.width,
+            measurementDiv.clientHeight / canvas.height,
+          );
+          setScaleFactor(scale);
+        });
+      };
+
+      handleResize();
+      WINDOW.addEventListener('resize', handleResize);
       return () => {
-        WINDOW.removeEventListener('resize', resize);
+        WINDOW.removeEventListener('resize', handleResize);
       };
-    }, []);
+    }, [screenshot]);
+
+    // Set the size of the canvas element to match our screenshot
+    const setCanvasSize = hooks.useCallback(
+      (maybeCanvas: MaybeCanvas, scale: number): void => {
+        with2dContext(maybeCanvas, { alpha: true }, (canvas, ctx) => {
+          // Must call `scale()` before setting `width` & `height`
+          ctx.scale(scale, scale);
+          canvas.width = screenshot.canvas.width;
+          canvas.height = screenshot.canvas.height;
+        });
+      },
+      [screenshot],
+    );
+
+    // Draw the screenshot into the background
+    hooks.useEffect(() => {
+      setCanvasSize(backgroundRef.current, screenshot.dpi);
+      paintImage(backgroundRef.current, screenshot.canvas);
+    }, [screenshot]);
+
+    // Draw the commands into the foreground
+    hooks.useEffect(() => {
+      setCanvasSize(foregroundRef.current, screenshot.dpi);
+      with2dContext(foregroundRef.current, { alpha: true }, (canvas, ctx) => {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+      });
+      paintForeground(foregroundRef.current, strokeColor, drawCommands);
+    }, [drawCommands, strokeColor]);
 
-    function resizeCanvas(canvasRef: Hooks.Ref<HTMLCanvasElement>, imageDimensions: Rect): void {
-      const canvas = canvasRef.current;
-      if (!canvas) {
+    // Draw into the output outputBuffer
+    hooks.useEffect(() => {
+      setCanvasSize(outputBuffer, screenshot.dpi);
+      paintImage(outputBuffer, screenshot.canvas);
+      with2dContext(DOCUMENT.createElement('canvas'), { alpha: true }, (foreground, ctx) => {
+        ctx.scale(screenshot.dpi, screenshot.dpi); // The scale needs to be set before we set the width/height and paint
+        foreground.width = screenshot.canvas.width;
+        foreground.height = screenshot.canvas.height;
+        paintForeground(foreground, strokeColor, drawCommands);
+        paintImage(outputBuffer, foreground);
+      });
+    }, [drawCommands, screenshot, strokeColor]);
+
+    const handleMouseDown = (e: MouseEvent): void => {
+      if (!action || !mouseRef.current) {
         return;
       }
 
-      canvas.width = imageDimensions.width * DPI;
-      canvas.height = imageDimensions.height * DPI;
-      canvas.style.width = `${imageDimensions.width}px`;
-      canvas.style.height = `${imageDimensions.height}px`;
-      const ctx = canvas.getContext('2d');
-      if (ctx) {
-        ctx.scale(DPI, DPI);
-      }
-    }
+      const boundingRect = mouseRef.current.getBoundingClientRect();
+      const startingPoint: DrawCommand = {
+        type: action,
+        x: e.offsetX / scaleFactor,
+        y: e.offsetY / scaleFactor,
+        w: 0,
+        h: 0,
+      };
 
-    function resize(): void {
-      const imageDimensions = getContainedSize(imageBuffer);
+      const getDrawCommand = (startingPoint: DrawCommand, e: MouseEvent): DrawCommand => {
+        const x = (e.clientX - boundingRect.x) / scaleFactor;
+        const y = (e.clientY - boundingRect.y) / scaleFactor;
+        return {
+          type: startingPoint.type,
+          x: Math.min(startingPoint.x, x),
+          y: Math.min(startingPoint.y, y),
+          w: Math.abs(x - startingPoint.x),
+          h: Math.abs(y - startingPoint.y),
+        } as DrawCommand;
+      };
 
-      resizeCanvas(croppingRef, imageDimensions);
-      resizeCanvas(annotatingRef, imageDimensions);
+      const handleMouseMove = (e: MouseEvent): void => {
+        with2dContext(foregroundRef.current, { alpha: true }, (canvas, ctx) => {
+          ctx.clearRect(0, 0, canvas.width, canvas.height);
+        });
+        paintForeground(foregroundRef.current, strokeColor, [...drawCommands, getDrawCommand(startingPoint, e)]);
+      };
 
-      const cropContainer = cropContainerRef.current;
-      if (cropContainer) {
-        cropContainer.style.width = `${imageDimensions.width}px`;
-        cropContainer.style.height = `${imageDimensions.height}px`;
-      }
+      const handleMouseUp = (e: MouseEvent): void => {
+        const drawCommand = getDrawCommand(startingPoint, e);
 
-      setCroppingRect({ startX: 0, startY: 0, endX: imageDimensions.width, endY: imageDimensions.height });
-    }
+        // Prevent just clicking onto the canvas, mouse has to move at least 1 pixel
+        if (drawCommand.w * scaleFactor >= 1 && drawCommand.h * scaleFactor >= 1) {
+          setDrawCommands(prev => [...prev, drawCommand]);
+        }
+        DOCUMENT.removeEventListener('mousemove', handleMouseMove);
+        DOCUMENT.removeEventListener('mouseup', handleMouseUp);
+      };
+
+      DOCUMENT.addEventListener('mousemove', handleMouseMove);
+      DOCUMENT.addEventListener('mouseup', handleMouseUp);
+    };
+
+    const deleteRect = hooks.useCallback((index: number): hType.JSX.MouseEventHandler<HTMLButtonElement> => {
+      return (e: MouseEvent): void => {
+        e.preventDefault();
+        e.stopPropagation();
+        setDrawCommands(prev => {
+          const updatedRects = [...prev];
+          updatedRects.splice(index, 1);
+          return updatedRects;
+        });
+      };
+    }, []);
+
+    const dimensions = {
+      width: `${screenshot.canvas.width * scaleFactor}px`,
+      height: `${screenshot.canvas.height * scaleFactor}px`,
+    };
+
+    const handleStopPropagation = (e: MouseEvent): void => {
+      e.stopPropagation();
+    };
+
+    return (
+      <div class="editor">
+        <style nonce={options.styleNonce} dangerouslySetInnerHTML={editorStyleInnerText} />
+        <div class="editor__image-container">
+          <div class="editor__canvas-container" ref={measurementRef}>
+            <canvas ref={backgroundRef} id="background" style={dimensions} />
+            <canvas ref={foregroundRef} id="foreground" style={dimensions} />
+            <div ref={mouseRef} onMouseDown={handleMouseDown} style={dimensions}>
+              {drawCommands.map((rect, index) => (
+                <div
+                  key={index}
+                  class="editor__rect"
+                  style={{
+                    top: `${rect.y * scaleFactor}px`,
+                    left: `${rect.x * scaleFactor}px`,
+                    width: `${rect.w * scaleFactor}px`,
+                    height: `${rect.h * scaleFactor}px`,
+                  }}
+                >
+                  <button
+                    aria-label="Remove"
+                    onClick={deleteRect(index)}
+                    onMouseDown={handleStopPropagation}
+                    onMouseUp={handleStopPropagation}
+                    type="button"
+                  >
+                    <IconClose />
+                  </button>
+                </div>
+              ))}
+            </div>
+          </div>
+        </div>
+        <Toolbar action={action} setAction={setAction} />
+      </div>
+    );
+  };
+
+  return function Wrapper({ onError }: Props): VNode {
+    const [screenshot, setScreenshot] = hooks.useState<undefined | Screenshot>();
 
     useTakeScreenshot({
       onBeforeScreenshot: hooks.useCallback(() => {
-        (dialog.el as HTMLElement).style.display = 'none';
+        dialogStyle.display = 'none';
+      }, []),
+      onScreenshot: hooks.useCallback((screenshotVideo: HTMLVideoElement, dpi: number) => {
+        // Stash the original screenshot image so we can (re)draw it multiple times
+        with2dContext(DOCUMENT.createElement('canvas'), { alpha: false }, (canvas, ctx) => {
+          ctx.scale(dpi, dpi); // The scale needs to be set before we set the width/height and paint
+          canvas.width = screenshotVideo.videoWidth;
+          canvas.height = screenshotVideo.videoHeight;
+          ctx.drawImage(screenshotVideo, 0, 0, canvas.width, canvas.height);
+
+          setScreenshot({ canvas, dpi });
+        });
+
+        // The output buffer, we only need to set the width/height on this once, it stays the same forever
+        outputBuffer.width = screenshotVideo.videoWidth;
+        outputBuffer.height = screenshotVideo.videoHeight;
       }, []),
-      onScreenshot: hooks.useCallback(
-        (imageSource: HTMLVideoElement) => {
-          const context = imageBuffer.getContext('2d');
-          if (!context) {
-            throw new Error('Could not get canvas context');
-          }
-          imageBuffer.width = imageSource.videoWidth;
-          imageBuffer.height = imageSource.videoHeight;
-          imageBuffer.style.width = '100%';
-          imageBuffer.style.height = '100%';
-          context.drawImage(imageSource, 0, 0);
-        },
-        [imageBuffer],
-      ),
       onAfterScreenshot: hooks.useCallback(() => {
-        (dialog.el as HTMLElement).style.display = 'block';
-        const container = canvasContainerRef.current;
-        container?.appendChild(imageBuffer);
-        resize();
+        dialogStyle.display = 'block';
       }, []),
       onError: hooks.useCallback(error => {
-        (dialog.el as HTMLElement).style.display = 'block';
+        dialogStyle.display = 'block';
         onError(error);
       }, []),
     });
 
-    return (
-      <div class="editor">
-        <style nonce={options.styleNonce} dangerouslySetInnerHTML={styles} />
-        <div class="editor__image-container">
-          <div class="editor__canvas-container" ref={canvasContainerRef}>
-            <Crop
-              action={action}
-              imageBuffer={imageBuffer}
-              croppingRef={croppingRef}
-              cropContainerRef={cropContainerRef}
-              croppingRect={croppingRect}
-              setCroppingRect={setCroppingRect}
-              resize={resize}
-            />
-            <Annotations action={action} imageBuffer={imageBuffer} annotatingRef={annotatingRef} />
-          </div>
-        </div>
-        {options._experiments.annotations && <Toolbar action={action} setAction={setAction} />}
-      </div>
-    );
+    if (screenshot) {
+      return <ScreenshotEditor screenshot={screenshot} />;
+    }
+
+    return <div />;
   };
 }
diff --git a/packages/feedback/src/screenshot/components/ScreenshotInput.css.ts b/packages/feedback/src/screenshot/components/ScreenshotInput.css.ts
index 4a9b313cdd6b..cdfda0ddc3f9 100644
--- a/packages/feedback/src/screenshot/components/ScreenshotInput.css.ts
+++ b/packages/feedback/src/screenshot/components/ScreenshotInput.css.ts
@@ -15,10 +15,10 @@ export function createScreenshotInputStyles(styleNonce?: string): HTMLStyleEleme
   flex-grow: 1;
   flex-direction: column;
 }
+
 .editor__image-container {
-  padding: 10px;
-  padding-top: 65px;
-  padding-bottom: 65px;
+  justify-items: center;
+  padding: 15px;
   position: relative;
   height: 100%;
   border-radius: var(--menu-border-radius, 6px);
@@ -40,13 +40,6 @@ export function createScreenshotInputStyles(styleNonce?: string): HTMLStyleEleme
     );
 }
 
-.editor__annotation {
-  z-index: 1;
-}
-.editor__annotation--active {
-  z-index: 2;
-}
-
 .editor__canvas-container {
   width: 100%;
   height: 100%;
@@ -56,73 +49,22 @@ export function createScreenshotInputStyles(styleNonce?: string): HTMLStyleEleme
   justify-content: center;
 }
 
-.editor__canvas-container canvas {
+.editor__canvas-container > * {
   object-fit: contain;
   position: absolute;
 }
 
-.editor__crop-container {
-  custor: auto;
-  position: absolute;
-  z-index: 2;
-}
-.editor__crop-container--inactive {
-  z-index: 1;
-}
-.editor__crop-container--move {
-  cursor: move;
-}
-
-.editor__crop-btn-group {
-  padding: 8px;
-  gap: 8px;
-  border-radius: var(--menu-border-radius, 6px);
-  background: var(--button-background, var(--background));
-  width: 175px;
-  position: absolute;
-  display: none;
-}
-.editor__crop-btn-group--active {
-  display: flex;
-}
-
-.editor__crop-corner {
-  width: 30px;
-  height: 30px;
-  position: absolute;
-  background: none;
-  border: 3px solid #ffffff;
-}
-
-.editor__crop-corner--top-left {
-  cursor: nwse-resize;
-  border-right: none;
-  border-bottom: none;
-}
-.editor__crop-corner--top-right {
-  cursor: nesw-resize;
-  border-left: none;
-  border-bottom: none;
-}
-.editor__crop-corner--bottom-left {
-  cursor: nesw-resize;
-  border-right: none;
-  border-top: none;
-}
-.editor__crop-corner--bottom-right {
-  cursor: nwse-resize;
-  border-left: none;
-  border-top: none;
-}
 .editor__tool-container {
   padding-top: 8px;
   display: flex;
-  justify-content: space-between;
+  justify-content: center;
 }
+
 .editor__tool-bar {
   display: flex;
   gap: 8px;
 }
+
 .editor__tool {
   display: flex;
   padding: 8px 12px;
@@ -131,12 +73,33 @@ export function createScreenshotInputStyles(styleNonce?: string): HTMLStyleEleme
   border: var(--button-border, var(--border));
   border-radius: var(--button-border-radius, 6px);
   background: var(--button-background, var(--background));
-  color: var(--button-foreground, var(--foreground));
+  color: var(--button-color, var(--foreground));
 }
 
 .editor__tool--active {
   background: var(--button-primary-background, var(--accent-background));
-  color: var(--button-primary-foreground, var(--accent-foreground));
+  color: var(--button-primary-color, var(--accent-foreground));
+}
+
+.editor__rect {
+  position: absolute;
+  z-index: 2;
+}
+
+.editor__rect button {
+  opacity: 0;
+  position: absolute;
+  top: -12px;
+  right: -12px;
+  cursor: pointer;
+  padding: 0;
+  z-index: 3;
+  border: none;
+  background: none;
+}
+
+.editor__rect:hover button {
+  opacity: 1;
 }
 `;
 
diff --git a/packages/feedback/src/screenshot/components/Toolbar.tsx b/packages/feedback/src/screenshot/components/Toolbar.tsx
index 29bc35fab09b..1d85cb1392f6 100644
--- a/packages/feedback/src/screenshot/components/Toolbar.tsx
+++ b/packages/feedback/src/screenshot/components/Toolbar.tsx
@@ -1,55 +1,42 @@
 import type { VNode, h as hType } from 'preact';
 import type * as Hooks from 'preact/hooks';
-import CropIconFactory from './CropIcon';
-import PenIconFactory from './PenIcon';
 
 interface FactoryParams {
   h: typeof hType;
 }
 
-export default function ToolbarFactory({ h }: FactoryParams) {
+export default function ToolbarFactory({
+  h, // eslint-disable-line @typescript-eslint/no-unused-vars
+}: FactoryParams) {
   return function Toolbar({
     action,
     setAction,
   }: {
-    action: 'crop' | 'annotate' | '';
-    setAction: Hooks.StateUpdater<'crop' | 'annotate' | ''>;
+    action: 'highlight' | 'hide' | '';
+    setAction: Hooks.StateUpdater<'highlight' | 'hide' | ''>;
   }): VNode {
-    const PenIcon = PenIconFactory({ h });
-    const CropIcon = CropIconFactory({ h });
-
     return (
       <div class="editor__tool-container">
-        <div />
         <div class="editor__tool-bar">
           <button
             type="button"
-            class={`editor__tool ${action === 'crop' ? 'editor__tool--active' : ''}`}
+            class={`editor__tool ${action === 'highlight' ? 'editor__tool--active' : ''}`}
             onClick={() => {
-              if (action === 'crop') {
-                setAction('');
-              } else {
-                setAction('crop');
-              }
+              setAction(action === 'highlight' ? '' : 'highlight');
             }}
           >
-            <CropIcon />
+            Highlight
           </button>
           <button
             type="button"
-            class={`editor__tool ${action === 'annotate' ? 'editor__tool--active' : ''}`}
+            class={`editor__tool ${action === 'hide' ? 'editor__tool--active' : ''}`}
             onClick={() => {
-              if (action === 'annotate') {
-                setAction('');
-              } else {
-                setAction('annotate');
-              }
+              setAction(action === 'hide' ? '' : 'hide');
             }}
           >
-            <PenIcon />
+            Hide
           </button>
         </div>
-        <div />
       </div>
     );
   };
diff --git a/packages/feedback/src/screenshot/components/useTakeScreenshot.tsx b/packages/feedback/src/screenshot/components/useTakeScreenshot.tsx
index a0e70247a007..220c2fdaa4b0 100644
--- a/packages/feedback/src/screenshot/components/useTakeScreenshot.tsx
+++ b/packages/feedback/src/screenshot/components/useTakeScreenshot.tsx
@@ -7,7 +7,7 @@ interface FactoryParams {
 
 interface Props {
   onBeforeScreenshot: () => void;
-  onScreenshot: (imageSource: HTMLVideoElement) => void;
+  onScreenshot: (imageSource: HTMLVideoElement, dpi: number) => void;
   onAfterScreenshot: () => void;
   onError: (error: Error) => void;
 }
@@ -15,14 +15,37 @@ interface Props {
 type UseTakeScreenshot = ({ onBeforeScreenshot, onScreenshot, onAfterScreenshot, onError }: Props) => void;
 
 export function useTakeScreenshotFactory({ hooks }: FactoryParams): UseTakeScreenshot {
+  function useDpi(): number {
+    const [dpi, setDpi] = hooks.useState<number>(WINDOW.devicePixelRatio ?? 1);
+    hooks.useEffect(() => {
+      const onChange = (): void => {
+        setDpi(WINDOW.devicePixelRatio);
+      };
+      const media = matchMedia(`(resolution: ${WINDOW.devicePixelRatio}dppx)`);
+      media.addEventListener('change', onChange);
+      return () => {
+        media.removeEventListener('change', onChange);
+      };
+    }, []);
+
+    return dpi;
+  }
+
   return function useTakeScreenshot({ onBeforeScreenshot, onScreenshot, onAfterScreenshot, onError }: Props) {
+    const dpi = useDpi();
+
     hooks.useEffect(() => {
       const takeScreenshot = async (): Promise<void> => {
         onBeforeScreenshot();
+
+        // Chrome will animate a top-bar which can shrink the window height by a
+        // few pixels. The exact amount depends on how fast it takes to exec
+        // the onloadedmetadata callback.
+        // https://stackoverflow.com/q/75833049
         const stream = await NAVIGATOR.mediaDevices.getDisplayMedia({
           video: {
-            width: WINDOW.innerWidth * WINDOW.devicePixelRatio,
-            height: WINDOW.innerHeight * WINDOW.devicePixelRatio,
+            width: WINDOW.innerWidth * dpi,
+            height: WINDOW.innerHeight * dpi,
           },
           audio: false,
           // @ts-expect-error experimental flags: https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia#prefercurrenttab
@@ -36,7 +59,7 @@ export function useTakeScreenshotFactory({ hooks }: FactoryParams): UseTakeScree
         await new Promise<void>((resolve, reject) => {
           video.srcObject = stream;
           video.onloadedmetadata = () => {
-            onScreenshot(video);
+            onScreenshot(video, dpi);
             stream.getTracks().forEach(track => track.stop());
             resolve();
           };
diff --git a/packages/feedback/src/screenshot/integration.ts b/packages/feedback/src/screenshot/integration.ts
index 8281040f7655..79cb7f9118ff 100644
--- a/packages/feedback/src/screenshot/integration.ts
+++ b/packages/feedback/src/screenshot/integration.ts
@@ -11,20 +11,20 @@ export const feedbackScreenshotIntegration = ((): FeedbackScreenshotIntegration
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     setupOnce() {},
     createInput: ({ h, hooks, dialog, options }) => {
-      const imageBuffer = DOCUMENT.createElement('canvas');
+      const outputBuffer = DOCUMENT.createElement('canvas');
 
       return {
         input: ScreenshotEditorFactory({
           h: h as typeof hType,
           hooks: hooks as typeof Hooks,
-          imageBuffer,
+          outputBuffer,
           dialog,
           options,
         }) as any, // eslint-disable-line @typescript-eslint/no-explicit-any
 
         value: async () => {
           const blob = await new Promise<Parameters<BlobCallback>[0]>(resolve => {
-            imageBuffer.toBlob(resolve, 'image/png');
+            outputBuffer.toBlob(resolve, 'image/png');
           });
           if (blob) {
             const data = new Uint8Array(await blob.arrayBuffer());
diff --git a/packages/nextjs/src/client/browserTracingIntegration.ts b/packages/nextjs/src/client/browserTracingIntegration.ts
index 53cb3e4f6a3f..ab9ee6c43748 100644
--- a/packages/nextjs/src/client/browserTracingIntegration.ts
+++ b/packages/nextjs/src/client/browserTracingIntegration.ts
@@ -12,6 +12,16 @@ export function browserTracingIntegration(
     ...options,
     instrumentNavigation: false,
     instrumentPageLoad: false,
+    onRequestSpanStart(...args) {
+      const [span, { headers }] = args;
+
+      // Next.js prefetch requests have a `next-router-prefetch` header
+      if (headers?.get('next-router-prefetch')) {
+        span?.setAttribute('http.request.prefetch', true);
+      }
+
+      return options.onRequestSpanStart?.(...args);
+    },
   });
 
   const { instrumentPageLoad = true, instrumentNavigation = true } = options;
diff --git a/packages/nextjs/src/client/index.ts b/packages/nextjs/src/client/index.ts
index 37589467f5d6..e8712a3dca65 100644
--- a/packages/nextjs/src/client/index.ts
+++ b/packages/nextjs/src/client/index.ts
@@ -1,4 +1,5 @@
 import type { Client, EventProcessor, Integration } from '@sentry/core';
+import { consoleSandbox } from '@sentry/core';
 import { getGlobalScope } from '@sentry/core';
 import { GLOBAL_OBJ, addEventProcessor, applySdkMetadata } from '@sentry/core';
 import type { BrowserOptions } from '@sentry/react';
@@ -15,6 +16,9 @@ export * from '@sentry/react';
 export * from '../common';
 export { captureUnderscoreErrorException } from '../common/pages-router-instrumentation/_error';
 export { browserTracingIntegration } from './browserTracingIntegration';
+export { captureRouterTransitionStart } from './routing/appRouterRoutingInstrumentation';
+
+let clientIsInitialized = false;
 
 const globalWithInjectedValues = GLOBAL_OBJ as typeof GLOBAL_OBJ & {
   _sentryRewriteFramesAssetPrefixPath: string;
@@ -29,6 +33,16 @@ declare const __SENTRY_TRACING__: boolean;
 
 /** Inits the Sentry NextJS SDK on the browser with the React SDK. */
 export function init(options: BrowserOptions): Client | undefined {
+  if (clientIsInitialized) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[@sentry/nextjs] You are calling `Sentry.init()` more than once on the client. This can happen if you have both a `sentry.client.config.ts` and a `instrumentation-client.ts` file with `Sentry.init()` calls. It is recommended to call `Sentry.init()` once in `instrumentation-client.ts`.',
+      );
+    });
+  }
+  clientIsInitialized = true;
+
   const opts = {
     environment: getVercelEnv(true) || process.env.NODE_ENV,
     defaultIntegrations: getDefaultIntegrations(options),
diff --git a/packages/nextjs/src/client/routing/appRouterRoutingInstrumentation.ts b/packages/nextjs/src/client/routing/appRouterRoutingInstrumentation.ts
index 11f3351dcd15..55ed7dccc847 100644
--- a/packages/nextjs/src/client/routing/appRouterRoutingInstrumentation.ts
+++ b/packages/nextjs/src/client/routing/appRouterRoutingInstrumentation.ts
@@ -9,6 +9,28 @@ import { WINDOW, startBrowserTracingNavigationSpan, startBrowserTracingPageLoadS
 
 export const INCOMPLETE_APP_ROUTER_INSTRUMENTATION_TRANSACTION_NAME = 'incomplete-app-router-transaction';
 
+/**
+ * This mutable keeps track of what router navigation instrumentation mechanism we are using.
+ *
+ * The default one is 'router-patch' which is a way of instrumenting that worked up until Next.js 15.3.0 was released.
+ * For this method we took the global router instance and simply monkey patched all the router methods like push(), replace(), and so on.
+ * This worked because Next.js itself called the router methods for things like the <Link /> component.
+ * Vercel decided that it is not good to call these public API methods from within the framework so they switched to an internal system that completely bypasses our monkey patching. This happened in 15.3.0.
+ *
+ * We raised with Vercel that this breaks our SDK so together with them we came up with an API for `instrumentation-client.ts` called `onRouterTransitionStart` that is called whenever a navigation is kicked off.
+ *
+ * Now we have the problem of version compatibility.
+ * For older Next.js versions we cannot use the new hook so we need to always patch the router.
+ * For newer Next.js versions we cannot know whether the user actually registered our handler for the `onRouterTransitionStart` hook, so we need to wait until it was called at least once before switching the instrumentation mechanism.
+ * The problem is, that the user may still have registered a hook and then call a patched router method.
+ * First, the monkey patched router method will be called, starting a navigation span, then the hook will also called.
+ * We need to handle this case and not create two separate navigation spans but instead update the current navigation span and then switch to the new instrumentation mode.
+ * This is all denoted by this `navigationRoutingMode` variable.
+ */
+let navigationRoutingMode: 'router-patch' | 'transition-start-hook' = 'router-patch';
+
+const currentRouterPatchingNavigationSpanRef: NavigationSpanRef = { current: undefined };
+
 /** Instruments the Next.js app router for pageloads. */
 export function appRouterInstrumentPageLoad(client: Client): void {
   const origin = browserPerformanceTimeOrigin();
@@ -61,17 +83,41 @@ const GLOBAL_OBJ_WITH_NEXT_ROUTER = GLOBAL_OBJ as typeof GLOBAL_OBJ & {
 
 /** Instruments the Next.js app router for navigation. */
 export function appRouterInstrumentNavigation(client: Client): void {
-  const currentNavigationSpanRef: NavigationSpanRef = { current: undefined };
+  routerTransitionHandler = (href, navigationType) => {
+    const pathname = new URL(href, WINDOW.location.href).pathname;
+
+    if (navigationRoutingMode === 'router-patch') {
+      navigationRoutingMode = 'transition-start-hook';
+    }
+
+    const currentNavigationSpan = currentRouterPatchingNavigationSpanRef.current;
+    if (currentNavigationSpan) {
+      currentNavigationSpan.updateName(pathname);
+      currentNavigationSpan.setAttributes({
+        'navigation.type': `router.${navigationType}`,
+      });
+      currentRouterPatchingNavigationSpanRef.current = undefined;
+    } else {
+      startBrowserTracingNavigationSpan(client, {
+        name: pathname,
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'navigation',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.nextjs.app_router_instrumentation',
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
+          'navigation.type': `router.${navigationType}`,
+        },
+      });
+    }
+  };
 
   WINDOW.addEventListener('popstate', () => {
-    if (currentNavigationSpanRef.current?.isRecording()) {
-      currentNavigationSpanRef.current.updateName(WINDOW.location.pathname);
-      currentNavigationSpanRef.current.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'url');
+    if (currentRouterPatchingNavigationSpanRef.current?.isRecording()) {
+      currentRouterPatchingNavigationSpanRef.current.updateName(WINDOW.location.pathname);
+      currentRouterPatchingNavigationSpanRef.current.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'url');
     } else {
-      currentNavigationSpanRef.current = startBrowserTracingNavigationSpan(client, {
+      currentRouterPatchingNavigationSpanRef.current = startBrowserTracingNavigationSpan(client, {
         name: WINDOW.location.pathname,
         attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'navigation',
           [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.nextjs.app_router_instrumentation',
           [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
           'navigation.type': 'browser.popstate',
@@ -94,7 +140,7 @@ export function appRouterInstrumentNavigation(client: Client): void {
       clearInterval(checkForRouterAvailabilityInterval);
       routerPatched = true;
 
-      patchRouter(client, router, currentNavigationSpanRef);
+      patchRouter(client, router, currentRouterPatchingNavigationSpanRef);
 
       // If the router at any point gets overridden - patch again
       (['nd', 'next'] as const).forEach(globalValueName => {
@@ -103,7 +149,7 @@ export function appRouterInstrumentNavigation(client: Client): void {
           GLOBAL_OBJ_WITH_NEXT_ROUTER[globalValueName] = new Proxy(globalValue, {
             set(target, p, newValue) {
               if (p === 'router' && typeof newValue === 'object' && newValue !== null) {
-                patchRouter(client, newValue, currentNavigationSpanRef);
+                patchRouter(client, newValue, currentRouterPatchingNavigationSpanRef);
               }
 
               // @ts-expect-error we cannot possibly type this
@@ -139,6 +185,10 @@ function patchRouter(client: Client, router: NextRouter, currentNavigationSpanRe
       // @ts-expect-error Weird type error related to not knowing how to associate return values with the individual functions - we can just ignore
       router[routerFunctionName] = new Proxy(router[routerFunctionName], {
         apply(target, thisArg, argArray) {
+          if (navigationRoutingMode !== 'router-patch') {
+            return target.apply(thisArg, argArray);
+          }
+
           let transactionName = INCOMPLETE_APP_ROUTER_INSTRUMENTATION_TRANSACTION_NAME;
           const transactionAttributes: Record<string, string> = {
             [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'navigation',
@@ -148,11 +198,9 @@ function patchRouter(client: Client, router: NextRouter, currentNavigationSpanRe
 
           if (routerFunctionName === 'push') {
             transactionName = transactionNameifyRouterArgument(argArray[0]);
-            transactionAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'url';
             transactionAttributes['navigation.type'] = 'router.push';
           } else if (routerFunctionName === 'replace') {
             transactionName = transactionNameifyRouterArgument(argArray[0]);
-            transactionAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'url';
             transactionAttributes['navigation.type'] = 'router.replace';
           } else if (routerFunctionName === 'back') {
             transactionAttributes['navigation.type'] = 'router.back';
@@ -171,3 +219,14 @@ function patchRouter(client: Client, router: NextRouter, currentNavigationSpanRe
     }
   });
 }
+
+let routerTransitionHandler: undefined | ((href: string, navigationType: string) => void) = undefined;
+
+/**
+ * A handler for Next.js' `onRouterTransitionStart` hook in `instrumentation-client.ts` to record navigation spans in Sentry.
+ */
+export function captureRouterTransitionStart(href: string, navigationType: string): void {
+  if (routerTransitionHandler) {
+    routerTransitionHandler(href, navigationType);
+  }
+}
diff --git a/packages/nextjs/src/config/types.ts b/packages/nextjs/src/config/types.ts
index 95c15b887573..965233d08b76 100644
--- a/packages/nextjs/src/config/types.ts
+++ b/packages/nextjs/src/config/types.ts
@@ -44,7 +44,6 @@ export type NextConfigObject = {
   // Next.js experimental options
   experimental?: {
     instrumentationHook?: boolean;
-    clientInstrumentationHook?: boolean;
     clientTraceMetadata?: string[];
   };
   productionBrowserSourceMaps?: boolean;
diff --git a/packages/nextjs/src/config/webpack.ts b/packages/nextjs/src/config/webpack.ts
index 9155b0cd2b60..af7e40f5b58c 100644
--- a/packages/nextjs/src/config/webpack.ts
+++ b/packages/nextjs/src/config/webpack.ts
@@ -344,7 +344,7 @@ export function constructWebpackConfigFunction(
       if (clientSentryConfigFileName) {
         // eslint-disable-next-line no-console
         console.warn(
-          `[@sentry/nextjs] DEPRECATION WARNING: It is recommended renaming your \`${clientSentryConfigFileName}\` file, or moving its content to \`instrumentation-client.ts\`. When using Turbopack \`${clientSentryConfigFileName}\` will no longer work. Read more about the \`instrumentation-client.ts\` file: https://nextjs.org/docs/app/api-reference/config/next-config-js/clientInstrumentationHook`,
+          `[@sentry/nextjs] DEPRECATION WARNING: It is recommended renaming your \`${clientSentryConfigFileName}\` file, or moving its content to \`instrumentation-client.ts\`. When using Turbopack \`${clientSentryConfigFileName}\` will no longer work. Read more about the \`instrumentation-client.ts\` file: https://nextjs.org/docs/app/api-reference/file-conventions/instrumentation-client`,
         );
       }
     }
diff --git a/packages/nextjs/src/config/withSentryConfig.ts b/packages/nextjs/src/config/withSentryConfig.ts
index 4b24d8370393..0ecb2caee9b9 100644
--- a/packages/nextjs/src/config/withSentryConfig.ts
+++ b/packages/nextjs/src/config/withSentryConfig.ts
@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 /* eslint-disable complexity */
 import { isThenable, parseSemver } from '@sentry/core';
 
@@ -12,6 +13,8 @@ import type {
 } from './types';
 import { constructWebpackConfigFunction } from './webpack';
 import { getNextjsVersion } from './util';
+import * as fs from 'fs';
+import * as path from 'path';
 
 let showedExportModeTunnelWarning = false;
 
@@ -155,6 +158,18 @@ function getFinalConfigObject(
     }
   }
 
+  // We wanna check whether the user added a `onRouterTransitionStart` handler to their client instrumentation file.
+  const instrumentationClientFileContents = getInstrumentationClientFileContents();
+  if (
+    instrumentationClientFileContents !== undefined &&
+    !instrumentationClientFileContents.includes('onRouterTransitionStart')
+  ) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      '[@sentry/nextjs] ACTION REQUIRED: To instrument navigations, the Sentry SDK requires you to export an `onRouterTransitionStart` hook from your `instrumentation-client.(js|ts)` file. You can do so by adding `export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;` to the file.',
+    );
+  }
+
   if (nextJsVersion) {
     const { major, minor, patch, prerelease } = parseSemver(nextJsVersion);
     const isSupportedVersion =
@@ -173,15 +188,10 @@ function getFinalConfigObject(
       minor === 3 &&
       patch === 0 &&
       prerelease.startsWith('canary.') &&
-      parseInt(prerelease.split('.')[1] || '', 10) >= 8;
+      parseInt(prerelease.split('.')[1] || '', 10) >= 28;
     const supportsClientInstrumentation = isSupportedCanary || isSupportedVersion;
 
-    if (supportsClientInstrumentation) {
-      incomingUserNextConfigObject.experimental = {
-        clientInstrumentationHook: true,
-        ...incomingUserNextConfigObject.experimental,
-      };
-    } else if (process.env.TURBOPACK) {
+    if (!supportsClientInstrumentation && process.env.TURBOPACK) {
       if (process.env.NODE_ENV === 'development') {
         // eslint-disable-next-line no-console
         console.warn(
@@ -194,19 +204,6 @@ function getFinalConfigObject(
         );
       }
     }
-  } else {
-    // If we cannot detect a Next.js version for whatever reason, the sensible default is still to set the `experimental.instrumentationHook`.
-    incomingUserNextConfigObject.experimental = {
-      clientInstrumentationHook: true,
-      ...incomingUserNextConfigObject.experimental,
-    };
-  }
-
-  if (incomingUserNextConfigObject.experimental?.clientInstrumentationHook === false) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      '[@sentry/nextjs] WARNING: You set the `experimental.clientInstrumentationHook` option to `false`. Note that Sentry will not be initialized if you did not set it up inside `instrumentation-client.(js|ts)`.',
-    );
   }
 
   return {
@@ -361,3 +358,20 @@ function getGitRevision(): string | undefined {
   }
   return gitRevision;
 }
+
+function getInstrumentationClientFileContents(): string | void {
+  const potentialInstrumentationClientFileLocations = [
+    ['src', 'instrumentation-client.ts'],
+    ['src', 'instrumentation-client.js'],
+    ['instrumentation-client.ts'],
+    ['instrumentation-client.ts'],
+  ];
+
+  for (const pathSegments of potentialInstrumentationClientFileLocations) {
+    try {
+      return fs.readFileSync(path.join(process.cwd(), ...pathSegments), 'utf-8');
+    } catch {
+      // noop
+    }
+  }
+}
diff --git a/packages/node/src/integrations/http/SentryHttpInstrumentation.ts b/packages/node/src/integrations/http/SentryHttpInstrumentation.ts
index aa1f0157f2cf..0e0502b6fd1f 100644
--- a/packages/node/src/integrations/http/SentryHttpInstrumentation.ts
+++ b/packages/node/src/integrations/http/SentryHttpInstrumentation.ts
@@ -58,6 +58,15 @@ export type SentryHttpInstrumentationOptions = InstrumentationConfig & {
    */
   ignoreOutgoingRequests?: (url: string, request: RequestOptions) => boolean;
 
+  /**
+   * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
+   * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
+   *
+   * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the outgoing request.
+   * @param request Contains the {@type RequestOptions} object used to make the outgoing request.
+   */
+  ignoreIncomingRequestBody?: (url: string, request: RequestOptions) => boolean;
+
   /**
    * Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry.
    * Read more about Release Health: https://docs.sentry.io/product/releases/health/
@@ -150,6 +159,7 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
   ) => (this: unknown, event: string, ...args: unknown[]) => boolean {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const instrumentation = this;
+    const { ignoreIncomingRequestBody } = instrumentation.getConfig();
 
     return (
       original: (event: string, ...args: unknown[]) => boolean,
@@ -171,7 +181,10 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
         // request.ip is non-standard but some frameworks set this
         const ipAddress = (request as { ip?: string }).ip || request.socket?.remoteAddress;
 
-        patchRequestToCaptureBody(request, isolationScope);
+        const url = request.url || '/';
+        if (!ignoreIncomingRequestBody?.(url, request)) {
+          patchRequestToCaptureBody(request, isolationScope);
+        }
 
         // Update the isolation scope, isolate this request
         isolationScope.setSDKProcessingMetadata({ normalizedRequest, ipAddress });
@@ -180,7 +193,7 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
         // Ideally, framework instrumentations coming after the HttpInstrumentation
         // update the transactionName once we get a parameterized route.
         const httpMethod = (request.method || 'GET').toUpperCase();
-        const httpTarget = stripUrlQueryAndFragment(request.url || '/');
+        const httpTarget = stripUrlQueryAndFragment(url);
 
         const bestEffortTransactionName = `${httpMethod} ${httpTarget}`;
 
diff --git a/packages/node/src/integrations/http/index.ts b/packages/node/src/integrations/http/index.ts
index c8ba11655dcb..f46724aa9b72 100644
--- a/packages/node/src/integrations/http/index.ts
+++ b/packages/node/src/integrations/http/index.ts
@@ -73,6 +73,15 @@ interface HttpOptions {
    */
   ignoreIncomingRequests?: (urlPath: string, request: IncomingMessage) => boolean;
 
+  /**
+   * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
+   * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
+   *
+   * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the outgoing request.
+   * @param request Contains the {@type RequestOptions} object used to make the outgoing request.
+   */
+  ignoreIncomingRequestBody?: (url: string, request: RequestOptions) => boolean;
+
   /**
    * If true, do not generate spans for incoming requests at all.
    * This is used by Remix to avoid generating spans for incoming requests, as it generates its own spans.
diff --git a/packages/node/src/log.ts b/packages/node/src/log.ts
index 2523b0f77bf8..e66d8a24fd17 100644
--- a/packages/node/src/log.ts
+++ b/packages/node/src/log.ts
@@ -20,7 +20,7 @@ function captureLog(level: LogSeverityLevel, ...args: CaptureLogArgs): void {
     const attributes = { ...maybeAttributes };
     attributes['sentry.message.template'] = messageOrMessageTemplate;
     paramsOrAttributes.forEach((param, index) => {
-      attributes[`sentry.message.param.${index}`] = param;
+      attributes[`sentry.message.parameter.${index}`] = param;
     });
     const message = format(messageOrMessageTemplate, ...paramsOrAttributes);
     _INTERNAL_captureLog({ level, message, attributes });
diff --git a/packages/node/src/sdk/client.ts b/packages/node/src/sdk/client.ts
index 74f509ac42e7..d7fcbc5f23d6 100644
--- a/packages/node/src/sdk/client.ts
+++ b/packages/node/src/sdk/client.ts
@@ -4,7 +4,7 @@ import { trace } from '@opentelemetry/api';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import type { DynamicSamplingContext, Scope, ServerRuntimeClientOptions, TraceContext } from '@sentry/core';
-import { SDK_VERSION, ServerRuntimeClient, applySdkMetadata, logger } from '@sentry/core';
+import { _INTERNAL_flushLogsBuffer, SDK_VERSION, ServerRuntimeClient, applySdkMetadata, logger } from '@sentry/core';
 import { getTraceContextForScope } from '@sentry/opentelemetry';
 import { isMainThread, threadId } from 'worker_threads';
 import { DEBUG_BUILD } from '../debug-build';
@@ -18,13 +18,15 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
   private _tracer: Tracer | undefined;
   private _clientReportInterval: NodeJS.Timeout | undefined;
   private _clientReportOnExitFlushListener: (() => void) | undefined;
+  private _logOnExitFlushListener: (() => void) | undefined;
 
   public constructor(options: NodeClientOptions) {
+    const serverName = options.serverName || global.process.env.SENTRY_NAME || os.hostname();
     const clientOptions: ServerRuntimeClientOptions = {
       ...options,
       platform: 'node',
       runtime: { name: 'node', version: global.process.version },
-      serverName: options.serverName || global.process.env.SENTRY_NAME || os.hostname(),
+      serverName,
     };
 
     if (options.openTelemetryInstrumentations) {
@@ -40,6 +42,23 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
     );
 
     super(clientOptions);
+
+    if (this.getOptions()._experiments?.enableLogs) {
+      this._logOnExitFlushListener = () => {
+        _INTERNAL_flushLogsBuffer(this);
+      };
+
+      if (serverName) {
+        this.on('beforeCaptureLog', log => {
+          log.attributes = {
+            ...log.attributes,
+            'server.address': serverName,
+          };
+        });
+      }
+
+      process.on('beforeExit', this._logOnExitFlushListener);
+    }
   }
 
   /** Get the OTEL tracer. */
@@ -84,6 +103,10 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
       process.off('beforeExit', this._clientReportOnExitFlushListener);
     }
 
+    if (this._logOnExitFlushListener) {
+      process.off('beforeExit', this._logOnExitFlushListener);
+    }
+
     return super.close(timeout);
   }
 
diff --git a/packages/node/src/sdk/index.ts b/packages/node/src/sdk/index.ts
index d479407a4e67..21088a253fe3 100644
--- a/packages/node/src/sdk/index.ts
+++ b/packages/node/src/sdk/index.ts
@@ -214,6 +214,7 @@ function getClientOptions(
     release,
     tracesSampleRate,
     spotlight,
+    debug: envToBool(options.debug ?? process.env.SENTRY_DEBUG),
   };
 
   const integrations = options.integrations;
diff --git a/packages/node/test/log.test.ts b/packages/node/test/log.test.ts
index bd2e051ddf50..6ad6678d12f1 100644
--- a/packages/node/test/log.test.ts
+++ b/packages/node/test/log.test.ts
@@ -98,8 +98,8 @@ describe('Node Logger', () => {
         attributes: {
           userId: 123,
           'sentry.message.template': 'Hello %s, your balance is %d',
-          'sentry.message.param.0': 'John',
-          'sentry.message.param.1': 100,
+          'sentry.message.parameter.0': 'John',
+          'sentry.message.parameter.1': 100,
         },
       });
     });
@@ -111,8 +111,8 @@ describe('Node Logger', () => {
         message: 'User Alice logged in from mobile',
         attributes: {
           'sentry.message.template': 'User %s logged in from %s',
-          'sentry.message.param.0': 'Alice',
-          'sentry.message.param.1': 'mobile',
+          'sentry.message.parameter.0': 'Alice',
+          'sentry.message.parameter.1': 'mobile',
         },
       });
     });
diff --git a/packages/node/test/sdk/client.test.ts b/packages/node/test/sdk/client.test.ts
index 18b6c1d3ef53..7b7178660511 100644
--- a/packages/node/test/sdk/client.test.ts
+++ b/packages/node/test/sdk/client.test.ts
@@ -1,7 +1,7 @@
 import * as os from 'os';
 import { ProxyTracer } from '@opentelemetry/api';
 import * as opentelemetryInstrumentationPackage from '@opentelemetry/instrumentation';
-import type { Event, EventHint } from '@sentry/core';
+import type { Event, EventHint, Log } from '@sentry/core';
 import { SDK_VERSION, Scope, getCurrentScope, getGlobalScope, getIsolationScope } from '@sentry/core';
 import { setOpenTelemetryContextAsyncContextStrategy } from '@sentry/opentelemetry';
 import { afterEach, beforeEach, describe, expect, it, test, vi } from 'vitest';
@@ -281,4 +281,32 @@ describe('NodeClient', () => {
       }),
     );
   });
+
+  describe('log capture', () => {
+    it('adds server name to log attributes', () => {
+      const options = getDefaultNodeClientOptions({ _experiments: { enableLogs: true } });
+      const client = new NodeClient(options);
+
+      const log: Log = { level: 'info', message: 'test message', attributes: {} };
+      client.emit('beforeCaptureLog', log);
+
+      expect(log.attributes).toEqual({
+        'server.address': expect.any(String),
+      });
+    });
+
+    it('preserves existing log attributes', () => {
+      const serverName = 'test-server';
+      const options = getDefaultNodeClientOptions({ serverName, _experiments: { enableLogs: true } });
+      const client = new NodeClient(options);
+
+      const log: Log = { level: 'info', message: 'test message', attributes: { 'existing.attr': 'value' } };
+      client.emit('beforeCaptureLog', log);
+
+      expect(log.attributes).toEqual({
+        'existing.attr': 'value',
+        'server.address': serverName,
+      });
+    });
+  });
 });
diff --git a/packages/node/test/sdk/init.test.ts b/packages/node/test/sdk/init.test.ts
index d633926f9d2c..089d5c09b1da 100644
--- a/packages/node/test/sdk/init.test.ts
+++ b/packages/node/test/sdk/init.test.ts
@@ -149,6 +149,113 @@ describe('init()', () => {
 
     expect(client).toBeInstanceOf(NodeClient);
   });
+
+  describe('environment variable options', () => {
+    const originalProcessEnv = { ...process.env };
+
+    afterEach(() => {
+      process.env = originalProcessEnv;
+      global.__SENTRY__ = {};
+      cleanupOtel();
+      vi.clearAllMocks();
+    });
+
+    it('sets debug from `SENTRY_DEBUG` env variable', () => {
+      process.env.SENTRY_DEBUG = '1';
+
+      const client = init({ dsn: PUBLIC_DSN });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          debug: true,
+        }),
+      );
+    });
+
+    it('prefers `debug` option over `SENTRY_DEBUG` env variable', () => {
+      process.env.SENTRY_DEBUG = '1';
+
+      const client = init({ dsn: PUBLIC_DSN, debug: false });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          debug: false,
+        }),
+      );
+    });
+
+    it('sets tracesSampleRate from `SENTRY_TRACES_SAMPLE_RATE` env variable', () => {
+      process.env.SENTRY_TRACES_SAMPLE_RATE = '0.5';
+
+      const client = init({ dsn: PUBLIC_DSN });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          tracesSampleRate: 0.5,
+        }),
+      );
+    });
+
+    it('prefers `tracesSampleRate` option over `SENTRY_TRACES_SAMPLE_RATE` env variable', () => {
+      process.env.SENTRY_TRACES_SAMPLE_RATE = '0.5';
+
+      const client = init({ dsn: PUBLIC_DSN, tracesSampleRate: 0.1 });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          tracesSampleRate: 0.1,
+        }),
+      );
+    });
+
+    it('sets release from `SENTRY_RELEASE` env variable', () => {
+      process.env.SENTRY_RELEASE = '1.0.0';
+
+      const client = init({ dsn: PUBLIC_DSN });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          release: '1.0.0',
+        }),
+      );
+    });
+
+    it('prefers `release` option over `SENTRY_RELEASE` env variable', () => {
+      process.env.SENTRY_RELEASE = '1.0.0';
+
+      const client = init({ dsn: PUBLIC_DSN, release: '2.0.0' });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          release: '2.0.0',
+        }),
+      );
+    });
+
+    it('sets environment from `SENTRY_ENVIRONMENT` env variable', () => {
+      process.env.SENTRY_ENVIRONMENT = 'production';
+
+      const client = init({ dsn: PUBLIC_DSN });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          environment: 'production',
+        }),
+      );
+    });
+
+    it('prefers `environment` option over `SENTRY_ENVIRONMENT` env variable', () => {
+      process.env.SENTRY_ENVIRONMENT = 'production';
+
+      const client = init({ dsn: PUBLIC_DSN, environment: 'staging' });
+
+      expect(client?.getOptions()).toEqual(
+        expect.objectContaining({
+          environment: 'staging',
+        }),
+      );
+    });
+  });
 });
 
 describe('validateOpenTelemetrySetup', () => {
diff --git a/packages/nuxt/test/vite/sourceMaps.test.ts b/packages/nuxt/test/vite/sourceMaps.test.ts
index ab8fdcb3e385..259c402e4058 100644
--- a/packages/nuxt/test/vite/sourceMaps.test.ts
+++ b/packages/nuxt/test/vite/sourceMaps.test.ts
@@ -152,46 +152,64 @@ describe('getPluginOptions', () => {
     );
   });
 
-  it('sets filesToDeleteAfterUpload correctly based on fallback options', () => {
-    // Scenario 1: Both client and server fallback are true
-    const optionsBothTrue = getPluginOptions({}, { client: true, server: true });
-    expect(optionsBothTrue?.sourcemaps?.filesToDeleteAfterUpload).toEqual([
-      '.*/**/public/**/*.map',
-      '.*/**/server/**/*.map',
-      '.*/**/output/**/*.map',
-      '.*/**/function/**/*.map',
-    ]);
-
-    // Scenario 2: Only client fallback is true
-    const optionsClientTrue = getPluginOptions({}, { client: true, server: false });
-    expect(optionsClientTrue?.sourcemaps?.filesToDeleteAfterUpload).toEqual(['.*/**/public/**/*.map']);
-
-    // Scenario 3: Only server fallback is true
-    const optionsServerTrue = getPluginOptions({}, { client: false, server: true });
-    expect(optionsServerTrue?.sourcemaps?.filesToDeleteAfterUpload).toEqual([
-      '.*/**/server/**/*.map',
-      '.*/**/output/**/*.map',
-      '.*/**/function/**/*.map',
-    ]);
-
-    // Scenario 4: No fallback, but custom filesToDeleteAfterUpload is provided
-    const customDeleteFiles = ['custom/path/**/*.map'];
-    const optionsWithCustomDelete = getPluginOptions(
-      {
+  it.each([
+    {
+      name: 'both client and server fallback are true',
+      clientFallback: true,
+      serverFallback: true,
+      customOptions: {},
+      expectedFilesToDelete: [
+        '.*/**/public/**/*.map',
+        '.*/**/server/**/*.map',
+        '.*/**/output/**/*.map',
+        '.*/**/function/**/*.map',
+      ],
+    },
+    {
+      name: 'only client fallback is true',
+      clientFallback: true,
+      serverFallback: false,
+      customOptions: {},
+      expectedFilesToDelete: ['.*/**/public/**/*.map'],
+    },
+    {
+      name: 'only server fallback is true',
+      clientFallback: false,
+      serverFallback: true,
+      customOptions: {},
+      expectedFilesToDelete: ['.*/**/server/**/*.map', '.*/**/output/**/*.map', '.*/**/function/**/*.map'],
+    },
+    {
+      name: 'no fallback, but custom filesToDeleteAfterUpload is provided',
+      clientFallback: false,
+      serverFallback: false,
+      customOptions: {
         sourceMapsUploadOptions: {
           sourcemaps: {
-            filesToDeleteAfterUpload: customDeleteFiles,
+            filesToDeleteAfterUpload: ['custom/path/**/*.map'],
           },
         },
       },
-      { client: false, server: false },
-    );
-    expect(optionsWithCustomDelete?.sourcemaps?.filesToDeleteAfterUpload).toEqual(customDeleteFiles);
+      expectedFilesToDelete: ['custom/path/**/*.map'],
+    },
+    {
+      name: 'no fallback, both source maps explicitly false and no custom filesToDeleteAfterUpload',
+      clientFallback: false,
+      serverFallback: false,
+      customOptions: {},
+      expectedFilesToDelete: undefined,
+    },
+  ])(
+    'sets filesToDeleteAfterUpload correctly when $name',
+    ({ clientFallback, serverFallback, customOptions, expectedFilesToDelete }) => {
+      const options = getPluginOptions(customOptions as SentryNuxtModuleOptions, {
+        client: clientFallback,
+        server: serverFallback,
+      });
 
-    // Scenario 5: No fallback, both source maps explicitly false and no custom filesToDeleteAfterUpload
-    const optionsNoDelete = getPluginOptions({}, { client: false, server: false });
-    expect(optionsNoDelete?.sourcemaps?.filesToDeleteAfterUpload).toBeUndefined();
-  });
+      expect(options?.sourcemaps?.filesToDeleteAfterUpload).toEqual(expectedFilesToDelete);
+    },
+  );
 });
 
 describe('validate sourcemap settings', () => {
@@ -266,62 +284,61 @@ describe('change Nuxt source map settings', () => {
   let nuxt: { options: { sourcemap: { client: boolean | 'hidden'; server: boolean | 'hidden' } } };
   let sentryModuleOptions: SentryNuxtModuleOptions;
 
+  const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
   beforeEach(() => {
+    consoleLogSpy.mockClear();
+
     // @ts-expect-error - Nuxt types don't accept `undefined` but we want to test this case
     nuxt = { options: { sourcemap: { client: undefined } } };
     sentryModuleOptions = {};
   });
 
-  it('should handle nuxt.options.sourcemap.client settings', () => {
-    const cases = [
-      { clientSourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
-      { clientSourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
-      { clientSourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
-      { clientSourcemap: undefined, expectedSourcemap: 'hidden', expectedReturn: 'unset' },
-    ];
-
-    cases.forEach(({ clientSourcemap, expectedSourcemap, expectedReturn }) => {
+  it.each([
+    { clientSourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
+    { clientSourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
+    { clientSourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
+    { clientSourcemap: undefined, expectedSourcemap: 'hidden', expectedReturn: 'unset' },
+  ])(
+    'should handle client sourcemap setting: $clientSourcemap',
+    ({ clientSourcemap, expectedSourcemap, expectedReturn }) => {
       // @ts-expect-error - Nuxt types don't accept `undefined` but we want to test this case
       nuxt.options.sourcemap.client = clientSourcemap;
       const previousUserSourcemapSetting = changeNuxtSourceMapSettings(nuxt as Nuxt, sentryModuleOptions);
       expect(nuxt.options.sourcemap.client).toBe(expectedSourcemap);
       expect(previousUserSourcemapSetting.client).toBe(expectedReturn);
-    });
-  });
-
-  it('should handle nuxt.options.sourcemap.server settings', () => {
-    const cases = [
-      { serverSourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
-      { serverSourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
-      { serverSourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
-      { serverSourcemap: undefined, expectedSourcemap: 'hidden', expectedReturn: 'unset' },
-    ];
-
-    cases.forEach(({ serverSourcemap, expectedSourcemap, expectedReturn }) => {
+    },
+  );
+
+  it.each([
+    { serverSourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
+    { serverSourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
+    { serverSourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
+    { serverSourcemap: undefined, expectedSourcemap: 'hidden', expectedReturn: 'unset' },
+  ])(
+    'should handle server sourcemap setting: $serverSourcemap',
+    ({ serverSourcemap, expectedSourcemap, expectedReturn }) => {
       // @ts-expect-error server available
       nuxt.options.sourcemap.server = serverSourcemap;
       const previousUserSourcemapSetting = changeNuxtSourceMapSettings(nuxt as Nuxt, sentryModuleOptions);
       expect(nuxt.options.sourcemap.server).toBe(expectedSourcemap);
       expect(previousUserSourcemapSetting.server).toBe(expectedReturn);
-    });
-  });
+    },
+  );
 
   describe('should handle nuxt.options.sourcemap as a boolean', () => {
-    it('keeps setting of nuxt.options.sourcemap if it is set', () => {
-      const cases = [
-        { sourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
-        { sourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
-        { sourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
-      ];
-
-      cases.forEach(({ sourcemap, expectedSourcemap, expectedReturn }) => {
-        // @ts-expect-error string type is possible in Nuxt (but type says differently)
-        nuxt.options.sourcemap = sourcemap;
-        const previousUserSourcemapSetting = changeNuxtSourceMapSettings(nuxt as Nuxt, sentryModuleOptions);
-        expect(nuxt.options.sourcemap).toBe(expectedSourcemap);
-        expect(previousUserSourcemapSetting.client).toBe(expectedReturn);
-        expect(previousUserSourcemapSetting.server).toBe(expectedReturn);
-      });
+    it.each([
+      { sourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
+      { sourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
+      { sourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
+    ])('keeps nuxt.options.sourcemap setting: $sourcemap', ({ sourcemap, expectedSourcemap, expectedReturn }) => {
+      // @ts-expect-error string type is possible in Nuxt (but type says differently)
+      nuxt.options.sourcemap = sourcemap;
+      const previousUserSourcemapSetting = changeNuxtSourceMapSettings(nuxt as Nuxt, { debug: true });
+
+      expect(nuxt.options.sourcemap).toBe(expectedSourcemap);
+      expect(previousUserSourcemapSetting.client).toBe(expectedReturn);
+      expect(previousUserSourcemapSetting.server).toBe(expectedReturn);
     });
 
     it("sets client and server to 'hidden' if nuxt.options.sourcemap not set", () => {
@@ -333,5 +350,43 @@ describe('change Nuxt source map settings', () => {
       expect(previousUserSourcemapSetting.client).toBe('unset');
       expect(previousUserSourcemapSetting.server).toBe('unset');
     });
+
+    it('should log a message when source maps are enabled and debug is true', () => {
+      const settingKey = 'sourcemap.client';
+      const settingValue = 'hidden';
+
+      nuxt.options.sourcemap.client = settingValue;
+
+      changeNuxtSourceMapSettings(nuxt as Nuxt, { debug: true });
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        `[Sentry] \`${settingKey}\` is enabled with \`${settingValue}\`. This will correctly un-minify the code snippet on the Sentry Issue Details page.`,
+      );
+    });
+
+    it('should log a message when debug is false and one of the source maps are unset', () => {
+      nuxt.options.sourcemap.server = true;
+
+      const { client, server } = changeNuxtSourceMapSettings(nuxt as Nuxt, { debug: false });
+
+      expect(client).toBe('unset');
+      expect(server).toBe('enabled');
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        '[Sentry] Enabled source map generation in the build options with `sourcemap.client: hidden`.',
+      );
+    });
+
+    it('should not log a message when debug is false and client/server source maps are defined', () => {
+      nuxt.options.sourcemap.client = false;
+      nuxt.options.sourcemap.server = true;
+
+      const { client, server } = changeNuxtSourceMapSettings(nuxt as Nuxt, { debug: false });
+
+      expect(client).toBe('disabled');
+      expect(server).toBe('enabled');
+
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
   });
 });
diff --git a/packages/react-router/package.json b/packages/react-router/package.json
index 82709840eacc..287e35d33766 100644
--- a/packages/react-router/package.json
+++ b/packages/react-router/package.json
@@ -38,7 +38,7 @@
     "@opentelemetry/core": "^1.30.1",
     "@opentelemetry/semantic-conventions": "^1.30.0",
     "@sentry/browser": "9.11.0",
-    "@sentry/cli": "^2.42.3",
+    "@sentry/cli": "^2.43.0",
     "@sentry/core": "9.11.0",
     "@sentry/node": "9.11.0",
     "@sentry/vite-plugin": "^3.2.4",
diff --git a/packages/remix/package.json b/packages/remix/package.json
index c85549c2d52c..772bc2dac17a 100644
--- a/packages/remix/package.json
+++ b/packages/remix/package.json
@@ -60,7 +60,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@remix-run/router": "1.x",
-    "@sentry/cli": "^2.42.3",
+    "@sentry/cli": "^2.43.0",
     "@sentry/core": "9.11.0",
     "@sentry/node": "9.11.0",
     "@sentry/opentelemetry": "9.11.0",
diff --git a/packages/remix/test/integration/package.json b/packages/remix/test/integration/package.json
index 28bbfe12396e..7f4172b0b42f 100644
--- a/packages/remix/test/integration/package.json
+++ b/packages/remix/test/integration/package.json
@@ -8,16 +8,16 @@
     "start": "NODE_OPTIONS='--import=./instrument.server.mjs' remix-serve build/index.js"
   },
   "dependencies": {
-    "@remix-run/express": "2.15.2",
-    "@remix-run/node": "2.15.2",
-    "@remix-run/react": "2.15.2",
-    "@remix-run/serve": "2.15.2",
+    "@remix-run/express": "2.16.3",
+    "@remix-run/node": "2.16.3",
+    "@remix-run/react": "2.16.3",
+    "@remix-run/serve": "2.16.3",
     "@sentry/remix": "file:../..",
     "react": "^18",
     "react-dom": "^18"
   },
   "devDependencies": {
-    "@remix-run/dev": "2.15.2",
+    "@remix-run/dev": "2.16.3",
     "@types/react": "^18",
     "@types/react-dom": "^18",
     "nock": "^13.5.5",
diff --git a/packages/tanstackstart-react/src/config/index.ts b/packages/tanstackstart-react/src/config/index.ts
index 579fe3c7db00..e41b60609c43 100644
--- a/packages/tanstackstart-react/src/config/index.ts
+++ b/packages/tanstackstart-react/src/config/index.ts
@@ -9,7 +9,7 @@ export function wrapVinxiConfigWithSentry<C>(
     org?: string;
     project?: string;
     silent?: boolean;
-    authToken?: boolean;
+    authToken?: string;
   } = {},
 ): C {
   return config;
diff --git a/yarn.lock b/yarn.lock
index 27c0b61bb063..346dae607107 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6497,70 +6497,75 @@
   resolved "https://registry.yarnpkg.com/@sentry/cli-darwin/-/cli-darwin-2.42.2.tgz#a32a4f226e717122b37d9969e8d4d0e14779f720"
   integrity sha512-GtJSuxER7Vrp1IpxdUyRZzcckzMnb4N5KTW7sbTwUiwqARRo+wxS+gczYrS8tdgtmXs5XYhzhs+t4d52ITHMIg==
 
-"@sentry/cli-darwin@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-darwin/-/cli-darwin-2.42.3.tgz#34782c2bf889cec99794ec90287fec3836b1a691"
-  integrity sha512-QGNXZ5c2kbjB3O37ep/uVfqTspHaHkH4kmoMPNJ6j21A1oYyJq5t/AX9JWsueysRwvn6Jc0K0+XyzYZ13z0vsQ==
+"@sentry/cli-darwin@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-darwin/-/cli-darwin-2.43.0.tgz#544caac85069a34d435b0723d8ac6bb6a530ab33"
+  integrity sha512-0MYvRHJowXOMNY5W6XF4p9GQNH3LuQ+IHAQwVbZOsfwnEv8e20rf9BiPPzmJ9sIjZSWYR4yIqm6dBp6ABJFbGQ==
 
 "@sentry/cli-linux-arm64@2.42.2":
   version "2.42.2"
   resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm64/-/cli-linux-arm64-2.42.2.tgz#1c06c83ff21f51ec23acf5be3b1f8c7553bf86b1"
   integrity sha512-BOxzI7sgEU5Dhq3o4SblFXdE9zScpz6EXc5Zwr1UDZvzgXZGosUtKVc7d1LmkrHP8Q2o18HcDWtF3WvJRb5Zpw==
 
-"@sentry/cli-linux-arm64@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm64/-/cli-linux-arm64-2.42.3.tgz#b722270c81fbdd7703a26451f505f82528d97116"
-  integrity sha512-tRqWrmphK82G14KKFEouLdV8BdCpGsTuySZ8nzTqhoAtcjpWFaavX2/1UqKzPVYjkxwXc1npO3Q7qfZYW2HvjQ==
+"@sentry/cli-linux-arm64@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm64/-/cli-linux-arm64-2.43.0.tgz#e110758c7cf6ced78d8b0b3c8c56802984b0fb98"
+  integrity sha512-7URSaNjbEJQZyYJ33XK3pVKl6PU2oO9ETF6R/4Cz2FmU3fecACLKVldv7+OuNl9aspLZ62mnPMDvT732/Fp2Ug==
 
 "@sentry/cli-linux-arm@2.42.2":
   version "2.42.2"
   resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm/-/cli-linux-arm-2.42.2.tgz#00cadc359ae3c051efb3e63873c033c61dbd1ca1"
   integrity sha512-7udCw+YL9lwq+9eL3WLspvnuG+k5Icg92YE7zsteTzWLwgPVzaxeZD2f8hwhsu+wmL+jNqbpCRmktPteh3i2mg==
 
-"@sentry/cli-linux-arm@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm/-/cli-linux-arm-2.42.3.tgz#81373e1dd017a3d265a49172546063ebbcf69098"
-  integrity sha512-tipumegAsKy9KLq6Bk87E8FqkKErReaNzdhoHCb081jkxQxpzKN/MQPMl9mA0XeKc4A7OUBM3vjhIk6uNi1R2g==
+"@sentry/cli-linux-arm@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm/-/cli-linux-arm-2.43.0.tgz#00d36a7347480b8b693cf0ed5cff270ad40045e7"
+  integrity sha512-c2Fwb6HrFL1nbaGV4uRhHC1wEJPR+wfpKN5y06PgSNNbd10YrECAB3tqBHXC8CEmhuDyFR+ORGZ7VbswfCWEEQ==
 
 "@sentry/cli-linux-i686@2.42.2":
   version "2.42.2"
   resolved "https://registry.yarnpkg.com/@sentry/cli-linux-i686/-/cli-linux-i686-2.42.2.tgz#3b817b715dd806c20dfbffd539725ad8089c310a"
   integrity sha512-Sw/dQp5ZPvKnq3/y7wIJyxTUJYPGoTX/YeMbDs8BzDlu9to2LWV3K3r7hE7W1Lpbaw4tSquUHiQjP5QHCOS7aQ==
 
-"@sentry/cli-linux-i686@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-i686/-/cli-linux-i686-2.42.3.tgz#8342a137ea57df0bb0136a57c3a21eddc1e28991"
-  integrity sha512-pc4Kc7xTMNbUPiRLQ2UXcj2V2vbVmST0IyhOlVTmY0L3ZxMdiwTq7qgS/IcxI/CaCPyEZWplXnxlsa//mCMuYw==
+"@sentry/cli-linux-i686@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-i686/-/cli-linux-i686-2.43.0.tgz#83a31f47a13d8b3fae2716f86412fae2ffec5cf4"
+  integrity sha512-bFo/tpMZeMJ275HPGmAENREchnBxhALOOpZAphSyalUu3pGZ+EETEtlSLrKyVNJo26Dye5W7GlrYUV9+rkyCtg==
 
 "@sentry/cli-linux-x64@2.42.2":
   version "2.42.2"
   resolved "https://registry.yarnpkg.com/@sentry/cli-linux-x64/-/cli-linux-x64-2.42.2.tgz#ddf906bc3071cc79ce6e633eddcb76bb9068e688"
   integrity sha512-mU4zUspAal6TIwlNLBV5oq6yYqiENnCWSxtSQVzWs0Jyq97wtqGNG9U+QrnwjJZ+ta/hvye9fvL2X25D/RxHQw==
 
-"@sentry/cli-linux-x64@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-x64/-/cli-linux-x64-2.42.3.tgz#46c4331a46e9c5cee547dcc6c9e039fb8a45f331"
-  integrity sha512-CZoG2swc38/RruLYtvMJNpcbvzqpcSDl+dUFJ3y6wIvMsE1IQL3zrb4xSh1Acf8Hi+GhlFAtoZpgH1tpWWZ/Zw==
+"@sentry/cli-linux-x64@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-x64/-/cli-linux-x64-2.43.0.tgz#dac1641c0c862d5d9f45c2b2c0d77b0281c53261"
+  integrity sha512-EbAmKXUNU/Ii4pNGVRCepU6ks1M43wStMKx3pibrUTllrrCwqYKyPxRRdoFYySHkduwCxnoKZcLEg9vWZ3qS6A==
+
+"@sentry/cli-win32-arm64@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-arm64/-/cli-win32-arm64-2.43.0.tgz#ec499fc49c380252984ae5cde6b59ca0dbad79ef"
+  integrity sha512-KmJRCdQQGLSErJvrcGcN+yWo68m+5OdluhyJHsVYMOQknwu8YMOWLm12EIa+4t4GclDvwg5xcxLccCuiWMJUZw==
 
 "@sentry/cli-win32-i686@2.42.2":
   version "2.42.2"
   resolved "https://registry.yarnpkg.com/@sentry/cli-win32-i686/-/cli-win32-i686-2.42.2.tgz#9036085c7c6ce455ad45fda411c55ff39c06eb95"
   integrity sha512-iHvFHPGqgJMNqXJoQpqttfsv2GI3cGodeTq4aoVLU/BT3+hXzbV0x1VpvvEhncJkDgDicJpFLM8sEPHb3b8abw==
 
-"@sentry/cli-win32-i686@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-i686/-/cli-win32-i686-2.42.3.tgz#5fc97729eb895707808a757ec6d557fbbf4a44de"
-  integrity sha512-geiPcfeuSj23N346xwrxFAuohIivK48NKQQYllVFAADYoYrSawSznVzRyOIheiOte1AIrDkpqzoT/5igl7ANEQ==
+"@sentry/cli-win32-i686@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-i686/-/cli-win32-i686-2.43.0.tgz#bf686d387e91d7897cfbd96a681a52816f90fb0b"
+  integrity sha512-ZWxZdOyZX7NJ/CTskzg+dJ2xTpobFLXVNMOMq0HiwdhqXP2zYYJzKnIt3mHNJYA40zYFODGSgxIamodjpB8BuA==
 
 "@sentry/cli-win32-x64@2.42.2":
   version "2.42.2"
   resolved "https://registry.yarnpkg.com/@sentry/cli-win32-x64/-/cli-win32-x64-2.42.2.tgz#7d6464b63f32c9f97fff428f246b1f039b402233"
   integrity sha512-vPPGHjYoaGmfrU7xhfFxG7qlTBacroz5NdT+0FmDn6692D8IvpNXl1K+eV3Kag44ipJBBeR8g1HRJyx/F/9ACw==
 
-"@sentry/cli-win32-x64@2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-x64/-/cli-win32-x64-2.42.3.tgz#759f320d60dc1d923d8c8edc44945aca77813f67"
-  integrity sha512-sG+phJ+3WUMx6gTrUd7UH+q0L6X1YjS57ovMMf3XYyE/WIF8c+uc+vZC/RB3O5l3vTTCXoePqHf8+9ulgp9dkA==
+"@sentry/cli-win32-x64@2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-x64/-/cli-win32-x64-2.43.0.tgz#9d5e7b9888c0e639d3e62e4dd7a58468103b6bce"
+  integrity sha512-S/IRQYAziEnjpyROhnqzTqShDq3m8jcevXx+q5f49uQnFbfYcTgS1sdrEPqqao/K2boOWbffxYtTkvBiB/piQQ==
 
 "@sentry/cli@2.42.2":
   version "2.42.2"
@@ -6581,10 +6586,10 @@
     "@sentry/cli-win32-i686" "2.42.2"
     "@sentry/cli-win32-x64" "2.42.2"
 
-"@sentry/cli@^2.36.1", "@sentry/cli@^2.42.3":
-  version "2.42.3"
-  resolved "https://registry.yarnpkg.com/@sentry/cli/-/cli-2.42.3.tgz#9be5e7204f4b066048050ec3887eaa1c8e09afcd"
-  integrity sha512-SqY+QZGAISb0NWh6Y4HX/RUhUq9VQjN18ZhY3tTtObgxoaRkbngs21gEyemSKf5hv3HsVGuUf9jvxGQEalwrsw==
+"@sentry/cli@^2.36.1", "@sentry/cli@^2.43.0":
+  version "2.43.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli/-/cli-2.43.0.tgz#2b0dcb749a1529faeb2c239962307c5a2e33f817"
+  integrity sha512-gBE3bkx+PBJxopTrzIJLX4xHe5S0w87q5frIveWKDZ5ulVIU6YWnVumay0y07RIEweUEj3IYva1qH6HG2abfiA==
   dependencies:
     https-proxy-agent "^5.0.0"
     node-fetch "^2.6.7"
@@ -6592,13 +6597,14 @@
     proxy-from-env "^1.1.0"
     which "^2.0.2"
   optionalDependencies:
-    "@sentry/cli-darwin" "2.42.3"
-    "@sentry/cli-linux-arm" "2.42.3"
-    "@sentry/cli-linux-arm64" "2.42.3"
-    "@sentry/cli-linux-i686" "2.42.3"
-    "@sentry/cli-linux-x64" "2.42.3"
-    "@sentry/cli-win32-i686" "2.42.3"
-    "@sentry/cli-win32-x64" "2.42.3"
+    "@sentry/cli-darwin" "2.43.0"
+    "@sentry/cli-linux-arm" "2.43.0"
+    "@sentry/cli-linux-arm64" "2.43.0"
+    "@sentry/cli-linux-i686" "2.43.0"
+    "@sentry/cli-linux-x64" "2.43.0"
+    "@sentry/cli-win32-arm64" "2.43.0"
+    "@sentry/cli-win32-i686" "2.43.0"
+    "@sentry/cli-win32-x64" "2.43.0"
 
 "@sentry/rollup-plugin@3.2.4":
   version "3.2.4"
@@ -27011,6 +27017,7 @@ stylus@0.59.0, stylus@^0.59.0:
 
 sucrase@^3.27.0, sucrase@^3.35.0, sucrase@getsentry/sucrase#es2020-polyfills:
   version "3.36.0"
+  uid fd682f6129e507c00bb4e6319cc5d6b767e36061
   resolved "https://codeload.github.com/getsentry/sucrase/tar.gz/fd682f6129e507c00bb4e6319cc5d6b767e36061"
   dependencies:
     "@jridgewell/gen-mapping" "^0.3.2"