Record intent on span

Fix issues with middleware order
Document

Author: jboolean

contrib/mark3labs/mcp-go/README.md

@@ -20,6 +20,9 @@ func main() {
     // Do not use with `server.WithHooks(...)`, as this overwrites the tracing hooks. 
     // To add custom hooks alongside tracing, pass them via TracingConfig.Hooks, e.g.:
     // mcpgotrace.WithMCPServerTracing(&mcpgotrace.TracingConfig{Hooks: customHooks})
+
+    // To enable the capturing of intents on tool calls: `mcpgotrace.WithMCPServerTracing(&mcpgotrace.TracingConfig{IntentCaptureEnabled: true})`
+    // Note that intent captures modifies modifies the tools schemas with an additional parameter than is removed before the tool is called.
     srv := server.NewMCPServer("my-server", "1.0.0",
 		mcpgotrace.WithMCPServerTracing(nil))
 }
@@ -29,4 +32,7 @@ func main() {
 
 The integration automatically traces:
 - **Tool calls**: Creates LLMObs tool spans with input/output annotation for all tool invocations
-- **Session initialization**: Create LLMObs task spans for session initialization, including client information.
+- **Session initialization**: Create LLMObs task spans for session initialization, including client information.
+
+The integration can optionally capture "intent" on MCP tool calls. When enabled, this adds a parameter to the schema of each tool to request that the client include an explaination.
+This can help provide context in natural language about why tools are being used.

contrib/mark3labs/mcp-go/intent_capture.go

@@ -64,8 +64,8 @@ func injectDdtraceListToolsHook(ctx context.Context, id any, message *mcp.ListTo
 }
 
 // Removing tracing parameters from the tool call request so its not sent to the tool.
-// This must be registered before the tool handler middleware, so that the span is available.
-// This must be registered after any user-defined middleware so that it is not visible to them.
+// This must be registered after the tool handler middleware (mcp-go runs middleware in registration order).
+// This removes the ddtrace parameter before user-defined middleware or tool handlers can see it.
 var processAndRemoveDdtraceToolMiddleware = func(next server.ToolHandlerFunc) server.ToolHandlerFunc {
 	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 		if m, ok := request.Params.Arguments.(map[string]any); ok && m != nil {
@@ -108,6 +108,5 @@ func processDdtrace(ctx context.Context, m map[string]any) {
 	if !ok {
 		return
 	}
-	// TODO: Add fields to toolSpan to annotate intent
-	_ = toolSpan
+	toolSpan.Annotate(llmobs.WithIntent(intent))
 }

contrib/mark3labs/mcp-go/intent_capture_test.go

@@ -10,18 +10,17 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/DataDog/dd-trace-go/v2/ddtrace/mocktracer"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/mark3labs/mcp-go/server"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestIntentCapture(t *testing.T) {
-	mt := mocktracer.Start()
-	defer mt.Stop()
+	tt := testTracer(t)
+	defer tt.Stop()
 
-	srv := server.NewMCPServer("test-server", "1.0.0", WithTracing(&TracingConfig{IntentCaptureEnabled: true}))
+	srv := server.NewMCPServer("test-server", "1.0.0", WithMCPServerTracing(&TracingConfig{IntentCaptureEnabled: true}))
 
 	var receivedArgs map[string]any
 	calcTool := mcp.NewTool("calculator",
@@ -71,14 +70,24 @@ func TestIntentCapture(t *testing.T) {
 	session.Initialize()
 	ctx = srv.WithContext(ctx, session)
 
-	srv.HandleMessage(ctx, []byte(`{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"calculator","arguments":{"operation":"add","x":5,"y":3,"ddtrace":{"intent":"test"}}}}`))
+	srv.HandleMessage(ctx, []byte(`{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"calculator","arguments":{"operation":"add","x":5,"y":3,"ddtrace":{"intent":"test intent description"}}}}`))
 
 	// Ensure ddtrace is removed in tool call
 	require.NotNil(t, receivedArgs)
 	assert.Equal(t, "add", receivedArgs["operation"])
 	assert.Equal(t, float64(5), receivedArgs["x"])
 	assert.Equal(t, float64(3), receivedArgs["y"])
 	assert.NotContains(t, receivedArgs, "ddtrace")
+
+	// Verify intent was recorded on the LLMObs span
+	spans := tt.WaitForLLMObsSpans(t, 1)
+	require.Len(t, spans, 1)
+
+	toolSpan := spans[0]
+	assert.Equal(t, "tool", toolSpan.Meta["span.kind"])
+	assert.Equal(t, "calculator", toolSpan.Name)
+	assert.Contains(t, toolSpan.Meta, "intent")
+	assert.Equal(t, "test intent description", toolSpan.Meta["intent"])
 }
 
 func mustMarshal(v interface{}) []byte {

contrib/mark3labs/mcp-go/option.go

@@ -16,7 +16,9 @@ type TracingConfig struct {
 	// Hooks allows you to provide custom hooks that will be merged with Datadog tracing hooks.
 	// If nil, only Datadog tracing hooks will be added and any custom hooks provided via server.WithHooks(...) will be removed.
 	// If provided, your custom hooks will be executed alongside Datadog tracing hooks.
-	Hooks                *server.Hooks
+	Hooks *server.Hooks
+	// Enables intent capture for tool spans.
+	// This will modify the tool schemas to include a parameter for the client to provide the intent.
 	IntentCaptureEnabled bool
 }
 
@@ -55,12 +57,14 @@ func WithMCPServerTracing(options *TracingConfig) server.ServerOption {
 
 		server.WithHooks(hooks)(s)
 
+		// 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)
+
 		if options.IntentCaptureEnabled {
 			hooks.AddAfterListTools(injectDdtraceListToolsHook)
+			// Register intent capture middleware second so it runs second (after span is created)
 			server.WithToolHandlerMiddleware(processAndRemoveDdtraceToolMiddleware)(s)
 		}
-
-		// This must be after the intent capture middleware, so that span in available. Last registered middleware is run first.
-		server.WithToolHandlerMiddleware(toolHandlerMiddleware)(s)
 	}
 }

contrib/mark3labs/mcp-go/testing.go

@@ -0,0 +1,56 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2016 Datadog, Inc.
+
+package mcpgo
+
+import (
+	"testing"
+
+	"github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
+	"github.com/DataDog/dd-trace-go/v2/instrumentation/testutils/testtracer"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// testTracer creates a testtracer with LLMObs enabled for integration tests
+func testTracer(t *testing.T, opts ...testtracer.Option) *testtracer.TestTracer {
+	defaultOpts := []testtracer.Option{
+		testtracer.WithTracerStartOpts(
+			tracer.WithLLMObsEnabled(true),
+			tracer.WithLLMObsMLApp("test-mcp-app"),
+			tracer.WithLogStartup(false),
+		),
+		testtracer.WithAgentInfoResponse(testtracer.AgentInfo{
+			Endpoints: []string{"/evp_proxy/v2/"},
+		}),
+	}
+	allOpts := append(defaultOpts, opts...)
+	tt := testtracer.Start(t, allOpts...)
+	t.Cleanup(tt.Stop)
+	return tt
+}
+
+// mockSession is a simple mock implementation of server.ClientSession for testing
+type mockSession struct {
+	id             string
+	initialized    bool
+	notificationCh chan mcp.JSONRPCNotification
+}
+
+func (m *mockSession) SessionID() string {
+	return m.id
+}
+
+func (m *mockSession) Initialize() {
+	m.initialized = true
+	m.notificationCh = make(chan mcp.JSONRPCNotification, 10)
+}
+
+func (m *mockSession) Initialized() bool {
+	return m.initialized
+}
+
+func (m *mockSession) NotificationChannel() chan<- mcp.JSONRPCNotification {
+	return m.notificationCh
+}

contrib/mark3labs/mcp-go/tracing_test.go

@@ -13,7 +13,6 @@ import (
 	"testing"
 
 	"github.com/DataDog/dd-trace-go/v2/ddtrace/mocktracer"
-	"github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
 	"github.com/DataDog/dd-trace-go/v2/instrumentation/testutils/testtracer"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/mark3labs/mcp-go/server"
@@ -369,45 +368,3 @@ func TestWithMCPServerTracingWithCustomHooks(t *testing.T) {
 }
 
 // Test helpers
-
-// testTracer creates a testtracer with LLMObs enabled for integration tests
-func testTracer(t *testing.T, opts ...testtracer.Option) *testtracer.TestTracer {
-	defaultOpts := []testtracer.Option{
-		testtracer.WithTracerStartOpts(
-			tracer.WithLLMObsEnabled(true),
-			tracer.WithLLMObsMLApp("test-mcp-app"),
-			tracer.WithLogStartup(false),
-		),
-		testtracer.WithAgentInfoResponse(testtracer.AgentInfo{
-			Endpoints: []string{"/evp_proxy/v2/"},
-		}),
-	}
-	allOpts := append(defaultOpts, opts...)
-	tt := testtracer.Start(t, allOpts...)
-	t.Cleanup(tt.Stop)
-	return tt
-}
-
-// mockSession is a simple mock implementation of server.ClientSession for testing
-type mockSession struct {
-	id             string
-	initialized    bool
-	notificationCh chan mcp.JSONRPCNotification
-}
-
-func (m *mockSession) SessionID() string {
-	return m.id
-}
-
-func (m *mockSession) Initialize() {
-	m.initialized = true
-	m.notificationCh = make(chan mcp.JSONRPCNotification, 10)
-}
-
-func (m *mockSession) Initialized() bool {
-	return m.initialized
-}
-
-func (m *mockSession) NotificationChannel() chan<- mcp.JSONRPCNotification {
-	return m.notificationCh
-}