Merge branch 'develop' into timfish/feat/browser-view-hierarchy

Author: timfish

.github/workflows/build.yml

@@ -267,6 +267,8 @@ jobs:
         run: yarn lint:lerna
       - name: Lint C++ files
         run: yarn lint:clang
+      - name: Lint for ES compatibility
+        run: yarn lint:es-compatibility
 
   job_check_format:
     name: Check file formatting
@@ -1200,7 +1202,8 @@ jobs:
       - name: Run E2E test
         working-directory: dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}
         timeout-minutes: 10
-        run: xvfb-run --auto-servernum --server-args="-screen 0 1280x960x24" -- yarn test:assert
+        run: |
+          xvfb-run --auto-servernum --server-args="-screen 0 1280x960x24" -- yarn test:assert
 
   job_required_jobs_passed:
     name: All required jobs passed or were skipped

CHANGELOG.md

@@ -12,6 +12,50 @@
 
 Work in this release was contributed by @aloisklink, @arturovt, @benjick and @maximepvrt. Thank you for your contributions!
 
+- **feat(solidstart)!: Default to `--import` setup and add `autoInjectServerSentry` ([#14862](https://github.com/getsentry/sentry-javascript/pull/14862))**
+
+To enable the SolidStart SDK, wrap your SolidStart Config with `withSentry`. The `sentrySolidStartVite` plugin is now automatically
+added by `withSentry` and you can pass the Sentry build-time options like this:
+
+```js
+import { defineConfig } from '@solidjs/start/config';
+import { withSentry } from '@sentry/solidstart';
+
+export default defineConfig(
+  withSentry(
+    {
+      /* Your SolidStart config options... */
+    },
+    {
+      // Options for setting up source maps
+      org: process.env.SENTRY_ORG,
+      project: process.env.SENTRY_PROJECT,
+      authToken: process.env.SENTRY_AUTH_TOKEN,
+    },
+  ),
+);
+```
+
+With the `withSentry` wrapper, the Sentry server config should not be added to the `public` directory anymore.
+Add the Sentry server config in `src/instrument.server.ts`. Then, the server config will be placed inside the server build output as `instrument.server.mjs`.
+
+Now, there are two options to set up the SDK:
+
+1. **(recommended)** Provide an `--import` CLI flag to the start command like this (path depends on your server setup):
+   `node --import ./.output/server/instrument.server.mjs .output/server/index.mjs`
+2. Add `autoInjectServerSentry: 'top-level-import'` and the Sentry config will be imported at the top of the server entry (comes with tracing limitations)
+   ```js
+   withSentry(
+     {
+       /* Your SolidStart config options... */
+     },
+     {
+       // Optional: Install Sentry with a top-level import
+       autoInjectServerSentry: 'top-level-import',
+     },
+   );
+   ```
+
 ## 8.45.0
 
 - feat(core): Add `handled` option to `captureConsoleIntegration` ([#14664](https://github.com/getsentry/sentry-javascript/pull/14664))

MIGRATION.md

@@ -870,53 +870,35 @@ or look at the TypeScript type definitions of `withSentryConfig`.
 
 #### Updated the recommended way of calling `Sentry.init()`
 
-With version 8 of the SDK we will no longer support the use of `sentry.server.config.ts` and `sentry.edge.config.ts`
-files. Instead, please initialize the Sentry Next.js SDK for the serverside in a
-[Next.js instrumentation hook](https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation).
-**`sentry.client.config.ts|js` is still supported and encouraged for initializing the clientside SDK.**
+Version 8 of the Next.js SDK will require an additional `instrumentation.ts` file to execute the `sentry.server.config.js|ts` and `sentry.edge.config.js|ts` modules to initialize the SDK for the server-side.
+The `instrumentation.ts` file is a Next.js native API called [instrumentation hook](https://nextjs.org/docs/app/api-reference/file-conventions/instrumentation).
 
-The following is an example of how to initialize the serverside SDK in a Next.js instrumentation hook:
+To start using the Next.js instrumentation hook, follow these steps:
 
-1. First, enable the Next.js instrumentation hook by setting the `experimental.instrumentationHook` to `true` in your
-   `next.config.js`.
-2. Next, create a `instrumentation.ts|js` file in the root directory of your project (or in the `src` folder if you have
-   have one).
-3. Now, export a `register` function from the `instrumentation.ts|js` file and call `Sentry.init()` inside of it:
+1. First, enable the Next.js instrumentation hook by setting the [`experimental.instrumentationHook`](https://nextjs.org/docs/app/api-reference/next-config-js/instrumentationHook) to true in your `next.config.js`. (This step is no longer required with Next.js 15)
 
-   ```ts
-   import * as Sentry from '@sentry/nextjs';
-
-   export function register() {
-     if (process.env.NEXT_RUNTIME === 'nodejs') {
-       Sentry.init({
-         dsn: 'YOUR_DSN',
-         // Your Node.js Sentry configuration...
-       });
-     }
-
-     if (process.env.NEXT_RUNTIME === 'edge') {
-       Sentry.init({
-         dsn: 'YOUR_DSN',
-         // Your Edge Runtime Sentry configuration...
-       });
-     }
+   ```JavaScript {filename:next.config.js} {2-4}
+   module.exports = {
+     experimental: {
+       instrumentationHook: true, // Not required on Next.js 15+
+     },
    }
    ```
 
-   If you need to import a Node.js specific integration (like for example `@sentry/profiling-node`), you will have to
-   import the package using a dynamic import to prevent Next.js from bundling Node.js APIs into bundles for other
-   runtime environments (like the Browser or the Edge runtime). You can do so as follows:
+2. Next, create a `instrumentation.ts|js` file in the root directory of your project (or in the src folder if you have have one).
+
+3. Now, export a register function from the `instrumentation.ts|js` file and import your `sentry.server.config.js|ts` and `sentry.edge.config.js|ts` modules:
 
-   ```ts
+   ```JavaScript {filename:instrumentation.js}
    import * as Sentry from '@sentry/nextjs';
 
    export async function register() {
      if (process.env.NEXT_RUNTIME === 'nodejs') {
-       const { nodeProfilingIntegration } = await import('@sentry/profiling-node');
-       Sentry.init({
-         dsn: 'YOUR_DSN',
-         integrations: [nodeProfilingIntegration()],
-       });
+       await import('./sentry.server.config');
+     }
+
+     if (process.env.NEXT_RUNTIME === 'edge') {
+       await import('./sentry.edge.config');
      }
    }
    ```

dev-packages/browser-integration-tests/loader-suites/loader/noOnLoad/customOnErrorHandler/subject.js

@@ -2,7 +2,7 @@ const oldOnError = window.onerror;
 
 window.onerror = function () {
   console.log('custom error');
-  oldOnError && oldOnError.apply(this, arguments);
+  oldOnError?.apply(this, arguments);
 };
 
 window.doSomethingWrong();

dev-packages/browser-integration-tests/suites/integrations/captureConsole-attachStackTrace/init.js

@@ -6,6 +6,5 @@ window.Sentry = Sentry;
 Sentry.init({
   dsn: 'https://[email protected]/1337',
   integrations: [captureConsoleIntegration()],
-  autoSessionTracking: false,
   attachStacktrace: true,
 });

dev-packages/browser-integration-tests/suites/integrations/captureConsole-attachStackTrace/test.ts

@@ -19,10 +19,10 @@ sentryTest(
     const errorEvent = events.find(event => event.message === 'console error');
     const traceEvent = events.find(event => event.message === 'console trace');
     const errorWithErrorEvent = events.find(
-      event => event.exception && event.exception.values?.[0].value === 'console error with error object',
+      event => event.exception?.values?.[0].value === 'console error with error object',
     );
     const traceWithErrorEvent = events.find(
-      event => event.exception && event.exception.values?.[0].value === 'console trace with error object',
+      event => event.exception?.values?.[0].value === 'console trace with error object',
     );
 
     expect(logEvent).toEqual(

dev-packages/browser-integration-tests/suites/integrations/captureConsole/init.js

@@ -6,5 +6,4 @@ window.Sentry = Sentry;
 Sentry.init({
   dsn: 'https://[email protected]/1337',
   integrations: [captureConsoleIntegration()],
-  autoSessionTracking: false,
 });

dev-packages/browser-integration-tests/suites/integrations/captureConsole/test.ts

@@ -17,10 +17,10 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
   const errorEvent = events.find(event => event.message === 'console error');
   const traceEvent = events.find(event => event.message === 'console trace');
   const errorWithErrorEvent = events.find(
-    event => event.exception && event.exception.values?.[0].value === 'console error with error object',
+    event => event.exception?.values?.[0].value === 'console error with error object',
   );
   const traceWithErrorEvent = events.find(
-    event => event.exception && event.exception.values?.[0].value === 'console trace with error object',
+    event => event.exception?.values?.[0].value === 'console trace with error object',
   );
 
   expect(logEvent).toEqual(

dev-packages/browser-integration-tests/suites/integrations/featureFlags/featureFlags/withScope/test.ts

@@ -22,8 +22,8 @@ sentryTest('Flag evaluations in forked scopes are stored separately.', async ({
   const url = await getLocalTestUrl({ testDir: __dirname, skipDsnRouteHandler: true });
   await page.goto(url);
 
-  const forkedReqPromise = waitForErrorRequest(page, event => !!event.tags && event.tags.isForked === true);
-  const mainReqPromise = waitForErrorRequest(page, event => !!event.tags && event.tags.isForked === false);
+  const forkedReqPromise = waitForErrorRequest(page, event => !!event.tags?.isForked === true);
+  const mainReqPromise = waitForErrorRequest(page, event => !!event.tags?.isForked === false);
 
   await page.evaluate(() => {
     const Sentry = (window as any).Sentry;

dev-packages/browser-integration-tests/suites/integrations/featureFlags/launchdarkly/init.js

@@ -13,7 +13,7 @@ Sentry.init({
 // Also, no SDK has mock utils for FlagUsedHandler's.
 const MockLaunchDarkly = {
   initialize(_clientId, context, options) {
-    const flagUsedHandler = options && options.inspectors ? options.inspectors[0].method : undefined;
+    const flagUsedHandler = options.inspectors ? options.inspectors[0].method : undefined;
 
     return {
       variation(key, defaultValue) {