Merge branch 'develop' into patch-1

Author: mstrokin

.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

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/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/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/sessions/update-session/test.ts

@@ -2,14 +2,16 @@ import { expect } from '@playwright/test';
 import type { SessionContext } from '@sentry/core';
 
 import { sentryTest } from '../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest } from '../../../utils/helpers';
+import { getFirstSentryEnvelopeRequest, waitForSession } from '../../../utils/helpers';
 
 sentryTest('should update session when an error is thrown.', async ({ getLocalTestUrl, page }) => {
   const url = await getLocalTestUrl({ testDir: __dirname });
+
   const pageloadSession = await getFirstSentryEnvelopeRequest<SessionContext>(page, url);
-  const updatedSession = (
-    await Promise.all([page.locator('#throw-error').click(), getFirstSentryEnvelopeRequest<SessionContext>(page)])
-  )[1];
+
+  const updatedSessionPromise = waitForSession(page);
+  await page.locator('#throw-error').click();
+  const updatedSession = await updatedSessionPromise;
 
   expect(pageloadSession).toBeDefined();
   expect(pageloadSession.init).toBe(true);
@@ -25,9 +27,10 @@ sentryTest('should update session when an exception is captured.', async ({ getL
   const url = await getLocalTestUrl({ testDir: __dirname });
 
   const pageloadSession = await getFirstSentryEnvelopeRequest<SessionContext>(page, url);
-  const updatedSession = (
-    await Promise.all([page.locator('#capture-exception').click(), getFirstSentryEnvelopeRequest<SessionContext>(page)])
-  )[1];
+
+  const updatedSessionPromise = waitForSession(page);
+  await page.locator('#capture-exception').click();
+  const updatedSession = await updatedSessionPromise;
 
   expect(pageloadSession).toBeDefined();
   expect(pageloadSession.init).toBe(true);

dev-packages/browser-integration-tests/suites/sessions/v7-hub-start-session/init.js

@@ -5,8 +5,6 @@ window.Sentry = Sentry;
 Sentry.init({
   dsn: 'https://[email protected]/1337',
   release: '0.1',
-  // intentionally disabling this, we want to leverage the deprecated hub API
-  autoSessionTracking: false,
 });
 
 // simulate old startSessionTracking behavior

dev-packages/browser-integration-tests/utils/helpers.ts

@@ -7,6 +7,7 @@ import type {
   Event,
   EventEnvelope,
   EventEnvelopeHeaders,
+  SessionContext,
   TransactionEvent,
 } from '@sentry/core';
 
@@ -157,7 +158,7 @@ export const countEnvelopes = async (
  * @param {{ path?: string; content?: string }} impl
  * @return {*}  {Promise<void>}
  */
-async function runScriptInSandbox(
+export async function runScriptInSandbox(
   page: Page,
   impl: {
     path?: string;
@@ -178,7 +179,7 @@ async function runScriptInSandbox(
  * @param {string} [url]
  * @return {*}  {Promise<Array<Event>>}
  */
-async function getSentryEvents(page: Page, url?: string): Promise<Array<Event>> {
+export async function getSentryEvents(page: Page, url?: string): Promise<Array<Event>> {
   if (url) {
     await page.goto(url);
   }
@@ -250,6 +251,25 @@ export function waitForTransactionRequest(
   });
 }
 
+export async function waitForSession(page: Page): Promise<SessionContext> {
+  const req = await page.waitForRequest(req => {
+    const postData = req.postData();
+    if (!postData) {
+      return false;
+    }
+
+    try {
+      const event = envelopeRequestParser<SessionContext>(req);
+
+      return typeof event.init === 'boolean' && event.started !== undefined;
+    } catch {
+      return false;
+    }
+  });
+
+  return envelopeRequestParser<SessionContext>(req);
+}
+
 /**
  * We can only test tracing tests in certain bundles/packages:
  * - NPM (ESM, CJS)
@@ -353,7 +373,7 @@ async function getMultipleRequests<T>(
 /**
  * Wait and get multiple envelope requests at the given URL, or the current page
  */
-async function getMultipleSentryEnvelopeRequests<T>(
+export async function getMultipleSentryEnvelopeRequests<T>(
   page: Page,
   count: number,
   options?: {
@@ -374,7 +394,7 @@ async function getMultipleSentryEnvelopeRequests<T>(
  * @param {string} [url]
  * @return {*}  {Promise<T>}
  */
-async function getFirstSentryEnvelopeRequest<T>(
+export async function getFirstSentryEnvelopeRequest<T>(
   page: Page,
   url?: string,
   requestParser: (req: Request) => T = envelopeRequestParser as (req: Request) => T,
@@ -388,5 +408,3 @@ async function getFirstSentryEnvelopeRequest<T>(
 
   return req;
 }
-
-export { runScriptInSandbox, getMultipleSentryEnvelopeRequests, getFirstSentryEnvelopeRequest, getSentryEvents };

dev-packages/e2e-tests/test-applications/solidstart-spa/app.config.ts

@@ -1,9 +1,9 @@
-import { sentrySolidStartVite } from '@sentry/solidstart';
+import { withSentry } from '@sentry/solidstart';
 import { defineConfig } from '@solidjs/start/config';
 
-export default defineConfig({
-  ssr: false,
-  vite: {
-    plugins: [sentrySolidStartVite()],
-  },
-});
+export default defineConfig(
+  withSentry({
+    ssr: false,
+    middleware: './src/middleware.ts',
+  }),
+);

dev-packages/e2e-tests/test-applications/solidstart-spa/package.json

@@ -3,9 +3,9 @@
   "version": "0.0.0",
   "scripts": {
     "clean": "pnpx rimraf node_modules pnpm-lock.yaml .vinxi .output",
-    "dev": "NODE_OPTIONS='--import ./src/instrument.server.mjs' vinxi dev",
-    "build": "vinxi build && sh ./post_build.sh",
-    "preview": "HOST=localhost PORT=3030 NODE_OPTIONS='--import ./src/instrument.server.mjs' vinxi start",
+    "build": "vinxi build && sh post_build.sh",
+    "preview": "HOST=localhost PORT=3030 vinxi start",
+    "start:import": "HOST=localhost PORT=3030 node --import ./.output/server/instrument.server.mjs .output/server/index.mjs",
     "test:prod": "TEST_ENV=production playwright test",
     "test:build": "pnpm install && pnpm build",
     "test:assert": "pnpm test:prod"