Merge branch 'develop' into develop

Author: jrandolf

CHANGELOG.md

@@ -10,51 +10,7 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
-Work in this release was contributed by @tjhiggins, @GrizliK1988, @davidturissini, @nwalters512, @aloisklink, @arturovt, @benjick, @maximepvrt, @mstrokin, and @kunal-511. 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',
-     },
-   );
-   ```
+Work in this release was contributed by @tjhiggins, @GrizliK1988, @davidturissini, @nwalters512, @aloisklink, @arturovt, @benjick, @maximepvrt, @mstrokin, @kunal-511, @jahands, and @nathankleyn. Thank you for your contributions!
 
 ## 9.0.0-alpha.0
 

docs/migration/v8-to-v9.md

@@ -234,6 +234,22 @@ Sentry.init({
 - The `addNormalizedRequestDataToEvent` method has been removed. Use `httpRequestToRequestData` instead and put the resulting object directly on `event.request`.
 - A `sampleRand` field on `PropagationContext` is now required. This is relevant if you used `scope.setPropagationContext(...)`
 
+### `@sentry/solidstart`
+
+- The `sentrySolidStartVite` plugin is no longer exported. Instead, wrap the SolidStart config with `withSentry` and
+  provide Sentry options as the second parameter.
+
+  ```
+  // app.config.ts
+  import { defineConfig } from '@solidjs/start/config';
+  import { withSentry } from '@sentry/solidstart';
+
+  export default defineConfig(withSentry(
+    { /* SolidStart config */ },
+    { /* Sentry build-time config (like project and org) */ })
+  );
+  ```
+
 #### Other/Internal Changes
 
 The following changes are unlikely to affect users of the SDK. They are listed here only for completion sake, and to alert users that may be relying on internal behavior.

docs/pr-reviews.md

@@ -2,12 +2,8 @@
 
 Make sure to open PRs against `develop` branch.
 
-For feedback in PRs, we use the [LOGAF scale](https://blog.danlew.net/2020/04/15/the-logaf-scale/) to specify how
-important a comment is:
-
-- `l`: low - nitpick. You may address this comment, but you don't have to.
-- `m`: medium - normal comment. Worth addressing and fixing.
-- `h`: high - Very important. We must not merge this PR without addressing this issue.
+For feedback in PRs, we use the [LOGAF scale](https://develop.sentry.dev/engineering-practices/code-review/#logaf-scale) to specify how
+important a comment is.
 
 You only need one approval from a maintainer to be able to merge. For some PRs, asking specific or multiple people for
 review might be adequate. You can either assign SDK team members directly (e.g. if you have some people in mind who are

packages/bun/src/integrations/bunserver.ts

@@ -47,7 +47,18 @@ export function instrumentBunServe(): void {
   Bun.serve = new Proxy(Bun.serve, {
     apply(serveTarget, serveThisArg, serveArgs: Parameters<typeof Bun.serve>) {
       instrumentBunServeOptions(serveArgs[0]);
-      return serveTarget.apply(serveThisArg, serveArgs);
+      const server: ReturnType<typeof Bun.serve> = serveTarget.apply(serveThisArg, serveArgs);
+
+      // A Bun server can be reloaded, re-wrap any fetch function passed to it
+      // We can't use a Proxy for this as Bun does `instanceof` checks internally that fail if we
+      // wrap the Server instance.
+      const originalReload: typeof server.reload = server.reload.bind(server);
+      server.reload = (serveOptions: Parameters<typeof Bun.serve>[0]) => {
+        instrumentBunServeOptions(serveOptions);
+        return originalReload(serveOptions);
+      };
+
+      return server;
     },
   });
 }

packages/bun/test/integrations/bunserver.test.ts

@@ -1,67 +1,87 @@
-import { beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import { afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import type { Span } from '@sentry/core';
 import { getDynamicSamplingContextFromSpan, setCurrentClient, spanIsSampled, spanToJSON } from '@sentry/core';
 
 import { BunClient } from '../../src/client';
 import { instrumentBunServe } from '../../src/integrations/bunserver';
 import { getDefaultBunClientOptions } from '../helpers';
 
-// Fun fact: Bun = 2 21 14 :)
-const DEFAULT_PORT = 22114;
-
 describe('Bun Serve Integration', () => {
   let client: BunClient;
+  // Fun fact: Bun = 2 21 14 :)
+  let port: number = 22114;
 
   beforeAll(() => {
     instrumentBunServe();
   });
 
   beforeEach(() => {
-    const options = getDefaultBunClientOptions({ tracesSampleRate: 1, debug: true });
+    const options = getDefaultBunClientOptions({ tracesSampleRate: 1 });
     client = new BunClient(options);
     setCurrentClient(client);
     client.init();
   });
 
+  afterEach(() => {
+    // Don't reuse the port; Bun server stops lazily so tests may accidentally hit a server still closing from a
+    // previous test
+    port += 1;
+  });
+
   test('generates a transaction around a request', async () => {
+    let generatedSpan: Span | undefined;
+
     client.on('spanEnd', span => {
-      expect(spanToJSON(span).status).toBe('ok');
-      expect(spanToJSON(span).data?.['http.response.status_code']).toEqual(200);
-      expect(spanToJSON(span).op).toEqual('http.server');
-      expect(spanToJSON(span).description).toEqual('GET /');
+      generatedSpan = span;
     });
 
     const server = Bun.serve({
       async fetch(_req) {
         return new Response('Bun!');
       },
-      port: DEFAULT_PORT,
+      port,
     });
+    await fetch(`http://localhost:${port}/`);
+    server.stop();
 
-    await fetch('http://localhost:22114/');
+    if (!generatedSpan) {
+      throw 'No span was generated in the test';
+    }
 
-    server.stop();
+    expect(spanToJSON(generatedSpan).status).toBe('ok');
+    expect(spanToJSON(generatedSpan).data?.['http.response.status_code']).toEqual(200);
+    expect(spanToJSON(generatedSpan).op).toEqual('http.server');
+    expect(spanToJSON(generatedSpan).description).toEqual('GET /');
   });
 
   test('generates a post transaction', async () => {
+    let generatedSpan: Span | undefined;
+
     client.on('spanEnd', span => {
-      expect(spanToJSON(span).status).toBe('ok');
-      expect(spanToJSON(span).data?.['http.response.status_code']).toEqual(200);
-      expect(spanToJSON(span).op).toEqual('http.server');
-      expect(spanToJSON(span).description).toEqual('POST /');
+      generatedSpan = span;
     });
 
     const server = Bun.serve({
       async fetch(_req) {
         return new Response('Bun!');
       },
-      port: DEFAULT_PORT,
+      port,
     });
 
-    await fetch('http://localhost:22114/', {
+    await fetch(`http://localhost:${port}/`, {
       method: 'POST',
     });
 
     server.stop();
+
+    if (!generatedSpan) {
+      throw 'No span was generated in the test';
+    }
+
+    expect(spanToJSON(generatedSpan).status).toBe('ok');
+    expect(spanToJSON(generatedSpan).data?.['http.response.status_code']).toEqual(200);
+    expect(spanToJSON(generatedSpan).op).toEqual('http.server');
+    expect(spanToJSON(generatedSpan).description).toEqual('POST /');
   });
 
   test('continues a trace', async () => {
@@ -70,55 +90,93 @@ describe('Bun Serve Integration', () => {
     const PARENT_SAMPLED = '1';
 
     const SENTRY_TRACE_HEADER = `${TRACE_ID}-${PARENT_SPAN_ID}-${PARENT_SAMPLED}`;
-    const SENTRY_BAGGAGE_HEADER = 'sentry-version=1.0,sentry-environment=production';
+    const SENTRY_BAGGAGE_HEADER = 'sentry-version=1.0,sentry-sample_rand=0.42,sentry-environment=production';
 
-    client.on('spanEnd', span => {
-      expect(span.spanContext().traceId).toBe(TRACE_ID);
-      expect(spanToJSON(span).parent_span_id).toBe(PARENT_SPAN_ID);
-      expect(spanIsSampled(span)).toBe(true);
-      expect(span.isRecording()).toBe(false);
+    let generatedSpan: Span | undefined;
 
-      expect(getDynamicSamplingContextFromSpan(span)).toStrictEqual({
-        version: '1.0',
-        environment: 'production',
-      });
+    client.on('spanEnd', span => {
+      generatedSpan = span;
     });
 
     const server = Bun.serve({
       async fetch(_req) {
         return new Response('Bun!');
       },
-      port: DEFAULT_PORT,
+      port,
     });
 
-    await fetch('http://localhost:22114/', {
+    await fetch(`http://localhost:${port}/`, {
       headers: { 'sentry-trace': SENTRY_TRACE_HEADER, baggage: SENTRY_BAGGAGE_HEADER },
     });
 
     server.stop();
+
+    if (!generatedSpan) {
+      throw 'No span was generated in the test';
+    }
+
+    expect(generatedSpan.spanContext().traceId).toBe(TRACE_ID);
+    expect(spanToJSON(generatedSpan).parent_span_id).toBe(PARENT_SPAN_ID);
+    expect(spanIsSampled(generatedSpan)).toBe(true);
+    expect(generatedSpan.isRecording()).toBe(false);
+
+    expect(getDynamicSamplingContextFromSpan(generatedSpan)).toStrictEqual({
+      version: '1.0',
+      sample_rand: '0.42',
+      environment: 'production',
+    });
   });
 
   test('does not create transactions for OPTIONS or HEAD requests', async () => {
-    client.on('spanEnd', () => {
-      // This will never run, but we want to make sure it doesn't run.
-      expect(false).toEqual(true);
+    let generatedSpan: Span | undefined;
+
+    client.on('spanEnd', span => {
+      generatedSpan = span;
     });
 
     const server = Bun.serve({
       async fetch(_req) {
         return new Response('Bun!');
       },
-      port: DEFAULT_PORT,
+      port,
     });
 
-    await fetch('http://localhost:22114/', {
+    await fetch(`http://localhost:${port}/`, {
       method: 'OPTIONS',
     });
 
-    await fetch('http://localhost:22114/', {
+    await fetch(`http://localhost:${port}/`, {
       method: 'HEAD',
     });
 
     server.stop();
+
+    expect(generatedSpan).toBeUndefined();
+  });
+
+  test('intruments the server again if it is reloaded', async () => {
+    let serverWasInstrumented = false;
+    client.on('spanEnd', () => {
+      serverWasInstrumented = true;
+    });
+
+    const server = Bun.serve({
+      async fetch(_req) {
+        return new Response('Bun!');
+      },
+      port,
+    });
+
+    server.reload({
+      async fetch(_req) {
+        return new Response('Reloaded Bun!');
+      },
+    });
+
+    await fetch(`http://localhost:${port}/`);
+
+    server.stop();
+
+    expect(serverWasInstrumented).toBeTrue();
   });
 });

packages/bun/test/sdk.test.ts

@@ -1,14 +1,20 @@
-import { expect, test } from 'bun:test';
+import { describe, expect, test } from 'bun:test';
 
 import { init } from '../src/index';
 
-test("calling init shouldn't fail", () => {
-  init({
+describe('Bun SDK', () => {
+  const initOptions = {
     dsn: 'https://[email protected]/0000000',
+    tracesSampleRate: 1,
+  };
+
+  test("calling init shouldn't fail", () => {
+    expect(() => {
+      init(initOptions);
+    }).not.toThrow();
   });
-  expect(true).toBe(true);
-});
 
-test('should return client from init', () => {
-  expect(init({})).not.toBeUndefined();
+  test('should return client from init', () => {
+    expect(init(initOptions)).not.toBeUndefined();
+  });
 });

packages/core/package.json

@@ -61,5 +61,8 @@
   "volta": {
     "extends": "../../package.json"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "devDependencies": {
+    "zod": "^3.24.1"
+  }
 }