Setup Install the Braintrust Go SDK alongside the Eino packages, then configure your API keys. ```bash theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} go get github.com/braintrustdata/braintrust-sdk-go go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/cloudwego/eino go get github.com/cloudwego/eino-ext/components/model/openai ``` ```bash title=".env" theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} BRAINTRUST_API_KEY=your-braintrust-api-key OPENAI_API_KEY=your-openai-api-key ``` Auto-instrumentation To trace Eino without wiring Braintrust into your application code, build your app with [Orchestrion](https://github.com/DataDog/orchestrion), a compile-time tool that appends Braintrust’s handler to your `callbacks.AppendGlobalHandlers` call. Once the handler is registered, all `ChatModel`, tool, and embedding calls are traced. ```bash theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} go install github.com/DataDog/orchestrion@latest ``` ```go title="orchestrion.tool.go" #skip-compile theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} //go:build tools package main import ( _ "github.com/DataDog/orchestrion" _ "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/cloudwego/eino" ) ``` Register Eino’s global handlers with `callbacks.AppendGlobalHandlers()`. Orchestrion appends `traceeino.DefaultHandler()` to that call at build time, so you don’t import or construct the Braintrust handler yourself. ```go Go theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} package main import ( "context" "fmt" "log" "os" einoopenai "github.com/cloudwego/eino-ext/components/model/openai" "github.com/cloudwego/eino/callbacks" "github.com/cloudwego/eino/schema" "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) bt, err := braintrust.New(tp, braintrust.WithProject("my-eino-project"), braintrust.WithAPIKey(os.Getenv("BRAINTRUST_API_KEY")), ) if err != nil { log.Fatal(err) } // Orchestrion appends traceeino.DefaultHandler() to this call at build time. callbacks.AppendGlobalHandlers() ctx := context.Background() tracer := otel.Tracer("eino-example") ctx, span := tracer.Start(ctx, "eino-chat") defer span.End() chatModel, err := einoopenai.NewChatModel(ctx, &einoopenai.ChatModelConfig{ Model: "gpt-4o-mini", APIKey: os.Getenv("OPENAI_API_KEY"), }) if err != nil { log.Fatal(err) } messages := []*schema.Message{{ Role: schema.User, Content: "What is the capital of France?", }} resp, err := chatModel.Generate(ctx, messages) if err != nil { log.Fatal(err) } fmt.Printf("Response: %s\n", resp.Content) fmt.Printf("View trace: %s\n", bt.Permalink(span)) } ``` ```bash theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} go mod tidy orchestrion go build -o myapp ./myapp ``` Instead of running `orchestrion go build`, you can set a `GOFLAGS` environment variable to enable Orchestrion for normal `go build` commands: ```bash theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} export GOFLAGS="-toolexec='orchestrion toolexec'" go build ./... ``` Manual instrumentation To trace Eino manually, register Braintrust’s handler yourself by passing `traceeino.NewHandler()` to `callbacks.AppendGlobalHandlers`. All subsequent `ChatModel` calls are traced. ```go Go theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} package main import ( "context" "fmt" "log" "os" einoopenai "github.com/cloudwego/eino-ext/components/model/openai" "github.com/cloudwego/eino/callbacks" "github.com/cloudwego/eino/schema" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/sdk/trace" "github.com/braintrustdata/braintrust-sdk-go" traceeino "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/cloudwego/eino" ) func main() { tp := trace.NewTracerProvider() defer tp.Shutdown(context.Background()) otel.SetTracerProvider(tp) bt, err := braintrust.New(tp, braintrust.WithProject("my-eino-project"), braintrust.WithAPIKey(os.Getenv("BRAINTRUST_API_KEY")), ) if err != nil { log.Fatal(err) } handler := traceeino.NewHandler() callbacks.AppendGlobalHandlers(handler) ctx := context.Background() tracer := otel.Tracer("eino-example") ctx, span := tracer.Start(ctx, "eino-chat") defer span.End() chatModel, err := einoopenai.NewChatModel(ctx, &einoopenai.ChatModelConfig{ Model: "gpt-4o-mini", APIKey: os.Getenv("OPENAI_API_KEY"), }) if err != nil { log.Fatal(err) } messages := []*schema.Message{{ Role: schema.User, Content: "What is the capital of France?", }} resp, err := chatModel.Generate(ctx, messages) if err != nil { log.Fatal(err) } fmt.Printf("Response: %s\n", resp.Content) fmt.Printf("View trace: %s\n", bt.Permalink(span)) } ``` Streaming For streaming, call `Wait()` on the handler after closing the reader so asynchronously finalized span attributes are flushed before exit. Get the handler from `traceeino.NewHandler()` in the manual path, or from `traceeino.DefaultHandler()` when auto-instrumenting. ```go #skip-compile theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}} reader, err := chatModel.Stream(ctx, messages) if err != nil { log.Fatal(err) } // ... consume the stream ... reader.Close() handler.Wait() ``` Tracing embeddings Eino’s callback handler captures `EmbedStrings` calls with no setup beyond registering the handler. Embedding calls appear as LLM spans in Braintrust, with input texts, embedding count, and model metadata captured. What Braintrust traces Braintrust captures: * Chat model spans (`eino.`, for example `eino.OpenAI`), with input messages, model parameters (model, max\_tokens, temperature, top\_p, stop) in metadata, output message with finish reason and tool calls, and token usage metrics (prompt, completion, total, cached prompt, and reasoning tokens). * Streaming chat model output reconstructed from streamed chunks, with a `time_to_first_token` metric. * Tool spans (`eino.`), with the tool’s JSON arguments as input and its response as output. * Embedding spans (`eino.`), with input texts, an embeddings count and vector length summary as output, model and encoding format in metadata, and prompt and total token metrics. Resources * [CloudWeGo Eino documentation](https://github.com/cloudwego/eino) * [Go SDK example](https://github.com/braintrustdata/braintrust-sdk-go/tree/main/examples/cloudwego/eino) * [Trace LLM calls](/instrument/trace-llm-calls) for general Go auto-instrumentation setup