fix(core): set span.status to error when MCP tool returns JSON-RPC error response

When a tool handler threw an error, completeSpanWithResults() was ending
the span without setting its status to error. This caused all MCP tool
spans to appear with span.status=ok in Sentry, breaking the failure_rate()
metric in the MCP insights dashboard.

The fix passes hasError=true to completeSpanWithResults() when the
outgoing JSON-RPC response contains an error object, setting the span
status to internal_error directly on the stored span (bypassing
getActiveSpan() which doesn't return the right span at send() time).

Co-Authored-By: claude-sonnet-4-6 <noreply@anthropic.com>

Author: betegon

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

@@ -81,19 +81,23 @@ export function storeSpanForRequest(transport: MCPTransport, requestId: RequestI
  * @param requestId - Request identifier
  * @param result - Execution result for attribute extraction
  * @param options - Resolved MCP options
+ * @param hasError - Whether the JSON-RPC response contained an error
  */
 export function completeSpanWithResults(
   transport: MCPTransport,
   requestId: RequestId,
   result: unknown,
   options: ResolvedMcpOptions,
+  hasError = false,
 ): void {
   const spanMap = getOrCreateSpanMap(transport);
   const spanData = spanMap.get(requestId);
   if (spanData) {
     const { span, method } = spanData;
 
-    if (method === 'initialize') {
+    if (hasError) {
+      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
+    } else if (method === 'initialize') {
       const sessionData = extractSessionDataFromInitializeResponse(result);
       const serverAttributes = buildServerAttributesFromInfo(sessionData.serverInfo);
 

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

@@ -121,7 +121,7 @@ export function wrapTransportSend(transport: MCPTransport, options: ResolvedMcpO
               }
             }
 
-            completeSpanWithResults(this, message.id, message.result, options);
+            completeSpanWithResults(this, message.id, message.result, options, !!message.error);
           }
         }
 

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

@@ -182,6 +182,68 @@ describe('MCP Server Transport Instrumentation', () => {
       // Trigger onclose - should not throw
       expect(() => mockTransport.onclose?.()).not.toThrow();
     });
+
+    it('should set span status to error when JSON-RPC error response is sent', async () => {
+      const mockSpan = {
+        setAttributes: vi.fn(),
+        setStatus: vi.fn(),
+        end: vi.fn(),
+        isRecording: vi.fn().mockReturnValue(true),
+      };
+      startInactiveSpanSpy.mockReturnValue(mockSpan as any);
+
+      await wrappedMcpServer.connect(mockTransport);
+
+      // Simulate an incoming tools/call request
+      const jsonRpcRequest = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        id: 'req-err-1',
+        params: { name: 'always-error' },
+      };
+      mockTransport.onmessage?.(jsonRpcRequest, {});
+
+      // Simulate the MCP SDK sending back a JSON-RPC error response
+      const jsonRpcErrorResponse = {
+        jsonrpc: '2.0',
+        id: 'req-err-1',
+        error: { code: -32603, message: 'Internal error: tool threw an exception' },
+      };
+      await mockTransport.send?.(jsonRpcErrorResponse as any);
+
+      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 2, message: 'internal_error' });
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
+
+    it('should not set error span status for successful JSON-RPC responses', async () => {
+      const mockSpan = {
+        setAttributes: vi.fn(),
+        setStatus: vi.fn(),
+        end: vi.fn(),
+        isRecording: vi.fn().mockReturnValue(true),
+      };
+      startInactiveSpanSpy.mockReturnValue(mockSpan as any);
+
+      await wrappedMcpServer.connect(mockTransport);
+
+      const jsonRpcRequest = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        id: 'req-ok-1',
+        params: { name: 'echo' },
+      };
+      mockTransport.onmessage?.(jsonRpcRequest, {});
+
+      const jsonRpcSuccessResponse = {
+        jsonrpc: '2.0',
+        id: 'req-ok-1',
+        result: { content: [{ type: 'text', text: 'hello' }] },
+      };
+      await mockTransport.send?.(jsonRpcSuccessResponse as any);
+
+      expect(mockSpan.setStatus).not.toHaveBeenCalled();
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
   });
 
   describe('Stdio Transport Tests', () => {