update input/output capture logic to depend on sendDefaultPii option to avoid breaking changes

Author: betegon

packages/core/src/integrations/mcp-server/index.ts

@@ -1,3 +1,4 @@
+import { getClient } from '../../currentScopes';
 import { fill } from '../../utils/object';
 import { wrapAllMCPHandlers } from './handlers';
 import { wrapTransportError, wrapTransportOnClose, wrapTransportOnMessage, wrapTransportSend } from './transport';
@@ -22,15 +23,15 @@ const wrappedMcpServerInstances = new WeakSet();
  * import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
  * import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
  *
- * // Default: inputs and outputs are NOT captured
+ * // Default: inputs/outputs captured based on sendDefaultPii option
  * const server = Sentry.wrapMcpServerWithSentry(
  *   new McpServer({ name: "my-server", version: "1.0.0" })
  * );
  *
- * // Capture both inputs and outputs
+ * // Explicitly control input/output capture
  * const server = Sentry.wrapMcpServerWithSentry(
  *   new McpServer({ name: "my-server", version: "1.0.0" }),
- *   { recordInputs: true, recordOutputs: true }
+ *   { recordInputs: true, recordOutputs: false }
  * );
  *
  * const transport = new StreamableHTTPServerTransport();
@@ -51,8 +52,10 @@ export function wrapMcpServerWithSentry<S extends object>(mcpServerInstance: S,
   }
 
   const serverInstance = mcpServerInstance as MCPServerInstance;
-  const recordInputs = options?.recordInputs ?? false;
-  const recordOutputs = options?.recordOutputs ?? false;
+  const client = getClient();
+  const sendDefaultPii = Boolean(client?.getOptions().sendDefaultPii);
+  const recordInputs = options?.recordInputs ?? sendDefaultPii;
+  const recordOutputs = options?.recordOutputs ?? sendDefaultPii;
 
   fill(serverInstance, 'connect', originalConnect => {
     return async function (this: MCPServerInstance, transport: MCPTransport, ...restArgs: unknown[]) {

packages/core/src/integrations/mcp-server/types.ts

@@ -190,8 +190,8 @@ export type SessionData = {
  * @internal
  */
 export type McpServerWrapperOptions = {
-  /** Whether to capture tool/prompt input arguments in spans. @default false */
+  /** Whether to capture tool/prompt input arguments in spans. Defaults to sendDefaultPii. */
   recordInputs?: boolean;
-  /** Whether to capture tool/prompt output results in spans. @default false */
+  /** Whether to capture tool/prompt output results in spans. Defaults to sendDefaultPii. */
   recordOutputs?: boolean;
 };

packages/core/test/lib/integrations/mcp-server/transportInstrumentation.test.ts

@@ -662,7 +662,13 @@ describe('MCP Server Transport Instrumentation', () => {
   });
 
   describe('Wrapper Options', () => {
-    it('should NOT capture request arguments by default (recordInputs: false)', async () => {
+    it('should NOT capture inputs/outputs when sendDefaultPii is false', async () => {
+      getClientSpy.mockReturnValue({
+        getOptions: () => ({ sendDefaultPii: false }),
+        getDsn: () => ({ publicKey: 'test-key', host: 'test-host' }),
+        emit: vi.fn(),
+      } as any);
+
       const mockMcpServer = createMockMcpServer();
       const wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
       const transport = createMockTransport();
@@ -688,26 +694,68 @@ describe('MCP Server Transport Instrumentation', () => {
       );
     });
 
-    it('should NOT capture tool outputs by default (recordOutputs: false)', async () => {
+    it('should capture inputs/outputs when sendDefaultPii is true', async () => {
+      getClientSpy.mockReturnValue({
+        getOptions: () => ({ sendDefaultPii: true }),
+        getDsn: () => ({ publicKey: 'test-key', host: 'test-host' }),
+        emit: vi.fn(),
+      } as any);
+
       const mockMcpServer = createMockMcpServer();
       const wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
       const transport = createMockTransport();
 
       await wrappedMcpServer.connect(transport);
 
-      const setAttributesSpy = vi.fn();
-      const mockSpan = { setAttributes: setAttributesSpy, end: vi.fn() };
-      startInactiveSpanSpy.mockReturnValueOnce(mockSpan as any);
+      transport.onmessage?.(
+        {
+          jsonrpc: '2.0',
+          method: 'tools/call',
+          id: 'tool-1',
+          params: { name: 'weather', arguments: { location: 'London' } },
+        },
+        {},
+      );
 
-      transport.onmessage?.({ jsonrpc: '2.0', method: 'tools/call', id: 'tool-1', params: { name: 'weather' } }, {});
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          attributes: expect.objectContaining({
+            'mcp.request.argument.location': '"London"',
+          }),
+        }),
+      );
+    });
 
-      await transport.send?.({
-        jsonrpc: '2.0',
-        id: 'tool-1',
-        result: { content: [{ type: 'text', text: 'Sunny' }], isError: false },
-      });
+    it('should allow explicit override of defaults', async () => {
+      getClientSpy.mockReturnValue({
+        getOptions: () => ({ sendDefaultPii: true }),
+        getDsn: () => ({ publicKey: 'test-key', host: 'test-host' }),
+        emit: vi.fn(),
+      } as any);
 
-      expect(setAttributesSpy).not.toHaveBeenCalled();
+      const mockMcpServer = createMockMcpServer();
+      const wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer, { recordInputs: false });
+      const transport = createMockTransport();
+
+      await wrappedMcpServer.connect(transport);
+
+      transport.onmessage?.(
+        {
+          jsonrpc: '2.0',
+          method: 'tools/call',
+          id: 'tool-1',
+          params: { name: 'weather', arguments: { location: 'London' } },
+        },
+        {},
+      );
+
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          attributes: expect.not.objectContaining({
+            'mcp.request.argument.location': expect.anything(),
+          }),
+        }),
+      );
     });
   });
 });