test(mcp-server): Add tests for span creation and semantic conventions in MCP server

Author: betegon

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

@@ -169,6 +169,190 @@ describe('wrapMcpServerWithSentry', () => {
       expect(() => mockTransport.onclose?.()).not.toThrow();
     });
   });
+
+  describe('Span Creation & Semantic Conventions', () => {
+    let mockMcpServer: ReturnType<typeof createMockMcpServer>;
+    let wrappedMcpServer: ReturnType<typeof createMockMcpServer>;
+    let mockTransport: ReturnType<typeof createMockTransport>;
+
+    beforeEach(async () => {
+      mockMcpServer = createMockMcpServer();
+      wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
+      mockTransport = createMockTransport();
+      mockTransport.sessionId = 'test-session-123';
+      
+      await wrappedMcpServer.connect(mockTransport);
+    });
+
+    it('should create spans with correct MCP server semantic attributes for tool operations', () => {
+      const jsonRpcRequest = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        id: 'req-1',
+        params: { 
+          name: 'get-weather',
+          arguments: { 
+            location: 'Seattle, WA',
+            units: 'metric'
+          }
+        }
+      };
+
+      const extraWithClientInfo = {
+        requestInfo: {
+          remoteAddress: '192.168.1.100',
+          remotePort: 54321
+        }
+      };
+
+      mockTransport.onmessage?.(jsonRpcRequest, extraWithClientInfo);
+
+      expect(tracingModule.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'tools/call get-weather',
+          op: 'mcp.server',
+          forceTransaction: true,
+          attributes: expect.objectContaining({
+            // Required
+            'mcp.method.name': 'tools/call',
+            // Conditionally Required (tool operation)
+            'mcp.tool.name': 'get-weather',
+            'mcp.request.id': 'req-1',
+            // Recommended
+            'mcp.session.id': 'test-session-123',
+            'client.address': '192.168.1.100',
+            'client.port': 54321,
+            // Transport attributes
+            'mcp.transport': 'http',
+            'network.transport': 'tcp',
+            'network.protocol.version': '2.0',
+            // Tool arguments (JSON-stringified)
+            'mcp.request.argument.location': '"Seattle, WA"',
+            'mcp.request.argument.units': '"metric"',
+            // Sentry-specific
+            'sentry.origin': 'auto.function.mcp_server',
+          }),
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should create spans with correct attributes for resource operations', () => {
+      const jsonRpcRequest = {
+        jsonrpc: '2.0',
+        method: 'resources/read',
+        id: 'req-2',
+        params: { uri: 'file:///docs/api.md' }
+      };
+
+      mockTransport.onmessage?.(jsonRpcRequest, {});
+
+      expect(tracingModule.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'resources/read file:///docs/api.md',
+          op: 'mcp.server',
+          attributes: expect.objectContaining({
+            // Required
+            'mcp.method.name': 'resources/read',
+            // Conditionally Required (resource operation)
+            'mcp.resource.uri': 'file:///docs/api.md',
+            'mcp.request.id': 'req-2',
+            // Recommended
+            'mcp.session.id': 'test-session-123',
+          }),
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should create spans with correct attributes for prompt operations', () => {
+      const jsonRpcRequest = {
+        jsonrpc: '2.0',
+        method: 'prompts/get',
+        id: 'req-3',
+        params: { name: 'analyze-code' }
+      };
+
+      mockTransport.onmessage?.(jsonRpcRequest, {});
+
+      expect(tracingModule.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'prompts/get analyze-code',
+          op: 'mcp.server',
+          attributes: expect.objectContaining({
+            // Required
+            'mcp.method.name': 'prompts/get',
+            // Conditionally Required (prompt operation)
+            'mcp.prompt.name': 'analyze-code',
+            'mcp.request.id': 'req-3',
+            // Recommended
+            'mcp.session.id': 'test-session-123',
+          }),
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should create spans with correct attributes for notifications (no request id)', () => {
+      const jsonRpcNotification = {
+        jsonrpc: '2.0',
+        method: 'notifications/tools/list_changed',
+        params: {}
+      };
+
+      mockTransport.onmessage?.(jsonRpcNotification, {});
+
+      expect(tracingModule.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'notifications/tools/list_changed',
+          op: 'mcp.server',
+          attributes: expect.objectContaining({
+            // Required
+            'mcp.method.name': 'notifications/tools/list_changed',
+            // Recommended
+            'mcp.session.id': 'test-session-123',
+            // Notification-specific
+            'mcp.notification.direction': 'client_to_server',
+            // Sentry-specific
+            'sentry.origin': 'auto.mcp.notification',
+          }),
+        }),
+        expect.any(Function)
+      );
+
+      // Should not include mcp.request.id for notifications
+      const callArgs = vi.mocked(tracingModule.startSpan).mock.calls[0];
+      expect(callArgs).toBeDefined();
+      const attributes = callArgs?.[0]?.attributes;
+      expect(attributes).not.toHaveProperty('mcp.request.id');
+    });
+
+    it('should create spans for list operations without target in name', () => {
+      const jsonRpcRequest = {
+        jsonrpc: '2.0',
+        method: 'tools/list',
+        id: 'req-4',
+        params: {}
+      };
+
+      mockTransport.onmessage?.(jsonRpcRequest, {});
+
+      expect(tracingModule.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'tools/list',
+          op: 'mcp.server',
+          attributes: expect.objectContaining({
+            'mcp.method.name': 'tools/list',
+            'mcp.request.id': 'req-4',
+            'mcp.session.id': 'test-session-123',
+          }),
+        }),
+        expect.any(Function)
+      );
+    });
+
+
+  });
 });
 
 // Test helpers