Gin

Use the Last9 Go Agent to instrument your Gin application with automatic tracing and metrics. The agent wraps the official OpenTelemetry Gin middleware under the hood — full OTel compliance with minimal code changes.

Prerequisites

• Go 1.22 or higher
• Gin (github.com/gin-gonic/gin)
• Last9 account with OTLP credentials

Installation

1. Install the Last9 Go Agent

   go get github.com/last9/go-agent

2. Set Environment Variables

   export OTEL_SERVICE_NAME="your-gin-service"
   export OTEL_EXPORTER_OTLP_ENDPOINT="$last9_otlp_endpoint"
   export OTEL_EXPORTER_OTLP_HEADERS="Authorization=$last9_otlp_auth_header"
   export OTEL_TRACES_SAMPLER="always_on"
   export OTEL_RESOURCE_ATTRIBUTES="deployment.environment=production"

3. Instrument your application

   • New application
   • Minimal setup
   • Existing application

   Replace gin.Default() with ginagent.Default() — that’s the only change required:

   package main
   
   import (
       "log"
       "net/http"
   
       "github.com/gin-gonic/gin"
       "github.com/last9/go-agent"
       ginagent "github.com/last9/go-agent/instrumentation/gin"
   )
   
   func main() {
       if err := agent.Start(); err != nil {
           log.Fatalf("failed to start agent: %v", err)
       }
       defer agent.Shutdown()
   
       // Drop-in replacement for gin.Default() (includes logging & recovery)
       r := ginagent.Default()
   
       r.GET("/", indexHandler)
       r.GET("/users/:id", getUserHandler)
       r.POST("/users", createUserHandler)
   
       log.Fatal(r.Run(":8080"))
   }
   
   func indexHandler(c *gin.Context) {
       c.JSON(http.StatusOK, gin.H{"message": "ok"})
   }
   
   func getUserHandler(c *gin.Context) {
       c.JSON(http.StatusOK, gin.H{"id": c.Param("id")})
   }
   
   func createUserHandler(c *gin.Context) {
       c.JSON(http.StatusCreated, gin.H{"status": "created"})
   }

Database Instrumentation

Use the agent’s database integration for automatic SQL query tracing. Supported drivers: PostgreSQL, MySQL, SQLite.

import "github.com/last9/go-agent/integrations/database"

db, err := database.Open(database.Config{
    DriverName:   "postgres",
    DSN:          "postgres://user:pass@localhost/mydb",
    DatabaseName: "mydb",
})
if err != nil {
    log.Fatal(err)
}
defer db.Close()

// Use db normally — all queries are automatically traced
func getUserHandler(c *gin.Context) {
    rows, err := db.QueryContext(c.Request.Context(), "SELECT id, name FROM users WHERE id = $1", c.Param("id"))
    // ...
}

The agent automatically extracts server.address, server.port, db.user, and db.name from the DSN and attaches them to every span.

Redis Instrumentation

import redisagent "github.com/last9/go-agent/integrations/redis"

// Drop-in replacement for redis.NewClient()
rdb := redisagent.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

func cacheHandler(c *gin.Context) {
    val, err := rdb.Get(c.Request.Context(), "key").Result()
    // ...
}

HTTP Client Instrumentation

For outgoing requests with automatic traceparent propagation:

import httpagent "github.com/last9/go-agent/integrations/http"

client := httpagent.NewClient(&http.Client{
    Timeout: 10 * time.Second,
})

func proxyHandler(c *gin.Context) {
    req, _ := http.NewRequestWithContext(c.Request.Context(), "GET", "https://upstream.example.com/api", nil)
    resp, err := client.Do(req)
    // ...
}

Custom Spans

Add spans for business-critical operations:

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

func checkoutHandler(c *gin.Context) {
    tracer := otel.Tracer("checkout")
    ctx, span := tracer.Start(c.Request.Context(), "process_payment")
    defer span.End()

    span.SetAttributes(
        attribute.String("payment.method", "card"),
        attribute.Float64("order.total", 49.99),
    )

    if err := processPayment(ctx); err != nil {
        span.RecordError(err)
        span.SetStatus(codes.Error, err.Error())
        c.JSON(http.StatusInternalServerError, gin.H{"error": "payment failed"})
        return
    }

    span.SetStatus(codes.Ok, "")
    c.JSON(http.StatusOK, gin.H{"status": "paid"})
}

What Gets Traced Automatically

View Traces and Metrics

After running your application, navigate to Trace Explorer and Metrics Explorer in Last9 to view your telemetry data.

Troubleshooting

Please get in touch with us on Discord or Email if you have any questions.