feat(core): MCP server instrumentation without breaking Miniflare (#16817)

Closes #16826, #16654, #16666  #16978

Different approach from #16807 .

Using `Proxy` was causing issues in cloudflare #16182.

Now using `fill` we shouldn't have those problems as `fill` doesn't
create a new wrapper object with a different identity, so now:

1. `fill` just replaces the method on the existing object
2. The transport object keeps its original identity
3. When `transport.start()` runs and accesses private fields, this is
still the original transport object
4. The `WeakMap` recognizes it as the same object that owns the private
fields

- Support for new MCP SDK methods (`mcpServerInstance.tool()`,
`mcpServerInstance.resource()`, etc.)
- Tracing instrumentation
- Error handling

It follows [OTEL semantic conventions for
MCP](https://github.com/open-telemetry/semantic-conventions/blob/3097fb0af5b9492b0e3f55dc5f6c21a3dc2be8df/docs/gen-ai/mcp.md)
and adds more attributes we thought are useful.

It also handles PII based on user setting of `sendDefaultPii`.

1. **Transport receives tools/call request (`id: 2`)**
2. **Create INACTIVE `mcp.server` span**
3. **Store span in**`requestIdToSpanMap[2] = { span, method:
"tools/call", startTime }`
4. **Execute handler with span context** *(handler gets requestId: 2)*
5. **Handler finds span using** `requestId: 2`
6. **Tool execution happens within span context**
7. **Response sent with tool results**
8. `completeSpanWithToolResults(2, result)` **enriches and completes
span**

1.  **error capture** - `errorCapture.ts`
- Non-invasive error reporting that never interferes with MCP service
operation
- Error context with MCP-specific metadata
- PII filtering respects `sendDefaultPii` settings
- Resilient to Sentry failures (wrapped in try-catch)

2. **Tool execution error capturing** - `handlers.ts`
- Captures exceptions thrown during tool execution
- Preserves normal MCP behaviour (errors converted to `isError: true`)
- Includes tool name, arguments, and request context
- Handles both sync and async tool handlers

3. **Transport error instrumentation** - `transport.ts`
- Captures connection errors and network failures
- Intercepts JSON-RPC error responses
- Includes transport type and session information
- Handles error responses being sent back to clients

Author: betegon

dev-packages/e2e-tests/test-applications/node-express-v5/tests/mcp.test.ts

@@ -0,0 +1,109 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+
+test('Should record transactions for mcp handlers', async ({ baseURL }) => {
+  const transport = new SSEClientTransport(new URL(`${baseURL}/sse`));
+
+  const client = new Client({
+    name: 'test-client',
+    version: '1.0.0',
+  });
+
+  await client.connect(transport);
+
+  await test.step('tool handler', async () => {
+    const postTransactionPromise = waitForTransaction('node-express-v5', transactionEvent => {
+      return transactionEvent.transaction === 'POST /messages';
+    });
+    const toolTransactionPromise = waitForTransaction('node-express-v5', transactionEvent => {
+      return transactionEvent.transaction === 'tools/call echo';
+    });
+
+    const toolResult = await client.callTool({
+      name: 'echo',
+      arguments: {
+        message: 'foobar',
+      },
+    });
+
+    expect(toolResult).toMatchObject({
+      content: [
+        {
+          text: 'Tool echo: foobar',
+          type: 'text',
+        },
+      ],
+    });
+
+    const postTransaction = await postTransactionPromise;
+    expect(postTransaction).toBeDefined();
+
+    const toolTransaction = await toolTransactionPromise;
+    expect(toolTransaction).toBeDefined();
+
+    // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
+  });
+
+  await test.step('resource handler', async () => {
+    const postTransactionPromise = waitForTransaction('node-express-v5', transactionEvent => {
+      return transactionEvent.transaction === 'POST /messages';
+    });
+    const resourceTransactionPromise = waitForTransaction('node-express-v5', transactionEvent => {
+      return transactionEvent.transaction === 'resources/read echo://foobar';
+    });
+
+    const resourceResult = await client.readResource({
+      uri: 'echo://foobar',
+    });
+
+    expect(resourceResult).toMatchObject({
+      contents: [{ text: 'Resource echo: foobar', uri: 'echo://foobar' }],
+    });
+
+    const postTransaction = await postTransactionPromise;
+    expect(postTransaction).toBeDefined();
+
+    const resourceTransaction = await resourceTransactionPromise;
+    expect(resourceTransaction).toBeDefined();
+
+    // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
+  });
+
+  await test.step('prompt handler', async () => {
+    const postTransactionPromise = waitForTransaction('node-express-v5', transactionEvent => {
+      return transactionEvent.transaction === 'POST /messages';
+    });
+    const promptTransactionPromise = waitForTransaction('node-express-v5', transactionEvent => {
+      return transactionEvent.transaction === 'prompts/get echo';
+    });
+
+    const promptResult = await client.getPrompt({
+      name: 'echo',
+      arguments: {
+        message: 'foobar',
+      },
+    });
+
+    expect(promptResult).toMatchObject({
+      messages: [
+        {
+          content: {
+            text: 'Please process this message: foobar',
+            type: 'text',
+          },
+          role: 'user',
+        },
+      ],
+    });
+
+    const postTransaction = await postTransactionPromise;
+    expect(postTransaction).toBeDefined();
+
+    const promptTransaction = await promptTransactionPromise;
+    expect(promptTransaction).toBeDefined();
+
+    // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
+  });
+});

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

@@ -25,6 +25,8 @@ 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) => {

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

@@ -55,7 +55,7 @@ mcpRouter.post('/messages', async (req, res) => {
   const sessionId = req.query.sessionId;
   const transport = transports[sessionId as string];
   if (transport) {
-    await transport.handlePostMessage(req, res);
+    await transport.handlePostMessage(req, res, req.body);
   } else {
     res.status(400).send('No transport found for sessionId');
   }

dev-packages/e2e-tests/test-applications/node-express/tests/errors.test.ts

@@ -13,7 +13,7 @@ test('Sends correct error event', async ({ baseURL }) => {
   expect(errorEvent.exception?.values).toHaveLength(1);
   expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception with id 123');
 
-  expect(errorEvent.request).toEqual({
+  expect(errorEvent.request).toMatchObject({
     method: 'GET',
     cookies: {},
     headers: expect.any(Object),
@@ -43,11 +43,11 @@ test('Should record caught exceptions with local variable', async ({ baseURL })
 
 test('To not crash app from withMonitor', async ({ baseURL }) => {
   const doRequest = async (id: number) => {
-    const response = await fetch(`${baseURL}/crash-in-with-monitor/${id}`)
+    const response = await fetch(`${baseURL}/crash-in-with-monitor/${id}`);
     return response.json();
-  }
-  const [response1, response2] = await Promise.all([doRequest(1), doRequest(2)])
-  expect(response1.message).toBe('This is an exception withMonitor: 1')
-  expect(response2.message).toBe('This is an exception withMonitor: 2')
-  expect(response1.pid).toBe(response2.pid) //Just to double-check, TBS
+  };
+  const [response1, response2] = await Promise.all([doRequest(1), doRequest(2)]);
+  expect(response1.message).toBe('This is an exception withMonitor: 1');
+  expect(response2.message).toBe('This is an exception withMonitor: 2');
+  expect(response1.pid).toBe(response2.pid); //Just to double-check, TBS
 });

dev-packages/e2e-tests/test-applications/node-express/tests/mcp.test.ts

@@ -18,7 +18,7 @@ test('Should record transactions for mcp handlers', async ({ baseURL }) => {
       return transactionEvent.transaction === 'POST /messages';
     });
     const toolTransactionPromise = waitForTransaction('node-express', transactionEvent => {
-      return transactionEvent.transaction === 'mcp-server/tool:echo';
+      return transactionEvent.transaction === 'tools/call echo';
     });
 
     const toolResult = await client.callTool({
@@ -39,10 +39,12 @@ test('Should record transactions for mcp handlers', async ({ baseURL }) => {
 
     const postTransaction = await postTransactionPromise;
     expect(postTransaction).toBeDefined();
+    expect(postTransaction.contexts?.trace?.op).toEqual('http.server');
 
     const toolTransaction = await toolTransactionPromise;
     expect(toolTransaction).toBeDefined();
-
+    expect(toolTransaction.contexts?.trace?.op).toEqual('mcp.server');
+    expect(toolTransaction.contexts?.trace?.data?.['mcp.method.name']).toEqual('tools/call');
     // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
   });
 
@@ -51,7 +53,7 @@ test('Should record transactions for mcp handlers', async ({ baseURL }) => {
       return transactionEvent.transaction === 'POST /messages';
     });
     const resourceTransactionPromise = waitForTransaction('node-express', transactionEvent => {
-      return transactionEvent.transaction === 'mcp-server/resource:echo';
+      return transactionEvent.transaction === 'resources/read echo://foobar';
     });
 
     const resourceResult = await client.readResource({
@@ -64,10 +66,12 @@ test('Should record transactions for mcp handlers', async ({ baseURL }) => {
 
     const postTransaction = await postTransactionPromise;
     expect(postTransaction).toBeDefined();
+    expect(postTransaction.contexts?.trace?.op).toEqual('http.server');
 
     const resourceTransaction = await resourceTransactionPromise;
     expect(resourceTransaction).toBeDefined();
-
+    expect(resourceTransaction.contexts?.trace?.op).toEqual('mcp.server');
+    expect(resourceTransaction.contexts?.trace?.data?.['mcp.method.name']).toEqual('resources/read');
     // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
   });
 
@@ -76,7 +80,7 @@ test('Should record transactions for mcp handlers', async ({ baseURL }) => {
       return transactionEvent.transaction === 'POST /messages';
     });
     const promptTransactionPromise = waitForTransaction('node-express', transactionEvent => {
-      return transactionEvent.transaction === 'mcp-server/prompt:echo';
+      return transactionEvent.transaction === 'prompts/get echo';
     });
 
     const promptResult = await client.getPrompt({
@@ -100,10 +104,12 @@ test('Should record transactions for mcp handlers', async ({ baseURL }) => {
 
     const postTransaction = await postTransactionPromise;
     expect(postTransaction).toBeDefined();
+    expect(postTransaction.contexts?.trace?.op).toEqual('http.server');
 
     const promptTransaction = await promptTransactionPromise;
     expect(promptTransaction).toBeDefined();
-
+    expect(promptTransaction.contexts?.trace?.op).toEqual('mcp.server');
+    expect(promptTransaction.contexts?.trace?.data?.['mcp.method.name']).toEqual('prompts/get');
     // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
   });
 });

packages/core/src/index.ts

@@ -118,7 +118,7 @@ export { featureFlagsIntegration, type FeatureFlagsIntegration } from './integra
 export { profiler } from './profiling';
 export { instrumentFetchRequest } from './fetch';
 export { trpcMiddleware } from './trpc';
-export { wrapMcpServerWithSentry } from './mcp-server';
+export { wrapMcpServerWithSentry } from './integrations/mcp-server';
 export { captureFeedback } from './feedback';
 export type { ReportDialogOptions } from './report-dialog';
 export { _INTERNAL_captureLog, _INTERNAL_flushLogsBuffer, _INTERNAL_captureSerializedLog } from './logs/exports';