Instrumentations for Go¶

import (
    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

// Your app handler.
var handler http.Handler
handler = http.HandlerFunc(userProfileEndpoint)

// Wrap it with OpenTelemetry plugin.
handler = otelhttp.WithRouteTag("/profiles/:username", handler)
handler = otelhttp.NewHandler(handler, "server-name")

// Register handler.
http.Handle("/profiles/", handler)

func userProfileEndpoint(w http.ResponseWriter, req *http.Request) { ... }

go get go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc

import (
    "google.golang.org/grpc"
    "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
)

tracer := otel.Tracer("github.com/my/repo")

otelInterceptor := grpc.WithUnaryInterceptor(otelgrpc.UnaryClientInterceptor(tracer))
conn, err := grpc.Dial("grpc-server:9999", grpc.WithInsecure(), otelInterceptor)

import (
    "google.golang.org/grpc"
    "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
)

tracer := otel.Tracer("github.com/my/repo")

otelInterceptor := grpc.UnaryInterceptor(otelgrpc.UnaryServerInterceptor(tracer))
server := grpc.NewServer(otelInterceptor)

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

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

func main() {
    router := gin.Default()
    router.Use(otelgin.Middleware("service-name"))
    router.GET("/profiles/:username", userProfileEndpoint)
}

func userProfileEndpoint(c *gin.Context) {
    ctx := c.Request.Context()
    // Use request context to propagate active span.
    doSomething(ctx)

    // Use otelgin to instrument HTML generation.
    otelgin.HTML(c, http.StatusOK, "template-name", gin.H{
        "foo": "bar",
    })
}

go get go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho

import "go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho"

func main() {
    r := echo.New()
    r.Use(otelecho.Middleware("service-name"))
}

go get go.opentelemetry.io/contrib/instrumentation/github.com/astaxie/beego/otelbeego

import "go.opentelemetry.io/contrib/instrumentation/github.com/astaxie/beego/otelbeego"

func main() {
    // To enable tracing on template rendering, disable autorender and
    // call otelbeego.Render manually.
    beego.BConfig.WebConfig.AutoRender = false

    mware := otelbeego.NewOTelBeegoMiddleWare("service-name")
    beego.RunWithMiddleWares(":7777", mware)
}

go get go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux

import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"

func main() {
    r := mux.NewRouter()
    r.Use(otelmux.Middleware("service-name"))
}

go get go.opentelemetry.io/contrib/instrumentation/github.com/emicklei/go-restful/otelrestful

import "go.opentelemetry.io/contrib/instrumentation/github.com/emicklei/go-restful/otelrestful"

func main() {
    filter := otelrestful.OTelFilter("service-name")
    restful.DefaultContainer.Filter(filter)
}

go get go.opentelemetry.io/contrib/instrumentation/gopkg.in/macaron.v1/otelmacaron

import "go.opentelemetry.io/contrib/instrumentation/gopkg.in/macaron.v1/otelmacaron"

func main() {
    m := macaron.Classic()
    m.Use(otelmacaron.Middleware("service-name"))
    m.Run()
}

go get github.com/go-pg/pgext

db := pg.Connect(&pg.Options{
    Addr:     "postgresql-server:5432",
    User:     "postgres",
    Database: "example",
})

db.AddQueryHook(pgext.OpenTelemetryHook{})

go get go.opentelemetry.io/contrib/instrumentation/go.mongodb.org/mongo-driver/mongo/otelmongo

import (
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.opentelemetry.io/contrib/instrumentation/go.mongodb.org/mongo-driver/mongo/otelmongo"
)

opt := options.Client()
opt.Monitor = otelmongo.NewMonitor("service-name")

go get github.com/go-redis/redisext

import "github.com/go-redis/redisext"

rdb := redis.NewClient(&redis.Options{
    Addr: "redis-server:6379",
})
rdb.AddHook(redisext.OpenTelemetryHook{})

go get go.opentelemetry.io/contrib/instrumentation/github.com/bradfitz/gomemcache/memcache/otelmemcache

import "go.opentelemetry.io/contrib/instrumentation/github.com/bradfitz/gomemcache/memcache/otelmemcache"

// Wrap memcache client.
mc := otelmemcache.NewClientWithTracing(
    memcache.New("localhost:11211"),
)

func do(ctx context.Context, mc *otelmemcache.Client) {
    // Set context.
    mc = mc.WithContext(ctx)
}

go get go.opentelemetry.io/contrib/instrumentation/github.com/gocql/gocql/otelgocql

import (
    "github.com/gocql/gocql"
    "go.opentelemetry.io/contrib/instrumentation/github.com/gocql/gocql/otelgocql"
)

cluster := gocql.NewCluster("localhost")

session, err := otelgocql.NewSessionWithTracing(ctx, cluster)
if err != nil {
    panic(err)
}

go get github.com/uptrace/uptrace-go/extra/otellogrus

import (
    "github.com/sirupsen/logrus"
    "github.com/uptrace/uptrace-go/extra/otellogrus"
)

func main() {
    logrus.AddHook(otellogrus.NewLoggingHook())

    // You must use WithContext to propagate the active span.
    logrus.WithContext(ctx).
        WithError(err).
        WithField("foo", "bar").
        Error("something failed")
}