[jaegermcp] Log tool name in MCP middleware for tools/call requests

The logging middleware currently logs the MCP method (e.g. "tools/call")
but not which tool was invoked. This makes it difficult for operators to
identify tool-level usage patterns, latency, and errors from logs alone.

Extract the tool name from CallToolParamsRaw on tools/call requests and
include it as a "tool" field in both request and response log entries.

Signed-off-by: lopster568 <lopster568@users.noreply.github.com>

Author: lopster568

cmd/jaeger/internal/extension/jaegermcp/logging_middleware.go

@@ -12,6 +12,7 @@ import (
 )
 
 // createLoggingMiddleware creates an MCP middleware that logs method calls.
+// For tools/call requests it also logs the tool name.
 func createLoggingMiddleware(logger *zap.Logger) mcp.Middleware {
 	return func(next mcp.MethodHandler) mcp.MethodHandler {
 		return func(
@@ -22,31 +23,40 @@ func createLoggingMiddleware(logger *zap.Logger) mcp.Middleware {
 			start := time.Now()
 			sessionID := req.GetSession().ID()
 
-			// Log request details.
-			logger.Info("MCP request",
+			fields := []zap.Field{
 				zap.String("session_id", sessionID),
-				zap.String("method", method))
+				zap.String("method", method),
+			}
+			if toolName := extractToolName(method, req); toolName != "" {
+				fields = append(fields, zap.String("tool", toolName))
+			}
+
+			logger.Info("MCP request", fields...)
 
 			// Call the actual handler.
 			result, err := next(ctx, method, req)
 
 			// Log response details.
-			duration := time.Since(start)
-
+			fields = append(fields, zap.Duration("duration", time.Since(start)))
 			if err != nil {
-				logger.Error("MCP response",
-					zap.String("session_id", sessionID),
-					zap.String("method", method),
-					zap.Duration("duration", duration),
-					zap.Error(err))
+				fields = append(fields, zap.Error(err))
+				logger.Error("MCP response", fields...)
 			} else {
-				logger.Info("MCP response",
-					zap.String("session_id", sessionID),
-					zap.String("method", method),
-					zap.Duration("duration", duration))
+				logger.Info("MCP response", fields...)
 			}
 
 			return result, err
 		}
 	}
 }
+
+// extractToolName returns the tool name from a tools/call request, or empty string otherwise.
+func extractToolName(method string, req mcp.Request) string {
+	if method != "tools/call" {
+		return ""
+	}
+	if params, ok := req.GetParams().(*mcp.CallToolParamsRaw); ok {
+		return params.Name
+	}
+	return ""
+}

cmd/jaeger/internal/extension/jaegermcp/logging_middleware_test.go

@@ -17,37 +17,55 @@ import (
 	"go.uber.org/zap/zaptest/observer"
 )
 
-func TestLoggingMiddleware(t *testing.T) {
-	zapCore, logs := observer.New(zapcore.DebugLevel)
-	_, addr := startTestServerWithQueryService(t, nil, zap.New(zapCore))
-
-	// Send an MCP initialize request, which passes through the logging middleware.
-	initReq := `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}`
+// sendMCPRequest sends a JSON-RPC request to the MCP endpoint and returns
+// the session ID from the response.
+func sendMCPRequest(t *testing.T, addr, sessionID, body string) string {
+	t.Helper()
 	httpReq, err := http.NewRequest(
 		http.MethodPost,
 		fmt.Sprintf("http://%s/mcp", addr),
-		bytes.NewReader([]byte(initReq)),
+		bytes.NewReader([]byte(body)),
 	)
 	require.NoError(t, err)
 	httpReq.Header.Set("Content-Type", "application/json")
 	httpReq.Header.Set("Accept", "application/json, text/event-stream")
+	if sessionID != "" {
+		httpReq.Header.Set("Mcp-Session-Id", sessionID)
+	}
 
 	resp, err := http.DefaultClient.Do(httpReq)
 	require.NoError(t, err)
 	defer resp.Body.Close()
 	_, err = io.ReadAll(resp.Body)
 	require.NoError(t, err)
 
-	// Clean up the MCP session to avoid goroutine leaks.
-	sessionID := resp.Header.Get("Mcp-Session-Id")
-	if sessionID != "" {
-		delReq, err := http.NewRequest(http.MethodDelete, fmt.Sprintf("http://%s/mcp", addr), http.NoBody)
-		require.NoError(t, err)
-		delReq.Header.Set("Mcp-Session-Id", sessionID)
-		resp2, err := http.DefaultClient.Do(delReq)
-		require.NoError(t, err)
-		resp2.Body.Close()
+	if sid := resp.Header.Get("Mcp-Session-Id"); sid != "" {
+		return sid
 	}
+	return sessionID
+}
+
+// deleteMCPSession cleans up an MCP session to avoid goroutine leaks.
+func deleteMCPSession(t *testing.T, addr, sessionID string) {
+	t.Helper()
+	if sessionID == "" {
+		return
+	}
+	delReq, err := http.NewRequest(http.MethodDelete, fmt.Sprintf("http://%s/mcp", addr), http.NoBody)
+	require.NoError(t, err)
+	delReq.Header.Set("Mcp-Session-Id", sessionID)
+	resp, err := http.DefaultClient.Do(delReq)
+	require.NoError(t, err)
+	resp.Body.Close()
+}
+
+func TestLoggingMiddleware(t *testing.T) {
+	zapCore, logs := observer.New(zapcore.DebugLevel)
+	_, addr := startTestServerWithQueryService(t, nil, zap.New(zapCore))
+
+	initReq := `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}`
+	sessionID := sendMCPRequest(t, addr, "", initReq)
+	t.Cleanup(func() { deleteMCPSession(t, addr, sessionID) })
 
 	// The middleware should have emitted one "MCP request" and one "MCP response" entry.
 	requestLogs := logs.FilterMessage("MCP request").All()
@@ -63,3 +81,43 @@ func TestLoggingMiddleware(t *testing.T) {
 	assert.NotEmpty(t, respFields["session_id"])
 	assert.Contains(t, respFields, "duration")
 }
+
+func TestLoggingMiddlewareToolName(t *testing.T) {
+	zapCore, logs := observer.New(zapcore.DebugLevel)
+	_, addr := startTestServerWithQueryService(t, nil, zap.New(zapCore))
+
+	// Initialize session first
+	initReq := `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}`
+	sessionID := sendMCPRequest(t, addr, "", initReq)
+	require.NotEmpty(t, sessionID)
+	t.Cleanup(func() { deleteMCPSession(t, addr, sessionID) })
+
+	// Call the health tool
+	toolReq := `{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"health","arguments":{}}}`
+	sendMCPRequest(t, addr, sessionID, toolReq)
+
+	// Find the tools/call log entries
+	allRequests := logs.FilterMessage("MCP request").All()
+	var toolCallLog *observer.LoggedEntry
+	for i := range allRequests {
+		if allRequests[i].ContextMap()["method"] == "tools/call" {
+			toolCallLog = &allRequests[i]
+			break
+		}
+	}
+	require.NotNil(t, toolCallLog, "should have a tools/call request log")
+	assert.Equal(t, "health", toolCallLog.ContextMap()["tool"])
+
+	// Verify the response log also has the tool name
+	allResponses := logs.FilterMessage("MCP response").All()
+	var toolRespLog *observer.LoggedEntry
+	for i := range allResponses {
+		if allResponses[i].ContextMap()["method"] == "tools/call" {
+			toolRespLog = &allResponses[i]
+			break
+		}
+	}
+	require.NotNil(t, toolRespLog, "should have a tools/call response log")
+	assert.Equal(t, "health", toolRespLog.ContextMap()["tool"])
+	assert.Contains(t, toolRespLog.ContextMap(), "duration")
+}