Go SDK API Reference

go get github.com/langwatch/langwatch/sdk-go
go get github.com/langwatch/langwatch/sdk-go/instrumentation/openai

func setupLangWatch(ctx context.Context) func(context.Context) {
	exporter, err := langwatch.NewDefaultExporter(ctx)
	if err != nil {
		log.Fatalf("failed to create exporter: %v", err)
	}

	tp := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exporter))
	otel.SetTracerProvider(tp)

	return func(ctx context.Context) {
		if err := tp.Shutdown(ctx); err != nil {
			log.Printf("Error shutting down: %v", err)
		}
	}
}

exporter, err := langwatch.NewExporter(ctx,
	langwatch.WithAPIKey("your-api-key"),
	langwatch.WithEndpoint("https://custom.endpoint.ai"),
	langwatch.WithFilters(langwatch.LangWatchOnly()),
)

func Tracer(instrumentationName string, opts ...trace.TracerOption) LangWatchTracer

// Basic usage
tracer := langwatch.Tracer("my-app")

// With instrumentation version
tracer := langwatch.Tracer("my-app", 
    trace.WithInstrumentationVersion("1.0.0"))

type LangWatchTracer interface {
	Start(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, LangWatchSpan)
}

tracer := langwatch.Tracer("my-app")
ctx, span := tracer.Start(ctx, "HandleUserRequest")
defer span.End()

// The span is now active and can be used to record data
span.SetType(langwatch.SpanTypeLLM)
span.RecordInputString("User query")

func Middleware(instrumentationName string, opts ...Option) openai.Middleware

// NewDefaultExporter automatically uses ExcludeHTTPRequests
exporter, err := langwatch.NewDefaultExporter(ctx)

// Or choose your own filters
exporter, err := langwatch.NewExporter(ctx,
	langwatch.WithFilters(
		langwatch.ExcludeHTTPRequests(), // Remove GET, POST, etc. spans
		langwatch.LangWatchOnly(),       // Keep only LangWatch instrumentation
	),
)

exporter, err := langwatch.NewExporter(ctx,
	langwatch.WithFilters(
		// Keep only spans from specific scopes
		langwatch.Include(langwatch.Criteria{
			ScopeName: []langwatch.Matcher{
				langwatch.StartsWith("github.com/langwatch/"),
				langwatch.StartsWith("my-app/"),
			},
		}),
		// Remove database spans
		langwatch.Exclude(langwatch.Criteria{
			SpanName: []langwatch.Matcher{
				langwatch.StartsWith("database."),
			},
		}),
	),
)

func safeRecordInput(span langwatch.LangWatchSpan, input any) {
    defer func() {
        if r := recover(); r != nil {
            // Fallback to string representation
            span.RecordInputString(fmt.Sprintf("%v", input))
        }
    }()
    span.RecordInput(input)
}

package main

import (
	"context"
	"log"
	"os"
	"time"

	langwatch "github.com/langwatch/langwatch/sdk-go"
	otelopenai "github.com/langwatch/langwatch/sdk-go/instrumentation/openai"

	"github.com/openai/openai-go"
	"github.com/openai/openai-go/option"
	"go.opentelemetry.io/otel"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

func main() {
	ctx := context.Background()

	// Setup LangWatch tracing
	shutdown := setupLangWatch(ctx)
	// Critical: defer shutdown immediately to ensure traces are flushed
	// Without this, buffered traces will be lost when the application exits
	defer shutdown(ctx)

	// Create instrumented OpenAI client
	client := openai.NewClient(
		option.WithAPIKey(os.Getenv("OPENAI_API_KEY")),
		option.WithMiddleware(otelopenai.Middleware("rag-app",
			otelopenai.WithCaptureInput(),
			otelopenai.WithCaptureOutput(),
		)),
	)

	// Process user query
	if err := processQuery(ctx, client, "How do I implement JWT authentication in Go?"); err != nil {
		log.Fatalf("Failed to process query: %v", err)
	}
}

func processQuery(ctx context.Context, client *openai.Client, query string) error {
	tracer := langwatch.Tracer("rag-app")
	ctx, span := tracer.Start(ctx, "ProcessUserQuery")
	defer span.End()

	span.SetType(langwatch.SpanTypeRAG)
	span.SetThreadID("user-session-" + time.Now().Format("20060102"))
	span.SetUserID("user-123")
	span.RecordInputString(query)

	// Step 1: Retrieve relevant documents
	documents, err := retrieveDocuments(ctx, query)
	if err != nil {
		span.RecordError(err)
		return err
	}

	// Step 2: Generate response with context
	response, err := generateResponse(ctx, client, query, documents)
	if err != nil {
		span.RecordError(err)
		return err
	}

	span.RecordOutputString(response)
	return nil
}

func retrieveDocuments(ctx context.Context, query string) ([]string, error) {
	tracer := langwatch.Tracer("retrieval")
	ctx, span := tracer.Start(ctx, "RetrieveDocuments")
	defer span.End()

	span.SetType(langwatch.SpanTypeRetrieval)
	span.RecordInputString(query)

	// Simulate document retrieval
	documents := []string{
		"JWT tokens are commonly used for authentication...",
		"Use the crypto/bcrypt package for password hashing...",
	}

	chunks := []langwatch.SpanRAGContextChunk{
		{Content: documents[0], Source: "auth-guide", Score: 0.92},
		{Content: documents[1], Source: "go-docs", Score: 0.88},
	}
	span.SetRAGContextChunks(chunks)

	return documents, nil
}

func generateResponse(ctx context.Context, client *openai.Client, query string, documents []string) (string, error) {
	tracer := langwatch.Tracer("llm")
	ctx, span := tracer.Start(ctx, "GenerateResponse")
	defer span.End()

	span.SetType(langwatch.SpanTypeLLM)
	span.SetRequestModel("gpt-4o-mini")

	// Prepare context for LLM
	ragContext := "Context:\n" + documents[0] + "\n" + documents[1]

	response, err := client.Chat.Completions.New(ctx, openai.ChatCompletionNewParams{
		Model: openai.ChatModelGPT4oMini,
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.SystemMessage("You are a helpful assistant. Use the provided context to answer questions."),
			openai.UserMessage(ragContext + "\n\nQuestion: " + query),
		},
	})
	if err != nil {
		return "", err
	}

	content := response.Choices[0].Message.Content
	span.RecordOutputString(content)
	span.SetResponseModel(response.Model)

	return content, nil
}

func setupLangWatch(ctx context.Context) func(context.Context) {
	// NewDefaultExporter reads LANGWATCH_API_KEY from environment
	// and automatically applies the ExcludeHTTPRequests filter
	exporter, err := langwatch.NewDefaultExporter(ctx)
	if err != nil {
		log.Fatalf("failed to create LangWatch exporter: %v", err)
	}

	tp := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exporter))
	otel.SetTracerProvider(tp)

	return func(ctx context.Context) {
		// Shutdown flushes all pending traces to LangWatch
		// This is critical - without it, traces may be lost!
		if err := tp.Shutdown(ctx); err != nil {
			log.Printf("Error shutting down tracer provider: %v", err)
		}
	}
}