Cached layout, dynamic page
++ {id}:{Date.now()} +
+ {children} +` plain text to others, so the code is read from either format.
- const errorCode = /cf-error-code">(\d+)<|^error code: (\d+)/.exec(body)?.slice(1).find(Boolean);
-
- if (response.status === status && (status !== 500 || errorCode === '1101')) {
- return body;
- }
-
- lastAnswer = `${response.status}, cf-ray ${response.headers.get('cf-ray')}, error code ${errorCode ?? 'none'}, body: ${body.slice(0, 200)}`;
- } catch (error) {
- lastAnswer = String(error);
- }
-
- console.log(`The Worker did not answer ${url}: ${lastAnswer}`);
- await new Promise(resolve => setTimeout(resolve, 2_000));
- }
-
- throw new Error(`The Worker did not answer ${url} with status ${status} within 60s. Last answer: ${lastAnswer}`);
-}
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-setup.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-setup.ts
index b33f187e1d94..552ccce37a94 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-setup.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-setup.ts
@@ -1,61 +1,3 @@
-import { randomBytes } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { deleteWorker, deployWorker, keepsWorker, waitForWorker } from './deployed-worker';
+import { createWorkerGlobalSetup } from '@sentry-internal/test-utils/cloudflare';
-const WORKER_PREFIX = 'e2e-send-to-sentry';
-
-/**
- * In CI the name follows the ref, so `develop`, `master` and every PR get a stable Worker that the
- * next run of the same ref overwrites. Pull request refs look like `123/merge` and merge queue refs
- * like `gh-readonly-queue/`; both map to the PR's Worker.
- */
-export function getWorkerName(): string {
- if (!process.env.GITHUB_ACTIONS) {
- return `${WORKER_PREFIX}-local-${randomBytes(3).toString('hex')}`;
- }
-
- const { GITHUB_EVENT_NAME, GITHUB_REF_NAME = '' } = process.env;
- const prNumber =
- GITHUB_EVENT_NAME === 'pull_request' ? GITHUB_REF_NAME.split('/')[0] : /\/pr-(\d+)-/.exec(GITHUB_REF_NAME)?.[1];
- const ref = prNumber ? `pr-${prNumber}` : GITHUB_REF_NAME;
- // Worker names allow lowercase alphanumerics and dashes only, up to 63 characters.
- const slug = ref.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-
- return `${WORKER_PREFIX}-${slug}`.slice(0, 63).replace(/-+$/, '');
-}
-
-export default async function globalSetup(): Promise {
- if (!existsSync(new URL('.wrangler/deploy/config.json', import.meta.url))) {
- throw new Error('Run `pnpm build` first: wrangler would deploy the uninstrumented source.');
- }
- const { CLOUDFLARE_ACCOUNT_ID, E2E_TEST_DSN } = process.env;
- if (!E2E_TEST_DSN) {
- throw new Error('E2E_TEST_DSN must be set to deploy the test worker.');
- }
-
- // Wrangler authenticates with `CLOUDFLARE_API_TOKEN` (CI) or a `wrangler login` session (local),
- // but it cannot pick an account on its own outside of a terminal.
- if (!CLOUDFLARE_ACCOUNT_ID) {
- throw new Error('CLOUDFLARE_ACCOUNT_ID must be set to deploy the test worker.');
- }
-
- const workerName = getWorkerName();
- const workerUrl = deployWorker(workerName, E2E_TEST_DSN);
- process.env.E2E_TEST_WORKER_NAME = workerName;
-
- try {
- await waitForWorker(workerUrl);
- } catch (error) {
- if (!keepsWorker()) {
- try {
- deleteWorker(workerName);
- } catch (deleteError) {
- // The unreachable worker is the failure to report, not the cleanup.
- console.error(`Failed to delete worker ${workerName}:`, deleteError);
- }
- }
- throw error;
- }
-
- process.env.E2E_TEST_WORKER_URL = workerUrl;
-}
+export default createWorkerGlobalSetup({ workerPrefix: 'e2e-send-to-sentry' });
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-teardown.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-teardown.ts
index 9f012cd51101..c7bcfe696e66 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-teardown.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/global-teardown.ts
@@ -1,24 +1 @@
-import { deleteWorker, keepsWorker } from './deployed-worker';
-
-export default function globalTeardown(): void {
- const workerName = process.env.E2E_TEST_WORKER_NAME;
-
- if (!workerName) {
- return;
- }
-
- if (keepsWorker()) {
- console.log(`Keeping worker ${workerName} at ${process.env.E2E_TEST_WORKER_URL}`);
- return;
- }
-
- try {
- deleteWorker(workerName);
- } catch (error) {
- // A leaked worker is not an SDK failure, so it must not fail a run whose tests passed.
- console.error(
- `Failed to delete worker ${workerName}, delete it with \`wrangler delete --name ${workerName}\`:`,
- error,
- );
- }
-}
+export { workerGlobalTeardown as default } from '@sentry-internal/test-utils/cloudflare';
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/playwright.config.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/playwright.config.ts
index 91e214f15493..dde66a7e3685 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/playwright.config.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/playwright.config.ts
@@ -1,16 +1,16 @@
-import { defineConfig } from '@playwright/test';
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
-export default defineConfig({
- testDir: './tests',
+const config = getPlaywrightConfig(undefined, {
+ // The tests read what arrived in Sentry through the sentry CLI, so there is no event proxy to start.
+ webServer: undefined,
// The worker is deployed once for the whole run and deleted again afterwards.
globalSetup: './global-setup.ts',
globalTeardown: './global-teardown.ts',
/* Spans take ~2min to become queryable via the trace endpoint. */
timeout: 210_000,
- fullyParallel: true,
- forbidOnly: !!process.env.CI,
- retries: 0,
// Every test spends most of its time polling Sentry, so run them all at once.
+ fullyParallel: true,
workers: '100%',
- reporter: process.env.CI ? [['list'], ['junit', { outputFile: 'results.junit.xml' }]] : 'list',
});
+
+export default config;
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/env.d.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/env.d.ts
index aaf72be7640b..15557b010a50 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/env.d.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/env.d.ts
@@ -1,4 +1,5 @@
interface Env {
E2E_TEST_DSN: string;
SLEEP_WORKFLOW: Workflow;
+ AI: Ai;
}
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/index.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/index.ts
index 93f1c24f124e..324c9161cf69 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/index.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/src/index.ts
@@ -27,6 +27,10 @@ export default {
}
case '/test-unhandled-error':
throw new Error('E2E test unhandled error');
+ case '/test-workers-ai': {
+ await env.AI.run('@cf/meta/llama-3.2-1b-instruct', { prompt: 'Say hi', max_tokens: 5 });
+ return Response.json({ traceId: spanContext?.traceId });
+ }
case '/test-span':
return Response.json({ spanId: spanContext?.spanId, traceId: spanContext?.traceId });
case '/test-workflow-sleep': {
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts
index 8578ecb7bee7..2397db37089f 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts
@@ -2,13 +2,14 @@ import { randomBytes } from 'node:crypto';
import { expect, test } from '@playwright/test';
import {
EVENT_POLLING_OPTIONS,
+ fetchSpanAttributes,
fetchTrace,
findErrorInTrace,
findSpanInTrace,
flattenTrace,
traceTarget,
} from '@sentry-internal/test-utils/cli';
-import { fetchFromWorker } from '../deployed-worker';
+import { fetchFromWorker } from '@sentry-internal/test-utils/cloudflare';
// Set by global-setup.ts once the worker for this run is deployed.
const workerUrl = process.env.E2E_TEST_WORKER_URL;
@@ -73,3 +74,22 @@ test('Sends the spans of Workflow steps before the Workflow goes to sleep', asyn
);
expect(['running', 'waiting']).toContain(status);
});
+
+test('Sends a Workers AI gen_ai span to Sentry', async () => {
+ const { traceId }: { traceId: string } = JSON.parse(await fetchFromWorker(`${workerUrl}/test-workers-ai`, 200));
+
+ console.log(`Polling for gen_ai.chat span: sentry trace view ${traceTarget(traceId)}`);
+
+ let spanId: string | undefined;
+ await expect
+ .poll(() => (spanId = findSpanInTrace(traceId, 'gen_ai.chat')?.event_id), EVENT_POLLING_OPTIONS)
+ .toBeDefined();
+
+ // Sentry stores `gen_ai.response.text` as `gen_ai.output.messages`.
+ await expect
+ .poll(() => fetchSpanAttributes(traceId, spanId!), EVENT_POLLING_OPTIONS)
+ .toMatchObject({
+ 'gen_ai.input.messages': expect.stringContaining('Say hi'),
+ 'gen_ai.output.messages': expect.stringContaining('"role":"assistant"'),
+ });
+});
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tsconfig.node.json b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tsconfig.node.json
index 657ecc4ef24a..c49bedb6b3e3 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tsconfig.node.json
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tsconfig.node.json
@@ -3,5 +3,5 @@
"compilerOptions": {
"types": ["node"]
},
- "include": ["tests/**/*", "deployed-worker.ts", "global-setup.ts", "global-teardown.ts", "playwright.config.ts"]
+ "include": ["tests/**/*", "global-setup.ts", "global-teardown.ts", "playwright.config.ts"]
}
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/wrangler.jsonc b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/wrangler.jsonc
index d6b15b1dbf5e..f1c0857ea5dd 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/wrangler.jsonc
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/wrangler.jsonc
@@ -6,6 +6,7 @@
"compatibility_date": "2026-05-20",
"compatibility_flags": ["nodejs_compat"],
"workers_dev": true,
+ "ai": { "binding": "AI" },
// Workers Logs keep the invocations of the last 7 days, so a failed CI run can still be inspected.
"observability": { "enabled": true },
// Workflow names are unique per account, so deployWorker() renames it to the worker name.
diff --git a/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/package.json b/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/package.json
index 617e904f0bf6..660ab6ae4628 100644
--- a/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/package.json
+++ b/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/package.json
@@ -14,7 +14,7 @@
},
"devDependencies": {
"rollup": "^4.35.0",
- "vitest": "^3.2.7",
+ "vitest": "^4.1.11",
"@sentry/rollup-plugin": "^5.3.0"
},
"volta": {
diff --git a/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/tests/server.test.ts b/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/tests/server.test.ts
index 3ba3afae4fc8..0d9c81a7753c 100644
--- a/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/tests/server.test.ts
+++ b/dev-packages/e2e-tests/test-applications/debug-id-sourcemaps/tests/server.test.ts
@@ -28,56 +28,52 @@ function splitFrameContext(frame: SerializedFrame): Record {
};
}
-test(
- 'Find symbolicated event on sentry',
- async ({ expect }) => {
- const eventId = childProcess.execSync(`node ${path.join(__dirname, '..', 'dist', 'app.js')}`, {
- encoding: 'utf-8',
- });
-
- console.log(`Polling for error eventId: ${eventId}`);
+test('Find symbolicated event on sentry', { timeout: EVENT_POLLING_TIMEOUT }, async ({ expect }) => {
+ const eventId = childProcess.execSync(`node ${path.join(__dirname, '..', 'dist', 'app.js')}`, {
+ encoding: 'utf-8',
+ });
- let timedOut = false;
- setTimeout(() => {
- timedOut = true;
- }, EVENT_POLLING_TIMEOUT);
+ console.log(`Polling for error eventId: ${eventId}`);
- while (!timedOut) {
- await new Promise(resolve => setTimeout(resolve, 2000)); // poll every two seconds
- const response = await fetch(`https://sentry.io/api/0/organizations/${sentryTestOrgSlug}/eventids/${eventId}/`, {
- headers: { Authorization: `Bearer ${authToken}` },
- });
+ let timedOut = false;
+ setTimeout(() => {
+ timedOut = true;
+ }, EVENT_POLLING_TIMEOUT);
- // This is org scoped, so the auth token needs `org:read` on top of the project scopes.
- // That never resolves by waiting, so fail loudly rather than timing out.
- if (response.status === 401 || response.status === 403) {
- throw new Error(
- `Event lookup was rejected with ${response.status}: ${await response.text()}. ` +
- 'E2E_TEST_AUTH_TOKEN needs the `org:read` scope.',
- );
- }
+ while (!timedOut) {
+ await new Promise(resolve => setTimeout(resolve, 2000)); // poll every two seconds
+ const response = await fetch(`https://sentry.io/api/0/organizations/${sentryTestOrgSlug}/eventids/${eventId}/`, {
+ headers: { Authorization: `Bearer ${authToken}` },
+ });
- // A 404 means the event has not landed yet and a 429 is the shared test org being rate limited.
- // Both clear up by polling again.
- if (!response.ok) {
- expect([404, 429]).toContain(response.status);
- continue;
- }
+ // This is org scoped, so the auth token needs `org:read` on top of the project scopes.
+ // That never resolves by waiting, so fail loudly rather than timing out.
+ if (response.status === 401 || response.status === 403) {
+ throw new Error(
+ `Event lookup was rejected with ${response.status}: ${await response.text()}. ` +
+ 'E2E_TEST_AUTH_TOKEN needs the `org:read` scope.',
+ );
+ }
- const { event } = await response.json();
- const exception = event.entries.find((entry: { type: string }) => entry.type === 'exception');
- const frames: SerializedFrame[] = exception.data.values[0].stacktrace.frames;
- const topFrame = frames[frames.length - 1];
+ // A 404 means the event has not landed yet and a 429 is the shared test org being rate limited.
+ // Both clear up by polling again.
+ if (!response.ok) {
+ expect([404, 429]).toContain(response.status);
+ continue;
+ }
- if (topFrame === undefined) {
- throw new Error('Symbolicated event has no stack frames.');
- }
+ const { event } = await response.json();
+ const exception = event.entries.find((entry: { type: string }) => entry.type === 'exception');
+ const frames: SerializedFrame[] = exception.data.values[0].stacktrace.frames;
+ const topFrame = frames[frames.length - 1];
- expect(splitFrameContext(topFrame)).toMatchSnapshot();
- return;
+ if (topFrame === undefined) {
+ throw new Error('Symbolicated event has no stack frames.');
}
- throw new Error('Test timed out');
- },
- { timeout: EVENT_POLLING_TIMEOUT },
-);
+ expect(splitFrameContext(topFrame)).toMatchSnapshot();
+ return;
+ }
+
+ throw new Error('Test timed out');
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/.gitignore b/dev-packages/e2e-tests/test-applications/hono-4-legacy/.gitignore
new file mode 100644
index 000000000000..534f51704346
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/.gitignore
@@ -0,0 +1,36 @@
+# prod
+dist/
+
+# dev
+.yarn/
+!.yarn/releases
+.vscode/*
+!.vscode/launch.json
+!.vscode/*.code-snippets
+.idea/workspace.xml
+.idea/usage.statistics.xml
+.idea/shelf
+
+# deps
+node_modules/
+.wrangler
+
+# env
+.env
+.env.production
+.dev.vars
+
+# logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+# test
+test-results
+
+# misc
+.DS_Store
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/deno.json b/dev-packages/e2e-tests/test-applications/hono-4-legacy/deno.json
new file mode 100644
index 000000000000..d7748bc95ecb
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/deno.json
@@ -0,0 +1,11 @@
+{
+ "imports": {
+ "@sentry/hono": "npm:@sentry/hono",
+ "@sentry/hono/deno": "npm:@sentry/hono/deno",
+ "@sentry/deno": "npm:@sentry/deno",
+ "@sentry/core": "npm:@sentry/core",
+ "@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
+ "hono": "npm:hono@^4.13.1"
+ },
+ "nodeModulesDir": "manual"
+}
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/package.json b/dev-packages/e2e-tests/test-applications/hono-4-legacy/package.json
new file mode 100644
index 000000000000..ab3b68ce1f5d
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/package.json
@@ -0,0 +1,52 @@
+{
+ "name": "hono-4-legacy",
+ "type": "module",
+ "version": "0.0.0",
+ "private": true,
+ "scripts": {
+ "dev:cf": "wrangler dev --var \"E2E_TEST_DSN:$E2E_TEST_DSN\" --log-level=$(test $CI && echo 'none' || echo 'log')",
+ "dev:node": "node --import tsx/esm --import ./src/instrument.node.ts src/entry.node.ts",
+ "dev:bun": "bun src/entry.bun.ts",
+ "dev:deno": "deno run --allow-net --allow-env --allow-read src/entry.deno.ts",
+ "build": "wrangler deploy --dry-run",
+ "test:build": "pnpm install && pnpm build",
+ "test:assert": "TEST_ENV=production playwright test"
+ },
+ "dependencies": {
+ "@sentry/bun": "latest || *",
+ "@sentry/cloudflare": "latest || *",
+ "@sentry/deno": "latest || *",
+ "@sentry/hono": "latest || *",
+ "@sentry/node": "latest || *",
+ "@hono/node-server": "^2.0.5",
+ "hono": "^4.13.1"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.63.0",
+ "@cloudflare/workers-types": "^4.20240725.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils",
+ "tsx": "4.21.0",
+ "typescript": "^5.5.2",
+ "wrangler": "^4.61.0"
+ },
+ "volta": {
+ "node": "24.15.0",
+ "extends": "../../package.json"
+ },
+ "sentryTest": {
+ "variants": [
+ {
+ "assert-command": "RUNTIME=node pnpm test:assert",
+ "label": "hono-4-legacy (node)"
+ },
+ {
+ "assert-command": "RUNTIME=bun pnpm test:assert",
+ "label": "hono-4-legacy (bun)"
+ },
+ {
+ "assert-command": "RUNTIME=deno pnpm test:assert",
+ "label": "hono-4-legacy (deno)"
+ }
+ ]
+ }
+}
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/playwright.config.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/playwright.config.ts
new file mode 100644
index 000000000000..5087b887e1f2
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/playwright.config.ts
@@ -0,0 +1,30 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+import { RUNTIME, type Runtime } from './tests/constants';
+
+const testEnv = process.env.TEST_ENV;
+
+if (!testEnv) {
+ throw new Error('No test env defined');
+}
+
+const APP_PORT = 38787;
+
+const startCommands: Record = {
+ cloudflare: `pnpm dev:cf --port ${APP_PORT}`,
+ node: `pnpm dev:node`,
+ bun: `pnpm dev:bun`,
+ deno: `pnpm dev:deno`,
+};
+
+const config = getPlaywrightConfig(
+ {
+ startCommand: startCommands[RUNTIME],
+ port: APP_PORT,
+ },
+ {
+ workers: '100%',
+ retries: 0,
+ },
+);
+
+export default config;
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.bun.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.bun.ts
new file mode 100644
index 000000000000..6466b79717f5
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.bun.ts
@@ -0,0 +1,25 @@
+import { Hono } from 'hono';
+import { sentry } from '@sentry/hono/bun';
+import { addRoutes } from './routes';
+
+const app = new Hono();
+
+app.use(
+ sentry(app, {
+ dsn: process.env.E2E_TEST_DSN,
+ environment: 'qa',
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
+ }),
+);
+
+addRoutes(app);
+
+const port = Number(process.env.PORT || 38787);
+
+export default {
+ port,
+ fetch: app.fetch,
+};
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.cloudflare.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.cloudflare.ts
new file mode 100644
index 000000000000..e348dde56226
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.cloudflare.ts
@@ -0,0 +1,18 @@
+import { Hono } from 'hono';
+import { sentry } from '@sentry/hono/cloudflare';
+import { addRoutes } from './routes';
+
+const app = new Hono<{ Bindings: { E2E_TEST_DSN: string } }>();
+
+app.use(
+ sentry(app, env => ({
+ dsn: env.E2E_TEST_DSN,
+ environment: 'qa',
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+ })),
+);
+
+addRoutes(app);
+
+export default app;
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.deno.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.deno.ts
new file mode 100644
index 000000000000..15bd12a74111
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.deno.ts
@@ -0,0 +1,21 @@
+import { Hono } from 'hono';
+import { sentry } from '@sentry/hono/deno';
+import { addRoutes } from './routes';
+
+const app = new Hono();
+
+app.use(
+ sentry(app, {
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ environment: 'qa',
+ dataCollection: {},
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+ }),
+);
+
+addRoutes(app);
+
+const port = Number(Deno.env.get('PORT') || 38787);
+
+Deno.serve({ port }, app.fetch);
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.node.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.node.ts
new file mode 100644
index 000000000000..898a92e08be4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/entry.node.ts
@@ -0,0 +1,16 @@
+import { Hono } from 'hono';
+import { sentry } from '@sentry/hono/node';
+import { serve } from '@hono/node-server';
+import { addRoutes } from './routes';
+
+const app = new Hono();
+
+app.use(sentry(app));
+
+addRoutes(app);
+
+const port = Number(process.env.PORT || 38787);
+
+serve({ fetch: app.fetch, port }, () => {
+ console.log(`Hono (Node) listening on port ${port}`);
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/instrument.node.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/instrument.node.ts
new file mode 100644
index 000000000000..3d3c93040c25
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/instrument.node.ts
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/hono/node';
+
+Sentry.init({
+ dsn: process.env.E2E_TEST_DSN,
+ environment: 'qa',
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/middleware.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/middleware.ts
new file mode 100644
index 000000000000..9304a980dff3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/middleware.ts
@@ -0,0 +1,34 @@
+import type { MiddlewareHandler } from 'hono';
+
+// Defined as anonymous function expressions so the function name is inferred from the `const`
+// binding. A named expression (`const middlewareA = async function middlewareA() {}`) collides with
+// the binding when bundled, and Bun renames the inner function (→ `middlewareA2`), which would then
+// surface as the middleware span name. The inferred name stays stable across all runtimes.
+export const middlewareA: MiddlewareHandler = async function (c, next) {
+ // Add some delay
+ await new Promise(resolve => setTimeout(resolve, 50));
+ await next();
+};
+
+export const middlewareB: MiddlewareHandler = async function (_c, next) {
+ // Add some delay
+ await new Promise(resolve => setTimeout(resolve, 60));
+ await next();
+};
+
+let failingMiddlewareCount = 0;
+export const failingMiddleware: MiddlewareHandler = async function (_c, _next) {
+ // Each throw gets a unique suffix so the Dedupe integration doesn't collapse the identical errors
+ // that several tests (and their retries) trigger through this shared middleware — otherwise only the
+ // first would be reported and the other tests' `waitForError` would time out. Tests match on the
+ // stable `Middleware error` prefix.
+ throw new Error(`Middleware error #${(failingMiddlewareCount += 1)}`);
+};
+
+// Intentionally a NAMED function expression (unlike the anonymous ones above) so the named-function
+// path stays covered: the span name is taken from the function's own name. Under bundled Bun the inner
+// name collides with the `const` binding and is suffixed (→ `namedMiddleware2`), so the test matches on
+// the `namedMiddleware` prefix rather than an exact name.
+export const namedMiddleware: MiddlewareHandler = async function namedMiddleware(_c, next) {
+ await next();
+};
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-errors.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-errors.ts
new file mode 100644
index 000000000000..b8f2fd96fe93
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-errors.ts
@@ -0,0 +1,45 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+const errorRoutes = new Hono();
+
+// Middleware that throws a 5xx HTTPException (should be captured)
+errorRoutes.use('/middleware-http-exception/*', async (_c, _next) => {
+ throw new HTTPException(503, { message: 'Service Unavailable from middleware' });
+});
+
+errorRoutes.get('/middleware-http-exception', c => c.text('should not reach'));
+
+// Middleware that throws a 4xx HTTPException (should NOT be captured)
+errorRoutes.use('/middleware-http-exception-4xx/*', async (_c, _next) => {
+ throw new HTTPException(401, { message: 'Unauthorized from middleware' });
+});
+
+errorRoutes.get('/middleware-http-exception-4xx', c => c.text('should not reach'));
+
+// Sub-app with a custom onError handler that swallows errors
+const subAppWithOnError = new Hono();
+
+subAppWithOnError.onError((err, c) => {
+ return c.text(`Handled by onError: ${err.message}`, 500);
+});
+
+subAppWithOnError.get('/fail', () => {
+ throw new Error('Error caught by custom onError');
+});
+
+errorRoutes.route('/custom-on-error', subAppWithOnError);
+
+// Nested sub-apps: parent mounts child, child route throws
+const childApp = new Hono();
+
+childApp.get('/error', () => {
+ throw new Error('Nested child app error');
+});
+
+const parentApp = new Hono();
+parentApp.route('/child', childApp);
+
+errorRoutes.route('/nested', parentApp);
+
+export { errorRoutes };
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-middleware.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-middleware.ts
new file mode 100644
index 000000000000..6f21c1cac33b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-middleware.ts
@@ -0,0 +1,85 @@
+import { Hono } from 'hono';
+import { failingMiddleware, middlewareA, middlewareB, namedMiddleware } from '../middleware';
+
+const middlewareRoutes = new Hono();
+
+middlewareRoutes.get('/named', c => c.json({ middleware: 'named' }));
+middlewareRoutes.get('/anonymous', c => c.json({ middleware: 'anonymous' }));
+middlewareRoutes.get('/multi', c => c.json({ middleware: 'multi' }));
+middlewareRoutes.get('/error', c => c.text('should not reach'));
+middlewareRoutes.get('/param/:id', c => c.json({ paramId: c.req.param('id') }));
+middlewareRoutes.get('/declared', c => c.json({ middleware: 'declared' }));
+
+// Self-contained sub-app registering its own middleware via .use()
+const subAppWithMiddleware = new Hono();
+
+subAppWithMiddleware.use('/named/*', middlewareA);
+subAppWithMiddleware.use('/declared/*', namedMiddleware);
+subAppWithMiddleware.use('/anonymous/*', async (c, next) => {
+ c.header('X-Custom', 'anonymous');
+ await next();
+});
+subAppWithMiddleware.use('/multi/*', middlewareA, middlewareB);
+subAppWithMiddleware.use('/error/*', failingMiddleware);
+subAppWithMiddleware.use('/param/*', middlewareA);
+
+// .all() handler (1 parameter) — should NOT be wrapped as middleware by patchRoute.
+subAppWithMiddleware.all('/all-handler', async function allCatchAll(c) {
+ return c.json({ handler: 'all' });
+});
+
+subAppWithMiddleware.route('/', middlewareRoutes);
+
+// Sub-app with inline middleware for different registration styles.
+// patchRoute wraps non-last handlers per method+path group as middleware.
+const subAppWithInlineMiddleware = new Hono();
+
+const METHODS = ['get', 'post', 'put', 'delete', 'patch'] as const;
+
+// Direct method registration for each HTTP method
+METHODS.forEach(method => {
+ subAppWithInlineMiddleware[method](
+ '/direct',
+ async function inlineMiddleware(_c, next) {
+ await next();
+ },
+ c => c.text(`${method} direct response`),
+ );
+
+ subAppWithInlineMiddleware[method]('/direct/separately', async function inlineSeparateMiddleware(_c, next) {
+ await next();
+ });
+ subAppWithInlineMiddleware[method]('/direct/separately', c => c.text(`${method} direct separate response`));
+});
+
+// .all(): .all('/path', mw, handler)
+subAppWithInlineMiddleware.all(
+ '/all',
+ async function inlineMiddlewareAll(_c, next) {
+ await next();
+ },
+ c => c.text('all response'),
+);
+subAppWithInlineMiddleware.all('/all/separately', async function inlineSeparateMiddlewareAll(_c, next) {
+ await next();
+});
+subAppWithInlineMiddleware.all('/all/separately', c => c.text('all separate response'));
+
+// .on() registration for each HTTP method
+METHODS.forEach(method => {
+ subAppWithInlineMiddleware.on(
+ method,
+ '/on',
+ async function inlineMiddlewareOn(_c, next) {
+ await next();
+ },
+ c => c.text(`${method} on response`),
+ );
+
+ subAppWithInlineMiddleware.on(method, '/on/separately', async function inlineSeparateMiddlewareOn(_c, next) {
+ await next();
+ });
+ subAppWithInlineMiddleware.on(method, '/on/separately', c => c.text(`${method} on separate response`));
+});
+
+export { middlewareRoutes, subAppWithMiddleware, subAppWithInlineMiddleware };
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-multi-fetch.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-multi-fetch.ts
new file mode 100644
index 000000000000..ed9f0a3e131b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-multi-fetch.ts
@@ -0,0 +1,118 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+const ITEMS: Record = {
+ 'self-watering-plant': { name: 'Self-Watering Plant', stock: 5, price: 2500 },
+ 'solar-powered-cyberdeck': { name: 'Solar-Powered Cyberdeck', stock: 0, price: 5000 },
+};
+
+// Inventory service — standalone sub-app used as a data source.
+// Mounted on the main app AND called internally via .request() from the storefront.
+const inventoryApp = new Hono();
+
+inventoryApp.get('/item/:productId', c => {
+ const productId = c.req.param('productId');
+ const item = ITEMS[productId];
+ if (!item) {
+ throw new HTTPException(404, { message: `Item ${productId} not found` });
+ }
+ return c.json({ productId, ...item });
+});
+
+inventoryApp.get('/item/:productId/stock', c => {
+ const productId = c.req.param('productId');
+ const item = ITEMS[productId];
+ if (!item) {
+ throw new HTTPException(404, { message: `Stock check failed: ${productId}` });
+ }
+ return c.json({ productId, inStock: item.stock > 0, quantity: item.stock });
+});
+
+// Simulates an inner-route failure (a plain 5xx Error, not an HTTPException) reached only via an
+// internal .request() — used by the storefront's `/degraded` route below. Each throw gets a unique
+// suffix so the Dedupe integration doesn't collapse repeats across test retries.
+let dbErrorCount = 0;
+inventoryApp.get('/item/:productId/db-error', () => {
+ throw new Error(`inventory db is down #${(dbErrorCount += 1)}`);
+});
+
+// Storefront service — orchestrates internal .request() calls to inventoryApp.
+const storefrontApp = new Hono();
+
+storefrontApp.use('/*', async function storefrontAuth(_c, next) {
+ await new Promise(resolve => setTimeout(resolve, 10));
+ await next();
+});
+
+// Single internal fetch: look up one product
+storefrontApp.get('/product/:productId', async c => {
+ const res = await inventoryApp.request(`/item/${c.req.param('productId')}`);
+ if (!res.ok) {
+ throw new HTTPException(404, { message: 'Product not found' });
+ }
+ const item = await res.json();
+ return c.json({ product: item, source: 'storefront' });
+});
+
+// Parallel internal fetches: compare two products via Promise.all
+storefrontApp.get('/compare/:productId1/:productId2', async c => {
+ const [res1, res2] = await Promise.all([
+ inventoryApp.request(`/item/${c.req.param('productId1')}`),
+ inventoryApp.request(`/item/${c.req.param('productId2')}`),
+ ]);
+ if (!res1.ok || !res2.ok) {
+ throw new HTTPException(404, { message: 'One or more products not found' });
+ }
+ const [item1, item2] = (await Promise.all([res1.json(), res2.json()])) as [
+ Record,
+ Record,
+ ];
+ return c.json({
+ items: [item1, item2],
+ priceDifference: Math.abs(item1.price - item2.price),
+ });
+});
+
+// Sequential chained fetches: look up item, then check its stock
+storefrontApp.get('/product/:productId/availability', async c => {
+ const itemRes = await inventoryApp.request(`/item/${c.req.param('productId')}`);
+ if (!itemRes.ok) {
+ throw new HTTPException(404, { message: 'Product not found' });
+ }
+ const item: Record = await itemRes.json();
+
+ const stockRes = await inventoryApp.request(`/item/${item.productId}/stock`);
+ const stock: Record = await stockRes.json();
+
+ return c.json({
+ product: item.name,
+ available: stock.inStock,
+ quantity: stock.quantity,
+ });
+});
+
+// Degraded response: the inner route throws, but the outer handler swallows the failed internal
+// response and returns a 200 instead of propagating. The inner error should still reach Sentry (auto
+// instrumentation); the outer request stays healthy.
+storefrontApp.get('/product/:productId/degraded', async c => {
+ const res = await inventoryApp.request(`/item/${c.req.param('productId')}/db-error`);
+ if (!res.ok) {
+ return c.json({ product: null, degraded: true }, 200);
+ }
+ return c.json({ product: await res.json() });
+});
+
+// Error propagation: internal 404 causes the handler to throw a plain Error
+storefrontApp.get('/product-or-throw/:productId', async c => {
+ const res = await inventoryApp.request(`/item/${c.req.param('productId')}`);
+ if (!res.ok) {
+ throw new Error(`Failed to fetch product: ${c.req.param('productId')}`);
+ }
+ return c.json({ product: await res.json() });
+});
+
+const multiFetchRoutes = new Hono();
+multiFetchRoutes.route('/inventory', inventoryApp);
+multiFetchRoutes.route('/storefront', storefrontApp);
+
+export { multiFetchRoutes };
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-route-patterns.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-route-patterns.ts
new file mode 100644
index 000000000000..ac6fea1320cf
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/route-groups/test-route-patterns.ts
@@ -0,0 +1,33 @@
+import { Hono } from 'hono';
+
+const routePatterns = new Hono();
+
+const METHODS = ['get', 'post', 'put', 'delete', 'patch'] as const;
+
+// Direct method registration for each HTTP method (sync handlers)
+METHODS.forEach(method => {
+ routePatterns[method]('/', c => c.text(`${method} response`));
+});
+
+// Async handler
+routePatterns.get('/async', async c => {
+ await new Promise(resolve => setTimeout(resolve, 10));
+ return c.text('async response');
+});
+
+// Dedicated route for query_string test to avoid transaction name collisions
+routePatterns.get('/query-test', c => c.text('query test response'));
+
+// Dedicated route for request data extraction tests to avoid transaction name collisions
+routePatterns.get('/request-data', c => c.text('request data response'));
+routePatterns.post('/request-data', c => c.text('request data response'));
+
+// .all() registration
+routePatterns.all('/all', c => c.text('all handler response'));
+
+// .on() registration
+METHODS.forEach(method => {
+ routePatterns.on(method, '/on', c => c.text(`${method} on response`));
+});
+
+export { routePatterns };
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/routes.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/routes.ts
new file mode 100644
index 000000000000..008a1ca6fd53
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/src/routes.ts
@@ -0,0 +1,134 @@
+import { type Hono as HonoType, Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { failingMiddleware, middlewareA, middlewareB, namedMiddleware } from './middleware';
+import { errorRoutes } from './route-groups/test-errors';
+import { middlewareRoutes, subAppWithInlineMiddleware, subAppWithMiddleware } from './route-groups/test-middleware';
+import { multiFetchRoutes } from './route-groups/test-multi-fetch';
+import { routePatterns } from './route-groups/test-route-patterns';
+
+export function addRoutes(app: HonoType<{ Bindings?: { E2E_TEST_DSN: string } }>): void {
+ app.get('/', c => {
+ return c.text('Hello Hono!');
+ });
+
+ app.get('/test-param/:paramId', c => {
+ return c.json({ paramId: c.req.param('paramId') });
+ });
+
+ app.get('/error/:cause', c => {
+ throw new Error('This is a test error for Sentry!', {
+ cause: c.req.param('cause'),
+ });
+ });
+
+ app.get('/linked-error', () => {
+ const cause = new Error('Failure 1');
+ const errorCause = new Error('Failure 2', { cause });
+ throw new Error('Failure 3', { cause: errorCause });
+ });
+
+ app.get('/http-exception/:code', c => {
+ // oxlint-disable-next-line typescript/no-explicit-any
+ const code = Number(c.req.param('code')) as any;
+ throw new HTTPException(code, { message: `HTTPException ${code}` });
+ });
+
+ // Root-app middleware: registered on the patched main app instance
+ app.use('/test-middleware/named/*', middlewareA);
+ app.use('/test-middleware/anonymous/*', async (c, next) => {
+ c.header('X-Custom', 'anonymous');
+ await next();
+ });
+ app.use('/test-middleware/multi/*', middlewareA, middlewareB);
+ app.use('/test-middleware/error/*', failingMiddleware);
+ app.use('/test-middleware/param/*', middlewareA);
+ app.use('/test-middleware/declared/*', namedMiddleware);
+ app.route('/test-middleware', middlewareRoutes);
+
+ // Sub-app middleware: registered on the sub-app, wrapped at mount time by route() patching
+ app.route('/test-subapp-middleware', subAppWithMiddleware);
+
+ // Inline middleware patterns: direct method, .all(), .on() with inline/separate middleware
+ app.route('/test-inline-middleware', subAppWithInlineMiddleware);
+
+ // Inline middleware on the main app via HTTP method registration (not .use()).
+ app.get(
+ '/test-main-inline/get',
+ async function mainInlineGet(_c, next) {
+ await next();
+ },
+ c => c.text('main inline get'),
+ );
+ app.post(
+ '/test-main-inline/post',
+ async function mainInlinePost(_c, next) {
+ await next();
+ },
+ c => c.text('main inline post'),
+ );
+ app.all(
+ '/test-main-inline/all',
+ async function mainInlineAll(_c, next) {
+ await next();
+ },
+ c => c.text('main inline all'),
+ );
+ app.query(
+ '/test-main-inline/query',
+ async function mainInlineQuery(_c, next) {
+ await next();
+ },
+ async c => {
+ const body = await c.req.json<{ value: string }>();
+ return c.json({ method: c.req.method, value: body.value });
+ },
+ );
+
+ // Combined: .use() middleware + inline middleware via .get() on the same path.
+ app.use('/test-main-inline/combined/*', middlewareA);
+ app.get(
+ '/test-main-inline/combined/resource',
+ async function combinedInlineMw(_c, next) {
+ await next();
+ },
+ c => c.text('combined response'),
+ );
+
+ // Route patterns: HTTP methods, .all(), .on(), sync/async, errors
+ app.route('/test-routes', routePatterns);
+
+ // Error-specific routes: onError handler, nested sub-apps, middleware HTTPException
+ app.route('/test-errors', errorRoutes);
+
+ // Multi-fetch routes: storefront sub-app calls inventoryApp via .request()
+ app.route('/test-multi-fetch', multiFetchRoutes);
+
+ // .basePath() with sub-app mounting via .route()
+ const apiSubApp = new Hono();
+ apiSubApp.use(async function apiAuth(_c, next) {
+ await next();
+ });
+ apiSubApp.get('/users', c => c.json({ users: [{ id: 1, name: 'Alice' }] }));
+ apiSubApp.get('/users/:userId', c => c.json({ userId: c.req.param('userId') }));
+
+ app.basePath('/test-basepath').route('/v1', apiSubApp);
+
+ app.use(async function trailingMiddleware(_c, next) {
+ // Trailing middleware to make sure the route names are resolved correctly (not `/*`).
+ await new Promise(resolve => setTimeout(resolve, 50));
+ await next();
+ });
+
+ // .use() on the cloned instance returned by .basePath() — the clone has its own
+ // .use class field, so this tests whether middleware instrumentation propagates.
+ app
+ .basePath('/test-basepath-mw')
+ .use(async function basepathMiddleware(_c, next) {
+ await new Promise(resolve => setTimeout(resolve, 50));
+ await next();
+ })
+ .get('/hello', c => c.json({ greeting: 'world' }));
+
+ // .get() registered on the root app after .basePath()/.route() chains
+ app.get('/test-late-get', c => c.json({ registered: 'after-chains' }));
+}
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/hono-4-legacy/start-event-proxy.mjs
new file mode 100644
index 000000000000..8f6b794b1827
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+ port: 3031,
+ proxyServerName: 'hono-4-legacy',
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/basepath-and-late-routes.test.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/basepath-and-late-routes.test.ts
new file mode 100644
index 000000000000..c7ad43b6b945
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/basepath-and-late-routes.test.ts
@@ -0,0 +1,91 @@
+import { expect, test } from '@playwright/test';
+import { waitForStreamedSpan, getSpanOp, collectStreamedSpansUntilSegment } from '@sentry-internal/test-utils';
+import { APP_NAME } from './constants';
+
+test.describe('basePath with sub-app routes', () => {
+ test('traces GET on a sub-app mounted via .basePath().route()', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /test-basepath/v1/users',
+ );
+
+ const response = await fetch(`${baseURL}/test-basepath/v1/users`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ users: [{ id: 1, name: 'Alice' }] });
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe('GET /test-basepath/v1/users');
+ expect(getSpanOp(segment)).toBe('http.server');
+ });
+
+ test('traces parameterized route under .basePath().route()', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === 'GET /test-basepath/v1/users/:userId',
+ );
+
+ const response = await fetch(`${baseURL}/test-basepath/v1/users/42`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ userId: '42' });
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe('GET /test-basepath/v1/users/:userId');
+ expect(getSpanOp(segment)).toBe('http.server');
+ });
+});
+
+// TODO: this test is currently skipped because we do not yet support middleware registered on new instances (e.g. here via .basePath(..).use(...)).
+test.skip('.basePath() middleware instrumentation', () => {
+ test('creates middleware span for .use() on .basePath() clone', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === 'GET /test-basepath-mw/hello',
+ );
+
+ const response = await fetch(`${baseURL}/test-basepath-mw/hello`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ greeting: 'world' });
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /test-basepath-mw/hello',
+ )!;
+ expect(segment.name).toBe('GET /test-basepath-mw/hello');
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpan = spans.find(span => getSpanOp(span) === 'middleware' && span.name === 'basepathMiddleware');
+
+ expect(middlewareSpan).toBeDefined();
+ expect(middlewareSpan?.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ });
+});
+
+test('traces .get() route registered after .basePath()/.route() chains', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /test-late-get',
+ );
+
+ const response = await fetch(`${baseURL}/test-late-get`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ registered: 'after-chains' });
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe('GET /test-late-get');
+ expect(getSpanOp(segment)).toBe('http.server');
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/constants.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/constants.ts
new file mode 100644
index 000000000000..2aee60fc6be8
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/constants.ts
@@ -0,0 +1,5 @@
+export type Runtime = 'cloudflare' | 'node' | 'bun' | 'deno';
+
+export const RUNTIME = (process.env.RUNTIME || 'node') as Runtime;
+
+export const APP_NAME = 'hono-4-legacy';
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/errors.test.ts
new file mode 100644
index 000000000000..e3c44c67d4d6
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/errors.test.ts
@@ -0,0 +1,329 @@
+import { expect, test } from '@playwright/test';
+import {
+ waitForError,
+ waitForStreamedSpan,
+ getSpanOp,
+ collectStreamedSpansUntilSegment,
+} from '@sentry-internal/test-utils';
+import { APP_NAME, RUNTIME } from './constants';
+
+test.describe('route handler errors', () => {
+ test('captures error with mechanism and trace correlation', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'This is a test error for Sentry!';
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/error/'),
+ );
+
+ const response = await fetch(`${baseURL}/error/test-cause`);
+ expect(response.status).toBe(500);
+
+ const errorEvent = await errorPromise;
+ const segmentEvent = await segmentPromise;
+
+ expect(segmentEvent.name).toBe('GET /error/:cause');
+
+ expect(errorEvent.exception?.values).toHaveLength(1);
+
+ const exception = errorEvent.exception?.values?.[0];
+ expect(exception?.value).toBe('This is a test error for Sentry!');
+ expect(exception?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.http.hono.context_error',
+ });
+
+ expect(errorEvent.transaction).toBe('GET /error/:cause');
+ expect(errorEvent.request?.method).toBe('GET');
+ expect(errorEvent.request?.url).toContain('/error/test-cause');
+ expect(errorEvent.request?.headers).toBeDefined();
+
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(segmentEvent?.trace_id);
+ });
+
+ test('captures three linked errors', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.some(exception => exception.value === 'Failure 3');
+ });
+
+ const response = await fetch(`${baseURL}/linked-error`);
+ expect(response.status).toBe(500);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.exception?.values).toHaveLength(3);
+
+ const firstCause = errorEvent.exception?.values?.[0];
+ expect(firstCause?.value).toBe('Failure 1');
+ expect(firstCause?.mechanism).toEqual({
+ exception_id: 2,
+ handled: true,
+ parent_id: 1,
+ source: 'cause',
+ type: 'chained',
+ });
+
+ const secondCause = errorEvent.exception?.values?.[1];
+ expect(secondCause?.value).toBe('Failure 2');
+ expect(secondCause?.mechanism).toEqual({
+ exception_id: 1,
+ handled: true,
+ parent_id: 0,
+ source: 'cause',
+ type: 'chained',
+ });
+
+ const capturedError = errorEvent.exception?.values?.[2];
+ expect(capturedError?.value).toBe('Failure 3');
+ expect(capturedError?.mechanism).toEqual({
+ exception_id: 0,
+ handled: false,
+ type: 'auto.http.hono.context_error',
+ });
+
+ expect(errorEvent.transaction).toBe('GET /linked-error');
+ });
+});
+
+test.describe('HTTPException errors', () => {
+ test('captures 5xx HTTPException', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'HTTPException 500';
+ });
+
+ const response = await fetch(`${baseURL}/http-exception/500`);
+ expect(response.status).toBe(500);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.exception?.values?.[0]?.value).toBe('HTTPException 500');
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.http.hono.context_error',
+ });
+ });
+
+ // On Node/Bun, httpServerSpansIntegration drops transactions for 3xx/4xx responses (ignoreStatusCodes), so we just use a request guard.
+ // On Cloudflare the transaction is available, and we additionally verify its name.
+ [301, 302].forEach(code => {
+ test(`does not capture ${code} HTTPException`, async ({ baseURL }) => {
+ let errorEventOccurred = false;
+
+ waitForError(APP_NAME, event => {
+ if (event.exception?.values?.[0]?.value === `HTTPException ${code}`) {
+ errorEventOccurred = true;
+ }
+ return false;
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ (RUNTIME === 'cloudflare'
+ ? getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/http-exception/')
+ : getSpanOp(segment) === 'http.server' && segment.name === 'GET /'),
+ );
+
+ const response = await fetch(`${baseURL}/http-exception/${code}`, { redirect: 'manual' });
+ expect(response.status).toBe(code);
+
+ if (RUNTIME !== 'cloudflare') {
+ // Simple request guard for non-Cloudflare runtimes since the other transaction is dropped for 4xx responses
+ await fetch(`${baseURL}/`);
+ }
+
+ const segment = await segmentPromise;
+
+ if (RUNTIME === 'cloudflare') {
+ expect(segment.name).toBe('GET /http-exception/:code');
+ }
+
+ expect(errorEventOccurred).toBe(false);
+ });
+ });
+
+ [401, 403, 404].forEach(code => {
+ test(`does not capture ${code} HTTPException`, async ({ baseURL }) => {
+ let errorEventOccurred = false;
+
+ waitForError(APP_NAME, event => {
+ if (event.exception?.values?.[0]?.value === `HTTPException ${code}`) {
+ errorEventOccurred = true;
+ }
+ return false;
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ (RUNTIME === 'cloudflare'
+ ? getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/http-exception/')
+ : getSpanOp(segment) === 'http.server' && segment.name === 'GET /'),
+ );
+
+ const response = await fetch(`${baseURL}/http-exception/${code}`);
+ expect(response.status).toBe(code);
+
+ if (RUNTIME !== 'cloudflare') {
+ // Simple request guard for non-Cloudflare runtimes since the other transaction is dropped for 4xx responses
+ await fetch(`${baseURL}/`);
+ }
+
+ const segment = await segmentPromise;
+
+ if (RUNTIME === 'cloudflare') {
+ expect(segment.name).toBe('GET /http-exception/:code');
+ }
+
+ expect(errorEventOccurred).toBe(false);
+ });
+ });
+});
+
+test.describe('middleware errors', () => {
+ test('captures 5xx HTTPException thrown in middleware with error span status', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'Service Unavailable from middleware';
+ });
+
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment =>
+ getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-errors/middleware-http-exception'),
+ );
+
+ const response = await fetch(`${baseURL}/test-errors/middleware-http-exception`);
+ expect(response.status).toBe(503);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.exception?.values?.[0]?.value).toBe('Service Unavailable from middleware');
+ expect(errorEvent.exception?.values?.[0]?.mechanism?.type).toBe('auto.http.hono.context_error');
+ expect(errorEvent.exception?.values?.[0]?.mechanism?.handled).toBe(false);
+ expect(errorEvent.transaction).toBe('GET /test-errors/middleware-http-exception');
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ !!segment.name?.includes('/test-errors/middleware-http-exception'),
+ )!;
+ const middlewareSpan = segmentSpans
+ .filter(span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id)
+ .find(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpan?.status).toBe('error');
+ });
+
+ test('does not capture 4xx HTTPException thrown in middleware', async ({ baseURL }) => {
+ let errorEventOccurred = false;
+
+ waitForError(APP_NAME, event => {
+ if (event.exception?.values?.[0]?.value === 'Unauthorized from middleware') {
+ errorEventOccurred = true;
+ }
+ return false;
+ });
+
+ const segmentPromise = collectStreamedSpansUntilSegment(APP_NAME, segment => {
+ if (RUNTIME === 'cloudflare') {
+ return (
+ getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-errors/middleware-http-exception-4xx')
+ );
+ }
+ return getSpanOp(segment) === 'http.server' && segment.name === 'GET /';
+ });
+
+ const response = await fetch(`${baseURL}/test-errors/middleware-http-exception-4xx`);
+ expect(response.status).toBe(401);
+
+ if (RUNTIME !== 'cloudflare') {
+ await fetch(`${baseURL}/`);
+ }
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(segment => {
+ if (!segment.is_segment) return false;
+ if (RUNTIME === 'cloudflare') {
+ return (
+ getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-errors/middleware-http-exception-4xx')
+ );
+ }
+ return getSpanOp(segment) === 'http.server' && segment.name === 'GET /';
+ })!;
+
+ if (RUNTIME === 'cloudflare') {
+ expect(segment.name).toBe('GET /test-errors/middleware-http-exception-4xx');
+
+ const middlewareSpan = segmentSpans
+ .filter(span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id)
+ .find(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpan?.status).not.toBe('error');
+ }
+
+ expect(errorEventOccurred).toBe(false);
+ });
+});
+
+test.describe('nested sub-app errors', () => {
+ test('captures error from nested child sub-app', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'Nested child app error';
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/nested/child/error'),
+ );
+
+ const response = await fetch(`${baseURL}/test-errors/nested/child/error`);
+ expect(response.status).toBe(500);
+
+ const errorEvent = await errorPromise;
+ const segment = await segmentPromise;
+
+ expect(segment.name).toBe('GET /test-errors/nested/child/error');
+
+ expect(errorEvent.exception?.values?.[0]?.value).toBe('Nested child app error');
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.http.hono.context_error',
+ });
+ expect(errorEvent.request?.method).toBe('GET');
+ expect(errorEvent.request?.url).toContain('/test-errors/nested/child/error');
+ expect(errorEvent.request?.headers).toBeDefined();
+ });
+});
+
+test.describe('custom onError handler', () => {
+ test('captures error even when onError handles the response', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'Error caught by custom onError';
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/custom-on-error/fail'),
+ );
+
+ const response = await fetch(`${baseURL}/test-errors/custom-on-error/fail`);
+ expect(response.status).toBe(500);
+
+ const body = await response.text();
+ expect(body).toContain('Handled by onError');
+
+ const errorEvent = await errorPromise;
+ const segment = await segmentPromise;
+
+ expect(segment.name).toBe('GET /test-errors/custom-on-error/fail');
+
+ expect(errorEvent.exception?.values?.[0]?.value).toBe('Error caught by custom onError');
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.http.hono.context_error',
+ });
+ });
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/middleware.test.ts
new file mode 100644
index 000000000000..d760f12e6451
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/middleware.test.ts
@@ -0,0 +1,442 @@
+import { expect, test } from '@playwright/test';
+import { waitForError, getSpanOp, collectStreamedSpansUntilSegment } from '@sentry-internal/test-utils';
+import { APP_NAME } from './constants';
+
+const SCENARIOS = [
+ {
+ name: 'root app middleware',
+ prefix: '/test-middleware',
+ },
+ {
+ name: 'sub-app middleware (route group)',
+ prefix: '/test-subapp-middleware',
+ },
+] as const;
+
+for (const { name, prefix } of SCENARIOS) {
+ test.describe(name, () => {
+ test('creates a span for named middleware', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/named`),
+ );
+
+ const response = await fetch(`${baseURL}${prefix}/named`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/named`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/named`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const middlewareSpan = spans.find(span => getSpanOp(span) === 'middleware' && span.name === 'middlewareA');
+
+ expect(middlewareSpan).toEqual(
+ expect.objectContaining({
+ name: 'middlewareA',
+ attributes: expect.objectContaining({
+ 'sentry.op': { value: 'middleware', type: 'string' },
+ 'sentry.origin': { value: 'auto.middleware.hono', type: 'string' },
+ }),
+ }),
+ );
+ expect(middlewareSpan?.status).not.toBe('error');
+
+ const durationMs = (middlewareSpan!.end_timestamp - middlewareSpan!.start_timestamp) * 1000;
+ expect(durationMs).toBeGreaterThanOrEqual(49);
+ });
+
+ test('creates a span for anonymous middleware', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/anonymous`),
+ );
+
+ const response = await fetch(`${baseURL}${prefix}/anonymous`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/anonymous`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/anonymous`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const anonymousSpan = spans.find(span => getSpanOp(span) === 'middleware' && span.name === '');
+ expect(anonymousSpan).toBeDefined();
+ expect(anonymousSpan?.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(anonymousSpan?.status).not.toBe('error');
+ });
+
+ test('creates a span for a named-function middleware (name from the function binding)', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/declared`),
+ );
+
+ const response = await fetch(`${baseURL}${prefix}/declared`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/declared`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/declared`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ // Named function expression: the span name comes from the function's own name. A bundler (Bun)
+ // may append a numeric suffix when the inner name collides with the `const` binding, so match on
+ // the `namedMiddleware` prefix rather than an exact name.
+ const middlewareSpan = spans.find(
+ span => getSpanOp(span) === 'middleware' && !!span.name?.match(/^namedMiddleware\d*$/),
+ );
+
+ expect(middlewareSpan).toBeDefined();
+ expect(middlewareSpan?.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(middlewareSpan?.status).not.toBe('error');
+ });
+
+ test('multiple middleware are sibling spans under the same parent', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/multi`),
+ );
+
+ const response = await fetch(`${baseURL}${prefix}/multi`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/multi`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/multi`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const middlewareSpans = spans.sort((a, b) => (a.start_timestamp ?? 0) - (b.start_timestamp ?? 0));
+
+ expect(middlewareSpans).toHaveLength(2);
+ expect(middlewareSpans[0].name).toBe('middlewareA');
+ expect(middlewareSpans[1].name).toBe('middlewareB');
+
+ expect(middlewareSpans[0]?.parent_span_id).toBe(middlewareSpans[1]?.parent_span_id);
+
+ // middlewareA has a 50ms delay, middlewareB has a 60ms delay
+ const aDurationMs = (middlewareSpans[0].end_timestamp - middlewareSpans[0]?.start_timestamp) * 1000;
+ const bDurationMs = (middlewareSpans[1].end_timestamp - middlewareSpans[1]?.start_timestamp) * 1000;
+ expect(aDurationMs).toBeGreaterThanOrEqual(49);
+ expect(bDurationMs).toBeGreaterThanOrEqual(59);
+ });
+
+ test('captures error thrown in middleware', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return (
+ !!event.exception?.values?.[0]?.value?.startsWith('Middleware error') &&
+ !!event.request?.url?.includes(prefix)
+ );
+ });
+
+ const response = await fetch(`${baseURL}${prefix}/error`);
+ expect(response.status).toBe(500);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.exception?.values?.[0]?.value).toMatch(/^Middleware error/);
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual(
+ expect.objectContaining({
+ handled: false,
+ type: 'auto.http.hono.context_error',
+ }),
+ );
+
+ // The transaction name on the error event determines the culprit shown in Sentry.
+ expect(errorEvent.transaction).toBe(`GET ${prefix}/error`);
+ });
+
+ test('sets error status on middleware span when middleware throws', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/error`),
+ );
+
+ await fetch(`${baseURL}${prefix}/error`);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/error`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/error`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const failingSpan = spans.find(span => getSpanOp(span) === 'middleware' && span.status === 'error');
+
+ expect(failingSpan).toBeDefined();
+ expect(failingSpan?.status).toBe('error');
+ });
+
+ test('uses parameterized route in span name', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/param/`),
+ );
+
+ const response = await fetch(`${baseURL}${prefix}/param/42`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/param/`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/param/:id`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpan = spans.find(span => getSpanOp(span) === 'middleware' && span.name === 'middlewareA');
+ expect(middlewareSpan).toBeDefined();
+ });
+
+ test('includes request data on error events from middleware', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return (
+ !!event.exception?.values?.[0]?.value?.startsWith('Middleware error') &&
+ !!event.request?.url?.includes(prefix)
+ );
+ });
+
+ await fetch(`${baseURL}${prefix}/error`);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.request).toEqual(
+ expect.objectContaining({
+ method: 'GET',
+ url: expect.stringContaining(`${prefix}/error`),
+ }),
+ );
+ });
+ });
+}
+
+test.describe('.all() handler in sub-app', () => {
+ test('does not create middleware span for .all() route handler', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment =>
+ getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-subapp-middleware/all-handler'),
+ );
+
+ const response = await fetch(`${baseURL}/test-subapp-middleware/all-handler`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ handler: 'all' });
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ !!segment.name?.includes('/test-subapp-middleware/all-handler'),
+ )!;
+ expect(segment.name).toBe('GET /test-subapp-middleware/all-handler');
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ // No middleware is called for this route, so there should be no spans.
+ expect(spans).toEqual([]);
+ });
+});
+
+const INLINE_PREFIX = '/test-inline-middleware';
+
+const REGISTRATION_STYLES = [
+ { name: 'direct method (.get())', path: '/direct' },
+ { name: '.all()', path: '/all' },
+ { name: '.on()', path: '/on' },
+] as const;
+
+const MIDDLEWARE_STYLES = [
+ { name: 'inline', path: '' },
+ { name: 'separately registered', path: '/separately' },
+] as const;
+
+test.describe('inline middleware spans (sub-app)', () => {
+ for (const { name: regName, path: regPath } of REGISTRATION_STYLES) {
+ for (const { name: mwName, path: mwPath } of MIDDLEWARE_STYLES) {
+ test(`creates middleware span for ${mwName} middleware via ${regName}`, async ({ baseURL }) => {
+ const fullPath = `${INLINE_PREFIX}${regPath}${mwPath}`;
+
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(fullPath),
+ );
+
+ const response = await fetch(`${baseURL}${fullPath}`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(fullPath),
+ )!;
+ expect(segment.name).toBe(`GET ${fullPath}`);
+
+ const EXPECTED_DESCRIPTIONS: Record> = {
+ '/direct': { '': 'inlineMiddleware', '/separately': 'inlineSeparateMiddleware' },
+ '/all': { '': 'inlineMiddlewareAll', '/separately': 'inlineSeparateMiddlewareAll' },
+ '/on': { '': 'inlineMiddlewareOn', '/separately': 'inlineSeparateMiddlewareOn' },
+ };
+ const expectedDescription = EXPECTED_DESCRIPTIONS[regPath]![mwPath]!;
+
+ const inlineSpan = segmentSpans
+ .filter(span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id)
+ .find(s => s.name === expectedDescription);
+ expect(inlineSpan).toBeDefined();
+ expect(getSpanOp(inlineSpan!)).toBe('middleware');
+ expect(inlineSpan?.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(inlineSpan?.status).not.toBe('error');
+ });
+ }
+ }
+});
+
+const MAIN_INLINE_PREFIX = '/test-main-inline';
+
+const MAIN_INLINE_CASES = [
+ { name: '.get()', path: '/get', method: 'GET', expectedMiddlewareName: 'mainInlineGet' },
+ { name: '.post()', path: '/post', method: 'POST', expectedMiddlewareName: 'mainInlinePost' },
+ { name: '.all()', path: '/all', method: 'GET', expectedMiddlewareName: 'mainInlineAll' },
+] as const;
+
+test.describe('inline middleware spans (main app)', () => {
+ test('creates middleware span for inline middleware via .query()', async ({ baseURL }) => {
+ const fullPath = `${MAIN_INLINE_PREFIX}/query`;
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `QUERY ${fullPath}`,
+ );
+
+ const response = await fetch(`${baseURL}${fullPath}`, {
+ method: 'QUERY',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ value: 'query-body' }),
+ });
+ expect(response.status).toBe(200);
+ await expect(response.json()).resolves.toEqual({ method: 'QUERY', value: 'query-body' });
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `QUERY ${fullPath}`,
+ )!;
+ expect(segment.name).toBe(`QUERY ${fullPath}`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ expect(segment.attributes['sentry.segment.name.source']?.value).toBe('route');
+ expect(segment.attributes['http.request.method']?.value).toBe('QUERY');
+
+ const middlewareSpans = segmentSpans
+ .filter(span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id)
+ .filter(span => getSpanOp(span) === 'middleware');
+ expect(middlewareSpans).toHaveLength(1);
+ expect(middlewareSpans[0]).toEqual(
+ expect.objectContaining({
+ name: 'mainInlineQuery',
+ attributes: expect.objectContaining({
+ 'sentry.op': { value: 'middleware', type: 'string' },
+ 'sentry.origin': { value: 'auto.middleware.hono', type: 'string' },
+ }),
+ }),
+ );
+ });
+
+ MAIN_INLINE_CASES.forEach(({ name, path, method, expectedMiddlewareName }) => {
+ test(`creates middleware span for inline middleware via ${name}`, async ({ baseURL }) => {
+ const fullPath = `${MAIN_INLINE_PREFIX}${path}`;
+
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `${method} ${fullPath}`,
+ );
+
+ const response = await fetch(`${baseURL}${fullPath}`, { method });
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `${method} ${fullPath}`,
+ )!;
+ expect(segment.name).toBe(`${method} ${fullPath}`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const inlineSpan = spans.find(s => s.name === expectedMiddlewareName);
+
+ expect(inlineSpan).toBeDefined();
+ expect(getSpanOp(inlineSpan!)).toBe('middleware');
+ expect(inlineSpan?.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(inlineSpan?.status).not.toBe('error');
+
+ const middlewareSpans = spans.filter(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpans).toHaveLength(1);
+ });
+ });
+
+ test('creates spans for both .use() middleware and inline middleware via .get()', async ({ baseURL }) => {
+ const fullPath = `${MAIN_INLINE_PREFIX}/combined/resource`;
+
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `GET ${fullPath}`,
+ );
+
+ const response = await fetch(`${baseURL}${fullPath}`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `GET ${fullPath}`,
+ )!;
+ expect(segment.name).toBe(`GET ${fullPath}`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpans = spans.filter(s => getSpanOp(s) === 'middleware');
+
+ expect(middlewareSpans).toHaveLength(2);
+
+ const [spanA, spanB] = middlewareSpans.sort((a, b) => (a.name ?? '').localeCompare(b.name ?? ''));
+ expect(spanA.name).toBe('combinedInlineMw');
+ expect(getSpanOp(spanA!)).toBe('middleware');
+ expect(spanA.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(spanA?.status).not.toBe('error');
+
+ expect(spanB.name).toBe('middlewareA');
+ expect(getSpanOp(spanB!)).toBe('middleware');
+ expect(spanB.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(spanB?.status).not.toBe('error');
+ });
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/multi-fetch.test.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/multi-fetch.test.ts
new file mode 100644
index 000000000000..eecd5b99bca4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/multi-fetch.test.ts
@@ -0,0 +1,383 @@
+import { expect, test } from '@playwright/test';
+import {
+ waitForError,
+ waitForStreamedSpan,
+ getSpanOp,
+ collectStreamedSpansUntilSegment,
+} from '@sentry-internal/test-utils';
+import { APP_NAME } from './constants';
+
+const STOREFRONT = '/test-multi-fetch/storefront';
+const INVENTORY = '/test-multi-fetch/inventory';
+
+test.describe('multi-fetch: internal .request() calls between sub-apps', () => {
+ test.describe('single internal fetch', () => {
+ test('returns enriched product data and creates span with parameterized route', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product/:productId`,
+ );
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/product/self-watering-plant`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body.product).toEqual(
+ expect.objectContaining({
+ productId: 'self-watering-plant',
+ name: 'Self-Watering Plant',
+ stock: 5,
+ price: 2500,
+ }),
+ );
+ expect(body.source).toBe('storefront');
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe(`GET ${STOREFRONT}/product/:productId`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ });
+
+ test('creates storefrontAuth middleware span', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `GET ${STOREFRONT}/product/:productId`,
+ );
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/product/solar-powered-cyberdeck`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product/:productId`,
+ )!;
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const middlewareSpan = spans.find(span => getSpanOp(span) === 'middleware' && span.name === 'storefrontAuth');
+
+ expect(middlewareSpan).toEqual(
+ expect.objectContaining({
+ name: 'storefrontAuth',
+ attributes: expect.objectContaining({
+ 'sentry.op': { value: 'middleware', type: 'string' },
+ 'sentry.origin': { value: 'auto.middleware.hono', type: 'string' },
+ }),
+ }),
+ );
+ expect(middlewareSpan?.status).not.toBe('error');
+ });
+ });
+
+ test.describe('parallel internal fetches', () => {
+ test('aggregates data from two concurrent .request() calls', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/compare/:productId1/:productId2`,
+ );
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/compare/self-watering-plant/solar-powered-cyberdeck`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body.items).toHaveLength(2);
+ expect(body.items[0].productId).toBe('self-watering-plant');
+ expect(body.items[1].productId).toBe('solar-powered-cyberdeck');
+ expect(body.priceDifference).toBe(2500);
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe(`GET ${STOREFRONT}/compare/:productId1/:productId2`);
+ });
+ });
+
+ test.describe('sequential chained fetches', () => {
+ test('composes data from item lookup followed by stock check', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product/:productId/availability`,
+ );
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/product/self-watering-plant/availability`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ product: 'Self-Watering Plant', available: true, quantity: 5 });
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe(`GET ${STOREFRONT}/product/:productId/availability`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ });
+
+ test('reports out-of-stock item as unavailable', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product/:productId/availability`,
+ );
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/product/solar-powered-cyberdeck/availability`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual({ product: 'Solar-Powered Cyberdeck', available: false, quantity: 0 });
+
+ await segmentPromise;
+ });
+ });
+
+ test.describe('error propagation from internal fetch', () => {
+ test('captures error when handler throws after failed internal .request()', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'Failed to fetch product: nonexistent';
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product-or-throw/:productId`,
+ );
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/product-or-throw/nonexistent`);
+ expect(response.status).toBe(500);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.exception?.values?.[0]?.value).toBe('Failed to fetch product: nonexistent');
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual(expect.objectContaining({ handled: false }));
+ expect(errorEvent.transaction).toBe(`GET ${STOREFRONT}/product-or-throw/:productId`);
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe(`GET ${STOREFRONT}/product-or-throw/:productId`);
+ expect(segment?.status).toBe('error');
+ });
+
+ test('error event includes request data', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'Failed to fetch product: missing';
+ });
+
+ await fetch(`${baseURL}${STOREFRONT}/product-or-throw/missing`);
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.request).toEqual(
+ expect.objectContaining({
+ method: 'GET',
+ url: expect.stringContaining(`${STOREFRONT}/product-or-throw/missing`),
+ }),
+ );
+ });
+ });
+
+ test.describe('error inside internal fetch (degraded response)', () => {
+ // The manual `sentry()` middleware only instruments the main app's request lifecycle. An error
+ // thrown solely inside an internal sub-app `.request()` — whose failed response the outer handler
+ // swallows — is therefore NOT captured here, unlike the orchestrion auto-instrumentation in the
+ // `hono-4` app, which instruments every dispatched context. We assert only that the outer request
+ // stays healthy.
+ test('degrades to a 200 when the inner route fails', async ({ baseURL }) => {
+ const response = await fetch(`${baseURL}${STOREFRONT}/product/self-watering-plant/degraded`);
+ expect(response.status).toBe(200);
+ await expect(response.json()).resolves.toEqual({ product: null, degraded: true });
+ });
+ });
+
+ test.describe('inventory sub-app direct access', () => {
+ test('creates its own span when accessed directly via HTTP', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${INVENTORY}/item/:productId`,
+ );
+
+ const response = await fetch(`${baseURL}${INVENTORY}/item/self-watering-plant`);
+ expect(response.status).toBe(200);
+
+ const body = await response.json();
+ expect(body).toEqual(expect.objectContaining({ productId: 'self-watering-plant', name: 'Self-Watering Plant' }));
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe(`GET ${INVENTORY}/item/:productId`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ });
+ });
+
+ test.describe('trace propagation through internal .request() calls', () => {
+ test('single internal fetch produces an internal-request child span', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `GET ${STOREFRONT}/product/:productId`,
+ );
+
+ await fetch(`${baseURL}${STOREFRONT}/product/self-watering-plant`);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product/:productId`,
+ )!;
+ const traceId = segment?.trace_id;
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const internalRequestSpans = spans.filter(
+ s => s.attributes['sentry.origin']?.value === 'auto.http.hono.internal_request',
+ );
+
+ expect(internalRequestSpans).toHaveLength(1);
+ expect(internalRequestSpans[0]).toEqual(
+ expect.objectContaining({
+ trace_id: traceId,
+ attributes: expect.objectContaining({
+ 'sentry.op': { value: 'http.server', type: 'string' },
+ 'sentry.origin': { value: 'auto.http.hono.internal_request', type: 'string' },
+ }),
+ }),
+ );
+ expect(internalRequestSpans[0].name).toContain('GET /item/self-watering-plant');
+ });
+
+ test('parallel internal fetches produce two sibling internal-request spans', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment =>
+ getSpanOp(segment) === 'http.server' && segment.name === `GET ${STOREFRONT}/compare/:productId1/:productId2`,
+ );
+
+ await fetch(`${baseURL}${STOREFRONT}/compare/self-watering-plant/solar-powered-cyberdeck`);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/compare/:productId1/:productId2`,
+ )!;
+ const traceId = segment?.trace_id;
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const internalRequestSpans = spans.filter(
+ s => s.attributes['sentry.origin']?.value === 'auto.http.hono.internal_request',
+ );
+
+ expect(internalRequestSpans).toHaveLength(2);
+
+ expect(internalRequestSpans[0]?.parent_span_id).toBe(internalRequestSpans[1]?.parent_span_id);
+
+ expect(internalRequestSpans[0]?.trace_id).toBe(traceId);
+ expect(internalRequestSpans[1]?.trace_id).toBe(traceId);
+
+ expect(internalRequestSpans[0].attributes['sentry.origin']?.value).toBe('auto.http.hono.internal_request');
+ expect(internalRequestSpans[1].attributes['sentry.origin']?.value).toBe('auto.http.hono.internal_request');
+ });
+
+ test('sequential chained fetches produce two ordered internal-request spans', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment =>
+ getSpanOp(segment) === 'http.server' && segment.name === `GET ${STOREFRONT}/product/:productId/availability`,
+ );
+
+ await fetch(`${baseURL}${STOREFRONT}/product/self-watering-plant/availability`);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product/:productId/availability`,
+ )!;
+ const traceId = segment?.trace_id;
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const internalRequestSpans = spans
+ .filter(s => s.attributes['sentry.origin']?.value === 'auto.http.hono.internal_request')
+ .sort(
+ (a: { start_timestamp?: number }, b: { start_timestamp?: number }) =>
+ (a.start_timestamp ?? 0) - (b.start_timestamp ?? 0),
+ );
+
+ expect(internalRequestSpans).toHaveLength(2);
+
+ // Sequential: second span starts at or after first span ends (with tolerance for clock precision)
+ expect(internalRequestSpans[1].start_timestamp).toBeGreaterThanOrEqual(
+ internalRequestSpans[0].end_timestamp! - 0.001,
+ );
+
+ expect(internalRequestSpans[0]?.trace_id).toBe(traceId);
+ expect(internalRequestSpans[1]?.trace_id).toBe(traceId);
+ });
+
+ test('internal-request span has no error status for internal 4xx HTTPException', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment =>
+ getSpanOp(segment) === 'http.server' && segment.name === `GET ${STOREFRONT}/product-or-throw/:productId`,
+ );
+
+ await fetch(`${baseURL}${STOREFRONT}/product-or-throw/ghost`);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product-or-throw/:productId`,
+ )!;
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ const internalRequestSpans = spans.filter(
+ s => s.attributes['sentry.origin']?.value === 'auto.http.hono.internal_request',
+ );
+
+ expect(internalRequestSpans).toHaveLength(1);
+ expect(internalRequestSpans[0]?.status).not.toBe('error');
+ });
+
+ test('error from failed internal fetch is correlated with the storefront trace', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return event.exception?.values?.[0]?.value === 'Failed to fetch product: ghost';
+ });
+
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${STOREFRONT}/product-or-throw/:productId`,
+ );
+
+ await fetch(`${baseURL}${STOREFRONT}/product-or-throw/ghost`);
+
+ const [errorEvent, segment] = await Promise.all([errorPromise, segmentPromise]);
+
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(segment?.trace_id);
+ expect(errorEvent.contexts?.trace?.span_id).toBeDefined();
+ });
+ });
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/route-patterns.test.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/route-patterns.test.ts
new file mode 100644
index 000000000000..bfebb9f5b6ab
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/route-patterns.test.ts
@@ -0,0 +1,178 @@
+import { expect, test } from '@playwright/test';
+import { waitForStreamedSpan, getSpanOp, collectStreamedSpansUntilSegment } from '@sentry-internal/test-utils';
+import { APP_NAME } from './constants';
+
+const PREFIX = '/test-routes';
+
+const REGISTRATION_STYLES = [
+ { name: 'direct method', path: '' },
+ { name: '.all()', path: '/all' },
+ { name: '.on()', path: '/on' },
+] as const;
+
+test.describe('HTTP methods', () => {
+ ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].forEach(method => {
+ test(`sends transaction for ${method}`, async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `${method} ${PREFIX}`,
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}`, { method });
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `${method} ${PREFIX}`,
+ )!;
+ expect(segment.name).toBe(`${method} ${PREFIX}`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ expect(segment.attributes?.['sentry.segment.name.source']?.value).toBe('route');
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpans = spans.filter(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpans).toEqual([]);
+ });
+ });
+});
+
+test.describe('route registration styles', () => {
+ REGISTRATION_STYLES.forEach(({ name, path }) => {
+ test(`${name} sends transaction with route source`, async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `GET ${PREFIX}${path}`,
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}${path}`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `GET ${PREFIX}${path}`,
+ )!;
+ expect(segment.name).toBe(`GET ${PREFIX}${path}`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ expect(segment.attributes?.['sentry.segment.name.source']?.value).toBe('route');
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpans = spans.filter(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpans).toEqual([]);
+ });
+ });
+
+ [
+ { name: '.all()', path: '/all' },
+ { name: '.on()', path: '/on' },
+ ].forEach(({ name, path }) => {
+ test(`${name} responds to POST`, async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `POST ${PREFIX}${path}`,
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}${path}`, { method: 'POST' });
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `POST ${PREFIX}${path}`,
+ )!;
+ expect(segment.name).toBe(`POST ${PREFIX}${path}`);
+ expect(segment.attributes?.['sentry.segment.name.source']?.value).toBe('route');
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpans = spans.filter(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpans).toEqual([]);
+ });
+ });
+});
+
+test.describe('request data extraction', () => {
+ test('includes method, url, and headers on span', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `GET ${PREFIX}/request-data`,
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}/request-data`);
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+ expect(segment.attributes['http.request.method']?.value).toBe('GET');
+ expect(segment.attributes['url.full']?.value).toContain(PREFIX);
+ expect(segment.attributes['http.request.header.host']).toBeDefined();
+ });
+
+ test('includes query_string when present', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment &&
+ getSpanOp(segment) === 'http.server' &&
+ segment.name === `GET ${PREFIX}/query-test` &&
+ segment.attributes['url.query']?.value === 'foo=bar&baz=42',
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}/query-test?foo=bar&baz=42`);
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+
+ expect(segment.attributes['http.request.method']?.value).toBe('GET');
+ expect(segment.attributes['url.full']?.value).toContain(`${PREFIX}/query-test`);
+ expect(segment.attributes['url.query']?.value).toBe('foo=bar&baz=42');
+ });
+
+ test('includes request data for POST with headers', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `POST ${PREFIX}/request-data`,
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}/request-data`, {
+ method: 'POST',
+ headers: { 'X-Custom-Header': 'test-value' },
+ });
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+ expect(segment.attributes['http.request.method']?.value).toBe('POST');
+ expect(segment.attributes['url.full']?.value).toContain(PREFIX);
+ expect(segment.attributes['http.request.header.x-custom-header']?.value).toEqual(['test-value']);
+ });
+});
+
+test('async handler sends span', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && segment.name === `GET ${PREFIX}/async`,
+ );
+
+ const response = await fetch(`${baseURL}${PREFIX}/async`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === `GET ${PREFIX}/async`,
+ )!;
+ expect(segment.name).toBe(`GET ${PREFIX}/async`);
+ expect(getSpanOp(segment)).toBe('http.server');
+ expect(segment.attributes?.['sentry.segment.name.source']?.value).toBe('route');
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+ const middlewareSpans = spans.filter(s => getSpanOp(s) === 'middleware');
+ expect(middlewareSpans).toEqual([]);
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/tracing.test.ts b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/tracing.test.ts
new file mode 100644
index 000000000000..23ed5c7837fc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tests/tracing.test.ts
@@ -0,0 +1,144 @@
+import { expect, test } from '@playwright/test';
+import { waitForStreamedSpan, getSpanOp } from '@sentry-internal/test-utils';
+import { APP_NAME, RUNTIME } from './constants';
+
+test('sends a span for the index route', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /',
+ );
+
+ const response = await fetch(`${baseURL}/`);
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe('GET /');
+ expect(getSpanOp(segment)).toBe('http.server');
+});
+
+test('sends a span for a parameterized route', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-param/'),
+ );
+
+ const response = await fetch(`${baseURL}/test-param/123`);
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe('GET /test-param/:paramId');
+ expect(getSpanOp(segment)).toBe('http.server');
+});
+
+test('attaches HTTP connection info to the server span', async ({ baseURL, page }) => {
+ page.on('console', msg => {
+ console.log(`PAGE LOG: ${msg.text()}`);
+ });
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /',
+ );
+
+ const response = await fetch(`${baseURL}/`);
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+ const data = segment.attributes ?? {};
+
+ expect(data['client.address']?.value).toEqual(expect.any(String));
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+
+ if (RUNTIME !== 'deno') {
+ // Only exposed in `hono/deno`
+ expect(data['network.transport']?.value).toBeUndefined();
+ } else {
+ expect(data['network.transport']?.value).toMatch(/tcp/);
+ }
+
+ if (RUNTIME === 'node' || RUNTIME === 'bun') {
+ // Node (@hono/node-server) and Bun expose socket-level port and address family.
+ expect(data['client.port']?.value).toEqual(expect.any(Number));
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
+ expect(data['network.type']?.value).toMatch(/^ipv[46]$/);
+ } else if (RUNTIME === 'deno') {
+ expect(data['client.port']?.value).toEqual(expect.any(Number));
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
+ } else if (RUNTIME === 'cloudflare') {
+ // Cloudflare Workers expose no port, address family, or transport.
+ // This could change in the future and checking for the absence of these fields allows us to notice if/when that happens.
+ expect(data['client.port']?.value).toBeUndefined();
+ expect(data['network.peer.port']?.value).toBeUndefined();
+ expect(data['network.type']?.value).toBeUndefined();
+ } else {
+ throw new Error(`No tests for runtime: ${RUNTIME}`);
+ }
+});
+
+// Regression guard against connection info attributes.
+// The conninfo middleware must only *add* attributes, never replace or clear existing ones.
+// These are the baseline attributes the server transaction carries *without* the conninfo feature
+test("preserves the baseline server.*, client.* and network.* server span attributes that the SDK sends without Hono's conninfo", async ({
+ baseURL,
+}) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /',
+ );
+
+ const response = await fetch(`${baseURL}/`);
+ expect(response.status).toBe(200);
+
+ const segment = await segmentPromise;
+ const data = segment.attributes ?? {};
+
+ if (RUNTIME === 'node') {
+ expect(data['server.address']?.value).toBe('localhost');
+ expect(data['server.port']?.value).toBe(Number(new URL(baseURL!).port));
+ expect(data['client.address']?.value).toEqual(expect.any(String));
+ expect(data['client.port']?.value).toEqual(expect.any(Number));
+ expect(data['network.type']?.value).toMatch(/^ipv[46]$/);
+ expect(data['network.protocol.name']?.value).toBe('http');
+ expect(data['network.protocol.version']?.value).toBe('1.1');
+ expect(data['network.transport']?.value).toBeUndefined();
+ expect(data['network.local.port']?.value).toBe(data['server.port']?.value);
+ expect(data['network.local.address']?.value).toEqual(expect.any(String));
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
+ } else if (RUNTIME === 'bun') {
+ expect(data['client.address']?.value).toEqual(expect.any(String));
+ expect(data['client.port']?.value).toEqual(expect.any(Number));
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
+ expect(data['network.type']?.value).toMatch(/^ipv[46]$/);
+ } else if (RUNTIME === 'cloudflare') {
+ expect(data['server.address']?.value).toBe('localhost');
+ expect(data['client.address']?.value).toBe('::1');
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+ expect(data['network.protocol.name']?.value).toBe('http');
+ expect(data['network.protocol.version']?.value).toBe('1.1');
+ } else if (RUNTIME === 'deno') {
+ expect(data['server.address']?.value).toBe('localhost');
+ expect(data['client.address']?.value).toEqual(expect.any(String));
+ expect(data['client.port']?.value).toEqual(expect.any(Number));
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
+ expect(data['network.transport']?.value).toBe('tcp');
+ expect(data['network.protocol.name']?.value).toBe('http');
+ } else {
+ throw new Error(`No tests for runtime: ${RUNTIME}`);
+ }
+});
+
+test('sends a span for a route that throws', async ({ baseURL }) => {
+ const segmentPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/error/'),
+ );
+
+ await fetch(`${baseURL}/error/test-cause`);
+
+ const segment = await segmentPromise;
+ expect(segment.name).toBe('GET /error/:cause');
+ expect(getSpanOp(segment)).toBe('http.server');
+ expect(segment?.status).toBe('error');
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/tsconfig.json b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tsconfig.json
new file mode 100644
index 000000000000..3c4abeff44d6
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/tsconfig.json
@@ -0,0 +1,13 @@
+{
+ "compilerOptions": {
+ "target": "ESNext",
+ "module": "ESNext",
+ "moduleResolution": "Bundler",
+ "strict": true,
+ "skipLibCheck": true,
+ "lib": ["ESNext"],
+ "jsx": "react-jsx",
+ "jsxImportSource": "hono/jsx",
+ "types": ["@cloudflare/workers-types"]
+ }
+}
diff --git a/dev-packages/e2e-tests/test-applications/hono-4-legacy/wrangler.jsonc b/dev-packages/e2e-tests/test-applications/hono-4-legacy/wrangler.jsonc
new file mode 100644
index 000000000000..a3c646c03aa9
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4-legacy/wrangler.jsonc
@@ -0,0 +1,7 @@
+{
+ "$schema": "node_modules/wrangler/config-schema.json",
+ "name": "hono-4-legacy",
+ "main": "src/entry.cloudflare.ts",
+ "compatibility_date": "2026-04-20",
+ "compatibility_flags": ["nodejs_compat"],
+}
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/build-bun.ts b/dev-packages/e2e-tests/test-applications/hono-4/build-bun.ts
new file mode 100644
index 000000000000..fd337d063992
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4/build-bun.ts
@@ -0,0 +1,28 @@
+// Builds `src/entry.bun.ts` with the orchestrion `bun build` plugin, emitting `dist/entry.bun.js`
+// for the server to run. The plugin injects the `orchestrion:hono:context` diagnostics
+// channel into the bundled `hono`, which the `honoIntegration` default subscribes to.
+
+// @ts-ignore -- subpath export resolved by Bun at runtime; the package tsconfig's node module
+// resolution can't see `exports` subpaths.
+import { sentryBunPlugin } from '@sentry/bun/plugin';
+import { join } from 'path';
+
+void (async () => {
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'src/entry.bun.ts')],
+ target: 'bun',
+ outdir: join(__dirname, 'dist'),
+ // `@sentry/bun` (and its deps) stay external, so we don't bundle the whole SDK stack.
+ external: ['@sentry/bun'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log('BUILD_OK');
+})();
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/deno.json b/dev-packages/e2e-tests/test-applications/hono-4/deno.json
index d7748bc95ecb..7a7e681c4a82 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/deno.json
+++ b/dev-packages/e2e-tests/test-applications/hono-4/deno.json
@@ -1,7 +1,5 @@
{
"imports": {
- "@sentry/hono": "npm:@sentry/hono",
- "@sentry/hono/deno": "npm:@sentry/hono/deno",
"@sentry/deno": "npm:@sentry/deno",
"@sentry/core": "npm:@sentry/core",
"@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/package.json b/dev-packages/e2e-tests/test-applications/hono-4/package.json
index db3b18166812..a3fd78b9ec67 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/package.json
+++ b/dev-packages/e2e-tests/test-applications/hono-4/package.json
@@ -4,30 +4,35 @@
"version": "0.0.0",
"private": true,
"scripts": {
- "dev:cf": "wrangler dev --var \"E2E_TEST_DSN:$E2E_TEST_DSN\" --log-level=$(test $CI && echo 'none' || echo 'log')",
"dev:node": "node --import tsx/esm --import ./src/instrument.node.ts src/entry.node.ts",
- "dev:bun": "bun src/entry.bun.ts",
- "dev:deno": "deno run --allow-net --allow-env --allow-read src/entry.deno.ts",
- "build": "wrangler deploy --dry-run",
- "test:build": "pnpm install && pnpm build",
- "test:assert": "TEST_ENV=production playwright test"
+ "dev:bun": "bun run dist/entry.bun.js",
+ "dev:deno": "deno run --allow-net --allow-env --allow-read --preload=npm:@sentry/deno/import src/entry.deno.ts",
+ "dev:cloudflare": "wrangler dev --config ./dist/hono_4/wrangler.json --var \"E2E_TEST_DSN:$E2E_TEST_DSN\" --log-level=$(test $CI && echo 'none' || echo 'log')",
+ "test:build": "pnpm install",
+ "test": "TEST_ENV=production playwright test",
+ "test:assert": "pnpm test:assert:node",
+ "test:assert:node": "RUNTIME=node pnpm test",
+ "test:assert:bun": "bun run build-bun.ts && RUNTIME=bun pnpm test",
+ "test:assert:deno": "RUNTIME=deno pnpm test",
+ "test:assert:cloudflare": "vite build && RUNTIME=cloudflare pnpm test"
},
"dependencies": {
"@sentry/bun": "latest || *",
"@sentry/cloudflare": "latest || *",
"@sentry/deno": "latest || *",
- "@sentry/hono": "latest || *",
"@sentry/node": "latest || *",
"@hono/node-server": "^2.0.5",
"hono": "^4.13.1"
},
"devDependencies": {
"@playwright/test": "~1.63.0",
+ "@cloudflare/vite-plugin": "^1.47.0",
"@cloudflare/workers-types": "^4.20240725.0",
"@sentry-internal/test-utils": "link:../../../test-utils",
"tsx": "4.21.0",
"typescript": "^5.5.2",
- "wrangler": "^4.61.0"
+ "vite": "^8.1.5",
+ "wrangler": "^4.114.0"
},
"volta": {
"node": "24.15.0",
@@ -36,16 +41,16 @@
"sentryTest": {
"variants": [
{
- "assert-command": "RUNTIME=node pnpm test:assert",
- "label": "hono-4 (node)"
- },
- {
- "assert-command": "RUNTIME=bun pnpm test:assert",
+ "assert-command": "pnpm test:assert:bun",
"label": "hono-4 (bun)"
},
{
- "assert-command": "RUNTIME=deno pnpm test:assert",
+ "assert-command": "pnpm test:assert:deno",
"label": "hono-4 (deno)"
+ },
+ {
+ "assert-command": "pnpm test:assert:cloudflare",
+ "label": "hono-4 (cloudflare)"
}
]
}
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/playwright.config.ts b/dev-packages/e2e-tests/test-applications/hono-4/playwright.config.ts
index 5087b887e1f2..b8c04df05aee 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/playwright.config.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/playwright.config.ts
@@ -10,7 +10,7 @@ if (!testEnv) {
const APP_PORT = 38787;
const startCommands: Record = {
- cloudflare: `pnpm dev:cf --port ${APP_PORT}`,
+ cloudflare: `pnpm dev:cloudflare --port ${APP_PORT}`,
node: `pnpm dev:node`,
bun: `pnpm dev:bun`,
deno: `pnpm dev:deno`,
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.bun.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.bun.ts
index e057eb78d4c5..b47f15997480 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.bun.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.bun.ts
@@ -1,18 +1,11 @@
+// Import the Sentry init first so `honoIntegration` is set up (and subscribed to Hono's per-request
+// Context channel) before any request is handled.
+import './instrument.bun';
import { Hono } from 'hono';
-import { sentry } from '@sentry/hono/bun';
import { addRoutes } from './routes';
const app = new Hono();
-app.use(
- sentry(app, {
- dsn: process.env.E2E_TEST_DSN,
- environment: 'qa',
- tracesSampleRate: 1.0,
- tunnel: 'http://localhost:3031/',
- }),
-);
-
addRoutes(app);
const port = Number(process.env.PORT || 38787);
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.cloudflare.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.cloudflare.ts
index e348dde56226..7fb84f59947a 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.cloudflare.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.cloudflare.ts
@@ -1,18 +1,8 @@
import { Hono } from 'hono';
-import { sentry } from '@sentry/hono/cloudflare';
import { addRoutes } from './routes';
const app = new Hono<{ Bindings: { E2E_TEST_DSN: string } }>();
-app.use(
- sentry(app, env => ({
- dsn: env.E2E_TEST_DSN,
- environment: 'qa',
- tracesSampleRate: 1.0,
- tunnel: 'http://localhost:3031/',
- })),
-);
-
addRoutes(app);
export default app;
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.deno.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.deno.ts
index 15bd12a74111..cc2411fd6cf9 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.deno.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.deno.ts
@@ -1,19 +1,11 @@
+// Import the Sentry init first so `honoIntegration` is set up (and subscribed to Hono's per-request
+// Context channel) before any request is handled.
+import './instrument.deno';
import { Hono } from 'hono';
-import { sentry } from '@sentry/hono/deno';
import { addRoutes } from './routes';
const app = new Hono();
-app.use(
- sentry(app, {
- dsn: Deno.env.get('E2E_TEST_DSN'),
- environment: 'qa',
- dataCollection: {},
- tracesSampleRate: 1.0,
- tunnel: 'http://localhost:3031/',
- }),
-);
-
addRoutes(app);
const port = Number(Deno.env.get('PORT') || 38787);
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.node.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.node.ts
index 898a92e08be4..c67b3a206ef2 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/entry.node.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/entry.node.ts
@@ -1,16 +1,14 @@
-import { Hono } from 'hono';
-import { sentry } from '@sentry/hono/node';
import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
import { addRoutes } from './routes';
const app = new Hono();
-app.use(sentry(app));
-
addRoutes(app);
const port = Number(process.env.PORT || 38787);
serve({ fetch: app.fetch, port }, () => {
+ // eslint-disable-next-line no-console
console.log(`Hono (Node) listening on port ${port}`);
});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.bun.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.bun.ts
new file mode 100644
index 000000000000..9cb58d8c2aa2
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.bun.ts
@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/bun';
+
+Sentry.init({
+ dsn: process.env.E2E_TEST_DSN,
+ environment: 'qa',
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.deno.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.deno.ts
new file mode 100644
index 000000000000..49c9d1d452f1
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.deno.ts
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ environment: 'qa',
+ dataCollection: {},
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.node.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.node.ts
index 82f2a3864125..5c3e586fd48b 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.node.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.node.ts
@@ -1,4 +1,4 @@
-import * as Sentry from '@sentry/hono/node';
+import * as Sentry from '@sentry/node';
Sentry.init({
dsn: process.env.E2E_TEST_DSN,
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.server.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.server.ts
new file mode 100644
index 000000000000..d1990a0ea930
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/instrument.server.ts
@@ -0,0 +1,8 @@
+import { defineCloudflareOptions } from '@sentry/cloudflare';
+
+export default defineCloudflareOptions<{ E2E_TEST_DSN: string }>(env => ({
+ dsn: env.E2E_TEST_DSN,
+ environment: 'qa',
+ tracesSampleRate: 1.0,
+ tunnel: 'http://localhost:3031/',
+}));
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/middleware.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/middleware.ts
index cc7bfae9896d..9304a980dff3 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/middleware.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/middleware.ts
@@ -1,17 +1,34 @@
import type { MiddlewareHandler } from 'hono';
-export const middlewareA: MiddlewareHandler = async function middlewareA(c, next) {
+// Defined as anonymous function expressions so the function name is inferred from the `const`
+// binding. A named expression (`const middlewareA = async function middlewareA() {}`) collides with
+// the binding when bundled, and Bun renames the inner function (→ `middlewareA2`), which would then
+// surface as the middleware span name. The inferred name stays stable across all runtimes.
+export const middlewareA: MiddlewareHandler = async function (c, next) {
// Add some delay
await new Promise(resolve => setTimeout(resolve, 50));
await next();
};
-export const middlewareB: MiddlewareHandler = async function middlewareB(_c, next) {
+export const middlewareB: MiddlewareHandler = async function (_c, next) {
// Add some delay
await new Promise(resolve => setTimeout(resolve, 60));
await next();
};
-export const failingMiddleware: MiddlewareHandler = async function failingMiddleware(_c, _next) {
- throw new Error('Middleware error');
+let failingMiddlewareCount = 0;
+export const failingMiddleware: MiddlewareHandler = async function (_c, _next) {
+ // Each throw gets a unique suffix so the Dedupe integration doesn't collapse the identical errors
+ // that several tests (and their retries) trigger through this shared middleware — otherwise only the
+ // first would be reported and the other tests' `waitForError` would time out. Tests match on the
+ // stable `Middleware error` prefix.
+ throw new Error(`Middleware error #${(failingMiddlewareCount += 1)}`);
+};
+
+// Intentionally a NAMED function expression (unlike the anonymous ones above) so the named-function
+// path stays covered: the span name is taken from the function's own name. Under bundled Bun the inner
+// name collides with the `const` binding and is suffixed (→ `namedMiddleware2`), so the test matches on
+// the `namedMiddleware` prefix rather than an exact name.
+export const namedMiddleware: MiddlewareHandler = async function namedMiddleware(_c, next) {
+ await next();
};
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-middleware.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-middleware.ts
index d82201b7cdb3..6f21c1cac33b 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-middleware.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-middleware.ts
@@ -1,5 +1,5 @@
import { Hono } from 'hono';
-import { failingMiddleware, middlewareA, middlewareB } from '../middleware';
+import { failingMiddleware, middlewareA, middlewareB, namedMiddleware } from '../middleware';
const middlewareRoutes = new Hono();
@@ -8,11 +8,13 @@ middlewareRoutes.get('/anonymous', c => c.json({ middleware: 'anonymous' }));
middlewareRoutes.get('/multi', c => c.json({ middleware: 'multi' }));
middlewareRoutes.get('/error', c => c.text('should not reach'));
middlewareRoutes.get('/param/:id', c => c.json({ paramId: c.req.param('id') }));
+middlewareRoutes.get('/declared', c => c.json({ middleware: 'declared' }));
// Self-contained sub-app registering its own middleware via .use()
const subAppWithMiddleware = new Hono();
subAppWithMiddleware.use('/named/*', middlewareA);
+subAppWithMiddleware.use('/declared/*', namedMiddleware);
subAppWithMiddleware.use('/anonymous/*', async (c, next) => {
c.header('X-Custom', 'anonymous');
await next();
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-multi-fetch.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-multi-fetch.ts
index 58eb5b504640..ed9f0a3e131b 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-multi-fetch.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/route-groups/test-multi-fetch.ts
@@ -28,6 +28,14 @@ inventoryApp.get('/item/:productId/stock', c => {
return c.json({ productId, inStock: item.stock > 0, quantity: item.stock });
});
+// Simulates an inner-route failure (a plain 5xx Error, not an HTTPException) reached only via an
+// internal .request() — used by the storefront's `/degraded` route below. Each throw gets a unique
+// suffix so the Dedupe integration doesn't collapse repeats across test retries.
+let dbErrorCount = 0;
+inventoryApp.get('/item/:productId/db-error', () => {
+ throw new Error(`inventory db is down #${(dbErrorCount += 1)}`);
+});
+
// Storefront service — orchestrates internal .request() calls to inventoryApp.
const storefrontApp = new Hono();
@@ -83,6 +91,17 @@ storefrontApp.get('/product/:productId/availability', async c => {
});
});
+// Degraded response: the inner route throws, but the outer handler swallows the failed internal
+// response and returns a 200 instead of propagating. The inner error should still reach Sentry (auto
+// instrumentation); the outer request stays healthy.
+storefrontApp.get('/product/:productId/degraded', async c => {
+ const res = await inventoryApp.request(`/item/${c.req.param('productId')}/db-error`);
+ if (!res.ok) {
+ return c.json({ product: null, degraded: true }, 200);
+ }
+ return c.json({ product: await res.json() });
+});
+
// Error propagation: internal 404 causes the handler to throw a plain Error
storefrontApp.get('/product-or-throw/:productId', async c => {
const res = await inventoryApp.request(`/item/${c.req.param('productId')}`);
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/src/routes.ts b/dev-packages/e2e-tests/test-applications/hono-4/src/routes.ts
index b095618fb52b..008a1ca6fd53 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/src/routes.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/src/routes.ts
@@ -1,6 +1,6 @@
import { type Hono as HonoType, Hono } from 'hono';
import { HTTPException } from 'hono/http-exception';
-import { failingMiddleware, middlewareA, middlewareB } from './middleware';
+import { failingMiddleware, middlewareA, middlewareB, namedMiddleware } from './middleware';
import { errorRoutes } from './route-groups/test-errors';
import { middlewareRoutes, subAppWithInlineMiddleware, subAppWithMiddleware } from './route-groups/test-middleware';
import { multiFetchRoutes } from './route-groups/test-multi-fetch';
@@ -42,6 +42,7 @@ export function addRoutes(app: HonoType<{ Bindings?: { E2E_TEST_DSN: string } }>
app.use('/test-middleware/multi/*', middlewareA, middlewareB);
app.use('/test-middleware/error/*', failingMiddleware);
app.use('/test-middleware/param/*', middlewareA);
+ app.use('/test-middleware/declared/*', namedMiddleware);
app.route('/test-middleware', middlewareRoutes);
// Sub-app middleware: registered on the sub-app, wrapped at mount time by route() patching
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/tests/basepath-and-late-routes.test.ts b/dev-packages/e2e-tests/test-applications/hono-4/tests/basepath-and-late-routes.test.ts
index c7ad43b6b945..6295dc4c9e32 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/tests/basepath-and-late-routes.test.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/tests/basepath-and-late-routes.test.ts
@@ -42,8 +42,7 @@ test.describe('basePath with sub-app routes', () => {
});
});
-// TODO: this test is currently skipped because we do not yet support middleware registered on new instances (e.g. here via .basePath(..).use(...)).
-test.skip('.basePath() middleware instrumentation', () => {
+test.describe('.basePath() middleware instrumentation', () => {
test('creates middleware span for .use() on .basePath() clone', async ({ baseURL }) => {
const segmentPromise = collectStreamedSpansUntilSegment(
APP_NAME,
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/hono-4/tests/errors.test.ts
index e3c44c67d4d6..b315233ec15b 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/tests/errors.test.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/tests/errors.test.ts
@@ -5,7 +5,7 @@ import {
getSpanOp,
collectStreamedSpansUntilSegment,
} from '@sentry-internal/test-utils';
-import { APP_NAME, RUNTIME } from './constants';
+import { APP_NAME } from './constants';
test.describe('route handler errors', () => {
test('captures error with mechanism and trace correlation', async ({ baseURL }) => {
@@ -103,81 +103,37 @@ test.describe('HTTPException errors', () => {
});
});
- // On Node/Bun, httpServerSpansIntegration drops transactions for 3xx/4xx responses (ignoreStatusCodes), so we just use a request guard.
- // On Cloudflare the transaction is available, and we additionally verify its name.
- [301, 302].forEach(code => {
- test(`does not capture ${code} HTTPException`, async ({ baseURL }) => {
- let errorEventOccurred = false;
-
- waitForError(APP_NAME, event => {
- if (event.exception?.values?.[0]?.value === `HTTPException ${code}`) {
- errorEventOccurred = true;
- }
- return false;
- });
-
- const segmentPromise = waitForStreamedSpan(
- APP_NAME,
- segment =>
- segment.is_segment &&
- (RUNTIME === 'cloudflare'
- ? getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/http-exception/')
- : getSpanOp(segment) === 'http.server' && segment.name === 'GET /'),
- );
-
- const response = await fetch(`${baseURL}/http-exception/${code}`, { redirect: 'manual' });
- expect(response.status).toBe(code);
-
- if (RUNTIME !== 'cloudflare') {
- // Simple request guard for non-Cloudflare runtimes since the other transaction is dropped for 4xx responses
- await fetch(`${baseURL}/`);
- }
-
- const segment = await segmentPromise;
-
- if (RUNTIME === 'cloudflare') {
- expect(segment.name).toBe('GET /http-exception/:code');
+ // 3xx/4xx responses must not be captured as errors. Some runtimes drop the transaction for those
+ // status codes (httpServerSpansIntegration's ignoreStatusCodes), so instead of waiting on the
+ // HTTPException route's own (possibly dropped) transaction, we wait on a defined 2xx route's
+ // transaction as a flush guard — that one is produced on every runtime — then assert no error was
+ // captured. (Parametrized route naming is covered by tracing.test.ts on 2xx routes.)
+ const expectHttpExceptionNotCaptured = async (baseURL: string, code: number): Promise => {
+ let errorEventOccurred = false;
+ waitForError(APP_NAME, event => {
+ if (event.exception?.values?.[0]?.value === `HTTPException ${code}`) {
+ errorEventOccurred = true;
}
-
- expect(errorEventOccurred).toBe(false);
+ return false;
});
- });
- [401, 403, 404].forEach(code => {
- test(`does not capture ${code} HTTPException`, async ({ baseURL }) => {
- let errorEventOccurred = false;
-
- waitForError(APP_NAME, event => {
- if (event.exception?.values?.[0]?.value === `HTTPException ${code}`) {
- errorEventOccurred = true;
- }
- return false;
- });
-
- const segmentPromise = waitForStreamedSpan(
- APP_NAME,
- segment =>
- segment.is_segment &&
- (RUNTIME === 'cloudflare'
- ? getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/http-exception/')
- : getSpanOp(segment) === 'http.server' && segment.name === 'GET /'),
- );
-
- const response = await fetch(`${baseURL}/http-exception/${code}`);
- expect(response.status).toBe(code);
-
- if (RUNTIME !== 'cloudflare') {
- // Simple request guard for non-Cloudflare runtimes since the other transaction is dropped for 4xx responses
- await fetch(`${baseURL}/`);
- }
+ const guardPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /',
+ );
- const segment = await segmentPromise;
+ const response = await fetch(`${baseURL}/http-exception/${code}`, { redirect: 'manual' });
+ expect(response.status).toBe(code);
- if (RUNTIME === 'cloudflare') {
- expect(segment.name).toBe('GET /http-exception/:code');
- }
+ await fetch(`${baseURL}/`);
+ await guardPromise;
+
+ expect(errorEventOccurred).toBe(false);
+ };
- expect(errorEventOccurred).toBe(false);
+ [301, 302, 401, 403, 404].forEach(code => {
+ test(`does not capture ${code} HTTPException`, async ({ baseURL }) => {
+ await expectHttpExceptionNotCaptured(baseURL!, code);
});
});
});
@@ -226,41 +182,18 @@ test.describe('middleware errors', () => {
return false;
});
- const segmentPromise = collectStreamedSpansUntilSegment(APP_NAME, segment => {
- if (RUNTIME === 'cloudflare') {
- return (
- getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-errors/middleware-http-exception-4xx')
- );
- }
- return getSpanOp(segment) === 'http.server' && segment.name === 'GET /';
- });
+ // Guard on a defined 2xx route's transaction (produced on every runtime) rather than the 4xx
+ // route's own transaction, which some runtimes drop — then assert no error was captured.
+ const guardPromise = waitForStreamedSpan(
+ APP_NAME,
+ segment => segment.is_segment && getSpanOp(segment) === 'http.server' && segment.name === 'GET /',
+ );
const response = await fetch(`${baseURL}/test-errors/middleware-http-exception-4xx`);
expect(response.status).toBe(401);
- if (RUNTIME !== 'cloudflare') {
- await fetch(`${baseURL}/`);
- }
-
- const segmentSpans = await segmentPromise;
- const segment = segmentSpans.find(segment => {
- if (!segment.is_segment) return false;
- if (RUNTIME === 'cloudflare') {
- return (
- getSpanOp(segment) === 'http.server' && !!segment.name?.includes('/test-errors/middleware-http-exception-4xx')
- );
- }
- return getSpanOp(segment) === 'http.server' && segment.name === 'GET /';
- })!;
-
- if (RUNTIME === 'cloudflare') {
- expect(segment.name).toBe('GET /test-errors/middleware-http-exception-4xx');
-
- const middlewareSpan = segmentSpans
- .filter(span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id)
- .find(s => getSpanOp(s) === 'middleware');
- expect(middlewareSpan?.status).not.toBe('error');
- }
+ await fetch(`${baseURL}/`);
+ await guardPromise;
expect(errorEventOccurred).toBe(false);
});
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/hono-4/tests/middleware.test.ts
index 111ff3bfe34a..d760f12e6451 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/tests/middleware.test.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/tests/middleware.test.ts
@@ -78,6 +78,38 @@ for (const { name, prefix } of SCENARIOS) {
expect(anonymousSpan?.status).not.toBe('error');
});
+ test('creates a span for a named-function middleware (name from the function binding)', async ({ baseURL }) => {
+ const segmentPromise = collectStreamedSpansUntilSegment(
+ APP_NAME,
+ segment => getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/declared`),
+ );
+
+ const response = await fetch(`${baseURL}${prefix}/declared`);
+ expect(response.status).toBe(200);
+
+ const segmentSpans = await segmentPromise;
+ const segment = segmentSpans.find(
+ segment =>
+ segment.is_segment && getSpanOp(segment) === 'http.server' && !!segment.name?.includes(`${prefix}/declared`),
+ )!;
+ expect(segment.name).toBe(`GET ${prefix}/declared`);
+
+ const spans = segmentSpans.filter(
+ span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segment.span_id,
+ );
+
+ // Named function expression: the span name comes from the function's own name. A bundler (Bun)
+ // may append a numeric suffix when the inner name collides with the `const` binding, so match on
+ // the `namedMiddleware` prefix rather than an exact name.
+ const middlewareSpan = spans.find(
+ span => getSpanOp(span) === 'middleware' && !!span.name?.match(/^namedMiddleware\d*$/),
+ );
+
+ expect(middlewareSpan).toBeDefined();
+ expect(middlewareSpan?.attributes['sentry.origin']?.value).toBe('auto.middleware.hono');
+ expect(middlewareSpan?.status).not.toBe('error');
+ });
+
test('multiple middleware are sibling spans under the same parent', async ({ baseURL }) => {
const segmentPromise = collectStreamedSpansUntilSegment(
APP_NAME,
@@ -115,14 +147,17 @@ for (const { name, prefix } of SCENARIOS) {
test('captures error thrown in middleware', async ({ baseURL }) => {
const errorPromise = waitForError(APP_NAME, event => {
- return event.exception?.values?.[0]?.value === 'Middleware error';
+ return (
+ !!event.exception?.values?.[0]?.value?.startsWith('Middleware error') &&
+ !!event.request?.url?.includes(prefix)
+ );
});
const response = await fetch(`${baseURL}${prefix}/error`);
expect(response.status).toBe(500);
const errorEvent = await errorPromise;
- expect(errorEvent.exception?.values?.[0]?.value).toBe('Middleware error');
+ expect(errorEvent.exception?.values?.[0]?.value).toMatch(/^Middleware error/);
expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual(
expect.objectContaining({
handled: false,
@@ -184,7 +219,10 @@ for (const { name, prefix } of SCENARIOS) {
test('includes request data on error events from middleware', async ({ baseURL }) => {
const errorPromise = waitForError(APP_NAME, event => {
- return event.exception?.values?.[0]?.value === 'Middleware error' && !!event.request?.url?.includes(prefix);
+ return (
+ !!event.exception?.values?.[0]?.value?.startsWith('Middleware error') &&
+ !!event.request?.url?.includes(prefix)
+ );
});
await fetch(`${baseURL}${prefix}/error`);
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/tests/multi-fetch.test.ts b/dev-packages/e2e-tests/test-applications/hono-4/tests/multi-fetch.test.ts
index 29298c7b8f89..b98a7e6df7ee 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/tests/multi-fetch.test.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/tests/multi-fetch.test.ts
@@ -183,6 +183,24 @@ test.describe('multi-fetch: internal .request() calls between sub-apps', () => {
});
});
+ test.describe('error inside internal fetch (degraded response)', () => {
+ test('reports the inner-route error to Sentry even though the outer handler returns 200', async ({ baseURL }) => {
+ const errorPromise = waitForError(APP_NAME, event => {
+ return !!event.exception?.values?.[0]?.value?.startsWith('inventory db is down');
+ });
+
+ const response = await fetch(`${baseURL}${STOREFRONT}/product/self-watering-plant/degraded`);
+ expect(response.status).toBe(200);
+ await expect(response.json()).resolves.toEqual({ product: null, degraded: true });
+
+ const errorEvent = await errorPromise;
+ expect(errorEvent.exception?.values?.[0]?.value).toMatch(/^inventory db is down/);
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual(
+ expect.objectContaining({ handled: false, type: 'auto.http.hono.context_error' }),
+ );
+ });
+ });
+
test.describe('inventory sub-app direct access', () => {
test('creates its own span when accessed directly via HTTP', async ({ baseURL }) => {
const segmentPromise = waitForStreamedSpan(
@@ -347,8 +365,11 @@ test.describe('multi-fetch: internal .request() calls between sub-apps', () => {
});
test('error from failed internal fetch is correlated with the storefront trace', async ({ baseURL }) => {
+ // Use a param unique to this test: the `no error status` test above fetches `/ghost` too, and its
+ // identical `Failed to fetch product: ghost` error would otherwise be dropped by the Dedupe
+ // integration, so this test's `waitForError` would never fire.
const errorPromise = waitForError(APP_NAME, event => {
- return event.exception?.values?.[0]?.value === 'Failed to fetch product: ghost';
+ return event.exception?.values?.[0]?.value === 'Failed to fetch product: phantom';
});
const segmentPromise = waitForStreamedSpan(
@@ -359,7 +380,7 @@ test.describe('multi-fetch: internal .request() calls between sub-apps', () => {
segment.name === `GET ${STOREFRONT}/product-or-throw/:productId`,
);
- await fetch(`${baseURL}${STOREFRONT}/product-or-throw/ghost`);
+ await fetch(`${baseURL}${STOREFRONT}/product-or-throw/phantom`);
const [errorEvent, segment] = await Promise.all([errorPromise, segmentPromise]);
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/tests/tracing.test.ts b/dev-packages/e2e-tests/test-applications/hono-4/tests/tracing.test.ts
index 23ed5c7837fc..9350259d7e5c 100644
--- a/dev-packages/e2e-tests/test-applications/hono-4/tests/tracing.test.ts
+++ b/dev-packages/e2e-tests/test-applications/hono-4/tests/tracing.test.ts
@@ -1,6 +1,78 @@
import { expect, test } from '@playwright/test';
import { waitForStreamedSpan, getSpanOp } from '@sentry-internal/test-utils';
-import { APP_NAME, RUNTIME } from './constants';
+import { APP_NAME, RUNTIME, type Runtime } from './constants';
+
+const anyString = expect.any(String) as unknown;
+const anyNumber = expect.any(Number) as unknown;
+const ipvType = expect.stringMatching(/^ipv[46]$/) as unknown;
+
+// Per-runtime `http.server` connection-info expectations. Each runtime's `getConnInfo` helper exposes
+// a different set of fields, so the expected attribute values are declared here once (keyed by
+// runtime) instead of branching inside the tests. `undefined` means the attribute must be absent.
+// Relational checks (`network.peer.*` mirroring `client.*`) are asserted in the tests, since they
+// hold on every runtime (including when both sides are absent).
+//
+// - `added`: attributes Hono's conninfo middleware contributes.
+// - `baseline`: attributes the SDK sends independent of conninfo (regression guard that conninfo only
+// adds, never clobbers).
+const CONN_INFO: Record; baseline: Record }> = {
+ node: {
+ added: {
+ 'client.address': anyString,
+ 'client.port': anyNumber,
+ 'network.type': ipvType,
+ 'network.transport': undefined,
+ },
+ baseline: {
+ 'server.address': 'localhost',
+ 'server.port': anyNumber,
+ 'client.port': anyNumber,
+ 'network.type': ipvType,
+ 'network.protocol.name': 'http',
+ 'network.protocol.version': '1.1',
+ 'network.transport': undefined,
+ 'network.local.address': anyString,
+ 'network.local.port': anyNumber,
+ },
+ },
+ bun: {
+ added: {
+ 'client.address': anyString,
+ 'client.port': anyNumber,
+ 'network.type': ipvType,
+ 'network.transport': undefined,
+ },
+ baseline: { 'client.port': anyNumber, 'network.type': ipvType },
+ },
+ deno: {
+ // Only `hono/deno` exposes `network.transport`.
+ added: { 'client.address': anyString, 'client.port': anyNumber, 'network.transport': expect.stringMatching(/tcp/) },
+ baseline: {
+ 'server.address': 'localhost',
+ 'client.port': anyNumber,
+ 'network.transport': 'tcp',
+ 'network.protocol.name': 'http',
+ },
+ },
+ cloudflare: {
+ // Cloudflare Workers expose no client address, port, address family, or transport: there is no
+ // `getConnInfo` on Workers and nothing else populates `client.address`, so all of these are
+ // absent. Asserting `undefined` here lets us notice if that ever changes.
+ added: {
+ 'client.address': undefined,
+ 'client.port': undefined,
+ 'network.type': undefined,
+ 'network.transport': undefined,
+ },
+ baseline: {
+ 'server.address': 'localhost',
+ 'network.protocol.name': 'http',
+ 'network.protocol.version': '1.1',
+ },
+ },
+};
+
+const connInfo = CONN_INFO[RUNTIME];
test('sends a span for the index route', async ({ baseURL }) => {
const segmentPromise = waitForStreamedSpan(
@@ -45,33 +117,14 @@ test('attaches HTTP connection info to the server span', async ({ baseURL, page
const segment = await segmentPromise;
const data = segment.attributes ?? {};
- expect(data['client.address']?.value).toEqual(expect.any(String));
- expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
-
- if (RUNTIME !== 'deno') {
- // Only exposed in `hono/deno`
- expect(data['network.transport']?.value).toBeUndefined();
- } else {
- expect(data['network.transport']?.value).toMatch(/tcp/);
+ for (const [key, expected] of Object.entries(connInfo.added)) {
+ expect(data[key]?.value).toEqual(expected);
}
- if (RUNTIME === 'node' || RUNTIME === 'bun') {
- // Node (@hono/node-server) and Bun expose socket-level port and address family.
- expect(data['client.port']?.value).toEqual(expect.any(Number));
- expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
- expect(data['network.type']?.value).toMatch(/^ipv[46]$/);
- } else if (RUNTIME === 'deno') {
- expect(data['client.port']?.value).toEqual(expect.any(Number));
- expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
- } else if (RUNTIME === 'cloudflare') {
- // Cloudflare Workers expose no port, address family, or transport.
- // This could change in the future and checking for the absence of these fields allows us to notice if/when that happens.
- expect(data['client.port']?.value).toBeUndefined();
- expect(data['network.peer.port']?.value).toBeUndefined();
- expect(data['network.type']?.value).toBeUndefined();
- } else {
- throw new Error(`No tests for runtime: ${RUNTIME}`);
- }
+ // conninfo must only *add* attributes, never replace: peer mirrors client on every runtime
+ // (including when both are absent).
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
});
// Regression guard against connection info attributes.
@@ -91,42 +144,13 @@ test("preserves the baseline server.*, client.* and network.* server span attrib
const segment = await segmentPromise;
const data = segment.attributes ?? {};
- if (RUNTIME === 'node') {
- expect(data['server.address']?.value).toBe('localhost');
- expect(data['server.port']?.value).toBe(Number(new URL(baseURL!).port));
- expect(data['client.address']?.value).toEqual(expect.any(String));
- expect(data['client.port']?.value).toEqual(expect.any(Number));
- expect(data['network.type']?.value).toMatch(/^ipv[46]$/);
- expect(data['network.protocol.name']?.value).toBe('http');
- expect(data['network.protocol.version']?.value).toBe('1.1');
- expect(data['network.transport']?.value).toBeUndefined();
- expect(data['network.local.port']?.value).toBe(data['server.port']?.value);
- expect(data['network.local.address']?.value).toEqual(expect.any(String));
- expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
- expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
- } else if (RUNTIME === 'bun') {
- expect(data['client.address']?.value).toEqual(expect.any(String));
- expect(data['client.port']?.value).toEqual(expect.any(Number));
- expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
- expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
- expect(data['network.type']?.value).toMatch(/^ipv[46]$/);
- } else if (RUNTIME === 'cloudflare') {
- expect(data['server.address']?.value).toBe('localhost');
- expect(data['client.address']?.value).toBe('::1');
- expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
- expect(data['network.protocol.name']?.value).toBe('http');
- expect(data['network.protocol.version']?.value).toBe('1.1');
- } else if (RUNTIME === 'deno') {
- expect(data['server.address']?.value).toBe('localhost');
- expect(data['client.address']?.value).toEqual(expect.any(String));
- expect(data['client.port']?.value).toEqual(expect.any(Number));
- expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
- expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
- expect(data['network.transport']?.value).toBe('tcp');
- expect(data['network.protocol.name']?.value).toBe('http');
- } else {
- throw new Error(`No tests for runtime: ${RUNTIME}`);
+ for (const [key, expected] of Object.entries(connInfo.baseline)) {
+ expect(data[key]?.value).toEqual(expected);
}
+
+ // Relational checks that hold on every runtime (both sides absent → still equal).
+ expect(data['network.peer.address']?.value).toBe(data['client.address']?.value);
+ expect(data['network.peer.port']?.value).toBe(data['client.port']?.value);
});
test('sends a span for a route that throws', async ({ baseURL }) => {
diff --git a/dev-packages/e2e-tests/test-applications/hono-4/vite.config.ts b/dev-packages/e2e-tests/test-applications/hono-4/vite.config.ts
new file mode 100644
index 000000000000..005f4448f6cb
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/hono-4/vite.config.ts
@@ -0,0 +1,7 @@
+import { cloudflare } from '@cloudflare/vite-plugin';
+import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+ plugins: [cloudflare(), sentryCloudflareVitePlugin()],
+});
diff --git a/dev-packages/e2e-tests/test-applications/nestjs-11-static/src/instrument.ts b/dev-packages/e2e-tests/test-applications/nestjs-11-static/src/instrument.ts
index aa4c76f13ee5..0713640263be 100644
--- a/dev-packages/e2e-tests/test-applications/nestjs-11-static/src/instrument.ts
+++ b/dev-packages/e2e-tests/test-applications/nestjs-11-static/src/instrument.ts
@@ -10,4 +10,6 @@ Sentry.init({
// We expect the app to send a lot of events in a short time
bufferSize: 1000,
},
+ // The cron job throws the same error on every run, which Dedupe would drop after the first run.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nestjs-11/src/instrument.ts b/dev-packages/e2e-tests/test-applications/nestjs-11/src/instrument.ts
index 4f16ebb36d11..e1f373de1730 100644
--- a/dev-packages/e2e-tests/test-applications/nestjs-11/src/instrument.ts
+++ b/dev-packages/e2e-tests/test-applications/nestjs-11/src/instrument.ts
@@ -9,4 +9,6 @@ Sentry.init({
// We expect the app to send a lot of events in a short time
bufferSize: 1000,
},
+ // The cron job throws the same error on every run, which Dedupe would drop after the first run.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nestjs-12/src/instrument.ts b/dev-packages/e2e-tests/test-applications/nestjs-12/src/instrument.ts
index 4f16ebb36d11..e1f373de1730 100644
--- a/dev-packages/e2e-tests/test-applications/nestjs-12/src/instrument.ts
+++ b/dev-packages/e2e-tests/test-applications/nestjs-12/src/instrument.ts
@@ -9,4 +9,6 @@ Sentry.init({
// We expect the app to send a lot of events in a short time
bufferSize: 1000,
},
+ // The cron job throws the same error on every run, which Dedupe would drop after the first run.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nestjs-fastify/src/instrument.ts b/dev-packages/e2e-tests/test-applications/nestjs-fastify/src/instrument.ts
index 4f16ebb36d11..e1f373de1730 100644
--- a/dev-packages/e2e-tests/test-applications/nestjs-fastify/src/instrument.ts
+++ b/dev-packages/e2e-tests/test-applications/nestjs-fastify/src/instrument.ts
@@ -9,4 +9,6 @@ Sentry.init({
// We expect the app to send a lot of events in a short time
bufferSize: 1000,
},
+ // The cron job throws the same error on every run, which Dedupe would drop after the first run.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx
index a61f15ee7e3f..ed7d8d1716d8 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx
@@ -1,5 +1,6 @@
import type { ReactNode } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
// The awaited param puts the request id into the cache key, so a fresh id is a guaranteed miss
// and the entry cannot come from a build-time fill. `children` passes through as an uncached hole.
@@ -15,11 +16,14 @@ export default async function CachedMidLayout({
const { id } = await params;
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
-
- {id}:{Date.now()}
-
- {children}
-
+
+ Cached layout, dynamic page
+
+
+ {id}:{Date.now()}
+
+ {children}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx
index 94196e6e5ee8..1edb269289ba 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx
@@ -1,6 +1,11 @@
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function Page() {
await headers();
- return Dynamic leaf: {Date.now()}
;
+ return (
+
+ Dynamic leaf: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx
index 8e7de36d156a..494dee2483e2 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx
@@ -1,13 +1,16 @@
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
async function CachedLeaf({ id }: { id: string }) {
'use cache';
cacheLife('hours');
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
- {id}:{Date.now()}
-
+
+
+ {id}:{Date.now()}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx
index 412587fd8f33..4b9b4cffc9bf 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx
@@ -1,7 +1,16 @@
import type { ReactNode } from 'react';
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function DynamicLayout({ children }: { children: ReactNode }) {
await headers();
- return {children};
+ return (
+
+ Dynamic layout, cached leaf
+
+ request-time: {Date.now()}
+ {children}
+
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx
index 2b0b77b6e3a9..7920ef335dc2 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx
@@ -1,5 +1,6 @@
import type { ReactNode } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
// Hard-expires after 2s while the page's cached component lives for hours, so one request can
// refill the layout while hitting the component: two cached levels with different origin traces.
@@ -14,11 +15,14 @@ export default async function ShortLivedLayout({
cacheLife({ revalidate: 1, expire: 2 });
const { id } = await params;
return (
-
-
- {id}:{Date.now()}
-
- {children}
-
+
+ Mixed lifetimes
+
+
+ {id}:{Date.now()}
+
+ {children}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx
index 18913cbe9790..c1c0e31494f6 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx
@@ -1,19 +1,27 @@
import { headers } from 'next/headers';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function LongLivedComponent({ id }: { id: string }) {
'use cache';
cacheLife('hours');
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
- {id}:{Date.now()}
-
+
+
+ {id}:{Date.now()}
+
+
);
}
export default async function Page({ params }: { params: Promise<{ id: string }> }) {
const { id } = await params;
await headers();
- return
+ request-time: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx
index ec8d5e21d947..606b9f01a2b2 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx
@@ -1,6 +1,11 @@
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function Page() {
await headers();
- return Route a: {Date.now()}
;
+ return (
+
+ Route a: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx
index 9a1b84b2ca28..18bff4a0ed35 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx
@@ -1,6 +1,11 @@
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function Page() {
await headers();
- return Route b: {Date.now()}
;
+ return (
+
+ Route b: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx
index 220fdcf92ca8..16fa37dbd71e 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx
@@ -1,5 +1,6 @@
import type { ReactNode } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
// One cache entry (keyed by id) shared by the sibling routes `a` and `b` below.
export default async function SharedLayout({
@@ -14,11 +15,14 @@ export default async function SharedLayout({
const { id } = await params;
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
-
- {children}
-
+
+ Shared layout across sibling routes
+
+
+ {children}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/api/use-cache-swr/route.ts b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/api/use-cache-swr/route.ts
new file mode 100644
index 000000000000..0332efe522b3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/api/use-cache-swr/route.ts
@@ -0,0 +1,15 @@
+import { cacheLife } from 'next/cache';
+import type { NextRequest } from 'next/server';
+
+async function getSwrValue(id: string): Promise<{ id: string; createdAt: number }> {
+ 'use cache';
+ // After `revalidate` (2s), a read serves the stale value and triggers a background refill.
+ // `expire` is long so the entry stays valid for the whole test.
+ cacheLife({ stale: 5, revalidate: 2, expire: 300 });
+ return { id, createdAt: Date.now() };
+}
+
+export async function GET(request: NextRequest) {
+ const id = request.nextUrl.searchParams.get('id') ?? 'default-id';
+ return Response.json(await getSwrValue(id));
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/cached-sibling-components/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/cached-sibling-components/page.tsx
index c8b8858f7785..c3e4050539bb 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/cached-sibling-components/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/cached-sibling-components/page.tsx
@@ -1,14 +1,17 @@
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function CachedSection({ id, label }: { id: string; label: string }) {
'use cache';
cacheLife('hours');
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
- {label}:{id}:{Date.now()}
-
+
+
+ {label}:{id}:{Date.now()}
+
+
);
}
@@ -18,17 +21,21 @@ async function DynamicContent({ searchParams }: { searchParams: Promise<{ id?: s
// separate entries (the props are part of the cache key).
const { id = 'default-id' } = await searchParams;
return (
- <>
+
+ request-time: {Date.now()}
);
}
export default function Page({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
return (
- Loading...}>
-
+
+ Cached sibling components
+ Loading...}>
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/layout.tsx
index c8f9cee0b787..5ffd72655346 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/layout.tsx
@@ -1,7 +1,12 @@
export default function Layout({ children }: { children: React.ReactNode }) {
return (
- {children}
+
+
+ ← Cache scenarios
+
+ {children}
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/nested-caches/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/nested-caches/page.tsx
index 481d7e5e46e6..1115c4054b3f 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/nested-caches/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/nested-caches/page.tsx
@@ -1,5 +1,6 @@
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function getSlowChangingValue(id: string): Promise<{ id: string; createdAt: number }> {
'use cache';
@@ -14,20 +15,34 @@ async function ShortLivedSection({ id }: { id: string }) {
// delayed request refills the component and reads the nested entry as a hit inside that fill.
cacheLife({ revalidate: 1, expire: 2 });
const nested = await getSlowChangingValue(id);
- return {JSON.stringify({ ...nested, renderedAt: Date.now() })};
+ return (
+
+
+ {JSON.stringify({ ...nested, renderedAt: Date.now() })}
+
+
+ );
}
async function DynamicContent({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
// Awaiting searchParams makes this hole dynamic, so every request renders it and consults the
// cache handler instead of serving prerendered output.
const { id = 'default-id' } = await searchParams;
- return
+ request-time: {Date.now()}
+
+ );
}
export default function Page({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
return (
- Loading...}>
-
+
+ Nested caches with different lifetimes
+ Loading...}>
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/page.tsx
index 433db8283beb..bea2cf1d875f 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/page.tsx
@@ -1,3 +1,120 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+
+type Scenario = { name: string; href: (id: string) => string; description: string };
+
+const groups: { title: string; scenarios: Scenario[] }[] = [
+ {
+ title: 'Route handlers (JSON)',
+ scenarios: [
+ {
+ name: '/api/use-cache',
+ href: id => `/api/use-cache?id=${id}`,
+ description: 'cached function that lives for hours. The second request with the same id is a hit.',
+ },
+ {
+ name: '/api/use-cache-expiring',
+ href: id => `/api/use-cache-expiring?id=${id}`,
+ description: 'the entry expires after 2 seconds. Request again after 3 seconds for a refill.',
+ },
+ {
+ name: '/api/use-cache-swr',
+ href: id => `/api/use-cache-swr?id=${id}`,
+ description:
+ 'the entry goes stale after 2 seconds. A stale read serves the old value and refills in the background.',
+ },
+ ],
+ },
+ {
+ title: 'Rendered pages',
+ scenarios: [
+ {
+ name: '/use-cache-page',
+ href: id => `/use-cache-page?id=${id}`,
+ description: 'a cached data function inside a dynamic hole.',
+ },
+ {
+ name: '/cached-sibling-components',
+ href: id => `/cached-sibling-components?id=${id}`,
+ description: 'two cached sibling components. Each section is its own cache entry.',
+ },
+ {
+ name: '/nested-caches',
+ href: id => `/nested-caches?id=${id}`,
+ description:
+ 'a cached component that expires after 2 seconds and calls a cached function that lives for hours.',
+ },
+ ],
+ },
+ {
+ title: 'Nested layouts',
+ scenarios: [
+ {
+ name: '/cached-mid-layout/[id]',
+ href: id => `/cached-mid-layout/${id}`,
+ description: 'a cached layout above a dynamic page.',
+ },
+ {
+ name: '/dynamic-layouts/[id]/layout-cached-leaf',
+ href: id => `/dynamic-layouts/${id}/layout-cached-leaf`,
+ description: 'dynamic layouts above a cached leaf component.',
+ },
+ {
+ name: '/mixed-lifetimes/[id]',
+ href: id => `/mixed-lifetimes/${id}`,
+ description: 'a cached layout that expires after 2 seconds around a cached component that lives for hours.',
+ },
+ {
+ name: '/shared-layout/[id]/a',
+ href: id => `/shared-layout/${id}/a`,
+ description: 'route a fills the layout entry that routes a and b share.',
+ },
+ {
+ name: '/shared-layout/[id]/b',
+ href: id => `/shared-layout/${id}/b`,
+ description: 'route b hits the layout entry that route a filled.',
+ },
+ ],
+ },
+ {
+ title: 'Pageload',
+ scenarios: [
+ {
+ name: '/pageload-tracing',
+ href: () => '/pageload-tracing',
+ description: 'a prerendered shell with a dynamic hole. Check the pageload and server trace connection here.',
+ },
+ ],
+ },
+];
+
+// The links are plain `` elements so that every click is a full document request with its own
+// server trace. `` would navigate through the client-side router instead.
export default function Page() {
- return Next 16 CacheComponents test app
;
+ const [id, setId] = useState('');
+ // Generated after hydration so the prerendered shell does not bake in one fixed id.
+ useEffect(() => setId(crypto.randomUUID()), []);
+
+ return (
+
+ Next 16 Cache Components scenarios
+
+ Every link carries a random id that becomes part of the cache key. The first click fills the cache. A second
+ click on the same link, or a reload of the target page, hits it. Reload this page to get fresh ids.
+
+ {groups.map(group => (
+
+ {group.title}
+
+ {group.scenarios.map(scenario => (
+ -
+ {scenario.name}: {scenario.description}
+
+ ))}
+
+
+ ))}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/use-cache-page/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/use-cache-page/page.tsx
index 1e41b4436e20..3450928fe090 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/use-cache-page/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/app/use-cache-page/page.tsx
@@ -1,5 +1,6 @@
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function getCachedPageData(id: string): Promise<{ id: string; createdAt: number }> {
'use cache';
@@ -10,9 +11,12 @@ async function getCachedPageData(id: string): Promise<{ id: string; createdAt: n
export default function Page({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
return (
- Loading...}>
-
+
+ Cached data function in a page
+ Loading...}>
+
+
);
}
@@ -21,5 +25,12 @@ async function CachedContent({ searchParams }: { searchParams: Promise<{ id?: st
// cache handler instead of serving prerendered output.
const { id = 'default-id' } = await searchParams;
const data = await getCachedPageData(id);
- return {JSON.stringify(data)};
+ return (
+
+ request-time: {Date.now()}
+
+ {JSON.stringify(data)}
+
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/components/scenarioBox.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/components/scenarioBox.tsx
new file mode 100644
index 000000000000..cf2d318d64cc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/components/scenarioBox.tsx
@@ -0,0 +1,34 @@
+import type { CSSProperties, ReactNode } from 'react';
+
+const box: CSSProperties = {
+ padding: '8px 12px',
+ margin: '12px 0',
+ borderRadius: 8,
+};
+
+const badge: CSSProperties = {
+ display: 'inline-block',
+ fontSize: 12,
+ fontWeight: 600,
+ color: '#fff',
+ padding: '1px 8px',
+ borderRadius: 4,
+};
+
+export function CachedBox({ label, children }: { label: string; children: ReactNode }) {
+ return (
+
+ Cached · {label}
+ {children}
+
+ );
+}
+
+export function DynamicBox({ label, children }: { label: string; children: ReactNode }) {
+ return (
+
+ Dynamic · {label}
+ {children}
+
+ );
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/tests/cacheOriginLinks-revalidation.spec.ts b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/tests/cacheOriginLinks-revalidation.spec.ts
new file mode 100644
index 000000000000..50f88a41bdbb
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-cacheComponents/tests/cacheOriginLinks-revalidation.spec.ts
@@ -0,0 +1,113 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+// Background stale-while-revalidate refills. Target behavior: the revalidation gets its own trace,
+// separate from the request trace that served the stale value. The revalidation trace links back to
+// that request, and its `cache.put` becomes the `cache_origin` for future hits.
+
+/*
+
+Trace1 (fill) Trace2 (stale hit) Trace3 (hit)
+|- put key:A <----link-----o get hit=true key:A |- get hit=true key:A
+ ^ |
+ | link (type TBD in the spec) |
+TraceR: cache.revalidate --o (own trace) |
+| |
+|- put key:A <----------------------link-------------------o cache_origin
+
+*/
+
+// Not implemented yet. Unlike cacheOriginLinks-nesting.spec.ts, this test cannot document the
+// target behavior with `test.fail()`: it would wait for a `cache.revalidate` trace that never
+// arrives and time out, and Playwright reports a timeout as a real failure even under
+// `test.fail()`. So the test is `test.fixme()` until the SDK emits the revalidation trace.
+
+test('runs background revalidation in its own trace linked to the triggering request', async ({ request }) => {
+ test.skip(process.env.TEST_ENV !== 'production', 'SWR revalidation timing only holds in production');
+ test.fixme();
+
+ const id = crypto.randomUUID();
+
+ const fillTxPromise = waitForTransaction('nextjs-16-cacheComponents', transactionEvent => {
+ return (
+ transactionEvent.transaction === 'GET /api/use-cache-swr' &&
+ !!transactionEvent.spans?.some(span => span.op === 'cache.put')
+ );
+ });
+
+ await request.get(`/api/use-cache-swr?id=${id}`);
+ const fillTx = await fillTxPromise;
+
+ // Sleep past `revalidate` (2s) but not `expire`, so the next read serves the stale value and triggers a background refill.
+ await new Promise(resolve => setTimeout(resolve, 3_000));
+
+ const staleHitTxPromise = waitForTransaction('nextjs-16-cacheComponents', transactionEvent => {
+ return (
+ transactionEvent.transaction === 'GET /api/use-cache-swr' &&
+ !!transactionEvent.spans?.some(span => span.op === 'cache.get' && span.data?.['cache.hit'] === true)
+ );
+ });
+
+ const revalidationTxPromise = waitForTransaction('nextjs-16-cacheComponents', transactionEvent => {
+ return transactionEvent.contexts?.trace?.op === 'cache.revalidate';
+ });
+
+ await request.get(`/api/use-cache-swr?id=${id}`);
+ const staleHitTx = await staleHitTxPromise;
+
+ const fillPutSpan = fillTx.spans?.find(span => span.op === 'cache.put');
+ expect(fillPutSpan).toBeDefined();
+
+ // The stale response still came from the original fill.
+ const staleHitGetSpan = staleHitTx.spans?.find(span => span.op === 'cache.get' && span.data?.['cache.hit'] === true);
+ expect(staleHitGetSpan).toBeDefined();
+ expect(staleHitGetSpan?.links).toEqual([
+ {
+ trace_id: fillTx.contexts?.trace?.trace_id,
+ span_id: fillPutSpan!.span_id,
+ sampled: true,
+ attributes: { 'sentry.link.type': 'cache_origin' },
+ },
+ ]);
+
+ // The visitor never waited for the refill, so the refill is not part of the serving trace: the
+ // background revalidation is its own trace, linked back to the request that triggered it.
+ const revalidationTx = await revalidationTxPromise;
+ expect(revalidationTx.contexts?.trace?.trace_id).not.toBe(staleHitTx.contexts?.trace?.trace_id);
+ expect(revalidationTx.contexts?.trace?.links).toEqual([
+ {
+ trace_id: staleHitTx.contexts?.trace?.trace_id,
+ span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
+ sampled: true,
+ // No link type for cache spans specced yet, so assert only the link target.
+ attributes: { 'sentry.link.type': expect.any(String) },
+ },
+ ]);
+
+ const revalidationPutSpan = revalidationTx.spans?.find(span => span.op === 'cache.put');
+ expect(revalidationPutSpan).toBeDefined();
+
+ // The revalidation's `cache.put` becomes the `cache_origin` for future hits.
+ const hitAfterRefillTxPromise = waitForTransaction('nextjs-16-cacheComponents', transactionEvent => {
+ return (
+ transactionEvent.transaction === 'GET /api/use-cache-swr' &&
+ !!transactionEvent.spans?.some(span => span.op === 'cache.get' && span.data?.['cache.hit'] === true)
+ );
+ });
+
+ await request.get(`/api/use-cache-swr?id=${id}`);
+ const hitAfterRefillTx = await hitAfterRefillTxPromise;
+
+ const hitAfterRefillGetSpan = hitAfterRefillTx.spans?.find(
+ span => span.op === 'cache.get' && span.data?.['cache.hit'] === true,
+ );
+ expect(hitAfterRefillGetSpan).toBeDefined();
+ expect(hitAfterRefillGetSpan?.links).toEqual([
+ {
+ trace_id: revalidationTx.contexts?.trace?.trace_id,
+ span_id: revalidationPutSpan!.span_id,
+ sampled: true,
+ attributes: { 'sentry.link.type': 'cache_origin' },
+ },
+ ]);
+});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx
index a61f15ee7e3f..ed7d8d1716d8 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/layout.tsx
@@ -1,5 +1,6 @@
import type { ReactNode } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
// The awaited param puts the request id into the cache key, so a fresh id is a guaranteed miss
// and the entry cannot come from a build-time fill. `children` passes through as an uncached hole.
@@ -15,11 +16,14 @@ export default async function CachedMidLayout({
const { id } = await params;
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
-
- {id}:{Date.now()}
-
- {children}
-
+
+ Cached layout, dynamic page
+
+
+ {id}:{Date.now()}
+
+ {children}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx
index 94196e6e5ee8..1edb269289ba 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/cached-mid-layout/[id]/page.tsx
@@ -1,6 +1,11 @@
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function Page() {
await headers();
- return Dynamic leaf: {Date.now()}
;
+ return (
+
+ Dynamic leaf: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx
index 8e7de36d156a..494dee2483e2 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout-cached-leaf/page.tsx
@@ -1,13 +1,16 @@
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
async function CachedLeaf({ id }: { id: string }) {
'use cache';
cacheLife('hours');
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
- {id}:{Date.now()}
-
+
+
+ {id}:{Date.now()}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx
index 412587fd8f33..4b9b4cffc9bf 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/dynamic-layouts/[id]/layout.tsx
@@ -1,7 +1,16 @@
import type { ReactNode } from 'react';
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function DynamicLayout({ children }: { children: ReactNode }) {
await headers();
- return {children};
+ return (
+
+ Dynamic layout, cached leaf
+
+ request-time: {Date.now()}
+ {children}
+
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx
index 2b0b77b6e3a9..7920ef335dc2 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/layout.tsx
@@ -1,5 +1,6 @@
import type { ReactNode } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
// Hard-expires after 2s while the page's cached component lives for hours, so one request can
// refill the layout while hitting the component: two cached levels with different origin traces.
@@ -14,11 +15,14 @@ export default async function ShortLivedLayout({
cacheLife({ revalidate: 1, expire: 2 });
const { id } = await params;
return (
-
-
- {id}:{Date.now()}
-
- {children}
-
+
+ Mixed lifetimes
+
+
+ {id}:{Date.now()}
+
+ {children}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx
index 18913cbe9790..c1c0e31494f6 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/mixed-lifetimes/[id]/page.tsx
@@ -1,19 +1,27 @@
import { headers } from 'next/headers';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function LongLivedComponent({ id }: { id: string }) {
'use cache';
cacheLife('hours');
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
- {id}:{Date.now()}
-
+
+
+ {id}:{Date.now()}
+
+
);
}
export default async function Page({ params }: { params: Promise<{ id: string }> }) {
const { id } = await params;
await headers();
- return
+ request-time: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx
index ec8d5e21d947..606b9f01a2b2 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/a/page.tsx
@@ -1,6 +1,11 @@
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function Page() {
await headers();
- return Route a: {Date.now()}
;
+ return (
+
+ Route a: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx
index 9a1b84b2ca28..18bff4a0ed35 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/b/page.tsx
@@ -1,6 +1,11 @@
import { headers } from 'next/headers';
+import { DynamicBox } from '@/components/scenarioBox';
export default async function Page() {
await headers();
- return Route b: {Date.now()}
;
+ return (
+
+ Route b: {Date.now()}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx
index 220fdcf92ca8..16fa37dbd71e 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/(cached-nesting)/shared-layout/[id]/layout.tsx
@@ -1,5 +1,6 @@
import type { ReactNode } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox } from '@/components/scenarioBox';
// One cache entry (keyed by id) shared by the sibling routes `a` and `b` below.
export default async function SharedLayout({
@@ -14,11 +15,14 @@ export default async function SharedLayout({
const { id } = await params;
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
-
- {children}
-
+
+ Shared layout across sibling routes
+
+
+ {children}
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/api/use-cache-swr/route.ts b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/api/use-cache-swr/route.ts
new file mode 100644
index 000000000000..0332efe522b3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/api/use-cache-swr/route.ts
@@ -0,0 +1,15 @@
+import { cacheLife } from 'next/cache';
+import type { NextRequest } from 'next/server';
+
+async function getSwrValue(id: string): Promise<{ id: string; createdAt: number }> {
+ 'use cache';
+ // After `revalidate` (2s), a read serves the stale value and triggers a background refill.
+ // `expire` is long so the entry stays valid for the whole test.
+ cacheLife({ stale: 5, revalidate: 2, expire: 300 });
+ return { id, createdAt: Date.now() };
+}
+
+export async function GET(request: NextRequest) {
+ const id = request.nextUrl.searchParams.get('id') ?? 'default-id';
+ return Response.json(await getSwrValue(id));
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/cached-sibling-components/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/cached-sibling-components/page.tsx
index c8b8858f7785..c3e4050539bb 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/cached-sibling-components/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/cached-sibling-components/page.tsx
@@ -1,14 +1,17 @@
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function CachedSection({ id, label }: { id: string; label: string }) {
'use cache';
cacheLife('hours');
await new Promise(resolve => setTimeout(resolve, 100));
return (
-
- {label}:{id}:{Date.now()}
-
+
+
+ {label}:{id}:{Date.now()}
+
+
);
}
@@ -18,17 +21,21 @@ async function DynamicContent({ searchParams }: { searchParams: Promise<{ id?: s
// separate entries (the props are part of the cache key).
const { id = 'default-id' } = await searchParams;
return (
- <>
+
+ request-time: {Date.now()}
);
}
export default function Page({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
return (
- Loading...}>
-
+
+ Cached sibling components
+ Loading...}>
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/layout.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/layout.tsx
index c8f9cee0b787..5ffd72655346 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/layout.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/layout.tsx
@@ -1,7 +1,12 @@
export default function Layout({ children }: { children: React.ReactNode }) {
return (
- {children}
+
+
+ ← Cache scenarios
+
+ {children}
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/nested-caches/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/nested-caches/page.tsx
index 481d7e5e46e6..1115c4054b3f 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/nested-caches/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/nested-caches/page.tsx
@@ -1,5 +1,6 @@
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
+import { CachedBox, DynamicBox } from '@/components/scenarioBox';
async function getSlowChangingValue(id: string): Promise<{ id: string; createdAt: number }> {
'use cache';
@@ -14,20 +15,34 @@ async function ShortLivedSection({ id }: { id: string }) {
// delayed request refills the component and reads the nested entry as a hit inside that fill.
cacheLife({ revalidate: 1, expire: 2 });
const nested = await getSlowChangingValue(id);
- return {JSON.stringify({ ...nested, renderedAt: Date.now() })};
+ return (
+
+
+ {JSON.stringify({ ...nested, renderedAt: Date.now() })}
+
+
+ );
}
async function DynamicContent({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
// Awaiting searchParams makes this hole dynamic, so every request renders it and consults the
// cache handler instead of serving prerendered output.
const { id = 'default-id' } = await searchParams;
- return
+ request-time: {Date.now()}
+
+ );
}
export default function Page({ searchParams }: { searchParams: Promise<{ id?: string }> }) {
return (
- Loading...}>
-
+
+ Nested caches with different lifetimes
+ Loading...}>
+
+
);
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/page.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/page.tsx
index 433db8283beb..8f7d5cf7558e 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/page.tsx
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/app/page.tsx
@@ -1,3 +1,115 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+
+type Scenario = { name: string; href: (id: string) => string; description: string };
+
+const groups: { title: string; scenarios: Scenario[] }[] = [
+ {
+ title: 'Route handlers (JSON)',
+ scenarios: [
+ {
+ name: '/api/use-cache',
+ href: id => `/api/use-cache?id=${id}`,
+ description: 'cached function that lives for hours. The second request with the same id is a hit.',
+ },
+ {
+ name: '/api/use-cache-expiring',
+ href: id => `/api/use-cache-expiring?id=${id}`,
+ description: 'the entry expires after 2 seconds. Request again after 3 seconds for a refill.',
+ },
+ {
+ name: '/api/use-cache-swr',
+ href: id => `/api/use-cache-swr?id=${id}`,
+ description:
+ 'the entry goes stale after 2 seconds. A stale read serves the old value and refills in the background.',
+ },
+ ],
+ },
+ {
+ title: 'Rendered pages',
+ scenarios: [
+ {
+ name: '/cached-sibling-components',
+ href: id => `/cached-sibling-components?id=${id}`,
+ description: 'two cached sibling components. Each section is its own cache entry.',
+ },
+ {
+ name: '/nested-caches',
+ href: id => `/nested-caches?id=${id}`,
+ description:
+ 'a cached component that expires after 2 seconds and calls a cached function that lives for hours.',
+ },
+ ],
+ },
+ {
+ title: 'Nested layouts',
+ scenarios: [
+ {
+ name: '/cached-mid-layout/[id]',
+ href: id => `/cached-mid-layout/${id}`,
+ description: 'a cached layout above a dynamic page.',
+ },
+ {
+ name: '/dynamic-layouts/[id]/layout-cached-leaf',
+ href: id => `/dynamic-layouts/${id}/layout-cached-leaf`,
+ description: 'dynamic layouts above a cached leaf component.',
+ },
+ {
+ name: '/mixed-lifetimes/[id]',
+ href: id => `/mixed-lifetimes/${id}`,
+ description: 'a cached layout that expires after 2 seconds around a cached component that lives for hours.',
+ },
+ {
+ name: '/shared-layout/[id]/a',
+ href: id => `/shared-layout/${id}/a`,
+ description: 'route a fills the layout entry that routes a and b share.',
+ },
+ {
+ name: '/shared-layout/[id]/b',
+ href: id => `/shared-layout/${id}/b`,
+ description: 'route b hits the layout entry that route a filled.',
+ },
+ ],
+ },
+ {
+ title: 'Pageload',
+ scenarios: [
+ {
+ name: '/pageload-tracing',
+ href: () => '/pageload-tracing',
+ description: 'a prerendered shell with a dynamic hole. Check the pageload and server trace connection here.',
+ },
+ ],
+ },
+];
+
+// The links are plain `` elements so that every click is a full document request with its own
+// server trace. `` would navigate through the client-side router instead.
export default function Page() {
- return Next 16 CacheComponents test app
;
+ const [id, setId] = useState('');
+ // Generated after hydration so the prerendered shell does not bake in one fixed id.
+ useEffect(() => setId(crypto.randomUUID()), []);
+
+ return (
+
+ Next 16 Cache Components scenarios (span streaming)
+
+ Every link carries a random id that becomes part of the cache key. The first click fills the cache. A second
+ click on the same link, or a reload of the target page, hits it. Reload this page to get fresh ids.
+
+ {groups.map(group => (
+
+ {group.title}
+
+ {group.scenarios.map(scenario => (
+ -
+ {scenario.name}: {scenario.description}
+
+ ))}
+
+
+ ))}
+
+ );
}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/components/scenarioBox.tsx b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/components/scenarioBox.tsx
new file mode 100644
index 000000000000..cf2d318d64cc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/components/scenarioBox.tsx
@@ -0,0 +1,34 @@
+import type { CSSProperties, ReactNode } from 'react';
+
+const box: CSSProperties = {
+ padding: '8px 12px',
+ margin: '12px 0',
+ borderRadius: 8,
+};
+
+const badge: CSSProperties = {
+ display: 'inline-block',
+ fontSize: 12,
+ fontWeight: 600,
+ color: '#fff',
+ padding: '1px 8px',
+ borderRadius: 4,
+};
+
+export function CachedBox({ label, children }: { label: string; children: ReactNode }) {
+ return (
+
+ Cached · {label}
+ {children}
+
+ );
+}
+
+export function DynamicBox({ label, children }: { label: string; children: ReactNode }) {
+ return (
+
+ Dynamic · {label}
+ {children}
+
+ );
+}
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/tests/cacheOriginLinks-revalidation.spec.ts b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/tests/cacheOriginLinks-revalidation.spec.ts
new file mode 100644
index 000000000000..b6aa21aa89c2
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/tests/cacheOriginLinks-revalidation.spec.ts
@@ -0,0 +1,119 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
+import { CACHE_ORIGIN_LINK_ATTRIBUTES, findCacheSpan } from './cacheOriginLinks-utils';
+
+// Background stale-while-revalidate refills. Target behavior: the revalidation gets its own trace,
+// separate from the request trace that served the stale value. The revalidation trace links back to
+// that request, and its `cache.put` becomes the `cache_origin` for future hits.
+
+/*
+
+Trace1 (fill) Trace2 (stale hit) Trace3 (hit)
+|- put key:A <----link-----o get hit=true key:A |- get hit=true key:A
+ ^ |
+ | link (type TBD in the spec) |
+TraceR: cache.revalidate --o (own trace) |
+| |
+|- put key:A <----------------------link-------------------o cache_origin
+
+*/
+
+// Not implemented yet. Unlike cacheOriginLinks-nesting.spec.ts, this test cannot document the
+// target behavior with `test.fail()`: it would wait for a `cache.revalidate` trace that never
+// arrives and time out, and Playwright reports a timeout as a real failure even under
+// `test.fail()`. So the test is `test.fixme()` until the SDK emits the revalidation trace.
+
+test('runs background revalidation in its own trace linked to the triggering request', async ({ request }) => {
+ test.skip(process.env.TEST_ENV !== 'production', 'SWR revalidation timing only holds in production');
+ test.fixme();
+
+ const id = crypto.randomUUID();
+
+ const fillSpansPromise = collectStreamedSpans('nextjs-16-streaming-cacheComponents', spansOfTrace => {
+ return (
+ spansOfTrace.some(span => span.name === 'GET /api/use-cache-swr' && span.is_segment) &&
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.put')
+ );
+ });
+
+ await request.get(`/api/use-cache-swr?id=${id}`);
+ const fillSpans = await fillSpansPromise;
+
+ // Sleep past `revalidate` (2s) but not `expire`, so the next read serves the stale value and
+ // triggers a background refill.
+ await new Promise(resolve => setTimeout(resolve, 3_000));
+
+ const staleHitSpansPromise = collectStreamedSpans('nextjs-16-streaming-cacheComponents', spansOfTrace => {
+ return (
+ spansOfTrace.some(span => span.name === 'GET /api/use-cache-swr' && span.is_segment) &&
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.get' && span.attributes['cache.hit']?.value === true)
+ );
+ });
+
+ // The visitor never waited for the refill, so the refill is not part of the serving trace: the
+ // background revalidation is its own trace with a `cache.revalidate` segment.
+ const revalidationSpansPromise = collectStreamedSpans('nextjs-16-streaming-cacheComponents', spansOfTrace => {
+ return (
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.revalidate' && span.is_segment) &&
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.put')
+ );
+ });
+
+ await request.get(`/api/use-cache-swr?id=${id}`);
+ const staleHitSpans = await staleHitSpansPromise;
+
+ const fillPutSpan = findCacheSpan(fillSpans, 'cache.put');
+ expect(fillPutSpan).toBeDefined();
+
+ // The stale response still came from the original fill.
+ const staleHitGetSpan = findCacheSpan(staleHitSpans, 'cache.get', true);
+ expect(staleHitGetSpan).toBeDefined();
+ expect(staleHitGetSpan?.links).toEqual([
+ {
+ trace_id: fillPutSpan!.trace_id,
+ span_id: fillPutSpan!.span_id,
+ sampled: true,
+ attributes: CACHE_ORIGIN_LINK_ATTRIBUTES,
+ },
+ ]);
+
+ const revalidationSpans = await revalidationSpansPromise;
+ const revalidationSegment = revalidationSpans.find(span => span.is_segment && getSpanOp(span) === 'cache.revalidate');
+ expect(revalidationSegment).toBeDefined();
+ expect(revalidationSegment!.trace_id).not.toBe(staleHitGetSpan!.trace_id);
+ expect(revalidationSegment!.links).toEqual([
+ {
+ trace_id: staleHitGetSpan!.trace_id,
+ span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
+ sampled: true,
+ // No link type for cache spans specced yet, so assert only the link target.
+ attributes: { 'sentry.link.type': { value: expect.any(String), type: 'string' } },
+ },
+ ]);
+
+ const revalidationPutSpan = findCacheSpan(revalidationSpans, 'cache.put');
+ expect(revalidationPutSpan).toBeDefined();
+
+ // The revalidation's `cache.put` becomes the `cache_origin` for future hits.
+ const hitAfterRefillSpansPromise = collectStreamedSpans('nextjs-16-streaming-cacheComponents', spansOfTrace => {
+ return (
+ spansOfTrace.some(span => span.name === 'GET /api/use-cache-swr' && span.is_segment) &&
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.get' && span.attributes['cache.hit']?.value === true) &&
+ spansOfTrace.every(span => span.trace_id !== staleHitGetSpan!.trace_id)
+ );
+ });
+
+ await request.get(`/api/use-cache-swr?id=${id}`);
+ const hitAfterRefillSpans = await hitAfterRefillSpansPromise;
+
+ const hitAfterRefillGetSpan = findCacheSpan(hitAfterRefillSpans, 'cache.get', true);
+ expect(hitAfterRefillGetSpan).toBeDefined();
+ expect(hitAfterRefillGetSpan?.links).toEqual([
+ {
+ trace_id: revalidationPutSpan!.trace_id,
+ span_id: revalidationPutSpan!.span_id,
+ sampled: true,
+ attributes: CACHE_ORIGIN_LINK_ATTRIBUTES,
+ },
+ ]);
+});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/tests/useCacheSpans.spec.ts b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/tests/useCacheSpans.spec.ts
new file mode 100644
index 000000000000..2704de1a11f6
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-streaming-cacheComponents/tests/useCacheSpans.spec.ts
@@ -0,0 +1,33 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
+import { findCacheSpan } from './cacheOriginLinks-utils';
+
+test('uses low-cardinality names for `use cache` spans', async ({ request }) => {
+ // A fresh id makes the request a guaranteed cache miss (the id is part of the cache key), so the
+ // trace contains both a `cache.get` and a `cache.put` span.
+ const id = crypto.randomUUID();
+
+ const spansPromise = collectStreamedSpans('nextjs-16-streaming-cacheComponents', spansOfTrace => {
+ return (
+ spansOfTrace.some(span => span.name === 'GET /api/use-cache' && span.is_segment) &&
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.get') &&
+ spansOfTrace.some(span => getSpanOp(span) === 'cache.put')
+ );
+ });
+
+ await request.get(`/api/use-cache?id=${id}`);
+ const spans = await spansPromise;
+
+ // With span streaming the span name is the low-cardinality op; the key digest stays on
+ // `cache.key`, where Relay reads the span description from.
+ const getSpan = findCacheSpan(spans, 'cache.get');
+ expect(getSpan).toBeDefined();
+ expect(getSpan!.name).toBe('cache.get');
+ const cacheKeyDigest = getSpan!.attributes['cache.key']?.value;
+ expect(cacheKeyDigest).toEqual([expect.stringMatching(/^[0-9a-f]{12}$/)]);
+
+ const putSpan = findCacheSpan(spans, 'cache.put');
+ expect(putSpan).toBeDefined();
+ expect(putSpan!.name).toBe('cache.put');
+ expect(putSpan!.attributes['cache.key']?.value).toEqual(cacheKeyDigest);
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-mastra/src/mastra/index.ts b/dev-packages/e2e-tests/test-applications/node-mastra/src/mastra/index.ts
index 71ad1709ad55..b6f2dd975b39 100644
--- a/dev-packages/e2e-tests/test-applications/node-mastra/src/mastra/index.ts
+++ b/dev-packages/e2e-tests/test-applications/node-mastra/src/mastra/index.ts
@@ -26,6 +26,11 @@ export const mastra = new Mastra({
port: 4111,
apiRoutes: [manualRoute],
},
+ // No `bundler.externals` override: `mastra build` defaults to externalizing all non-workspace deps,
+ // so Hono (and the other instrumented modules) stay unbundled and the `--import` orchestrion hook
+ // can transform them in prod. In `mastra dev` the bundler inlines its own Hono-based server
+ // framework into the entry regardless of any `externals` config, so Hono is not
+ // orchestrion-instrumented in dev — the tests assert the un-routed span name there.
});
/**
diff --git a/dev-packages/e2e-tests/test-applications/node-mastra/tests/manual-route.test.ts b/dev-packages/e2e-tests/test-applications/node-mastra/tests/manual-route.test.ts
index e3aa759000cc..f287cc794217 100644
--- a/dev-packages/e2e-tests/test-applications/node-mastra/tests/manual-route.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-mastra/tests/manual-route.test.ts
@@ -3,6 +3,12 @@ import { collectStreamedSpans, getSpanOp, SerializedStreamedSpan } from '@sentry
const APP = 'node-mastra';
+// In `mastra dev`, Mastra inlines its Hono-based server into the dev bundle, so the `--import`
+// orchestrion hook cannot transform Hono and the request span is not route-enriched: its name is the
+// bare method and it carries no `http.route`/route name source. In prod (`mastra build`/`start`) Hono
+// is external and fully instrumented, so the span is named after the matched route.
+const IS_DEV = process.env.TEST_ENV === 'development';
+
const attrValue = (span: SerializedStreamedSpan, key: string): unknown => span.attributes?.[key]?.value;
// A plain custom route registered on the Mastra (Hono) server — see the
@@ -21,19 +27,17 @@ test('wraps a custom Mastra route in an http.server span with correct attributes
await res.json();
const spans = await spansPromise;
- const serverSpan = spans.find(isManualRouteServerSpan);
+ const serverSpan = spans.find(isManualRouteServerSpan)!;
expect(serverSpan).toBeDefined();
- expect(getSpanOp(serverSpan!)).toBe('http.server');
- expect(serverSpan!.name).toBe('GET');
- expect(attrValue(serverSpan!, 'http.request.method')).toBe('GET');
- expect(attrValue(serverSpan!, 'http.response.status_code')).toBe(200);
- expect(String(attrValue(serverSpan!, 'url.full') ?? '')).toContain('/manual-route');
-
- // Codifies current behavior: the transaction name is derived from the URL path,
- // not a route pattern. Mastra serves custom routes through Hono, which Sentry
- // does not route-instrument the way it does Express — so there is no `http.route`
- // attribute and the name source is `url` (an Express route would give `route`).
- expect(attrValue(serverSpan!, 'sentry.segment.name.source')).toBe('url');
- expect(attrValue(serverSpan!, 'http.route')).toBeUndefined();
+ expect(getSpanOp(serverSpan)).toBe('http.server');
+ expect(attrValue(serverSpan, 'http.request.method')).toBe('GET');
+ expect(attrValue(serverSpan, 'http.response.status_code')).toBe(200);
+ expect(String(attrValue(serverSpan, 'url.full') ?? '')).toContain('/manual-route');
+ expect(serverSpan.name).toBe(IS_DEV ? 'GET' : 'GET /manual-route');
+
+ if (!IS_DEV) {
+ expect(attrValue(serverSpan, 'sentry.segment.name.source')).toBe('route');
+ expect(attrValue(serverSpan, 'http.route')).toBe('/manual-route');
+ }
});
diff --git a/dev-packages/e2e-tests/test-applications/node-mastra/tests/mastra.test.ts b/dev-packages/e2e-tests/test-applications/node-mastra/tests/mastra.test.ts
index ef68fdf82b9a..7927a8f9531a 100644
--- a/dev-packages/e2e-tests/test-applications/node-mastra/tests/mastra.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-mastra/tests/mastra.test.ts
@@ -4,6 +4,12 @@ import { runAgentTurn } from './utils';
const APP = 'node-mastra';
+// In `mastra dev`, Mastra inlines its Hono-based server into the dev bundle, so the `--import`
+// orchestrion hook cannot transform Hono and the root request span is not route-enriched: its name is
+// the bare method and it carries no `http.route`/route name source. In prod (`mastra build`/`start`)
+// Hono is external and fully instrumented, so the span is named after the matched route.
+const IS_DEV = process.env.TEST_ENV === 'development';
+
const attrValue = (span: SerializedStreamedSpan, key: string): unknown => span.attributes?.[key]?.value;
const MASTRA_ORIGIN = 'auto.ai.mastra';
@@ -34,11 +40,16 @@ test('captures Mastra agent spans (invoke_agent, chat, execute_tool) with inputs
// across envelopes until the agent/model spans have also arrived. Tool spans are
// matched by op alone (not origin), so a double-instrumented span is collected
// too and caught by the assertions below.
+ const isGenerateServerSpan = (span: SerializedStreamedSpan): boolean =>
+ isOp('http.server')(span) && String(attrValue(span, 'url.full') ?? '').includes('/api/agents/');
+
const traceSpansPromise = collectStreamedSpans(
APP,
spansOfTrace =>
spansOfTrace.some(callsTool('get_weather')) &&
- ['gen_ai.invoke_agent', 'gen_ai.chat'].every(op => spansOfTrace.some(isOp(op))),
+ ['gen_ai.invoke_agent', 'gen_ai.chat'].every(op => spansOfTrace.some(isOp(op))) &&
+ // The root `http.server` span ends (and streams) after its children, so wait for it too.
+ spansOfTrace.some(isGenerateServerSpan),
);
await runAgentTurn(baseURL!, 'What is the weather in Paris?', { thread, resource: 'e2e-user' });
@@ -96,6 +107,24 @@ test('captures Mastra agent spans (invoke_agent, chat, execute_tool) with inputs
expect(attrValue(invokeAgent!, 'gen_ai.conversation.id')).toBe(thread);
expect(attrValue(chat!, 'gen_ai.conversation.id')).toBe(thread);
expect(attrValue(executeTool!, 'gen_ai.conversation.id')).toBe(thread);
+
+ // http.server span: Mastra serves the agent through its internal Hono server, so the incoming
+ // `POST /api/agents/weatherAgent/generate` request is the root `http.server` span of this trace,
+ // and the AI spans above are its children.
+ const serverSpan = traceSpans.find(isGenerateServerSpan);
+ expect(serverSpan).toBeDefined();
+ expect(getSpanOp(serverSpan!)).toBe('http.server');
+ expect(attrValue(serverSpan!, 'http.request.method')).toBe('POST');
+ expect(attrValue(serverSpan!, 'http.response.status_code')).toBe(200);
+ expect(String(attrValue(serverSpan!, 'url.full') ?? '')).toContain('/api/agents/weatherAgent/generate');
+
+ if (IS_DEV) {
+ expect(serverSpan!.name).toBe('POST');
+ } else {
+ expect(attrValue(serverSpan!, 'sentry.segment.name.source')).toBe('route');
+ expect(attrValue(serverSpan!, 'http.route')).toMatch(/^\/api\/agents\/:[^/]+\/generate$/);
+ expect(serverSpan!.name).toMatch(/^POST \/api\/agents\/:[^/]+\/generate$/);
+ }
});
test('captures a Mastra tool error as an issue and marks the tool span', async ({ baseURL }) => {
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3-top-level-import/sentry.server.config.ts b/dev-packages/e2e-tests/test-applications/nuxt-3-top-level-import/sentry.server.config.ts
index f08dea23ae03..688c63d7f00c 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-3-top-level-import/sentry.server.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-3-top-level-import/sentry.server.config.ts
@@ -6,4 +6,6 @@ Sentry.init({
tracesSampleRate: 1.0, // Capture 100% of the transactions
tunnel: 'http://localhost:3031/', // proxy server
debug: !!process.env.DEBUG,
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4-static/sentry.server.config.ts b/dev-packages/e2e-tests/test-applications/nuxt-4-static/sentry.server.config.ts
index 626a375fe574..d954cf92b242 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4-static/sentry.server.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4-static/sentry.server.config.ts
@@ -8,4 +8,6 @@ Sentry.init({
// Opt into the Sentry OpenTelemetry tracer provider in the "(tracer provider)" e2e variant.
// Leaving it `undefined` otherwise keeps the SDK's default (no provider).
enableOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? true : undefined,
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/docker-compose.yml b/dev-packages/e2e-tests/test-applications/nuxt-4/docker-compose.yml
index a50a0097e5ae..c87cae49aab6 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4/docker-compose.yml
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/docker-compose.yml
@@ -17,6 +17,22 @@ services:
retries: 30
start_period: 10s
+ mongo:
+ image: mongo:8
+ restart: always
+ container_name: e2e-tests-nuxt-4-mongo
+ ports:
+ - '27017:27017'
+ environment:
+ MONGO_INITDB_ROOT_USERNAME: root
+ MONGO_INITDB_ROOT_PASSWORD: docker
+ healthcheck:
+ test: ['CMD-SHELL', 'mongosh --quiet --eval "db.adminCommand(''ping'').ok"']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 10s
+
redis:
image: redis:7
restart: always
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/global-setup.mjs b/dev-packages/e2e-tests/test-applications/nuxt-4/global-setup.mjs
index cb48d539c466..4d0386045cb1 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4/global-setup.mjs
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/global-setup.mjs
@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
const __dirname = dirname(fileURLToPath(import.meta.url));
export default async function globalSetup() {
- // Start MySQL + Redis via Docker Compose. `--wait` blocks until the
+ // Start MySQL, MongoDB, and Redis via Docker Compose. `--wait` blocks until the
// healthchecks in docker-compose.yml pass, so the app can connect immediately.
execSync('docker compose up -d --wait', {
cwd: __dirname,
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/package.json b/dev-packages/e2e-tests/test-applications/nuxt-4/package.json
index 9eb23775a79b..ac1ea1939999 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4/package.json
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/package.json
@@ -23,6 +23,7 @@
"@pinia/nuxt": "^0.5.5",
"@sentry/nuxt": "file:../../packed/sentry-nuxt-packed.tgz",
"ioredis": "5.10.1",
+ "mongoose": "^9.10.2",
"mysql": "^2.18.1",
"nuxt": "^4.1.2"
},
@@ -31,8 +32,7 @@
"@sentry-internal/test-utils": "link:../../../test-utils"
},
"volta": {
- "extends": "../../package.json",
- "node": "22.20.0"
+ "extends": "../../package.json"
},
"sentryTest": {
"variants": [
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/sentry.server.config.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/sentry.server.config.ts
index 50ea077473eb..acce04cc9d04 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4/sentry.server.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/sentry.server.config.ts
@@ -7,4 +7,6 @@ Sentry.init({
// Opt into the Sentry OpenTelemetry tracer provider in the "(tracer provider)" e2e variant.
// Leaving it `undefined` otherwise keeps the SDK's default (no provider).
enableOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? true : undefined,
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/db-mongoose.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/db-mongoose.ts
new file mode 100644
index 000000000000..6a203cceaa9e
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/db-mongoose.ts
@@ -0,0 +1,19 @@
+import { defineEventHandler } from '#imports';
+import mongoose from 'mongoose';
+
+const BlogPost = mongoose.model('BlogPost', new mongoose.Schema({ title: String }));
+
+// SCRAM-SHA-1 on purpose: this handshake lazily `require()`s the `crypto` builtin inside a try
+// block, which only works when the bundled driver gets a real interop for builtin requires (#24775).
+const MONGO_URL = 'mongodb://root:docker@127.0.0.1:27017/test?authSource=admin&authMechanism=SCRAM-SHA-1';
+
+export default defineEventHandler(async () => {
+ if (mongoose.connection.readyState !== mongoose.ConnectionStates.connected) {
+ await mongoose.connect(MONGO_URL);
+ }
+
+ await new BlogPost({ title: 'test-post' }).save();
+ const found = await BlogPost.findOne({ title: 'test-post' });
+
+ return { title: found?.title };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/tests/db-drivers.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/tests/db-drivers.test.ts
index a093dd9e8d67..5b1bccedab4d 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4/tests/db-drivers.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/tests/db-drivers.test.ts
@@ -67,6 +67,46 @@ test('Instruments ioredis automatically', async ({ baseURL }) => {
);
});
+// The Nitro bundle force-inlines the instrumented drivers while their CommonJS dependencies and
+// Node builtins stay external, and every `require()` across that boundary needs working interop.
+test('Instruments mongoose automatically', async ({ baseURL }) => {
+ const spansPromise = collectRequestSpans('/api/db-mongoose');
+
+ const response = await fetch(`${baseURL}/api/db-mongoose`);
+ expect(response.status).toBe(200);
+ await expect(response.json()).resolves.toEqual({ title: 'test-post' });
+
+ const spans = await spansPromise;
+
+ const rootSpan = spans.find(span => span.is_segment);
+ expect(rootSpan).toBeDefined();
+ expect(getSpanOp(rootSpan!)).toBe('http.server');
+
+ const mongooseSpans = spans.filter(
+ span => span.attributes['sentry.origin']?.value === 'auto.db.mongoose.diagnostic_channel',
+ );
+ expect(mongooseSpans).toHaveLength(2);
+
+ const saveSpan = mongooseSpans.find(span => span.name === 'save blogposts');
+ expect(saveSpan?.status).toBe('ok');
+ expect(saveSpan?.is_segment).toBe(false);
+ expect(saveSpan?.attributes['sentry.op']).toEqual({ type: 'string', value: 'db' });
+ expect(saveSpan?.attributes['db.system.name']).toEqual({ type: 'string', value: 'mongodb' });
+ expect(saveSpan?.attributes['db.namespace']).toEqual({ type: 'string', value: 'test' });
+ expect(saveSpan?.attributes['db.collection.name']).toEqual({ type: 'string', value: 'blogposts' });
+ expect(saveSpan?.attributes['db.operation.name']).toEqual({ type: 'string', value: 'save' });
+
+ const findOneSpan = mongooseSpans.find(span => span.name === 'findOne blogposts');
+ expect(findOneSpan?.status).toBe('ok');
+ expect(findOneSpan?.is_segment).toBe(false);
+ expect(findOneSpan?.attributes['sentry.op']).toEqual({ type: 'string', value: 'db' });
+ expect(findOneSpan?.attributes['db.system.name']).toEqual({ type: 'string', value: 'mongodb' });
+ expect(findOneSpan?.attributes['db.namespace']).toEqual({ type: 'string', value: 'test' });
+ expect(findOneSpan?.attributes['db.collection.name']).toEqual({ type: 'string', value: 'blogposts' });
+ expect(findOneSpan?.attributes['db.operation.name']).toEqual({ type: 'string', value: 'findOne' });
+ expect(findOneSpan?.attributes['db.query.text']).toEqual({ type: 'string', value: '{"title":"?"}' });
+});
+
test('Instruments mysql automatically', async ({ baseURL }) => {
const spansPromise = collectRequestSpans('/api/db-mysql');
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/docker-compose.yml b/dev-packages/e2e-tests/test-applications/nuxt-5/docker-compose.yml
new file mode 100644
index 000000000000..a392ebd433af
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/docker-compose.yml
@@ -0,0 +1,16 @@
+services:
+ mongo:
+ image: mongo:8
+ restart: always
+ container_name: e2e-tests-nuxt-5-mongo
+ ports:
+ - '27017:27017'
+ environment:
+ MONGO_INITDB_ROOT_USERNAME: root
+ MONGO_INITDB_ROOT_PASSWORD: docker
+ healthcheck:
+ test: ['CMD-SHELL', 'mongosh --quiet --eval "db.adminCommand(''ping'').ok"']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 10s
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/global-setup.mjs b/dev-packages/e2e-tests/test-applications/nuxt-5/global-setup.mjs
new file mode 100644
index 000000000000..fbc228dc4e55
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/global-setup.mjs
@@ -0,0 +1,14 @@
+import { execSync } from 'child_process';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default async function globalSetup() {
+ // Start MongoDB via Docker Compose. `--wait` blocks until the
+ // healthcheck in docker-compose.yml passes, so the app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/global-teardown.mjs b/dev-packages/e2e-tests/test-applications/nuxt-5/global-teardown.mjs
new file mode 100644
index 000000000000..2742279431ad
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/global-teardown.mjs
@@ -0,0 +1,12 @@
+import { execSync } from 'child_process';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default async function globalTeardown() {
+ execSync('docker compose down --volumes', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/package.json b/dev-packages/e2e-tests/test-applications/nuxt-5/package.json
index 36aea2e0b856..6a38a24d8f3c 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/package.json
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/package.json
@@ -19,9 +19,6 @@
},
"//": [
"Currently, we need to install the latest version of Nitro and the Nuxt nightlies as those contain Nuxt v5",
- "@nuxt/cli is pinned. The CLI nightlies register nitro runtime plugins that live inside the CLI package: https://github.com/nuxt/cli/pull/1570",
- "Nuxt's impound guard blocks imports from that package in the dev server runtime, so every SSR request fails in dev mode.",
- "TODO: remove the @nuxt/cli override when impound allows the CLI runtime plugins",
"TODO: remove nitro from dependencies",
"Nuxt generates `fetch.server.mjs` as a virtual module that imports `ofetch`, and since a virtual id is neither absolute nor on disk, Vite resolves from its `root` (the srcDir) instead of the importer's folder.",
"This fails because `ofetch` is a dependency of `nuxt` rather than the app, so pnpm leaves it in `.pnpm/`",
@@ -30,6 +27,7 @@
"dependencies": {
"@pinia/nuxt": "^0.11.3",
"@sentry/nuxt": "file:../../packed/sentry-nuxt-packed.tgz",
+ "mongoose": "^9.10.2",
"ofetch": "^2.0.0-alpha.3",
"nitro": "latest",
"nuxt": "npm:nuxt-nightly@5x",
@@ -39,17 +37,11 @@
"@playwright/test": "~1.63.0",
"@sentry-internal/test-utils": "link:../../../test-utils"
},
- "pnpm": {
- "overrides": {
- "@nuxt/cli": "npm:@nuxt/cli-nightly@4.0.0-20260927-110353-6eaa0eb"
- }
- },
"sentryTest": {
"optional": true
},
"volta": {
"extends": "../../package.json",
- "node": "22.20.0",
"pnpm": "11.10.0"
}
}
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/playwright.config.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/playwright.config.ts
index 80df201381ce..308691754a0b 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/playwright.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/playwright.config.ts
@@ -23,4 +23,8 @@ const config = getPlaywrightConfig({
startCommand: getStartCommand(),
});
-export default config;
+export default {
+ ...config,
+ globalSetup: './global-setup.mjs',
+ globalTeardown: './global-teardown.mjs',
+};
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/sentry.server.config.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/sentry.server.config.ts
index 26519911072b..58d541b5228b 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/sentry.server.config.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/sentry.server.config.ts
@@ -4,4 +4,6 @@ Sentry.init({
dsn: 'https://public@dsn.ingest.sentry.io/1337',
tracesSampleRate: 1.0, // Capture 100% of the transactions
tunnel: 'http://localhost:3031/', // proxy server
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/db-mongoose.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/db-mongoose.ts
new file mode 100644
index 000000000000..5bed443ac90a
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/db-mongoose.ts
@@ -0,0 +1,19 @@
+import mongoose from 'mongoose';
+import { defineHandler } from 'nitro';
+
+const BlogPost = mongoose.model('BlogPost', new mongoose.Schema({ title: String }));
+
+// SCRAM-SHA-1 on purpose: this handshake lazily `require()`s the `crypto` builtin inside a try
+// block, which only works when the bundled driver gets a real interop for builtin requires (#24775).
+const MONGO_URL = 'mongodb://root:docker@127.0.0.1:27017/test?authSource=admin&authMechanism=SCRAM-SHA-1';
+
+export default defineHandler(async () => {
+ if (mongoose.connection.readyState !== mongoose.ConnectionStates.connected) {
+ await mongoose.connect(MONGO_URL);
+ }
+
+ await new BlogPost({ title: 'test-post' }).save();
+ const found = await BlogPost.findOne({ title: 'test-post' });
+
+ return { title: found?.title };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/db-mongoose.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/db-mongoose.test.ts
new file mode 100644
index 000000000000..e48c97ed1af6
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/db-mongoose.test.ts
@@ -0,0 +1,49 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpansUntilSegment } from '@sentry-internal/test-utils';
+
+// The Nitro bundle force-inlines the instrumented drivers while their CommonJS dependencies and
+// Node builtins stay external, and every `require()` across that boundary needs working interop
+// (#24775). mongoose covers both: `new mquery()`, and SCRAM-SHA-1 auth lazily requiring `crypto`.
+async function collectRequestSpans() {
+ const spans = await collectStreamedSpansUntilSegment(
+ 'nuxt-5',
+ span => span.attributes['url.path']?.value === '/api/db-mongoose',
+ );
+ const rootSpan = spans.find(span => span.is_segment && span.attributes['url.path']?.value === '/api/db-mongoose');
+
+ return spans.filter(span => span.trace_id === rootSpan?.trace_id);
+}
+
+test('Instruments mongoose automatically', async ({ baseURL }) => {
+ const spansPromise = collectRequestSpans();
+
+ const response = await fetch(`${baseURL}/api/db-mongoose`);
+ expect(response.status).toBe(200);
+ await expect(response.json()).resolves.toEqual({ title: 'test-post' });
+
+ const spans = await spansPromise;
+
+ const mongooseSpans = spans.filter(
+ span => span.attributes['sentry.origin']?.value === 'auto.db.mongoose.diagnostic_channel',
+ );
+ expect(mongooseSpans).toHaveLength(2);
+
+ const saveSpan = mongooseSpans.find(span => span.name === 'save blogposts');
+ expect(saveSpan?.status).toBe('ok');
+ expect(saveSpan?.is_segment).toBe(false);
+ expect(saveSpan?.attributes['sentry.op']).toEqual({ type: 'string', value: 'db' });
+ expect(saveSpan?.attributes['db.system.name']).toEqual({ type: 'string', value: 'mongodb' });
+ expect(saveSpan?.attributes['db.namespace']).toEqual({ type: 'string', value: 'test' });
+ expect(saveSpan?.attributes['db.collection.name']).toEqual({ type: 'string', value: 'blogposts' });
+ expect(saveSpan?.attributes['db.operation.name']).toEqual({ type: 'string', value: 'save' });
+
+ const findOneSpan = mongooseSpans.find(span => span.name === 'findOne blogposts');
+ expect(findOneSpan?.status).toBe('ok');
+ expect(findOneSpan?.is_segment).toBe(false);
+ expect(findOneSpan?.attributes['sentry.op']).toEqual({ type: 'string', value: 'db' });
+ expect(findOneSpan?.attributes['db.system.name']).toEqual({ type: 'string', value: 'mongodb' });
+ expect(findOneSpan?.attributes['db.namespace']).toEqual({ type: 'string', value: 'test' });
+ expect(findOneSpan?.attributes['db.collection.name']).toEqual({ type: 'string', value: 'blogposts' });
+ expect(findOneSpan?.attributes['db.operation.name']).toEqual({ type: 'string', value: 'findOne' });
+ expect(findOneSpan?.attributes['db.query.text']).toEqual({ type: 'string', value: '{"title":"?"}' });
+});
diff --git a/dev-packages/e2e-tests/test-applications/react-router-7-framework-instrumentation/instrument.mjs b/dev-packages/e2e-tests/test-applications/react-router-7-framework-instrumentation/instrument.mjs
index c16240141b6d..c4bdeea732a4 100644
--- a/dev-packages/e2e-tests/test-applications/react-router-7-framework-instrumentation/instrument.mjs
+++ b/dev-packages/e2e-tests/test-applications/react-router-7-framework-instrumentation/instrument.mjs
@@ -5,4 +5,6 @@ Sentry.init({
environment: 'qa', // dynamic sampling bias to keep transactions
tracesSampleRate: 1.0,
tunnel: `http://localhost:3031/`, // proxy server
+ // Several tests trigger the same server error one after another, which Dedupe would drop.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/e2e-tests/test-applications/react-router-8-framework/app/entry.server.tsx b/dev-packages/e2e-tests/test-applications/react-router-8-framework/app/entry.server.tsx
index 738cd1515a4d..01682288ab71 100644
--- a/dev-packages/e2e-tests/test-applications/react-router-8-framework/app/entry.server.tsx
+++ b/dev-packages/e2e-tests/test-applications/react-router-8-framework/app/entry.server.tsx
@@ -1,5 +1,6 @@
import { createReadableStreamFromReadable } from '@react-router/node';
import * as Sentry from '@sentry/react-router';
+import { randomBytes } from 'node:crypto';
import { renderToPipeableStream } from 'react-dom/server';
import { ServerRouter } from 'react-router';
import { type HandleErrorFunction } from 'react-router';
@@ -11,6 +12,7 @@ const handleRequest = Sentry.createSentryHandleRequest({
ServerRouter,
renderToPipeableStream,
createReadableStreamFromReadable,
+ getNonce: () => randomBytes(16).toString('base64'),
});
export default handleRequest;
diff --git a/dev-packages/e2e-tests/test-applications/react-router-8-framework/tests/csp-nonce.server.test.ts b/dev-packages/e2e-tests/test-applications/react-router-8-framework/tests/csp-nonce.server.test.ts
new file mode 100644
index 000000000000..1787bde746cb
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/react-router-8-framework/tests/csp-nonce.server.test.ts
@@ -0,0 +1,23 @@
+import { expect, test } from '@playwright/test';
+
+function getScriptNonces(html: string): string[] {
+ return Array.from(html.matchAll(/]*\snonce="([^"]+)"/g), match => match[1]!);
+}
+
+test.describe('CSP nonce', () => {
+ test('adds the same per-request nonce to all inline scripts', async ({ request }) => {
+ const firstHtml = await (await request.get('/')).text();
+ const secondHtml = await (await request.get('/')).text();
+
+ const firstNonces = getScriptNonces(firstHtml);
+ const secondNonces = getScriptNonces(secondHtml);
+
+ expect(firstNonces.length).toBeGreaterThan(0);
+ expect(firstNonces.length).toBe((firstHtml.match(/);
},
+ user(context) {
+ return Response.json({ id: context.params.id });
+ },
+ teapot() {
+ return new Response("I'm a teapot", { status: 418 });
+ },
},
});
diff --git a/dev-packages/e2e-tests/test-applications/remix-v3/app/router.ts b/dev-packages/e2e-tests/test-applications/remix-v3/app/router.ts
index aef480456066..03724dd7ea27 100644
--- a/dev-packages/e2e-tests/test-applications/remix-v3/app/router.ts
+++ b/dev-packages/e2e-tests/test-applications/remix-v3/app/router.ts
@@ -19,3 +19,9 @@ export const router = createRouter({
});
router.map(routes, controller);
+
+// Mounted rather than added to the route map, so the tests cover a route whose pattern carries a mount
+// prefix.
+router.mount('/api', api => {
+ api.get('/items/:itemId', context => Response.json({ itemId: context.params.itemId }));
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-v3/app/routes.ts b/dev-packages/e2e-tests/test-applications/remix-v3/app/routes.ts
index 1ebc77927332..77b32281374b 100644
--- a/dev-packages/e2e-tests/test-applications/remix-v3/app/routes.ts
+++ b/dev-packages/e2e-tests/test-applications/remix-v3/app/routes.ts
@@ -3,4 +3,6 @@ import { get, route } from 'remix/routes';
export const routes = route({
assets: get('/assets/*path'),
home: '/',
+ user: get('/users/:id'),
+ teapot: get('/teapot'),
});
diff --git a/dev-packages/e2e-tests/test-applications/remix-v3/tests/server-spans.test.ts b/dev-packages/e2e-tests/test-applications/remix-v3/tests/server-spans.test.ts
new file mode 100644
index 000000000000..96e618b7b7f1
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-v3/tests/server-spans.test.ts
@@ -0,0 +1,51 @@
+import { expect, test } from '@playwright/test';
+import type { SerializedStreamedSpan } from '@sentry-internal/test-utils';
+import { getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+
+const APP_NAME = 'remix-v3';
+
+/**
+ * Selecting the span by `http.route` rather than by name is what makes the name assertions below mean
+ * something: a request that never resolved its route would not match, instead of matching and then
+ * passing a name check against whatever it happened to be called.
+ */
+function waitForServerSpan(route: string): Promise {
+ return waitForStreamedSpan(
+ APP_NAME,
+ span =>
+ getSpanOp(span) === 'http.server' && span.is_segment === true && span.attributes?.['http.route']?.value === route,
+ );
+}
+
+test('names a parameterized route after its pattern', async ({ baseURL }) => {
+ const spanPromise = waitForServerSpan('/users/:id');
+
+ await fetch(`${baseURL}/users/12345`);
+
+ const span = await spanPromise;
+ expect(span.name).toBe('GET /users/:id');
+ // An id in the name would make every request its own transaction.
+ expect(span.name).not.toContain('12345');
+ expect(span.attributes?.['sentry.segment.name.source']?.value).toBe('route');
+});
+
+test('includes the mount prefix in the name of a mounted route', async ({ baseURL }) => {
+ const spanPromise = waitForServerSpan('/api/items/:itemId');
+
+ await fetch(`${baseURL}/api/items/abc`);
+
+ const span = await spanPromise;
+ expect(span.name).toBe('GET /api/items/:itemId');
+ expect(span.name).not.toContain('abc');
+});
+
+test('records the response status', async ({ baseURL }) => {
+ const spanPromise = waitForServerSpan('/teapot');
+
+ await fetch(`${baseURL}/teapot`);
+
+ const span = await spanPromise;
+ expect(span.attributes?.['http.response.status_code']?.value).toBe(418);
+ // OpenTelemetry leaves a 4xx server span unset, so the error status is the SDK's own doing.
+ expect(span.status).toBe('error');
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-v3/tests/smoke.test.ts b/dev-packages/e2e-tests/test-applications/remix-v3/tests/smoke.test.ts
index 85e4619e49c4..3b005133749a 100644
--- a/dev-packages/e2e-tests/test-applications/remix-v3/tests/smoke.test.ts
+++ b/dev-packages/e2e-tests/test-applications/remix-v3/tests/smoke.test.ts
@@ -1,20 +1,7 @@
import { expect, test } from '@playwright/test';
-import { waitForStreamedSpan } from '@sentry-internal/test-utils';
-// There is no instrumentation yet. This app exists so later pull requests add instrumentation and its
-// tests together, rather than also introducing a new CI surface.
test('the app boots under the Sentry --import entry', async ({ page }) => {
await page.goto('/');
await expect(page.locator('#home')).toBeVisible();
});
-
-test('Sentry.init from the v3 subpath reports a server span', async ({ baseURL }) => {
- // Names are still URL based. This only proves the subpath resolves and the SDK is live.
- const spanPromise = waitForStreamedSpan('remix-v3', span => span.is_segment === true);
-
- await fetch(`${baseURL}/`);
-
- const span = await spanPromise;
- expect(span.attributes?.['http.request.method']?.value).toBe('GET');
-});
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-2/README.md b/dev-packages/e2e-tests/test-applications/solidstart-2/README.md
index 9a141e9c2f0d..2b2846ee4ac8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-2/README.md
+++ b/dev-packages/e2e-tests/test-applications/solidstart-2/README.md
@@ -31,15 +31,4 @@ Solid apps are built with _presets_, which optimise your project for deployment
By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add
it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
-## Testing
-
-Tests are written with `vitest`, `@solidjs/testing-library` and `@testing-library/jest-dom` to extend expect with some
-helpful custom matchers.
-
-To run them, simply start:
-
-```sh
-npm test
-```
-
## This project was created with the [Solid CLI](https://solid-cli.netlify.app)
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-2/package.json b/dev-packages/e2e-tests/test-applications/solidstart-2/package.json
index 58c2b2b37c00..9fd694db92d4 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-2/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-2/package.json
@@ -25,13 +25,11 @@
"@solidjs/testing-library": "^0.8.10",
"@testing-library/jest-dom": "^6.4.2",
"@testing-library/user-event": "^14.5.2",
- "@vitest/ui": "^1.5.0",
"jsdom": "^24.0.0",
"solid-js": "1.9.14",
"typescript": "^5.4.5",
"vite": "^8.1.5",
- "vite-plugin-solid": "^2.11.6",
- "vitest": "^1.5.0"
+ "vite-plugin-solid": "^2.11.6"
},
"volta": {
"extends": "../../package.json"
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-2/tsconfig.json b/dev-packages/e2e-tests/test-applications/solidstart-2/tsconfig.json
index 3dcf7bfb7398..773b6011155d 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-2/tsconfig.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-2/tsconfig.json
@@ -10,7 +10,7 @@
"allowJs": true,
"strict": true,
"noEmit": true,
- "types": ["@solidjs/start/env", "vitest/globals", "@testing-library/jest-dom"],
+ "types": ["@solidjs/start/env", "@testing-library/jest-dom"],
"isolatedModules": true,
"paths": {
"~/*": ["./src/*"]
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-2/vitest.config.ts b/dev-packages/e2e-tests/test-applications/solidstart-2/vitest.config.ts
deleted file mode 100644
index 6c2b639dc300..000000000000
--- a/dev-packages/e2e-tests/test-applications/solidstart-2/vitest.config.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import solid from 'vite-plugin-solid';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
- plugins: [solid()],
- resolve: {
- conditions: ['development', 'browser'],
- },
- envPrefix: 'PUBLIC_',
-});
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/README.md b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/README.md
index 9a141e9c2f0d..2b2846ee4ac8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/README.md
+++ b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/README.md
@@ -31,15 +31,4 @@ Solid apps are built with _presets_, which optimise your project for deployment
By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add
it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
-## Testing
-
-Tests are written with `vitest`, `@solidjs/testing-library` and `@testing-library/jest-dom` to extend expect with some
-helpful custom matchers.
-
-To run them, simply start:
-
-```sh
-npm test
-```
-
## This project was created with the [Solid CLI](https://solid-cli.netlify.app)
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/package.json b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/package.json
index 9072e925225b..9d4519417b19 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/package.json
@@ -28,8 +28,7 @@
"typescript": "^5.4.5",
"vinxi": "^0.4.0",
"vite": "^5.4.10",
- "vite-plugin-solid": "^2.11.6",
- "vitest": "^3.2.7"
+ "vite-plugin-solid": "^2.11.6"
},
"volta": {
"extends": "../../package.json"
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/tsconfig.json b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/tsconfig.json
index 6f11292cc5d8..8619427a3226 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/tsconfig.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/tsconfig.json
@@ -10,7 +10,7 @@
"allowJs": true,
"strict": true,
"noEmit": true,
- "types": ["vinxi/types/client", "vitest/globals", "@testing-library/jest-dom"],
+ "types": ["vinxi/types/client", "@testing-library/jest-dom"],
"isolatedModules": true,
"paths": {
"~/*": ["./src/*"]
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/vitest.config.ts b/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/vitest.config.ts
deleted file mode 100644
index 6c2b639dc300..000000000000
--- a/dev-packages/e2e-tests/test-applications/solidstart-dynamic-import/vitest.config.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import solid from 'vite-plugin-solid';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
- plugins: [solid()],
- resolve: {
- conditions: ['development', 'browser'],
- },
- envPrefix: 'PUBLIC_',
-});
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-spa/README.md b/dev-packages/e2e-tests/test-applications/solidstart-spa/README.md
index 9a141e9c2f0d..2b2846ee4ac8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-spa/README.md
+++ b/dev-packages/e2e-tests/test-applications/solidstart-spa/README.md
@@ -31,15 +31,4 @@ Solid apps are built with _presets_, which optimise your project for deployment
By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add
it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
-## Testing
-
-Tests are written with `vitest`, `@solidjs/testing-library` and `@testing-library/jest-dom` to extend expect with some
-helpful custom matchers.
-
-To run them, simply start:
-
-```sh
-npm test
-```
-
## This project was created with the [Solid CLI](https://solid-cli.netlify.app)
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-spa/package.json b/dev-packages/e2e-tests/test-applications/solidstart-spa/package.json
index 88f352108701..9636c7bb4600 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-spa/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-spa/package.json
@@ -28,8 +28,7 @@
"typescript": "^5.4.5",
"vinxi": "^0.4.0",
"vite": "^5.4.11",
- "vite-plugin-solid": "^2.11.6",
- "vitest": "^3.2.7"
+ "vite-plugin-solid": "^2.11.6"
},
"volta": {
"extends": "../../package.json"
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-spa/tsconfig.json b/dev-packages/e2e-tests/test-applications/solidstart-spa/tsconfig.json
index 6f11292cc5d8..8619427a3226 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-spa/tsconfig.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-spa/tsconfig.json
@@ -10,7 +10,7 @@
"allowJs": true,
"strict": true,
"noEmit": true,
- "types": ["vinxi/types/client", "vitest/globals", "@testing-library/jest-dom"],
+ "types": ["vinxi/types/client", "@testing-library/jest-dom"],
"isolatedModules": true,
"paths": {
"~/*": ["./src/*"]
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-spa/vitest.config.ts b/dev-packages/e2e-tests/test-applications/solidstart-spa/vitest.config.ts
deleted file mode 100644
index 6c2b639dc300..000000000000
--- a/dev-packages/e2e-tests/test-applications/solidstart-spa/vitest.config.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import solid from 'vite-plugin-solid';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
- plugins: [solid()],
- resolve: {
- conditions: ['development', 'browser'],
- },
- envPrefix: 'PUBLIC_',
-});
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-static/README.md b/dev-packages/e2e-tests/test-applications/solidstart-static/README.md
index 9a141e9c2f0d..2b2846ee4ac8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-static/README.md
+++ b/dev-packages/e2e-tests/test-applications/solidstart-static/README.md
@@ -31,15 +31,4 @@ Solid apps are built with _presets_, which optimise your project for deployment
By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add
it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
-## Testing
-
-Tests are written with `vitest`, `@solidjs/testing-library` and `@testing-library/jest-dom` to extend expect with some
-helpful custom matchers.
-
-To run them, simply start:
-
-```sh
-npm test
-```
-
## This project was created with the [Solid CLI](https://solid-cli.netlify.app)
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-static/package.json b/dev-packages/e2e-tests/test-applications/solidstart-static/package.json
index 1077b195acb6..ebc880b29186 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-static/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-static/package.json
@@ -30,11 +30,9 @@
"typescript": "^5.4.5",
"vinxi": "^0.4.0",
"vite": "^5.4.11",
- "vite-plugin-solid": "^2.11.6",
- "vitest": "^3.2.7"
+ "vite-plugin-solid": "^2.11.6"
},
"volta": {
- "node": "20.19.5",
"extends": "../../package.json"
}
}
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-static/tsconfig.json b/dev-packages/e2e-tests/test-applications/solidstart-static/tsconfig.json
index 6f11292cc5d8..8619427a3226 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-static/tsconfig.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-static/tsconfig.json
@@ -10,7 +10,7 @@
"allowJs": true,
"strict": true,
"noEmit": true,
- "types": ["vinxi/types/client", "vitest/globals", "@testing-library/jest-dom"],
+ "types": ["vinxi/types/client", "@testing-library/jest-dom"],
"isolatedModules": true,
"paths": {
"~/*": ["./src/*"]
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-static/vitest.config.ts b/dev-packages/e2e-tests/test-applications/solidstart-static/vitest.config.ts
deleted file mode 100644
index 6c2b639dc300..000000000000
--- a/dev-packages/e2e-tests/test-applications/solidstart-static/vitest.config.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import solid from 'vite-plugin-solid';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
- plugins: [solid()],
- resolve: {
- conditions: ['development', 'browser'],
- },
- envPrefix: 'PUBLIC_',
-});
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/README.md b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/README.md
index 9a141e9c2f0d..2b2846ee4ac8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/README.md
+++ b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/README.md
@@ -31,15 +31,4 @@ Solid apps are built with _presets_, which optimise your project for deployment
By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add
it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
-## Testing
-
-Tests are written with `vitest`, `@solidjs/testing-library` and `@testing-library/jest-dom` to extend expect with some
-helpful custom matchers.
-
-To run them, simply start:
-
-```sh
-npm test
-```
-
## This project was created with the [Solid CLI](https://solid-cli.netlify.app)
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/package.json b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/package.json
index ad24ad3da154..fd1d1c82cbdc 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/package.json
@@ -28,8 +28,7 @@
"typescript": "^5.4.5",
"vinxi": "^0.4.0",
"vite": "^5.4.11",
- "vite-plugin-solid": "^2.11.6",
- "vitest": "^3.2.7"
+ "vite-plugin-solid": "^2.11.6"
},
"volta": {
"extends": "../../package.json"
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/tsconfig.json b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/tsconfig.json
index 6f11292cc5d8..8619427a3226 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/tsconfig.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/tsconfig.json
@@ -10,7 +10,7 @@
"allowJs": true,
"strict": true,
"noEmit": true,
- "types": ["vinxi/types/client", "vitest/globals", "@testing-library/jest-dom"],
+ "types": ["vinxi/types/client", "@testing-library/jest-dom"],
"isolatedModules": true,
"paths": {
"~/*": ["./src/*"]
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/vitest.config.ts b/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/vitest.config.ts
deleted file mode 100644
index 6c2b639dc300..000000000000
--- a/dev-packages/e2e-tests/test-applications/solidstart-top-level-import/vitest.config.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import solid from 'vite-plugin-solid';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
- plugins: [solid()],
- resolve: {
- conditions: ['development', 'browser'],
- },
- envPrefix: 'PUBLIC_',
-});
diff --git a/dev-packages/e2e-tests/test-applications/solidstart/README.md b/dev-packages/e2e-tests/test-applications/solidstart/README.md
index 9a141e9c2f0d..2b2846ee4ac8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart/README.md
+++ b/dev-packages/e2e-tests/test-applications/solidstart/README.md
@@ -31,15 +31,4 @@ Solid apps are built with _presets_, which optimise your project for deployment
By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add
it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
-## Testing
-
-Tests are written with `vitest`, `@solidjs/testing-library` and `@testing-library/jest-dom` to extend expect with some
-helpful custom matchers.
-
-To run them, simply start:
-
-```sh
-npm test
-```
-
## This project was created with the [Solid CLI](https://solid-cli.netlify.app)
diff --git a/dev-packages/e2e-tests/test-applications/solidstart/package.json b/dev-packages/e2e-tests/test-applications/solidstart/package.json
index ed907f5c5a47..ac2b8c393432 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart/package.json
@@ -32,11 +32,9 @@
"typescript": "^5.4.5",
"vinxi": "^0.4.0",
"vite": "^5.4.11",
- "vite-plugin-solid": "^2.11.6",
- "vitest": "^3.2.7"
+ "vite-plugin-solid": "^2.11.6"
},
"volta": {
- "node": "20.19.5",
"extends": "../../package.json"
}
}
diff --git a/dev-packages/e2e-tests/test-applications/solidstart/tsconfig.json b/dev-packages/e2e-tests/test-applications/solidstart/tsconfig.json
index 6f11292cc5d8..8619427a3226 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart/tsconfig.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart/tsconfig.json
@@ -10,7 +10,7 @@
"allowJs": true,
"strict": true,
"noEmit": true,
- "types": ["vinxi/types/client", "vitest/globals", "@testing-library/jest-dom"],
+ "types": ["vinxi/types/client", "@testing-library/jest-dom"],
"isolatedModules": true,
"paths": {
"~/*": ["./src/*"]
diff --git a/dev-packages/e2e-tests/test-applications/solidstart/vitest.config.ts b/dev-packages/e2e-tests/test-applications/solidstart/vitest.config.ts
deleted file mode 100644
index 6c2b639dc300..000000000000
--- a/dev-packages/e2e-tests/test-applications/solidstart/vitest.config.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import solid from 'vite-plugin-solid';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
- plugins: [solid()],
- resolve: {
- conditions: ['development', 'browser'],
- },
- envPrefix: 'PUBLIC_',
-});
diff --git a/dev-packages/e2e-tests/test-applications/supabase-nextjs/package.json b/dev-packages/e2e-tests/test-applications/supabase-nextjs/package.json
index 7b0c34c4587d..2f4e79c2bfaf 100644
--- a/dev-packages/e2e-tests/test-applications/supabase-nextjs/package.json
+++ b/dev-packages/e2e-tests/test-applications/supabase-nextjs/package.json
@@ -36,5 +36,8 @@
},
"volta": {
"extends": "../../package.json"
+ },
+ "sentryTest": {
+ "optional": true
}
}
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/src/routes/prerendered/+page.svelte b/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/src/routes/prerendered/+page.svelte
new file mode 100644
index 000000000000..46d423a3693d
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/src/routes/prerendered/+page.svelte
@@ -0,0 +1 @@
+Prerendered page
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/src/routes/prerendered/+page.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/src/routes/prerendered/+page.ts
new file mode 100644
index 000000000000..189f71e2e1b3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/src/routes/prerendered/+page.ts
@@ -0,0 +1 @@
+export const prerender = true;
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/tests/prerender.test.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/tests/prerender.test.ts
new file mode 100644
index 000000000000..9e9a5bbf4be8
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2-kit-tracing/tests/prerender.test.ts
@@ -0,0 +1,14 @@
+import { expect, test } from '@playwright/test';
+
+test("Doesn't add trace meta tags to prerendered pages", async ({ request }) => {
+ const prerenderedHtml = await (await request.get('/prerendered')).text();
+ const ssrHtml = await (await request.get('/')).text();
+
+ expect(prerenderedHtml).toContain('Prerendered page');
+ expect(prerenderedHtml).not.toContain('Prerendered page
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2-static/src/routes/prerendered/+page.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2-static/src/routes/prerendered/+page.ts
new file mode 100644
index 000000000000..189f71e2e1b3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2-static/src/routes/prerendered/+page.ts
@@ -0,0 +1 @@
+export const prerender = true;
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2-static/tests/sdk.test.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2-static/tests/sdk.test.ts
index 8633439eb503..23bce25b7ec4 100644
--- a/dev-packages/e2e-tests/test-applications/sveltekit-2-static/tests/sdk.test.ts
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2-static/tests/sdk.test.ts
@@ -13,4 +13,17 @@ test.describe('SDK-internal behavior', () => {
// fetch proxy script didn't run
expect(proxyHandle).toBe('undefined');
});
+
+ test("Doesn't add trace meta tags to prerendered pages", async ({ request }) => {
+ const prerenderedHtml = await (await request.get('/prerendered')).text();
+ const ssrHtml = await (await request.get('/')).text();
+
+ expect(prerenderedHtml).toContain('Prerendered page');
+ expect(prerenderedHtml).not.toContain('Prerendered page
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-3/src/routes/prerendered/+page.ts b/dev-packages/e2e-tests/test-applications/sveltekit-3/src/routes/prerendered/+page.ts
new file mode 100644
index 000000000000..189f71e2e1b3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-3/src/routes/prerendered/+page.ts
@@ -0,0 +1 @@
+export const prerender = true;
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-3/tests/prerender.test.ts b/dev-packages/e2e-tests/test-applications/sveltekit-3/tests/prerender.test.ts
new file mode 100644
index 000000000000..9e9a5bbf4be8
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-3/tests/prerender.test.ts
@@ -0,0 +1,14 @@
+import { expect, test } from '@playwright/test';
+
+test("Doesn't add trace meta tags to prerendered pages", async ({ request }) => {
+ const prerenderedHtml = await (await request.get('/prerendered')).text();
+ const ssrHtml = await (await request.get('/')).text();
+
+ expect(prerenderedHtml).toContain('Prerendered page');
+ expect(prerenderedHtml).not.toContain('
new Promise(resolve => {
diff --git a/dev-packages/e2e-tests/test-applications/vue-3/tests/performance.test.ts b/dev-packages/e2e-tests/test-applications/vue-3/tests/performance.test.ts
index 107ac0fa9f82..a7ae9b1599ca 100644
--- a/dev-packages/e2e-tests/test-applications/vue-3/tests/performance.test.ts
+++ b/dev-packages/e2e-tests/test-applications/vue-3/tests/performance.test.ts
@@ -172,10 +172,13 @@ test('sends a pageload span with a route name as span name if available', async
});
});
-// True on both variants: the mixin arms one debounce timer per component (`tracing.ts`), so a
-// late child never clears the root's earlier timer and the span ends at the root's mount. The
-// `app.mount()` wrap only observes the root, so it matches.
-test('ends the application render span before a delayed async component mounts', async ({ page }) => {
+// Mixin: records render activity from every component, so the late child pushes the root render span's end out to its own mount.
+// `app.mount()` wrap: only observes the root, so without the Options API the span still ends before the child mounts.
+const [minRenderSpanDuration, maxRenderSpanDuration] = OPTIONS_API_DISABLED
+ ? [0, ASYNC_CHILD_DELAY_S]
+ : [ASYNC_CHILD_DELAY_S, 10];
+
+test('ends the application render span at the last observed render activity', async ({ page }) => {
const spansPromise = collectStreamedSpans('vue-3', spans =>
spans.some(
span => span.is_segment && getSpanOp(span) === 'pageload' && span.attributes['url.path']?.value === '/delayed',
@@ -197,7 +200,8 @@ test('ends the application render span before a delayed async component mounts',
expect(applicationRenderSpan?.end_timestamp).toEqual(expect.any(Number));
const duration = (applicationRenderSpan?.end_timestamp ?? 0) - (applicationRenderSpan?.start_timestamp ?? 0);
- expect(duration).toBeLessThan(ASYNC_CHILD_DELAY_S);
+ expect(duration).toBeGreaterThanOrEqual(minRenderSpanDuration);
+ expect(duration).toBeLessThan(maxRenderSpanDuration);
});
test('sends a lifecycle span for the root and for each tracked component only', async ({ page }) => {
diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index cef002121320..8451a12a86d6 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -68,12 +68,12 @@
"cron": "^3.1.6",
"dataloader": "2.2.2",
"express": "^4.21.2",
- "fastify": "^5.12.1",
+ "fastify": "^5.12.5",
"generic-pool": "^3.9.0",
"graphql": "^16.11.0",
"groq-sdk": "1.6.0",
"graphql-tag": "^2.12.7",
- "hono": "^4.13.5",
+ "hono": "^4.13.7",
"http-terminator": "^3.2.0",
"ioredis": "5.10.1",
"ioredis-5": "npm:ioredis@^5.11.0",
diff --git a/dev-packages/node-integration-tests/suites/express/layer-span-end/instrument.mjs b/dev-packages/node-integration-tests/suites/express/layer-span-end/instrument.mjs
new file mode 100644
index 000000000000..46a27dd03b74
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/layer-span-end/instrument.mjs
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ tracesSampleRate: 1.0,
+ transport: loggingTransport,
+});
diff --git a/dev-packages/node-integration-tests/suites/express/layer-span-end/scenario.mjs b/dev-packages/node-integration-tests/suites/express/layer-span-end/scenario.mjs
new file mode 100644
index 000000000000..ef383e7eb933
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/layer-span-end/scenario.mjs
@@ -0,0 +1,29 @@
+import express from 'express';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+const MIDDLEWARE_COUNT = 12;
+
+const app = express();
+
+// More synchronous middleware than Node's default of 10 listeners per event, so
+// layer spans that stayed open until `next()` returned would pile up a response
+// `finish` listener per layer.
+for (let i = 0; i < MIDDLEWARE_COUNT; i++) {
+ app.use(function syncMiddleware(_req, _res, next) {
+ next();
+ });
+}
+
+app.get('/test/express', (_req, res) => {
+ const finishListeners = res.listenerCount('finish');
+
+ // Without the fix, this work is included in every preceding middleware's span.
+ const until = Date.now() + 50;
+ while (Date.now() < until) {
+ // busy-wait
+ }
+
+ res.send({ finishListeners });
+});
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/layer-span-end/test.ts b/dev-packages/node-integration-tests/suites/express/layer-span-end/test.ts
new file mode 100644
index 000000000000..cb5512f134a1
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/layer-span-end/test.ts
@@ -0,0 +1,48 @@
+import { EventEmitter } from 'node:events';
+import { afterAll, describe, expect } from 'vitest';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+
+const MIDDLEWARE_COUNT = 12;
+
+describe('express layer span end', () => {
+ afterAll(() => {
+ cleanupChildProcesses();
+ });
+
+ createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+ test('ends each middleware span when it calls `next`, before the route handler runs', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const middlewareSpans = container.items.filter(
+ item => item.attributes['express.type']?.value === 'middleware',
+ );
+ const handlerSpan = container.items.find(
+ item => item.attributes['express.type']?.value === 'request_handler',
+ );
+
+ // Express 4 also runs its built-in `query` and `expressInit` middleware.
+ expect(middlewareSpans.filter(span => span.name === 'syncMiddleware')).toHaveLength(MIDDLEWARE_COUNT);
+ expect(handlerSpan).toBeDefined();
+
+ for (const middlewareSpan of middlewareSpans) {
+ expect(middlewareSpan.end_timestamp).toBeLessThanOrEqual(handlerSpan!.start_timestamp);
+ }
+ },
+ })
+ .start();
+
+ runner.makeRequest('get', '/test/express');
+ await runner.completed();
+ });
+
+ test('does not accumulate a response `finish` listener per layer', async () => {
+ const runner = createRunner().start();
+
+ const response = await runner.makeRequest<{ finishListeners: number }>('get', '/test/express');
+
+ expect(response?.finishListeners).toBeLessThan(EventEmitter.defaultMaxListeners);
+ });
+ });
+});
diff --git a/dev-packages/node-integration-tests/suites/hono/instrument.mjs b/dev-packages/node-integration-tests/suites/hono/instrument.mjs
new file mode 100644
index 000000000000..62e64bf8dc10
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/hono/instrument.mjs
@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ tracesSampleRate: 1.0,
+ transport: loggingTransport,
+});
diff --git a/dev-packages/node-integration-tests/suites/hono/scenario.mjs b/dev-packages/node-integration-tests/suites/hono/scenario.mjs
new file mode 100644
index 000000000000..ed0f816c03cf
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/hono/scenario.mjs
@@ -0,0 +1,102 @@
+import { serve } from '@hono/node-server';
+import { sendPortToRunner } from '@sentry-internal/node-integration-tests';
+import { Hono } from 'hono';
+
+// No `@sentry/hono` and no `sentry()` middleware: the app is instrumented automatically by the
+// `honoIntegration` default in `@sentry/node` (via orchestrion hooking the `Context` constructor).
+const app = new Hono();
+
+app.get('/', c => {
+ return c.text('Hello from Hono on Node!');
+});
+
+app.get('/hello/:name', c => {
+ const name = c.req.param('name');
+ return c.text(`Hello, ${name}!`);
+});
+
+app.get('/error/:param', () => {
+ throw new Error('Test error from Hono app');
+});
+
+// A route handler declared with an unused `next` param (arity 2). It is the last handler in its
+// method+path group, so it must be classified as the route handler — not wrapped as a middleware
+// span — even though arity alone would misclassify it.
+app.get('/arity-two-handler', (c, _next) => c.text('handler with two params'));
+
+// A sub-app with a named middleware, mounted via `app.route()`. The sub-app is also
+// auto-instrumented (every `new Hono()` is), so its own Sentry middleware must NOT show up as an
+// `` middleware span when it is copied into the parent at mount time.
+const subApp = new Hono();
+subApp.use(async function subMiddleware(_c, next) {
+ await next();
+});
+subApp.get('/hello', c => c.text('sub hello'));
+app.route('/sub', subApp);
+
+// An inner app dispatched to via internal `.request()`. It runs in a fresh Hono context but the same
+// isolation scope, so its auto-registered Sentry middleware must be deduplicated — it must not
+// re-name the internal-request span, overwrite the request data, or add a middleware span.
+const innerApp = new Hono();
+innerApp.get('/item/:itemId', c => c.json({ itemId: c.req.param('itemId') }));
+innerApp.get('/flaky/:itemId', () => {
+ throw new Error('inventory db is down');
+});
+
+app.get('/outer/:itemId', async c => {
+ const res = await innerApp.request(`/item/${c.req.param('itemId')}`);
+ const data = await res.json();
+ return c.json({ outer: c.req.param('itemId'), inner: data });
+});
+
+// The inner route throws, but the outer handler catches the failed internal response and degrades to
+// a 200 instead of propagating. The inner route's error must still reach Sentry.
+app.get('/degraded/:itemId', async c => {
+ const res = await innerApp.request(`/flaky/${c.req.param('itemId')}`);
+ if (!res.ok) {
+ return c.json({ item: null, degraded: true }, 200);
+ }
+ return c.json({ item: await res.json() });
+});
+
+app.get('/outer-error/:itemId', async c => {
+ // Do a successful internal dispatch first — this is what used to overwrite the request data on the
+ // isolation scope — then throw from the outer handler, so the captured error must still carry the
+ // outer request's data.
+ await innerApp.request(`/item/${c.req.param('itemId')}`);
+ throw new Error('Test error from outer Hono app after internal request');
+});
+
+// Overlapping handlers: a parameterized handler and a catch-all handler both match `/overlap/:id`.
+// The parameterized handler is registered first and responds, so `routeIndex` lands on it and the
+// transaction must resolve to `/overlap/:id` — not the catch-all `/*`.
+app.get('/overlap/:id', c => c.json({ id: c.req.param('id') }));
+app.get('/overlap/*', c => c.text('catch-all handler'));
+
+// Middleware-only match: a scoped middleware short-circuits with its own response and no route
+// handler matches. The transaction name must fall back to the matched middleware path `/mw-only/*`.
+app.use('/mw-only/*', async (_c, _next) => new Response('handled by middleware'));
+
+// Middleware span status by thrown error (see `wrapMiddlewareWithSpan` + `defaultShouldHandleError`):
+// only 5xx and status-less errors set the middleware span to `error` — 3xx and 4xx do not, even
+// though they still fail the request.
+app.use('/mw-throw/:code', async function throwingMiddleware(c, _next) {
+ const status = Number(c.req.param('code'));
+ throw Object.assign(new Error(`middleware failed (${status})`), { status });
+});
+app.get('/mw-throw/:code', c => c.text('never reached'));
+
+// Middleware registered via `.use()` on the clone returned by `.basePath()`. The clone shares the
+// root router, so the middleware still ends up in the matched-handler list at dispatch — the
+// per-request orchestrion hook must wrap it as a middleware span regardless of which instance
+// registered it.
+app
+ .basePath('/test-basepath-mw')
+ .use(async function basepathMiddleware(_c, next) {
+ await next();
+ })
+ .get('/hello', c => c.json({ greeting: 'world' }));
+
+serve({ fetch: app.fetch, port: 0 }, info => {
+ sendPortToRunner(info.port);
+});
diff --git a/dev-packages/node-integration-tests/suites/hono/test.ts b/dev-packages/node-integration-tests/suites/hono/test.ts
new file mode 100644
index 000000000000..20a16f7e1eba
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/hono/test.ts
@@ -0,0 +1,323 @@
+import { afterAll, describe, expect } from 'vitest';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../utils/runner';
+
+// Verifies that Hono is auto-instrumented out of the box by `@sentry/node` (the `honoIntegration`
+// default), without importing `@sentry/hono` or registering the `sentry()` middleware manually.
+//
+// The SDK runs with the default `traceLifecycle` (span streaming), so the transaction is asserted via
+// the streamed span container (`container.items`, root = `is_segment`) rather than a `transaction`
+// envelope, and `.unordered()` lets the segment/child spans and error events arrive in any order
+// while ignoring unrelated envelopes (client reports, etc.).
+
+// oxlint-disable-next-line typescript/no-explicit-any
+type StreamedSpan = { name?: string; status?: string; is_segment?: boolean; attributes?: Record };
+
+const attr = (span: StreamedSpan, key: string): unknown => span.attributes?.[key]?.value;
+const op = (span: StreamedSpan): unknown => attr(span, 'sentry.op');
+
+describe('hono auto-instrumentation', () => {
+ afterAll(() => {
+ cleanupChildProcesses();
+ });
+
+ createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+ test('creates a transaction for a basic GET request', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /');
+ if (!segment) {
+ throw new Error('segment for `GET /` not in this container');
+ }
+ expect(op(segment)).toBe('http.server');
+ expect(segment.status).toBe('ok');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/');
+ await runner.completed();
+ });
+
+ test('creates a transaction with a parametrized route name', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /hello/:name');
+ if (!segment) {
+ throw new Error('segment for `GET /hello/:name` not in this container');
+ }
+ expect(op(segment)).toBe('http.server');
+ expect(attr(segment, 'sentry.segment.name.source')).toBe('route');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/hello/world');
+ await runner.completed();
+ });
+
+ test('captures an error with the correct mechanism', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ event: {
+ exception: {
+ values: [
+ {
+ type: 'Error',
+ value: 'Test error from Hono app',
+ mechanism: {
+ type: 'auto.http.hono.context_error',
+ handled: false,
+ },
+ },
+ ],
+ },
+ transaction: 'GET /error/:param',
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/error/param-123', { expectError: true });
+ await runner.completed();
+ });
+
+ test('creates a transaction with internal_error status when an error occurs', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /error/:param');
+ if (!segment) {
+ throw new Error('segment for `GET /error/:param` not in this container');
+ }
+ expect(op(segment)).toBe('http.server');
+ expect(segment.status).toBe('error');
+ expect(attr(segment, 'http.response.status_code')).toBe(500);
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/error/param-456', { expectError: true });
+ await runner.completed();
+ });
+
+ test('does not wrap a route handler declared with an unused next param as middleware', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /arity-two-handler');
+ if (!segment) {
+ throw new Error('segment for `GET /arity-two-handler` not in this container');
+ }
+ // The arity-2 handler is the route handler (last in its method+path group), so it must not
+ // produce a middleware span.
+ const middlewareSpans = container.items.filter(item => op(item) === 'middleware');
+ expect(middlewareSpans).toHaveLength(0);
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/arity-two-handler');
+ await runner.completed();
+ });
+
+ test('creates a middleware span for .use() on a .basePath() clone', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(
+ item => item.is_segment && item.name === 'GET /test-basepath-mw/hello',
+ );
+ if (!segment) {
+ throw new Error('segment for `GET /test-basepath-mw/hello` not in this container');
+ }
+ const middlewareSpan = container.items.find(
+ item => op(item) === 'middleware' && item.name === 'basepathMiddleware',
+ );
+ expect(middlewareSpan).toBeDefined();
+ expect(attr(middlewareSpan!, 'sentry.origin')).toBe('auto.middleware.hono');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/test-basepath-mw/hello');
+ await runner.completed();
+ });
+
+ test('does not create a middleware span for the Sentry middleware in a mounted sub-app', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /sub/hello');
+ if (!segment) {
+ throw new Error('segment for `GET /sub/hello` not in this container');
+ }
+ const middlewareNames = container.items.filter(item => op(item) === 'middleware').map(item => item.name);
+ // The sub-app's user middleware is traced …
+ expect(middlewareNames).toContain('subMiddleware');
+ // … but the sub-app's own auto-registered Sentry middleware must not appear as a span
+ // (it is copied into the parent at mount time and must stay unwrapped).
+ expect(middlewareNames).not.toContain('');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/sub/hello');
+ await runner.completed();
+ });
+
+ test('traces an internal .request() call without the inner app re-instrumenting the request', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ // Transaction is named after the outer route, not the internal one.
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /outer/:itemId');
+ if (!segment) {
+ throw new Error('segment for `GET /outer/:itemId` not in this container');
+ }
+
+ // The internal dispatch is traced with the raw inner path — the inner app's Sentry
+ // middleware must not re-name it to the parametrized route.
+ const internalRequestSpans = container.items.filter(
+ item => attr(item, 'sentry.origin') === 'auto.http.hono.internal_request',
+ );
+ expect(internalRequestSpans).toHaveLength(1);
+ expect(internalRequestSpans[0]?.name).toBe('GET /item/self-watering-plant');
+
+ // The inner app's Sentry middleware must not add a middleware span.
+ const middlewareNames = container.items.filter(item => op(item) === 'middleware').map(item => item.name);
+ expect(middlewareNames).not.toContain('');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/outer/self-watering-plant');
+ await runner.completed();
+ });
+
+ test('captures an error thrown inside an internal .request() even when the outer handler degrades to 200', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ event: event => {
+ expect(event.exception?.values?.[0]?.value).toBe('inventory db is down');
+ expect(event.exception?.values?.[0]?.mechanism).toEqual(
+ expect.objectContaining({ type: 'auto.http.hono.context_error', handled: false }),
+ );
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/degraded/self-watering-plant');
+ await runner.completed();
+ });
+
+ test('captures an error thrown after an internal .request() with the outer request data', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ event: event => {
+ expect(event.exception?.values?.[0]?.value).toBe('Test error from outer Hono app after internal request');
+ // The internal `.request()` dispatch must not overwrite the request data with its own URL.
+ expect(event.request?.url).toContain('/outer-error/self-watering-plant');
+ expect(event.request?.url).not.toContain('/item/');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/outer-error/self-watering-plant', { expectError: true });
+ await runner.completed();
+ });
+
+ test('resolves overlapping handlers to the responding route, not the catch-all', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /overlap/:id');
+ if (!segment) {
+ throw new Error('segment for `GET /overlap/:id` not in this container');
+ }
+ // The catch-all `GET /overlap/*` handler also matched, but the parameterized handler
+ // responded — the route name must not collapse to `/overlap/*`.
+ expect(attr(segment, 'sentry.segment.name.source')).toBe('route');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/overlap/123');
+ await runner.completed();
+ });
+
+ test('falls back to the matched middleware path when only middleware matched', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const segment = container.items.find(item => item.is_segment && item.name === 'GET /mw-only/*');
+ if (!segment) {
+ throw new Error('segment for `GET /mw-only/*` not in this container');
+ }
+ expect(op(segment)).toBe('http.server');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/mw-only/anything');
+ await runner.completed();
+ });
+
+ test('does not set the middleware span to error for a 3xx middleware error', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const middlewareSpan = container.items.find(
+ item => op(item) === 'middleware' && item.name === 'throwingMiddleware',
+ );
+ if (!middlewareSpan) {
+ throw new Error('middleware span `throwingMiddleware` not in this container');
+ }
+ expect(middlewareSpan.status).not.toBe('error');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/mw-throw/301', { expectError: true });
+ await runner.completed();
+ });
+
+ test('does not set the middleware span to error for a 4xx middleware error', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const middlewareSpan = container.items.find(
+ item => op(item) === 'middleware' && item.name === 'throwingMiddleware',
+ );
+ if (!middlewareSpan) {
+ throw new Error('middleware span `throwingMiddleware` not in this container');
+ }
+ expect(middlewareSpan.status).not.toBe('error');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/mw-throw/404', { expectError: true });
+ await runner.completed();
+ });
+
+ test('sets the middleware span to error for a 5xx middleware error', async () => {
+ const runner = createRunner()
+ .unordered()
+ .expect({
+ span: container => {
+ const middlewareSpan = container.items.find(
+ item => op(item) === 'middleware' && item.name === 'throwingMiddleware',
+ );
+ if (!middlewareSpan) {
+ throw new Error('middleware span `throwingMiddleware` not in this container');
+ }
+ expect(middlewareSpan.status).toBe('error');
+ },
+ })
+ .start();
+ runner.makeRequest('get', '/mw-throw/503', { expectError: true });
+ await runner.completed();
+ });
+ });
+});
diff --git a/dev-packages/node-integration-tests/suites/integrations/dedupe/scenario-without-dedupe.ts b/dev-packages/node-integration-tests/suites/integrations/dedupe/scenario-without-dedupe.ts
new file mode 100644
index 000000000000..01c67101c2cd
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/integrations/dedupe/scenario-without-dedupe.ts
@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
+});
+
+for (let i = 0; i < 2; i++) {
+ Sentry.captureException(new Error('duplicate error'));
+}
diff --git a/dev-packages/node-integration-tests/suites/integrations/dedupe/scenario.ts b/dev-packages/node-integration-tests/suites/integrations/dedupe/scenario.ts
new file mode 100644
index 000000000000..282963f2186b
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/integrations/dedupe/scenario.ts
@@ -0,0 +1,21 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+});
+
+function captureError(): void {
+ Sentry.captureException(new Error('duplicate error'));
+}
+
+function captureMessage(): void {
+ Sentry.captureMessage('duplicate message');
+}
+
+// One call site for all captures, so that equal events also have equal stack traces.
+for (const capture of [captureError, captureError, captureMessage, captureMessage, captureError]) {
+ capture();
+}
diff --git a/dev-packages/node-integration-tests/suites/integrations/dedupe/test.ts b/dev-packages/node-integration-tests/suites/integrations/dedupe/test.ts
new file mode 100644
index 000000000000..8c1af089cebb
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/integrations/dedupe/test.ts
@@ -0,0 +1,34 @@
+import { afterAll, describe, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+describe('Dedupe integration', () => {
+ afterAll(() => {
+ cleanupChildProcesses();
+ });
+
+ test('drops an event that duplicates the event captured right before it', async () => {
+ await createRunner(__dirname, 'scenario.ts')
+ .unignore('client_report')
+ // Event processing is async, so on Bun a later event can be sent before an earlier one.
+ .unordered()
+ .expect({ event: { exception: { values: [{ type: 'Error', value: 'duplicate error' }] } } })
+ .expect({ event: { message: 'duplicate message' } })
+ // Same error as the first event, but not a duplicate of the message event right before it.
+ .expect({ event: { exception: { values: [{ type: 'Error', value: 'duplicate error' }] } } })
+ .expect({
+ client_report: {
+ discarded_events: [{ category: 'error', quantity: 2, reason: 'event_processor' }],
+ },
+ })
+ .start()
+ .completed();
+ });
+
+ test('sends duplicate events when the integration is removed', async () => {
+ await createRunner(__dirname, 'scenario-without-dedupe.ts')
+ .expect({ event: { exception: { values: [{ type: 'Error', value: 'duplicate error' }] } } })
+ .expect({ event: { exception: { values: [{ type: 'Error', value: 'duplicate error' }] } } })
+ .start()
+ .completed();
+ });
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/anthropic/scenario-with-response.mjs b/dev-packages/node-integration-tests/suites/tracing/anthropic/scenario-with-response.mjs
index c7e0a4f5a9ce..704453d9b158 100644
--- a/dev-packages/node-integration-tests/suites/tracing/anthropic/scenario-with-response.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/anthropic/scenario-with-response.mjs
@@ -6,6 +6,16 @@ function startMockAnthropicServer() {
const app = express();
app.use(express.json());
+ app.post('/anthropic/v1/complete', (req, res) => {
+ res.send({
+ id: 'compl_withresponse',
+ type: 'completion',
+ model: req.body.model,
+ completion: 'Testing .asResponse() method!',
+ stop_reason: 'stop_sequence',
+ });
+ });
+
app.post('/anthropic/v1/messages', (req, res) => {
const model = req.body.model;
@@ -135,6 +145,8 @@ async function run() {
// Call .asResponse() and verify it returns raw Response
const rawResponse = await result2.asResponse();
+ await rawResponse.json();
+
// Verify response is a Response object with correct headers
if (!(rawResponse instanceof Response)) {
throw new Error('.asResponse() did not return a Response object');
@@ -188,6 +200,34 @@ async function run() {
for await (const _ of streamWithResponse.data) {
void _;
}
+
+ const betaResponse = await client.beta.messages
+ .create({
+ model: 'claude-3-haiku-20240307',
+ max_tokens: 100,
+ messages: [{ role: 'user', content: 'Test beta asResponse' }],
+ })
+ .asResponse();
+ await betaResponse.json();
+
+ const completionResponse = await client.completions
+ .create({
+ model: 'claude-2',
+ max_tokens_to_sample: 100,
+ prompt: '\n\nHuman: Test asResponse\n\nAssistant:',
+ })
+ .asResponse();
+ await completionResponse.json();
+
+ const rawStreamResponse = await client.messages
+ .create({
+ model: 'claude-3-haiku-20240307',
+ max_tokens: 100,
+ messages: [{ role: 'user', content: 'Test streaming asResponse' }],
+ stream: true,
+ })
+ .asResponse();
+ await rawStreamResponse.text();
});
// Wait for the stream event handler to finish
diff --git a/dev-packages/node-integration-tests/suites/tracing/anthropic/test.ts b/dev-packages/node-integration-tests/suites/tracing/anthropic/test.ts
index ee2bb16b37dc..937ae389ca30 100644
--- a/dev-packages/node-integration-tests/suites/tracing/anthropic/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/anthropic/test.ts
@@ -40,11 +40,11 @@ describe('Anthropic integration', () => {
})
.expect({
span: container => {
- expect(container.items).toHaveLength(3);
+ expect(container.items).toHaveLength(6);
const nonStreamingSpans = container.items.filter(
span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'msg_withresponse',
);
- expect(nonStreamingSpans).toHaveLength(2);
+ expect(nonStreamingSpans).toHaveLength(1);
for (const span of nonStreamingSpans) {
expect(span.name).toBe('chat claude-3-haiku-20240307');
expect(span.status).toBe('ok');
@@ -59,6 +59,21 @@ describe('Anthropic integration', () => {
expect(streamingSpan!.name).toBe('chat claude-3-haiku-20240307');
expect(streamingSpan!.status).toBe('ok');
expect(streamingSpan!.attributes[GEN_AI_RESPONSE_STREAMING].value).toBe(true);
+
+ const rawResponseSpans = container.items.filter(span => span.attributes[GEN_AI_RESPONSE_ID] === undefined);
+ expect(rawResponseSpans).toHaveLength(4);
+ for (const span of rawResponseSpans) {
+ expect(span.name).toBe(`chat ${span.attributes[GEN_AI_REQUEST_MODEL].value}`);
+ expect(span.status).toBe('ok');
+ expect(span.attributes[GEN_AI_OPERATION_NAME].value).toBe('chat');
+ expect(span.attributes[GEN_AI_RESPONSE_MODEL]).toBeUndefined();
+ }
+ expect(rawResponseSpans.map(span => span.attributes[GEN_AI_REQUEST_MODEL].value)).toEqual([
+ 'claude-3-haiku-20240307',
+ 'claude-3-haiku-20240307',
+ 'claude-2',
+ 'claude-3-haiku-20240307',
+ ]);
},
})
.start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/groq/scenario.mjs b/dev-packages/node-integration-tests/suites/tracing/groq/scenario.mjs
index 03f656eb1ee4..e7f5561190ce 100644
--- a/dev-packages/node-integration-tests/suites/tracing/groq/scenario.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/groq/scenario.mjs
@@ -130,6 +130,31 @@ async function run() {
model: 'nomic-embed-text-v1_5',
input: 'Embedding test!',
});
+
+ const rawChatResponse = await client.chat.completions
+ .create({
+ model: 'llama-3.3-70b-versatile',
+ messages: [{ role: 'user', content: 'Raw response test!' }],
+ })
+ .asResponse();
+ await rawChatResponse.json();
+
+ const rawStreamResponse = await client.chat.completions
+ .create({
+ model: 'llama-3.1-8b-instant',
+ messages: [{ role: 'user', content: 'Raw stream test!' }],
+ stream: true,
+ })
+ .asResponse();
+ await rawStreamResponse.text();
+
+ const rawEmbeddingsResponse = await client.embeddings
+ .create({
+ model: 'nomic-embed-text-v1_5',
+ input: 'Raw embedding test!',
+ })
+ .asResponse();
+ await rawEmbeddingsResponse.json();
});
await Sentry.flush(2000);
diff --git a/dev-packages/node-integration-tests/suites/tracing/groq/test.ts b/dev-packages/node-integration-tests/suites/tracing/groq/test.ts
index c494401817b0..5797f38d2d1b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/groq/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/groq/test.ts
@@ -74,6 +74,25 @@ describe('Groq integration', () => {
expect(embeddingsSpan!.attributes[GEN_AI_PROVIDER_NAME]?.value).toBe(PROVIDER);
expect(embeddingsSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBe(8);
expect(embeddingsSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]).toBeUndefined();
+
+ const rawSpans = container.items.filter(
+ s =>
+ s.attributes[GEN_AI_PROVIDER_NAME]?.value === PROVIDER &&
+ s.status === 'ok' &&
+ s.attributes[GEN_AI_RESPONSE_ID] === undefined,
+ );
+ expect(rawSpans).toHaveLength(3);
+ expect(rawSpans.map(s => s.name)).toEqual([
+ 'chat llama-3.3-70b-versatile',
+ 'chat llama-3.1-8b-instant',
+ 'embeddings nomic-embed-text-v1_5',
+ ]);
+ for (const span of rawSpans) {
+ expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]?.value).toBe(ORIGIN);
+ expect(span.attributes[GEN_AI_RESPONSE_MODEL]).toBeUndefined();
+ expect(span.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toBeUndefined();
+ expect(span.attributes[GEN_AI_RESPONSE_TEXT]).toBeUndefined();
+ }
},
})
.start()
@@ -100,6 +119,26 @@ describe('Groq integration', () => {
);
expect(embeddingsSpan).toBeDefined();
expect(embeddingsSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]?.value).toContain('Embedding test!');
+
+ const rawChatSpan = container.items.find(
+ s =>
+ s.attributes[GEN_AI_REQUEST_MODEL]?.value === 'llama-3.3-70b-versatile' &&
+ s.attributes[GEN_AI_RESPONSE_ID] === undefined,
+ );
+ expect(rawChatSpan).toBeDefined();
+ expect(rawChatSpan!.attributes[GEN_AI_INPUT_MESSAGES]?.value).toBe(
+ '[{"role":"user","content":"Raw response test!"}]',
+ );
+ expect(rawChatSpan!.attributes[GEN_AI_RESPONSE_TEXT]).toBeUndefined();
+
+ const rawEmbeddingsSpan = container.items.find(
+ s =>
+ s.attributes[GEN_AI_REQUEST_MODEL]?.value === 'nomic-embed-text-v1_5' &&
+ s.attributes[GEN_AI_RESPONSE_ID] === undefined,
+ );
+ expect(rawEmbeddingsSpan).toBeDefined();
+ expect(rawEmbeddingsSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]?.value).toContain('Raw embedding test!');
+ expect(rawEmbeddingsSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toBeUndefined();
},
})
.start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts b/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts
index e5332df32f76..e6866955ca5c 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts
@@ -1,6 +1,7 @@
import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
import type { SerializedStreamedSpanContainer } from '@sentry/core';
import { afterAll, describe, expect } from 'vitest';
+import { EXPECTED_SDK_NAME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
describeWithDockerCompose(
@@ -135,7 +136,7 @@ describeWithDockerCompose(
'sentry.op': op,
'sentry.origin': ORIGIN,
'sentry.release': '1.0',
- 'sentry.sdk.name': 'sentry.javascript.node',
+ 'sentry.sdk.name': EXPECTED_SDK_NAME,
'sentry.segment.name': SEGMENT_NAME,
'server.address': HOST,
'server.port': PORT,
diff --git a/dev-packages/node-integration-tests/suites/tracing/openai/scenario-chat.mjs b/dev-packages/node-integration-tests/suites/tracing/openai/scenario-chat.mjs
index 6031b6861f5b..6b8bc76b582b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/openai/scenario-chat.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/openai/scenario-chat.mjs
@@ -270,6 +270,17 @@ async function run() {
} catch {
// Error is expected and handled
}
+
+ // scenario: parse responses
+ await client.chat.completions.parse({
+ model: 'gpt-4o',
+ messages: [{ role: 'user', content: 'What is the capital of France?' }],
+ });
+
+ await client.responses.parse({
+ model: 'gpt-4o',
+ input: 'What is the capital of France?',
+ });
});
server.close();
diff --git a/dev-packages/node-integration-tests/suites/tracing/openai/scenario-conversation.mjs b/dev-packages/node-integration-tests/suites/tracing/openai/scenario-conversation.mjs
index 7088a6ca9cbe..1075bd80bf2b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/openai/scenario-conversation.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/openai/scenario-conversation.mjs
@@ -87,6 +87,9 @@ async function run() {
input: 'Explain why that is funny',
previous_response_id: firstResponse.id,
});
+
+ const rawResponse = await client.conversations.create().asResponse();
+ await rawResponse.json();
});
server.close();
diff --git a/dev-packages/node-integration-tests/suites/tracing/openai/scenario-embeddings.mjs b/dev-packages/node-integration-tests/suites/tracing/openai/scenario-embeddings.mjs
index 42c6a94c5199..688f407873b1 100644
--- a/dev-packages/node-integration-tests/suites/tracing/openai/scenario-embeddings.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/openai/scenario-embeddings.mjs
@@ -73,6 +73,14 @@ async function run() {
input: ['First input text', 'Second input text', 'Third input text'],
model: 'text-embedding-3-small',
});
+
+ const rawResponse = await client.embeddings
+ .create({
+ input: 'Raw embedding test!',
+ model: 'text-embedding-3-large',
+ })
+ .asResponse();
+ await rawResponse.json();
});
server.close();
diff --git a/dev-packages/node-integration-tests/suites/tracing/openai/test.ts b/dev-packages/node-integration-tests/suites/tracing/openai/test.ts
index 0a2be19dbc3f..a27e3308179a 100644
--- a/dev-packages/node-integration-tests/suites/tracing/openai/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/openai/test.ts
@@ -1,4 +1,5 @@
import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import type { SerializedStreamedSpanContainer } from '@sentry/core';
import { afterAll, describe, expect } from 'vitest';
import {
GEN_AI_CONVERSATION_ID,
@@ -36,9 +37,11 @@ describe('OpenAI integration', () => {
.expect({ transaction: { transaction: 'main' } })
.expect({
span: container => {
- expect(container.items).toHaveLength(6);
+ expect(container.items).toHaveLength(8);
const chatCompletionSpan = container.items.find(
- span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123',
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-3.5-turbo',
);
expect(chatCompletionSpan).toBeDefined();
expect(chatCompletionSpan!.name).toBe('chat gpt-3.5-turbo');
@@ -93,7 +96,9 @@ describe('OpenAI integration', () => {
});
const responsesSpan = container.items.find(
- span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456',
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-3.5-turbo',
);
expect(responsesSpan).toBeDefined();
expect(responsesSpan!.name).toBe('chat gpt-3.5-turbo');
@@ -323,6 +328,109 @@ describe('OpenAI integration', () => {
value: 'auto.ai.openai',
});
+ const parsedChatCompletionSpan = container.items.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedChatCompletionSpan).toBeDefined();
+ expect(parsedChatCompletionSpan!.name).toBe('chat gpt-4o');
+ expect(parsedChatCompletionSpan!.status).toBe('ok');
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'chat',
+ });
+ expect(parsedChatCompletionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(parsedChatCompletionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
+ type: 'string',
+ value: 'openai',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_ID]).toEqual({
+ type: 'string',
+ value: 'chatcmpl-mock123',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_FINISH_REASONS]).toEqual({
+ type: 'string',
+ value: '["stop"]',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 10,
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 15,
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toEqual({
+ type: 'integer',
+ value: 25,
+ });
+
+ const parsedResponsesSpan = container.items.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedResponsesSpan).toBeDefined();
+ expect(parsedResponsesSpan!.name).toBe('chat gpt-4o');
+ expect(parsedResponsesSpan!.status).toBe('ok');
+ expect(parsedResponsesSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'chat',
+ });
+ expect(parsedResponsesSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(parsedResponsesSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({ type: 'string', value: 'openai' });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_ID]).toEqual({
+ type: 'string',
+ value: 'resp_mock456',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_FINISH_REASONS]).toEqual({
+ type: 'string',
+ value: '["completed"]',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 5,
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 8,
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toEqual({
+ type: 'integer',
+ value: 13,
+ });
+
// GenAI inputs and outputs must never be recorded when `dataCollection.genAI` disables them.
// Asserting over every span in the envelope catches attributes leaking onto
// spans which are not individually inspected above.
@@ -345,9 +453,11 @@ describe('OpenAI integration', () => {
.expect({ transaction: { transaction: 'main' } })
.expect({
span: container => {
- expect(container.items).toHaveLength(6);
+ expect(container.items).toHaveLength(8);
const chatCompletionSpan = container.items.find(
- span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123',
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-3.5-turbo',
);
expect(chatCompletionSpan).toBeDefined();
expect(chatCompletionSpan!.name).toBe('chat gpt-3.5-turbo');
@@ -414,7 +524,9 @@ describe('OpenAI integration', () => {
});
const responsesSpan = container.items.find(
- span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456',
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-3.5-turbo',
);
expect(responsesSpan).toBeDefined();
expect(responsesSpan!.name).toBe('chat gpt-3.5-turbo');
@@ -679,6 +791,126 @@ describe('OpenAI integration', () => {
type: 'string',
value: 'auto.ai.openai',
});
+
+ const parsedChatCompletionSpan = container.items.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedChatCompletionSpan).toBeDefined();
+ expect(parsedChatCompletionSpan!.name).toBe('chat gpt-4o');
+ expect(parsedChatCompletionSpan!.status).toBe('ok');
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'chat',
+ });
+ expect(parsedChatCompletionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(parsedChatCompletionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
+ type: 'string',
+ value: 'openai',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_INPUT_MESSAGES]).toEqual({
+ type: 'string',
+ value: '[{"role":"user","content":"What is the capital of France?"}]',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_SYSTEM_INSTRUCTIONS]).toBeUndefined();
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_ID]).toEqual({
+ type: 'string',
+ value: 'chatcmpl-mock123',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_FINISH_REASONS]).toEqual({
+ type: 'string',
+ value: '["stop"]',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_TEXT]).toEqual({
+ type: 'string',
+ value: '["Hello from OpenAI mock!"]',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 10,
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 15,
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toEqual({
+ type: 'integer',
+ value: 25,
+ });
+
+ const parsedResponsesSpan = container.items.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedResponsesSpan).toBeDefined();
+ expect(parsedResponsesSpan!.name).toBe('chat gpt-4o');
+ expect(parsedResponsesSpan!.status).toBe('ok');
+ expect(parsedResponsesSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'chat',
+ });
+ expect(parsedResponsesSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(parsedResponsesSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({ type: 'string', value: 'openai' });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_INPUT_MESSAGES]).toEqual({
+ type: 'string',
+ value: 'What is the capital of France?',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_TEXT]).toEqual({
+ type: 'string',
+ value: 'Response to: What is the capital of France?',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_FINISH_REASONS]).toEqual({
+ type: 'string',
+ value: '["completed"]',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_ID]).toEqual({
+ type: 'string',
+ value: 'resp_mock456',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 5,
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS]).toEqual({
+ type: 'integer',
+ value: 8,
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toEqual({
+ type: 'integer',
+ value: 13,
+ });
},
})
.start()
@@ -692,9 +924,11 @@ describe('OpenAI integration', () => {
.expect({ transaction: { transaction: 'main' } })
.expect({
span: container => {
- expect(container.items).toHaveLength(6);
+ expect(container.items).toHaveLength(8);
const chatCompletionSpan = container.items.find(
- span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123',
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-3.5-turbo',
);
expect(chatCompletionSpan).toBeDefined();
expect(chatCompletionSpan!.attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE]).toBeUndefined();
@@ -723,6 +957,38 @@ describe('OpenAI integration', () => {
type: 'string',
value: expect.any(String),
});
+
+ const parsedChatCompletionSpan = container.items.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedChatCompletionSpan).toBeDefined();
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE]).toBeUndefined();
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_INPUT_MESSAGES]).toMatchObject({
+ type: 'string',
+ value: expect.any(String),
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_RESPONSE_TEXT]).toMatchObject({
+ type: 'string',
+ value: expect.any(String),
+ });
+
+ const parsedResponsesSpan = container.items.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedResponsesSpan).toBeDefined();
+ expect(parsedResponsesSpan!.attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE]).toBeUndefined();
+ expect(parsedResponsesSpan!.attributes[GEN_AI_INPUT_MESSAGES]).toMatchObject({
+ type: 'string',
+ value: expect.any(String),
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_RESPONSE_TEXT]).toMatchObject({
+ type: 'string',
+ value: expect.any(String),
+ });
},
})
.start()
@@ -740,7 +1006,7 @@ describe('OpenAI integration', () => {
})
.expect({
span: container => {
- expect(container.items).toHaveLength(3);
+ expect(container.items).toHaveLength(4);
const singleEmbeddingSpan = container.items.find(
span =>
span.name === 'embeddings text-embedding-3-small' &&
@@ -865,6 +1131,34 @@ describe('OpenAI integration', () => {
expect(span.attributes[GEN_AI_RESPONSE_TEXT]).toBeUndefined();
expect(span.attributes[GEN_AI_EMBEDDINGS_INPUT]).toBeUndefined();
}
+
+ const rawEmbeddingSpan = container.items.find(span => span.name === 'embeddings text-embedding-3-large');
+ expect(rawEmbeddingSpan).toBeDefined();
+ expect(rawEmbeddingSpan!.name).toBe('embeddings text-embedding-3-large');
+ expect(rawEmbeddingSpan!.status).toBe('ok');
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'embeddings',
+ });
+ expect(rawEmbeddingSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.embeddings',
+ });
+ expect(rawEmbeddingSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
+ type: 'string',
+ value: 'openai',
+ });
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'text-embedding-3-large',
+ });
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_RESPONSE_MODEL]).toBeUndefined();
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toBeUndefined();
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toBeUndefined();
},
})
.start()
@@ -882,7 +1176,7 @@ describe('OpenAI integration', () => {
})
.expect({
span: container => {
- expect(container.items).toHaveLength(3);
+ expect(container.items).toHaveLength(4);
const singleEmbeddingSpan = container.items.find(
span => span.attributes[GEN_AI_EMBEDDINGS_INPUT]?.value === 'Embedding test!',
);
@@ -1009,6 +1303,38 @@ describe('OpenAI integration', () => {
type: 'integer',
value: 10,
});
+
+ const rawEmbeddingSpan = container.items.find(span => span.name === 'embeddings text-embedding-3-large');
+ expect(rawEmbeddingSpan).toBeDefined();
+ expect(rawEmbeddingSpan!.name).toBe('embeddings text-embedding-3-large');
+ expect(rawEmbeddingSpan!.status).toBe('ok');
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'embeddings',
+ });
+ expect(rawEmbeddingSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.embeddings',
+ });
+ expect(rawEmbeddingSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
+ type: 'string',
+ value: 'openai',
+ });
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'text-embedding-3-large',
+ });
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_RESPONSE_MODEL]).toBeUndefined();
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toBeUndefined();
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toBeUndefined();
+ expect(rawEmbeddingSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]).toEqual({
+ type: 'string',
+ value: 'Raw embedding test!',
+ });
},
})
.start()
@@ -1111,7 +1437,7 @@ describe('OpenAI integration', () => {
})
.expect({
span: container => {
- expect(container.items).toHaveLength(4);
+ expect(container.items).toHaveLength(5);
const conversationCreateSpan = container.items.find(span => span.name === 'chat unknown');
expect(conversationCreateSpan).toBeDefined();
expect(conversationCreateSpan!.name).toBe('chat unknown');
@@ -1212,6 +1538,30 @@ describe('OpenAI integration', () => {
type: 'string',
value: 'resp_mock_conv_123',
});
+
+ const rawConversationSpan = container.items.find(
+ span => span.name === 'chat unknown' && span.attributes[GEN_AI_CONVERSATION_ID] === undefined,
+ );
+ expect(rawConversationSpan).toBeDefined();
+ expect(rawConversationSpan!.name).toBe('chat unknown');
+ expect(rawConversationSpan!.status).toBe('ok');
+ expect(rawConversationSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'chat',
+ });
+ expect(rawConversationSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(rawConversationSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(rawConversationSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
+ type: 'string',
+ value: 'openai',
+ });
+ expect(rawConversationSpan!.attributes[GEN_AI_CONVERSATION_ID]).toBeUndefined();
},
})
.start()
@@ -1356,17 +1706,24 @@ describe('OpenAI integration', () => {
span: container => {
expect(container.items).toHaveLength(2);
- // Both calls should produce spans with the same response ID
for (const span of container.items) {
expect(span!.name).toBe('chat gpt-4');
expect(span!.status).toBe('ok');
expect(span!.attributes[GEN_AI_OPERATION_NAME]).toEqual({ type: 'string', value: 'chat' });
expect(span!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({ type: 'string', value: 'gpt-4' });
- expect(span!.attributes[GEN_AI_RESPONSE_ID]).toEqual({
- type: 'string',
- value: 'chatcmpl-withresponse',
- });
}
+
+ const parsedSpans = container.items.filter(span => span.attributes[GEN_AI_RESPONSE_ID] !== undefined);
+ expect(parsedSpans).toHaveLength(1);
+ expect(parsedSpans[0]!.attributes[GEN_AI_RESPONSE_ID]).toEqual({
+ type: 'string',
+ value: 'chatcmpl-withresponse',
+ });
+
+ const rawSpans = container.items.filter(span => span.attributes[GEN_AI_RESPONSE_ID] === undefined);
+ expect(rawSpans).toHaveLength(1);
+ expect(rawSpans[0]!.attributes[GEN_AI_RESPONSE_TEXT]).toBeUndefined();
+ expect(rawSpans[0]!.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toBeUndefined();
},
})
.start()
@@ -1376,11 +1733,17 @@ describe('OpenAI integration', () => {
createEsmAndCjsTests(__dirname, 'scenario-chat.mjs', 'instrument-span-streaming.mjs', (createRunner, test) => {
test('creates openai related spans with span streaming enabled', async () => {
+ const spans: SerializedStreamedSpanContainer['items'] = [];
+
await createRunner()
+ .unordered()
.expect({
span: container => {
- const chatCompletionSpan = container.items.find(
- span => span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123',
+ spans.push(...container.items);
+ const chatCompletionSpan = spans.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-3.5-turbo',
);
expect(chatCompletionSpan).toBeDefined();
expect(chatCompletionSpan!.name).toBe('chat gpt-3.5-turbo');
@@ -1403,6 +1766,66 @@ describe('OpenAI integration', () => {
value: '[{"role":"user","content":"What is the capital of France?"}]',
});
expect(chatCompletionSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({ type: 'string', value: 'openai' });
+
+ const parsedChatCompletionSpan = spans.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'chatcmpl-mock123' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedChatCompletionSpan).toBeDefined();
+ expect(parsedChatCompletionSpan!.name).toBe('chat gpt-4o');
+ expect(parsedChatCompletionSpan!.status).toBe('ok');
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
+ type: 'string',
+ value: 'chat',
+ });
+ expect(parsedChatCompletionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(parsedChatCompletionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_INPUT_MESSAGES]).toEqual({
+ type: 'string',
+ value: '[{"role":"user","content":"What is the capital of France?"}]',
+ });
+ expect(parsedChatCompletionSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
+ type: 'string',
+ value: 'openai',
+ });
+
+ const parsedResponsesSpan = spans.find(
+ span =>
+ span.attributes[GEN_AI_RESPONSE_ID]?.value === 'resp_mock456' &&
+ span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4o',
+ );
+ expect(parsedResponsesSpan).toBeDefined();
+ expect(parsedResponsesSpan!.name).toBe('chat gpt-4o');
+ expect(parsedResponsesSpan!.status).toBe('ok');
+ expect(parsedResponsesSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({ type: 'string', value: 'chat' });
+ expect(parsedResponsesSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+ type: 'string',
+ value: 'gen_ai.chat',
+ });
+ expect(parsedResponsesSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+ type: 'string',
+ value: 'auto.ai.openai',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
+ type: 'string',
+ value: 'gpt-4o',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_INPUT_MESSAGES]).toEqual({
+ type: 'string',
+ value: 'What is the capital of France?',
+ });
+ expect(parsedResponsesSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({ type: 'string', value: 'openai' });
},
})
.start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts
index 92a48d809282..3a2cea4a4c74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts
@@ -2,7 +2,7 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
import type { SerializedStreamedSpanContainer } from '@sentry/core';
import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
import { afterAll, describe, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { conditionalTest, EXPECTED_SDK_NAME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
// Query-span origin depends on which instrumentation is active. Blocks driving the SDK's default
@@ -58,7 +58,7 @@ const COMMON_DB_ATTRIBUTES = {
},
'sentry.sdk.name': {
type: 'string',
- value: 'sentry.javascript.node',
+ value: EXPECTED_SDK_NAME,
},
'sentry.sdk.version': {
type: 'string',
@@ -228,7 +228,8 @@ describeWithDockerCompose('postgres auto instrumentation (streamed)', { workingD
});
// Deno: with a module load hook installed, Deno compiles a native addon (`libpq`) as JavaScript.
- conditionalTest({ max: 25, skipRuntimes: ['deno'] })('pg-native', () => {
+ // Bun: the `libpq` addon needs the Node symbol `node::EmitAsyncInit`, which Bun does not provide.
+ conditionalTest({ max: 25, skipRuntimes: ['bun', 'deno'] })('pg-native', () => {
createEsmAndCjsTests(
__dirname,
'scenario-native.mjs',
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
index 304af1aaffb0..6533e2cca588 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
@@ -277,7 +277,8 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
});
// Deno: with a module load hook installed, Deno compiles a native addon (`libpq`) as JavaScript.
- conditionalTest({ max: 25, skipRuntimes: ['deno'] })('pg-native', () => {
+ // Bun: the `libpq` addon needs the Node symbol `node::EmitAsyncInit`, which Bun does not provide.
+ conditionalTest({ max: 25, skipRuntimes: ['bun', 'deno'] })('pg-native', () => {
const EXPECTED_TRANSACTION = {
transaction: 'Test Transaction',
spans: expect.arrayContaining([
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts
index e77702f8242b..5acbaba41e8f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts
@@ -1,7 +1,11 @@
import type { SerializedStreamedSpanContainer } from '@sentry/core';
import { afterAll, describe, expect } from 'vitest';
+import { RUNTIME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
+// On Bun, `postgres` resolves to its ESM build through the `bun` export condition, so
+// `require('postgres')` returns the module namespace instead of the `postgres` function.
+
/**
* Streamed span attributes are `{ value, type }` objects, unlike transaction span `data`,
* which stores values directly.
@@ -168,30 +172,34 @@ describeWithDockerCompose('postgresjs auto instrumentation (streamed)', { workin
},
};
- createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
- test('should auto-instrument `postgres` package', { timeout: 90_000 }, async () => {
- await createTestRunner()
- .expect({
- span: container => {
- expect(container).toMatchObject(EXPECTED_SPANS);
+ createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should auto-instrument `postgres` package',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .expect({
+ span: container => {
+ expect(container).toMatchObject(EXPECTED_SPANS);
- // The assertions above only cover the queries the scenario issues itself. postgres.js
- // also runs internal ones (e.g. the `pg_catalog` type lookup), so guard the invariant
- // across every query span: the name is the summary, never the statement.
- const dbSpans = getDbSpans(container);
- expect(dbSpans.length).toBeGreaterThan(0);
- for (const span of dbSpans) {
- expect(span.name).toBe(span.attributes['db.query.summary']?.value);
- }
- },
- })
- .expect({ event: EXPECTED_ERROR_EVENT })
- // The error event is captured via an unhandled rejection processed on a later tick than
- // the spans, so the two envelopes can reach the transport in either order.
- .unordered()
- .start()
- .completed();
- });
+ // The assertions above only cover the queries the scenario issues itself. postgres.js
+ // also runs internal ones (e.g. the `pg_catalog` type lookup), so guard the invariant
+ // across every query span: the name is the summary, never the statement.
+ const dbSpans = getDbSpans(container);
+ expect(dbSpans.length).toBeGreaterThan(0);
+ for (const span of dbSpans) {
+ expect(span.name).toBe(span.attributes['db.query.summary']?.value);
+ }
+ },
+ })
+ .expect({ event: EXPECTED_ERROR_EVENT })
+ // The error event is captured via an unhandled rejection processed on a later tick than
+ // the spans, so the two envelopes can reach the transport in either order.
+ .unordered()
+ .start()
+ .completed();
+ },
+ );
});
});
@@ -228,10 +236,14 @@ describeWithDockerCompose('postgresjs auto instrumentation (streamed)', { workin
__dirname,
'scenario-requestHook.mjs',
'instrument-requestHook.mjs',
- (createTestRunner, test) => {
- test('should call requestHook when provided', { timeout: 90_000 }, async () => {
- await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
- });
+ (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should call requestHook when provided',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
+ },
+ );
},
);
});
@@ -262,10 +274,14 @@ describeWithDockerCompose('postgresjs auto instrumentation (streamed)', { workin
]),
};
- createEsmAndCjsTests(__dirname, 'scenario-url.mjs', 'instrument.mjs', (createTestRunner, test) => {
- test('should instrument postgres package with URL initialization', { timeout: 90_000 }, async () => {
- await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
- });
+ createEsmAndCjsTests(__dirname, 'scenario-url.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should instrument postgres package with URL initialization',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
+ },
+ );
});
});
@@ -296,10 +312,14 @@ describeWithDockerCompose('postgresjs auto instrumentation (streamed)', { workin
]),
};
- createEsmAndCjsTests(__dirname, 'scenario-unsafe.mjs', 'instrument.mjs', (createTestRunner, test) => {
- test('should instrument sql.unsafe() queries', { timeout: 90_000 }, async () => {
- await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
- });
+ createEsmAndCjsTests(__dirname, 'scenario-unsafe.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should instrument sql.unsafe() queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
+ },
+ );
});
});
});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
index d893e5200004..a0fffe40d453 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
@@ -1,6 +1,10 @@
import { afterAll, describe, expect } from 'vitest';
+import { RUNTIME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
+// On Bun, `postgres` resolves to its ESM build through the `bun` export condition, so
+// `require('postgres')` returns the module namespace instead of the `postgres` function.
+
describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory: [__dirname] }, () => {
afterAll(() => {
cleanupChildProcesses();
@@ -223,17 +227,21 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
},
};
- createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
- test('should auto-instrument `postgres` package', { timeout: 60_000 }, async () => {
- await createTestRunner()
- .expect({ transaction: EXPECTED_TRANSACTION })
- .expect({ event: EXPECTED_ERROR_EVENT })
- // The error event is captured via an unhandled rejection processed on a later tick than
- // the transaction, so the two envelopes can reach the transport in either order.
- .unordered()
- .start()
- .completed();
- });
+ createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should auto-instrument `postgres` package',
+ { timeout: 60_000 },
+ async () => {
+ await createTestRunner()
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .expect({ event: EXPECTED_ERROR_EVENT })
+ // The error event is captured via an unhandled rejection processed on a later tick than
+ // the transaction, so the two envelopes can reach the transport in either order.
+ .unordered()
+ .start()
+ .completed();
+ },
+ );
});
});
@@ -326,10 +334,14 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
__dirname,
'scenario-requestHook.mjs',
'instrument-requestHook.mjs',
- (createTestRunner, test) => {
- test('should call requestHook when provided', { timeout: 60_000 }, async () => {
- await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
- });
+ (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should call requestHook when provided',
+ { timeout: 60_000 },
+ async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ },
+ );
},
);
});
@@ -407,10 +419,14 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
]),
};
- createEsmAndCjsTests(__dirname, 'scenario-url.mjs', 'instrument.mjs', (createTestRunner, test) => {
- test('should instrument postgres package with URL initialization', { timeout: 90_000 }, async () => {
- await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
- });
+ createEsmAndCjsTests(__dirname, 'scenario-url.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should instrument postgres package with URL initialization',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ },
+ );
});
});
@@ -486,12 +502,16 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
]),
};
- createEsmAndCjsTests(__dirname, 'scenario-unsafe.mjs', 'instrument.mjs', (createTestRunner, test) => {
- test('should instrument sql.unsafe() queries', { timeout: 90_000 }, async () => {
- // The last query fails on purpose, and its unhandled rejection also sends an error event, which can
- // arrive before the transaction.
- await createTestRunner().ignore('event').expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
- });
+ createEsmAndCjsTests(__dirname, 'scenario-unsafe.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
+ test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+ 'should instrument sql.unsafe() queries',
+ { timeout: 90_000 },
+ async () => {
+ // The last query fails on purpose, and its unhandled rejection also sends an error event, which can
+ // arrive before the transaction.
+ await createTestRunner().ignore('event').expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ },
+ );
});
});
});
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts b/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts
index a6c77cd01225..2e8de3443a55 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts
@@ -1,6 +1,7 @@
import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
import type { SerializedStreamedSpanContainer } from '@sentry/core';
import { afterAll, describe, expect } from 'vitest';
+import { EXPECTED_SDK_NAME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory: [__dirname] }, () => {
@@ -705,7 +706,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
'sentry.kind': 'client',
'sentry.origin': redisOrigin,
'sentry.release': '1.0',
- 'sentry.sdk.name': 'sentry.javascript.node',
+ 'sentry.sdk.name': EXPECTED_SDK_NAME,
'sentry.segment.name': segmentName,
[SENTRY_TRACE_LIFECYCLE]: 'stream',
}),
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts b/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts
index 77cf91663ed0..06d8cac5a465 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts
@@ -1,6 +1,7 @@
import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
import type { SerializedStreamedSpanContainer } from '@sentry/core';
import { afterAll, describe, expect } from 'vitest';
+import { EXPECTED_SDK_NAME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
describeWithDockerCompose(
@@ -183,7 +184,7 @@ describeWithDockerCompose(
'sentry.op': op,
'sentry.origin': ORIGIN,
'sentry.release': '1.0',
- 'sentry.sdk.name': 'sentry.javascript.node',
+ 'sentry.sdk.name': EXPECTED_SDK_NAME,
'sentry.segment.name': SEGMENT_NAME,
'server.address': HOST,
'server.port': PORT,
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis/test.ts b/dev-packages/node-integration-tests/suites/tracing/redis/test.ts
index 8d5b9339ec33..50cd473957b8 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/redis/test.ts
@@ -1,6 +1,7 @@
import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
import { SEMANTIC_ATTRIBUTE_SENTRY_OP, type SerializedStreamedSpanContainer } from '@sentry/core';
import { afterAll, describe, expect } from 'vitest';
+import { EXPECTED_SDK_NAME } from '../../../utils';
import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
describeWithDockerCompose('redis auto instrumentation', { workingDirectory: [__dirname] }, () => {
@@ -85,7 +86,7 @@ describeWithDockerCompose('redis auto instrumentation', { workingDirectory: [__d
'sentry.op': { type: 'string', value: redisSpanOp },
'sentry.origin': { type: 'string', value: origin },
'sentry.release': { type: 'string', value: '1.0' },
- 'sentry.sdk.name': { type: 'string', value: 'sentry.javascript.node' },
+ 'sentry.sdk.name': { type: 'string', value: EXPECTED_SDK_NAME },
'sentry.sdk.version': { type: 'string', value: expect.any(String) },
'sentry.segment.id': { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
'sentry.segment.name': { type: 'string', value: 'Test Span' },
diff --git a/dev-packages/node-integration-tests/suites/tracing/together-ai/scenario.mjs b/dev-packages/node-integration-tests/suites/tracing/together-ai/scenario.mjs
index 6ef405ed2abf..0fc375370abd 100644
--- a/dev-packages/node-integration-tests/suites/tracing/together-ai/scenario.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/together-ai/scenario.mjs
@@ -129,6 +129,31 @@ async function run() {
model: 'togethercomputer/m2-bert-80M-8k-retrieval',
input: 'Embedding test!',
});
+
+ const rawChatResponse = await client.chat.completions
+ .create({
+ model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+ messages: [{ role: 'user', content: 'Raw response test!' }],
+ })
+ .asResponse();
+ await rawChatResponse.json();
+
+ const rawStreamResponse = await client.chat.completions
+ .create({
+ model: 'meta-llama/Llama-3.1-8B-Instruct-Turbo',
+ messages: [{ role: 'user', content: 'Raw stream test!' }],
+ stream: true,
+ })
+ .asResponse();
+ await rawStreamResponse.text();
+
+ const rawEmbeddingsResponse = await client.embeddings
+ .create({
+ model: 'togethercomputer/m2-bert-80M-8k-retrieval',
+ input: 'Raw embedding test!',
+ })
+ .asResponse();
+ await rawEmbeddingsResponse.json();
});
await Sentry.flush(2000);
diff --git a/dev-packages/node-integration-tests/suites/tracing/together-ai/test.ts b/dev-packages/node-integration-tests/suites/tracing/together-ai/test.ts
index c33de6ebfb53..2e7c3b94dc7b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/together-ai/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/together-ai/test.ts
@@ -74,6 +74,25 @@ describe('Together integration', () => {
expect(embeddingsSpan!.attributes[GEN_AI_PROVIDER_NAME]?.value).toBe(PROVIDER);
expect(embeddingsSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBe(8);
expect(embeddingsSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]).toBeUndefined();
+
+ const rawSpans = container.items.filter(
+ s =>
+ s.attributes[GEN_AI_PROVIDER_NAME]?.value === PROVIDER &&
+ s.status === 'ok' &&
+ s.attributes[GEN_AI_RESPONSE_ID] === undefined,
+ );
+ expect(rawSpans).toHaveLength(3);
+ expect(rawSpans.map(s => s.name)).toEqual([
+ 'chat meta-llama/Llama-3.3-70B-Instruct-Turbo',
+ 'chat meta-llama/Llama-3.1-8B-Instruct-Turbo',
+ 'embeddings togethercomputer/m2-bert-80M-8k-retrieval',
+ ]);
+ for (const span of rawSpans) {
+ expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]?.value).toBe(ORIGIN);
+ expect(span.attributes[GEN_AI_RESPONSE_MODEL]).toBeUndefined();
+ expect(span.attributes[GEN_AI_USAGE_TOTAL_TOKENS]).toBeUndefined();
+ expect(span.attributes[GEN_AI_RESPONSE_TEXT]).toBeUndefined();
+ }
},
})
.start()
@@ -100,6 +119,26 @@ describe('Together integration', () => {
);
expect(embeddingsSpan).toBeDefined();
expect(embeddingsSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]?.value).toContain('Embedding test!');
+
+ const rawChatSpan = container.items.find(
+ s =>
+ s.attributes[GEN_AI_REQUEST_MODEL]?.value === 'meta-llama/Llama-3.3-70B-Instruct-Turbo' &&
+ s.attributes[GEN_AI_RESPONSE_ID] === undefined,
+ );
+ expect(rawChatSpan).toBeDefined();
+ expect(rawChatSpan!.attributes[GEN_AI_INPUT_MESSAGES]?.value).toBe(
+ '[{"role":"user","content":"Raw response test!"}]',
+ );
+ expect(rawChatSpan!.attributes[GEN_AI_RESPONSE_TEXT]).toBeUndefined();
+
+ const rawEmbeddingsSpan = container.items.find(
+ s =>
+ s.attributes[GEN_AI_REQUEST_MODEL]?.value === 'togethercomputer/m2-bert-80M-8k-retrieval' &&
+ s.attributes[GEN_AI_RESPONSE_ID] === undefined,
+ );
+ expect(rawEmbeddingsSpan).toBeDefined();
+ expect(rawEmbeddingsSpan!.attributes[GEN_AI_EMBEDDINGS_INPUT]?.value).toContain('Raw embedding test!');
+ expect(rawEmbeddingsSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS]).toBeUndefined();
},
})
.start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs
index 8f18b1779ced..8a06ee49c873 100644
--- a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs
+++ b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs
@@ -7,4 +7,6 @@ Sentry.init({
release: '1.0',
transport: loggingTransport,
tracesSampleRate: 1.0,
+ // Each request captures the same error, which Dedupe would drop after the first request.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
diff --git a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts
index 18536be6786e..d9b232f2ccc9 100644
--- a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts
@@ -6,6 +6,8 @@ Sentry.init({
dsn: 'https://public@dsn.ingest.sentry.io/1337',
release: '1.0',
transport: loggingTransport,
+ // Each request captures the same error, which Dedupe would drop after the first request.
+ integrations: integrations => integrations.filter(integration => integration.name !== 'Dedupe'),
});
import express from 'express';
diff --git a/dev-packages/node-integration-tests/utils/runner/createRunner.ts b/dev-packages/node-integration-tests/utils/runner/createRunner.ts
index e737cfa4be8e..ed94c1e1bd5a 100644
--- a/dev-packages/node-integration-tests/utils/runner/createRunner.ts
+++ b/dev-packages/node-integration-tests/utils/runner/createRunner.ts
@@ -14,7 +14,7 @@ import type {
} from '@sentry/core';
import { normalize } from '@sentry/core';
import { createBasicSentryServer } from '@sentry-internal/test-utils';
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
import { existsSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
@@ -501,8 +501,9 @@ export function createRunner(...paths: string[]) {
!ensureNoErrorOutput && (expectedEnvelopes.length > 0 || (expectedEnvelopeHeaders?.length ?? 0) > 0);
const runtime = getRuntime();
const childFlags = wantsAutoFlush ? [...buildAutoFlushFlags(flags, testPath, runtime), ...flags] : flags;
+ const entryPath = buildScenario(runtime, testPath);
- child = spawn(runtime, buildRuntimeArgs(runtime, childFlags, testPath), { env, cwd: PACKAGE_ROOT });
+ child = spawn(runtime, buildRuntimeArgs(runtime, childFlags, entryPath), { env, cwd: PACKAGE_ROOT });
spawnedAt = Date.now();
child.on('error', e => {
@@ -794,6 +795,27 @@ function buildAutoFlushFlags(existingFlags: readonly string[], testPath: string,
* `DENO_IMPORT_MAP`. Any other Node flag throws, so a suite that needs one fails with a clear
* message instead of running with different behavior.
*/
+/**
+ * Returns the file the runtime runs for `testPath`. When `RUNTIME_BUILD_SCRIPT` is set, that
+ * script is run by the same runtime with `testPath`, builds the scenario, and prints
+ * `BUILD_OK