test(e2e): Preserve static Express coverage (#24155)

Preserve transaction-based Express coverage in a dedicated
static-lifecycle app before migrating the original app to span
streaming.

part of #23800

Co-authored-by: GPT-6 <codex@openai.com>

Author: msonnb

dev-packages/e2e-tests/test-applications/node-express-static/.gitignore

@@ -0,0 +1 @@
+dist

dev-packages/e2e-tests/test-applications/node-express-static/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "node-express-static-app",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/app.js",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@sentry/node": "file:../../packed/sentry-node-packed.tgz",
+    "@trpc/server": "10.45.4",
+    "@trpc/client": "10.45.4",
+    "@types/express": "^4.17.21",
+    "@types/node": "^18.19.1",
+    "express": "^4.21.2",
+    "typescript": "~5.0.0",
+    "zod": "~3.25.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.56.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "@sentry/core": "file:../../packed/sentry-core-packed.tgz"
+  },
+  "resolutions": {
+    "@types/qs": "6.9.17"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "sentryTest": {
+    "variants": [
+      {
+        "build-command": "E2E_TEST_OTEL_SETUP=true pnpm test:build",
+        "assert-command": "E2E_TEST_OTEL_SETUP=true pnpm test:assert",
+        "label": "node-express (tracer provider)"
+      }
+    ]
+  }
+}

dev-packages/e2e-tests/test-applications/node-express-static/playwright.config.mjs

@@ -0,0 +1,7 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: `pnpm start`,
+});
+
+export default config;

dev-packages/e2e-tests/test-applications/node-express-static/src/app.ts

@@ -0,0 +1,175 @@
+import * as Sentry from '@sentry/node';
+// Keep the dedicated MCP server evaluation ahead of initialization without loading Express before its instrumentation.
+import './mcpCapturePolicyServer';
+
+declare global {
+  namespace globalThis {
+    var transactionIds: string[];
+  }
+}
+
+Sentry.init({
+  traceLifecycle: 'static',
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: process.env.E2E_TEST_DSN,
+  includeLocalVariables: true,
+  debug: !!process.env.DEBUG,
+  tunnel: `http://localhost:3031/`, // proxy server
+  tracesSampleRate: 1,
+  dataCollection: {
+    genAI: {
+      inputs: false,
+      outputs: false,
+    },
+  },
+  // 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,
+  integrations: [
+    Sentry.nativeNodeFetchIntegration({
+      headersToSpanAttributes: {
+        responseHeaders: ['content-length'],
+      },
+    }),
+  ],
+});
+
+import { TRPCError, initTRPC } from '@trpc/server';
+import * as trpcExpress from '@trpc/server/adapters/express';
+import express from 'express';
+import { z } from 'zod';
+import { mcpRouter } from './mcp';
+
+const app = express();
+const port = 3030;
+
+app.use(express.json());
+
+app.use(mcpRouter);
+
+app.get('/crash-in-with-monitor/:id', async (req, res) => {
+  try {
+    await Sentry.withMonitor('express-crash', async () => {
+      throw new Error(`This is an exception withMonitor: ${req.params.id}`);
+    });
+    res.sendStatus(200);
+  } catch (error: any) {
+    res.status(500);
+    res.send({ message: error.message, pid: process.pid });
+  }
+});
+
+app.get('/test-success', function (req, res) {
+  res.send({ version: 'v1' });
+});
+
+app.get('/test-log', function (req, res) {
+  Sentry.logger.debug('Accessed /test-log route');
+  res.send({ message: 'Log sent' });
+});
+
+app.get('/test-param/:param', function (req, res) {
+  res.send({ paramWas: req.params.param });
+});
+
+app.get('/test-transaction', function (_req, res) {
+  Sentry.startSpan({ name: 'test-span' }, () => undefined);
+
+  res.send({ status: 'ok' });
+});
+
+app.get('/test-outgoing-fetch', async function (_req, res) {
+  const response = await fetch('http://localhost:3030/test-success');
+  const data = await response.json();
+  res.send(data);
+});
+app.get('/test-error', async function (req, res) {
+  const exceptionId = Sentry.captureException(new Error('This is an error'));
+
+  await Sentry.flush(2000);
+
+  res.send({ exceptionId });
+});
+
+app.get('/test-exception/:id', function (req, _res) {
+  throw new Error(`This is an exception with id ${req.params.id}`);
+});
+
+app.get('/test-local-variables-uncaught', function (req, res) {
+  const randomVariableToRecord = Math.random();
+  throw new Error(`Uncaught Local Variable Error - ${JSON.stringify({ randomVariableToRecord })}`);
+});
+
+app.get('/test-local-variables-caught', function (req, res) {
+  const randomVariableToRecord = Math.random();
+
+  let exceptionId: string;
+  try {
+    throw new Error('Local Variable Error');
+  } catch (e) {
+    exceptionId = Sentry.captureException(e);
+  }
+
+  res.send({ exceptionId, randomVariableToRecord });
+});
+
+// @ts-ignore
+app.use(function onError(err, req, res, next) {
+  // The error id is attached to `res.sentry` to be returned
+  // and optionally displayed to the user for support.
+  res.statusCode = 500;
+  res.end(res.sentry + '\n');
+});
+
+app.listen(port, () => {
+  console.log(`Example app listening on port ${port}`);
+});
+
+Sentry.addEventProcessor(event => {
+  global.transactionIds = global.transactionIds || [];
+
+  if (event.type === 'transaction') {
+    const eventId = event.event_id;
+
+    if (eventId) {
+      global.transactionIds.push(eventId);
+    }
+  }
+
+  return event;
+});
+
+export const t = initTRPC.context<Context>().create();
+
+const procedure = t.procedure.use(Sentry.trpcMiddleware({ attachRpcInput: true }));
+
+export const appRouter = t.router({
+  getSomething: procedure.input(z.string()).query(opts => {
+    return { id: opts.input, name: 'Bilbo' };
+  }),
+  createSomething: procedure.mutation(async () => {
+    await new Promise(resolve => setTimeout(resolve, 400));
+    return { success: true };
+  }),
+  crashSomething: procedure
+    .input(z.object({ nested: z.object({ nested: z.object({ nested: z.string() }) }) }))
+    .mutation(() => {
+      throw new Error('I crashed in a trpc handler');
+    }),
+  badRequest: procedure.mutation(() => {
+    throw new TRPCError({ code: 'BAD_REQUEST', cause: new Error('Bad Request') });
+  }),
+});
+
+export type AppRouter = typeof appRouter;
+
+const createContext = () => ({ someStaticValue: 'asdf' });
+type Context = Awaited<ReturnType<typeof createContext>>;
+
+app.use(
+  '/trpc',
+  trpcExpress.createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  }),
+);