feat(contrib/mark3labs/mcp-go): support redacting tool output in LLMObs traces

Add RedactToolOutput bool to TracingConfig. When set, the tool result body
sent to LLMObs is replaced with '[REDACTED]'; the result.IsError flag is
still honored for span error status.

This is needed when downstream access controls (e.g. org2-dac in the
internal dd-source copy) forbid forwarding tool output to LLMObs traces.

Generalizes the hardcoded redaction in internal dd-source PR #429591 into
a configuration option so the original always-on behavior remains the
default for external users.

Author: jboolean

contrib/mark3labs/mcp-go/option.go

@@ -32,6 +32,13 @@ type TracingConfig struct {
 	// If both IntentCaptureEnabled and IntentCaptureEnabledFunc are set, the
 	// predicate wins. If both are unset, intent capture is disabled.
 	IntentCaptureEnabledFunc func(ctx context.Context) bool
+	// RedactToolOutput replaces the tool result body sent to LLMObs with a
+	// fixed "[REDACTED]" string. Use this when downstream access controls
+	// (e.g. org2-dac) forbid forwarding tool output to LLMObs traces.
+	//
+	// The result.IsError flag is still honored for span error status — only
+	// the output content is redacted.
+	RedactToolOutput bool
 }
 
 // intentCapturePredicate returns the runtime predicate for intent capture,
@@ -85,7 +92,7 @@ func WithMCPServerTracing(options *TracingConfig) server.ServerOption {
 
 		// Register toolHandlerMiddleware first so it runs first (creates the span)
 		// Note: mcp-go middleware runs in registration order (first registered runs first)
-		server.WithToolHandlerMiddleware(toolHandlerMiddleware)(s)
+		server.WithToolHandlerMiddleware(newToolHandlerMiddleware(options.RedactToolOutput))(s)
 
 		predicate := intentCapturePredicate(options)
 		if predicate != nil {

contrib/mark3labs/mcp-go/tracing.go

@@ -31,57 +31,76 @@ func appendTracingHooks(hooks *server.Hooks) {
 	hooks.AddOnError(tracingHooks.onError)
 }
 
-var toolHandlerMiddleware = func(next server.ToolHandlerFunc) server.ToolHandlerFunc {
-	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-		startOpts := []llmobs.StartSpanOption{
-			llmobs.WithIntegration(string(instrumentation.PackageMark3LabsMCPGo)),
-		}
-		if session := server.ClientSessionFromContext(ctx); session != nil {
-			startOpts = append(startOpts, llmobs.WithSessionID(session.SessionID()))
-		}
-		toolSpan, ctx := llmobs.StartToolSpan(ctx, request.Params.Name, startOpts...)
+// redactedOutput is the placeholder substituted for the tool result body
+// when TracingConfig.RedactToolOutput is set.
+const redactedOutput = "[REDACTED]"
+
+// newToolHandlerMiddleware returns the tool-call middleware. When
+// redactOutput is true, the tool result body sent to LLMObs is replaced
+// with redactedOutput; result.IsError is still honored for span error status.
+func newToolHandlerMiddleware(redactOutput bool) func(server.ToolHandlerFunc) server.ToolHandlerFunc {
+	return func(next server.ToolHandlerFunc) server.ToolHandlerFunc {
+		return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			startOpts := []llmobs.StartSpanOption{
+				llmobs.WithIntegration(string(instrumentation.PackageMark3LabsMCPGo)),
+			}
+			if session := server.ClientSessionFromContext(ctx); session != nil {
+				startOpts = append(startOpts, llmobs.WithSessionID(session.SessionID()))
+			}
+			toolSpan, ctx := llmobs.StartToolSpan(ctx, request.Params.Name, startOpts...)
 
-		var result *mcp.CallToolResult
-		var err error
+			var result *mcp.CallToolResult
+			var err error
 
-		defer func() {
-			inputJSON, marshalErr := json.Marshal(request)
-			if marshalErr != nil {
-				instr.Logger().Warn("mcp-go: failed to marshal tool request: %v", marshalErr)
-			}
-			var outputText string
-			if result != nil {
-				resultJSON, marshalErr := json.Marshal(result)
+			defer func() {
+				inputJSON, marshalErr := json.Marshal(request)
 				if marshalErr != nil {
-					instr.Logger().Warn("mcp-go: failed to marshal tool result: %v", marshalErr)
+					instr.Logger().Warn("mcp-go: failed to marshal tool request: %v", marshalErr)
 				}
-				outputText = string(resultJSON)
-			}
+				outputText := toolOutputForLLMObs(result, redactOutput)
+
+				toolSpan.Annotate(llmobs.WithAnnotatedTags(map[string]string{
+					instrmcp.MCPToolTag:     request.Params.Name,
+					instrmcp.MCPToolKindTag: "server",
+					instrmcp.MCPMethodTag:   request.Method,
+				}))
+				tagWithSessionID(ctx, toolSpan)
+				toolSpan.AnnotateTextIO(string(inputJSON), outputText)
+
+				// There are two ways a tool can express an error:
+				// 1. It can return a Go error.
+				// 2. It can return IsError: true as part of the tool result.
+				if err != nil {
+					toolSpan.Finish(llmobs.WithError(err))
+				} else if result != nil && result.IsError {
+					toolSpan.Finish(llmobs.WithError(errors.New("tool resulted in an error")))
+				} else {
+					toolSpan.Finish()
+				}
+			}()
 
-			toolSpan.Annotate(llmobs.WithAnnotatedTags(map[string]string{
-				instrmcp.MCPToolTag:     request.Params.Name,
-				instrmcp.MCPToolKindTag: "server",
-				instrmcp.MCPMethodTag:   request.Method,
-			}))
-			tagWithSessionID(ctx, toolSpan)
-			toolSpan.AnnotateTextIO(string(inputJSON), outputText)
-
-			// There are two ways a tool can express an error:
-			// 1. It can return a Go error.
-			// 2. It can return IsError: true as part of the tool result.
-			if err != nil {
-				toolSpan.Finish(llmobs.WithError(err))
-			} else if result != nil && result.IsError {
-				toolSpan.Finish(llmobs.WithError(errors.New("tool resulted in an error")))
-			} else {
-				toolSpan.Finish()
-			}
-		}()
+			result, err = next(ctx, request)
 
-		result, err = next(ctx, request)
+			return result, err
+		}
+	}
+}
 
-		return result, err
+// toolOutputForLLMObs marshals the tool result for the LLMObs span output
+// annotation, or returns the redaction placeholder when output redaction is
+// enabled. A nil result is reported as the empty string.
+func toolOutputForLLMObs(result *mcp.CallToolResult, redact bool) string {
+	if result == nil {
+		return ""
+	}
+	if redact {
+		return redactedOutput
+	}
+	resultJSON, marshalErr := json.Marshal(result)
+	if marshalErr != nil {
+		instr.Logger().Warn("mcp-go: failed to marshal tool result: %v", marshalErr)
 	}
+	return string(resultJSON)
 }
 
 func newHooks() *hooks {

contrib/mark3labs/mcp-go/tracing_test.go

@@ -25,7 +25,7 @@ func TestToolHandlerMiddleware(t *testing.T) {
 	mt := mocktracer.Start()
 	defer mt.Stop()
 
-	middleware := toolHandlerMiddleware
+	middleware := newToolHandlerMiddleware(false)
 	assert.NotNil(t, middleware)
 }
 
@@ -347,6 +347,71 @@ func TestIntegrationToolCallStructuredError(t *testing.T) {
 	assert.Contains(t, outputStr, "Validation failed")
 }
 
+func TestRedactToolOutput(t *testing.T) {
+	tt := testTracer(t)
+	defer tt.Stop()
+
+	srv := server.NewMCPServer("test-server", "1.0.0",
+		WithMCPServerTracing(&TracingConfig{RedactToolOutput: true}))
+
+	calcTool := mcp.NewTool("calculator", mcp.WithDescription("A simple calculator"))
+	srv.AddTool(calcTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return mcp.NewToolResultText(`{"result":42,"secret":"hunter2"}`), nil
+	})
+
+	ctx := context.Background()
+	session := &mockSession{id: "redact-session"}
+	session.Initialize()
+	ctx = srv.WithContext(ctx, session)
+
+	srv.HandleMessage(ctx, []byte(`{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"calculator","arguments":{}}}`))
+
+	spans := tt.WaitForLLMObsSpans(t, 1)
+	require.Len(t, spans, 1)
+
+	toolSpan := spans[0]
+	outputMeta, ok := toolSpan.Meta["output"].(map[string]interface{})
+	require.True(t, ok)
+	assert.Equal(t, "[REDACTED]", outputMeta["value"])
+	// Sensitive content from the actual result must not leak.
+	outputJSON, err := json.Marshal(outputMeta)
+	require.NoError(t, err)
+	assert.NotContains(t, string(outputJSON), "hunter2")
+	assert.NotContains(t, string(outputJSON), "42")
+}
+
+func TestRedactToolOutputStillReportsIsError(t *testing.T) {
+	tt := testTracer(t)
+	defer tt.Stop()
+
+	srv := server.NewMCPServer("test-server", "1.0.0",
+		WithMCPServerTracing(&TracingConfig{RedactToolOutput: true}))
+
+	failTool := mcp.NewTool("failing", mcp.WithDescription("A failing tool"))
+	srv.AddTool(failTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return mcp.NewToolResultError("permission denied: secret-detail"), nil
+	})
+
+	ctx := context.Background()
+	session := &mockSession{id: "redact-err"}
+	session.Initialize()
+	ctx = srv.WithContext(ctx, session)
+
+	srv.HandleMessage(ctx, []byte(`{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"failing","arguments":{}}}`))
+
+	spans := tt.WaitForLLMObsSpans(t, 1)
+	require.Len(t, spans, 1)
+
+	toolSpan := spans[0]
+	assert.Contains(t, toolSpan.Meta, "error.message")
+	outputMeta, ok := toolSpan.Meta["output"].(map[string]interface{})
+	require.True(t, ok)
+	assert.Equal(t, "[REDACTED]", outputMeta["value"])
+	outputJSON, err := json.Marshal(outputMeta)
+	require.NoError(t, err)
+	assert.NotContains(t, string(outputJSON), "secret-detail")
+}
+
 func TestWithMCPServerTracingWithCustomHooks(t *testing.T) {
 	tt := testTracer(t)
 	defer tt.Stop()