add e2e

Author: chargome

dev-packages/e2e-tests/test-applications/nextjs-15/app/api/endpoint-behind-middleware-2/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export function GET() {
+  return NextResponse.json({ name: 'Jane Doe' });
+}

dev-packages/e2e-tests/test-applications/nextjs-15/app/api/endpoint-behind-middleware/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export function GET() {
+  return NextResponse.json({ name: 'John Doe' });
+}

dev-packages/e2e-tests/test-applications/nextjs-15/middleware.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export async function middleware(request: NextRequest) {
+  // Keep this invocation in-flight for a bit so a concurrent request to the other matched endpoint genuinely
+  // overlaps with it — the concurrency test in tests/middleware.test.ts relies on this overlap.
+  if (request.nextUrl.pathname === '/api/endpoint-behind-middleware-2') {
+    await new Promise(resolve => setTimeout(resolve, 300));
+  }
+
+  return NextResponse.next();
+}
+
+// See "Matching Paths" below to learn more
+export const config = {
+  matcher: ['/api/endpoint-behind-middleware', '/api/endpoint-behind-middleware-2'],
+};

dev-packages/e2e-tests/test-applications/nextjs-15/sentry.edge.config.ts

@@ -4,7 +4,21 @@ Sentry.init({
   environment: 'qa', // dynamic sampling bias to keep transactions
   dsn: process.env.NEXT_PUBLIC_E2E_TEST_DSN,
   tunnel: `http://localhost:3031/`, // proxy server
-  tracesSampleRate: 1.0,
+  tracesSampler: samplingContext => {
+    if (samplingContext.attributes?.['next.span_type'] === 'Middleware.execute') {
+      // Only keep the middleware transaction when `normalizedRequest` was available at sampling time and belongs to
+      // the request that is being sampled (guards against concurrent requests leaking into each other's sampling
+      // context). The middleware e2e tests time out and fail when the transaction is dropped here.
+      const { normalizedRequest } = samplingContext;
+      return Boolean(
+        normalizedRequest?.method &&
+        normalizedRequest?.url &&
+        normalizedRequest.url === samplingContext.attributes['http.target'],
+      );
+    }
+
+    return 1.0;
+  },
   dataCollection: { userInfo: true },
   transportOptions: {
     // We are doing a lot of events at once in this test

dev-packages/e2e-tests/test-applications/nextjs-15/tests/middleware.test.ts

@@ -0,0 +1,47 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+// The `tracesSampler` in `sentry.edge.config.ts` only samples `Middleware.execute` spans when `normalizedRequest`
+// is available at sampling time, so this test times out if the request data does not reach the sampler.
+test('tracesSampler receives normalizedRequest for edge middleware', async ({ request }) => {
+  const middlewareTransactionPromise = waitForTransaction('nextjs-15', async transactionEvent => {
+    return transactionEvent?.transaction === 'middleware GET';
+  });
+
+  const response = await request.get('/api/endpoint-behind-middleware');
+  expect(await response.json()).toStrictEqual({ name: 'John Doe' });
+
+  const middlewareTransaction = await middlewareTransactionPromise;
+
+  expect(middlewareTransaction.contexts?.runtime?.name).toBe('vercel-edge');
+  expect(middlewareTransaction.contexts?.trace?.op).toBe('http.server.middleware');
+  expect(middlewareTransaction.request?.url).toContain('/api/endpoint-behind-middleware');
+  expect(middlewareTransaction.request?.method).toBe('GET');
+});
+
+// The `tracesSampler` additionally asserts that `normalizedRequest.url` matches the sampled span's own
+// `http.target`, so a request leaking into the sampling context of a concurrent one drops that transaction
+// and times this test out.
+test('does not leak normalizedRequest between concurrent middleware invocations', async ({ request }) => {
+  const firstTransactionPromise = waitForTransaction('nextjs-15', async transactionEvent => {
+    return (
+      transactionEvent?.transaction === 'middleware GET' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === '/api/endpoint-behind-middleware'
+    );
+  });
+
+  const secondTransactionPromise = waitForTransaction('nextjs-15', async transactionEvent => {
+    return (
+      transactionEvent?.transaction === 'middleware GET' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === '/api/endpoint-behind-middleware-2'
+    );
+  });
+
+  await Promise.all([request.get('/api/endpoint-behind-middleware'), request.get('/api/endpoint-behind-middleware-2')]);
+
+  const [firstTransaction, secondTransaction] = await Promise.all([firstTransactionPromise, secondTransactionPromise]);
+
+  expect(firstTransaction.request?.url).toContain('/api/endpoint-behind-middleware');
+  expect(firstTransaction.request?.url).not.toContain('/api/endpoint-behind-middleware-2');
+  expect(secondTransaction.request?.url).toContain('/api/endpoint-behind-middleware-2');
+});