A2A (Agent2Agent)

Setup

Install the Braintrust Go SDK alongside the A2A Go SDK, then configure your API key.

Install packages

go get github.com/braintrustdata/braintrust-sdk-go
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/a2a
go get github.com/a2aproject/a2a-go

Set environment variables

.env

BRAINTRUST_API_KEY=your-braintrust-api-key

Auto-instrumentation

To trace A2A calls without modifying your application code, build your app with Orchestrion. Orchestrion appends tracea2a.NewClientInterceptor() to a2aclient.NewFromCard(), a2aclient.NewFromEndpoints(), and a2aclient.NewFactory() calls, and appends tracea2a.InstrumentServer() to a2asrv.NewHandler() calls at compile time.

Install Orchestrion

go install github.com/DataDog/orchestrion@latest

Create orchestrion.tool.go in your project root

orchestrion.tool.go

//go:build tools

package main

import (
_ "github.com/DataDog/orchestrion"
_ "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/a2a"
)

Initialize Braintrust and use the A2A SDK as normal

Go #skip-compile

package main

import (
"context"
"log"

"github.com/a2aproject/a2a-go/a2a"
"github.com/a2aproject/a2a-go/a2aclient"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/sdk/trace"

"github.com/braintrustdata/braintrust-sdk-go"
)

func main() {
tp := trace.NewTracerProvider()
defer tp.Shutdown(context.Background())
otel.SetTracerProvider(tp)

_, err := braintrust.New(tp, braintrust.WithProject("my-project"))
if err != nil {
	log.Fatal(err)
}

// Orchestrion instruments NewFromEndpoints at compile time.
client, err := a2aclient.NewFromEndpoints(context.Background(), []a2a.AgentInterface{
	{Transport: a2a.TransportProtocolJSONRPC, URL: "http://localhost:8080/invoke"},
})
if err != nil {
	log.Fatal(err)
}
defer client.Destroy() //nolint:errcheck

result, err := client.SendMessage(context.Background(), &a2a.MessageSendParams{
	Message: a2a.NewMessage(a2a.MessageRoleUser, a2a.TextPart{Text: "Hello"}),
})
if err != nil {
	log.Fatal(err)
}
_ = result
}

Build and run with Orchestrion

orchestrion go run .

Manual instrumentation

Call tracea2a.InstrumentClient() after creating a client, and pass tracea2a.InstrumentServer() as an option to a2asrv.NewHandler().

Go #skip-compile

package main

import (
	"context"
	"log"
	"net/http"
	"net/http/httptest"

	"github.com/a2aproject/a2a-go/a2a"
	"github.com/a2aproject/a2a-go/a2aclient"
	"github.com/a2aproject/a2a-go/a2asrv"
	"github.com/a2aproject/a2a-go/a2asrv/eventqueue"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/sdk/trace"

	"github.com/braintrustdata/braintrust-sdk-go"
	tracea2a "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/a2a"
)

type greetingAgent struct{}

func (greetingAgent) Execute(ctx context.Context, _ *a2asrv.RequestContext, q eventqueue.Queue) error {
	return q.Write(ctx, a2a.NewMessage(a2a.MessageRoleAgent, a2a.TextPart{Text: "Hello from the A2A agent!"}))
}

func (greetingAgent) Cancel(context.Context, *a2asrv.RequestContext, eventqueue.Queue) error {
	return nil
}

func main() {
	tp := trace.NewTracerProvider()
	defer tp.Shutdown(context.Background())
	otel.SetTracerProvider(tp)

	_, err := braintrust.New(tp, braintrust.WithProject("my-project"))
	if err != nil {
		log.Fatal(err)
	}

	// Server side: pass InstrumentServer() to NewHandler.
	handler := a2asrv.NewHandler(greetingAgent{}, tracea2a.InstrumentServer())
	mux := http.NewServeMux()
	mux.Handle("/invoke", a2asrv.NewJSONRPCHandler(handler))
	server := httptest.NewServer(mux)
	defer server.Close()

	// Client side: call InstrumentClient after creating the client.
	client, err := a2aclient.NewFromEndpoints(context.Background(), []a2a.AgentInterface{
		{Transport: a2a.TransportProtocolJSONRPC, URL: server.URL + "/invoke"},
	})
	if err != nil {
		log.Fatal(err)
	}
	defer client.Destroy() //nolint:errcheck
	tracea2a.InstrumentClient(client)

	result, err := client.SendMessage(context.Background(), &a2a.MessageSendParams{
		Message: a2a.NewMessage(a2a.MessageRoleUser, a2a.TextPart{Text: "Hello"}),
	})
	if err != nil {
		log.Fatal(err)
	}
	_ = result
}

What Braintrust traces

Braintrust captures:

SendMessage and SendStreamingMessage client calls as task spans with span kind client, named a2a.SendMessage and a2a.SendStreamingMessage
OnSendMessage and OnSendMessageStream server request handling as task spans with span kind server
Input: the Message field of MessageSendParams
Output: the response message for non-streaming calls, and for streaming calls the accumulated content across all events (artifact parts and final status merged into the Task shape)
Metadata: A2A method name, protocol (a2a), and role (client or server)
time_to_first_token in span metrics, measured when the first content-bearing event arrives
Error status and exception event when a call fails
W3C TraceContext propagation across the A2A client-server boundary, so client and server spans share the same trace

Detached task lifecycle methods (GetTask, CancelTask), push notification methods, and agent card requests are not instrumented. Non-blocking SendMessage calls (where Config.Blocking is false) are also excluded.

AI providers

SDKs

Developer tools

Runtime environments

Setup

Auto-instrumentation

Manual instrumentation

What Braintrust traces

Resources

​Setup

​Auto-instrumentation

​Manual instrumentation

​What Braintrust traces

​Resources

Setup

Auto-instrumentation

Manual instrumentation

What Braintrust traces

Resources