Go Integration Guide

go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/sdk
go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
go get go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp
go get go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin

// Wrap a database/sql connection with tracing
sqlDB, _ := sql.Open("postgres", "postgres://localhost/mydb?sslmode=disable")
db := sdk.WrapDB(sqlDB, "postgresql")

// All queries are now automatically traced
rows, err := db.QueryContext(ctx, "SELECT id, name FROM users WHERE active = $1", true)
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

for rows.Next() {
    var id int
    var name string
    rows.Scan(&id, &name)
    // process row...
}

// Exec also creates spans automatically
_, err = db.ExecContext(ctx, "UPDATE users SET last_login = $1 WHERE id = $2", time.Now(), userID)

// Transactions are traced too
tx, _ := db.BeginTx(ctx, nil)
tx.ExecContext(ctx, "INSERT INTO orders (user_id, total) VALUES ($1, $2)", userID, total)
tx.Commit()

// Enable code monitoring in config
sdk, _ := tracekit.NewSDK(&tracekit.Config{
    APIKey:               os.Getenv("TRACEKIT_API_KEY"),
    ServiceName:          "order-service",
    EnableCodeMonitoring: true,
})
defer sdk.Shutdown(context.Background())

// Capture variables at a specific point in your code
func processOrder(ctx context.Context, orderID string, total float64) error {
    user := getCurrentUser(ctx)

    // CheckAndCapture only captures when a breakpoint is active at this location
    sdk.CheckAndCapture("handlers/order.go", 42, map[string]interface{}{
        "orderID": orderID,
        "total":   total,
        "user":    user,
    })

    // Context-aware version links snapshots to the current trace
    sdk.CheckAndCaptureWithContext(ctx, "order-processing", map[string]interface{}{
        "orderID": orderID,
        "total":   total,
        "status":  "validated",
    })

    // Business logic continues...
    return nil
}

// Using SDK wrapper methods (recommended)
ctx, span := sdk.StartSpan(ctx, "process-order")
defer span.End()

// Add typed attributes
sdk.AddAttribute(span, "order.id", orderID)
sdk.AddIntAttribute(span, "order.total", int64(total))

// Add semantic attributes for HTTP context
sdk.AddHTTPAttributes(span, "POST", "/api/orders", 201)

// Record business attributes
sdk.AddBusinessAttributes(span, map[string]interface{}{
    "order.priority": "high",
    "order.region":   region,
})

// Handle errors
if err != nil {
    sdk.RecordError(span, err)
    return err
}

sdk.SetSuccess(span)

// TraceFunction wraps an entire function call with automatic span management
err := sdk.TraceFunction(ctx, "validate-order", func(ctx context.Context, span trace.Span) error {
    sdk.AddAttribute(span, "order.id", orderID)

    // Your business logic here
    if !isValid(orderID) {
        return fmt.Errorf("invalid order: %s", orderID)
    }

    return nil
})
// If the function returns an error, TraceFunction automatically:
// 1. Records the error on the span
// 2. Sets span status to Error
// If it returns nil, span status is set to OK

package main

import (
    "context"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
)

func processOrder(ctx context.Context, orderID string) error {
    // Get tracer
    tracer := otel.Tracer("my-service")

    // Start a parent span
    ctx, span := tracer.Start(ctx, "processOrder")
    defer span.End()

    // Add attributes to the span
    span.SetAttributes(
        attribute.String("order.id", orderID),
        attribute.String("order.status", "processing"),
    )

    // Create nested child spans - they automatically inherit from parent via ctx
    if err := validateOrder(ctx, orderID); err != nil {
        span.RecordError(err)
        span.SetStatus(codes.Error, err.Error())
        return err
    }

    if err := chargePayment(ctx, orderID); err != nil {
        span.RecordError(err)
        span.SetStatus(codes.Error, err.Error())
        return err
    }

    // Mark span as successful
    span.SetStatus(codes.Ok, "Order processed successfully")
    return nil
}

func validateOrder(ctx context.Context, orderID string) error {
    tracer := otel.Tracer("my-service")

    // Child span - automatically linked to parent via ctx
    ctx, span := tracer.Start(ctx, "validateOrder")
    defer span.End()

    span.SetAttributes(attribute.String("order.id", orderID))

    // Validation logic here...
    span.SetStatus(codes.Ok, "Validation successful")
    return nil
}

func chargePayment(ctx context.Context, orderID string) error {
    tracer := otel.Tracer("my-service")

    // Another child span - also linked to parent via ctx
    ctx, span := tracer.Start(ctx, "chargePayment")
    defer span.End()

    span.SetAttributes(attribute.String("order.id", orderID))

    // Payment processing logic here...
    span.SetStatus(codes.Ok, "Payment successful")
    return nil
}

# .env
TRACEKIT_API_KEY=tk_your_generated_api_key_here
TRACEKIT_ENDPOINT=app.tracekit.dev
TRACEKIT_SERVICE_NAME=my-backend-service

import "os"

sdk, err := tracekit.NewSDK(&tracekit.Config{
    APIKey:      os.Getenv("TRACEKIT_API_KEY"),
    ServiceName: os.Getenv("TRACEKIT_SERVICE_NAME"),
    Endpoint:    os.Getenv("TRACEKIT_ENDPOINT"),
})

package main

import (
    "log"
    "os"

    "github.com/gin-gonic/gin"
    "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"

    "yourapp/tracing"
)

func main() {
    // Initialize tracing
    cleanup, err := tracing.InitTracer(
        "backend-api",
        "{ appURL }",
        os.Getenv("TRACEKIT_API_KEY"),
        false,
    )
    if err != nil {
        log.Fatalf("Failed to initialize tracer: %v", err)
    }
    defer cleanup()

    // Create Gin router
    r := gin.Default()
    r.Use(otelgin.Middleware("backend-api"))

    // Routes
    r.GET("/api/users", getUsers)
    r.POST("/api/users", createUser)

    // Start server
    log.Println("Server starting on :8080")
    r.Run(":8080")
}

func getUsers(c *gin.Context) {
    // This endpoint is automatically traced!
    c.JSON(200, gin.H{
        "users": []string{"alice", "bob", "charlie"},
    })
}

func createUser(c *gin.Context) {
    // This endpoint is automatically traced too!
    c.JSON(201, gin.H{
        "message": "User created successfully",
    })
}