手動計測ガイド

Goライブラリを利用してWhaTapエージェントにモニタリングデータを手動で送信できます。サンプルコードはgithub.com/whatap/go-api-exampleで確認できます。

ノート

自動計測 vs 手動計測

自動計測 (推奨): 自動計測ガイドを参照してコード自動挿入
手動計測: このドキュメントで説明するAPIを直接コードに追加

はじめに

次のコマンドでGo APIをインストールしてください。

go get github.com/whatap/go-api@latest

Init, Shutdown

モニタリングモジュールを初期化および終了する基本構造:

import "github.com/whatap/go-api/trace"

func main(){
    trace.Init(nil)
    defer trace.Shutdown()
    ...
}

Init関数の設定オプション:

map[string]string形式で初期設定可能
whatap.confファイルでも設定可能
デフォルトTCP接続: 127.0.0.1:6600

m := make(map[string]string)
m["net_ipc_host"] = "127.0.0.1"
m["net_ipc_port"] = "6601"
trace.Init(m)

whatap.conf設定:

accesskey={アクセスキー}
whatap.server.host={収集サーバーIPアドレス}
net_ipc_host=127.0.0.1
net_ipc_port=6600

Context管理

エージェントはwhatap context(trace.TraceCtx)を基準にトランザクションを区別します。トランザクション外のパフォーマンス情報は無視されるか、統計のみ収集されます。

トランザクション生成

var traceCtx *TraceCtx
traceCtx.Txid = keygen.Next()
ctx = context.WithValue(ctx, "whatap", traceCtx)

トランザクション追跡

Webトランザクション追跡

http.HandleFunc("/index", func(w http.ResponseWriter, r *http.Request) {
    ctx, _ := trace.StartWithRequest(r)
    defer trace.End(ctx, nil)
})

ラッピング関数:

trace.Func(): RequestURIをトランザクション名として設定
trace.HandlerFunc(): 同じ機能を提供

一般トランザクション追跡

func main() {
    ctx := context.Background()
    ctx, _ := trace.Start(ctx, "Custom Transaction")
    ...
    trace.End(ctx, nil)
}

トランザクションAPI

func Start(ctx context.Context, name string) (context.Context, error)
func End(ctx context.Context, err error) error
func StartWithRequest(r *http.Request) (context.Context, error)
func Step(ctx context.Context, title, message string, elapsed, value int) error
func HandlerFunc(handler func(http.ResponseWriter, *http.Request)) http.HandlerFunc
func Func(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request)

DB接続およびSQL追跡

制限事項:

SQL文: 最大32KB
Preparedパラメータ: 最大20個、各256byte

DB Connection追跡

import whatapsql "github.com/whatap/go-api/sql"

ctx, _ := trace.Start(context.Background(), "Trace Open DB")
defer trace.End(ctx, nil)

sqlCtx, _ := whatapsql.StartOpen(ctx, "id@tcp(x.x.x.x:3306)/test")
db, err := sql.Open("mysql", "id:pwd@tcp(x.x.x.x:3306)/test")
whatapsql.End(sqlCtx, err)
defer db.Close()

SQL Query追跡

query = "select id, subject from tbl_faq limit 10"
sqlCtx, _ = whatapsql.Start(ctx, "id:pwd@tcp(x.x.x.x:3306)/test", query)
rows, err := db.QueryContext(ctx, query)
whatapsql.End(sqlCtx, err)

Prepared Statement追跡

query = "select id, subject from tbl_faq where id = ? limit ?"
stmt, err := db.Prepare(query)
defer stmt.Close()

params := make([]interface{}, 0)
params = append(params, 8)
params = append(params, 1)

sqlCtx, _ := whatapsql.StartWithParamArray(ctx, "id:pwd@tcp(x.x.x.x:3306)/test", query, params)
rows, err := stmt.QueryContext(ctx, params...)
whatapsql.End(sqlCtx, err)

database/sqlパッケージの活用

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/whatap/go-api/instrumentation/database/sql/whatapsql"
)

db, err := whatapsql.OpenContext(ctx, "mysql", dataSource)
defer db.Close()

if rows, err := db.QueryContext(ctx, query); err == nil {
    ...
}

SQL API

func Start(ctx context.Context, dbhost, sql string) (*SqlCtx, error)
func StartOpen(ctx context.Context, dbhost string) (*SqlCtx, error)
func End(sqlCtx *SqlCtx, err error) error
func StartWithParam(ctx context.Context, dbhost, sql, param ...interface{}) (*SqlCtx, error)
func StartWithParamArray(ctx context.Context, dbhost, sql string, param []interface{}) (*SqlCtx, error)
func Trace(ctx context.Context, dbhost, sql, param string, elapsed int, err error) error

HTTPリクエスト追跡

import "github.com/whatap/go-api/httc"

ctx, _ := trace.Start(context.Background(), "Trace Http Call")
defer trace.End(ctx, nil)

httpcCtx, _ := httpc.Start(ctx, callUrl)
resp, err := http.Get(callUrl)
if err == nil {
    httpc.End(httpcCtx, resp.StatusCode, "", nil)
} else {
    httpc.End(httpcCtx, 0, "", err)
}

HTTP Transport RoundTrip

import "github.com/whatap/go-api/instrumentation/net/http/whataphttp"

ctx, _ := trace.Start(context.Background(), "Http call")
defer trace.End(ctx, nil)

client := http.DefaultClient
client.Transport = whataphttp.NewRoundTrip(ctx, http.DefaultTransport)
resp, err := client.Get(callUrl)
defer resp.Body.Close()

HTTP API

func Start(ctx context.Context, url string) (*HttpcCtx, error)
func End(httpcCtx *HttpcCtx, status int, reason string, err error) error
func Trace(ctx context.Context, host string, port int, url string, elapsed int, status int, reason string, err error) error

マルチトランザクション追跡 (分散追跡)

他のエージェントやプロジェクトに関連するトランザクションを追跡します。

ヘッダーキー値:

x-wtap-po
x-wtap-mst
x-wtap-sp1

また、OpenTraceのtraceparentヘッダーもサポートします。

エージェント設定

mtrace_enabled=true
mtrace_rate=100

Request Header処理

func UpdateMtrace(traceCtx *trace.TraceCtx, header http.Header)

trace.StartWithRequestは内部的にこの関数を呼び出します。

ctx, traceCtx := trace.GetTraceContext(ctx)
if traceCtx != nil {
    trace.UpdateMtrace(traceCtx, header)
}

func GetMTrace(ctx context.Context) http.Header

この関数は分散追跡に必要なHeaderを返します:

headers := trace.GetMTrace(wCtx)
for key, _ := range headers {
    req.Header.Set(key, headers.Get(key))
}

WhaTap transportにすでに含まれています:

client := http.Client{Timeout: timeout}
client.Transport = whataphttp.NewRoundTrip(ctx, http.DefaultTransport)
resp, err := client.Get(callUrl)

複数のTransport使用:

client.Transport = NewAccessLogRoundTrip(whataphttp.NewRoundTrip(ctx, http.DefaultTransport))

関数追跡

ユーザー関数または特定区間の実行時間測定:

import "github.com/whatap/go-api/method"

ctx, _ := trace.Start(context.Background(), "Trace Method")
defer trace.End(ctx, nil)

getUser(ctx)

func getUser(ctx context.Context) {
    methodCtx, _ := method.Start(ctx, "getUser")
    defer method.End(methodCtx, nil)
    time.Sleep(time.Duration(1) * time.Second)
}

関数追跡API

func Start(ctx context.Context, name string) (*MethodCtx, error)
func End(methodCtx *MethodCtx, err error) error
func Trace(ctx context.Context, name string, elapsed int, err error) error

Wrap関数 (Go 1.18+ Generics)

Wrap関数はクロージャーを使用して計測コードを簡潔に作成できるようにします。Go 1.18以上のGenericsを活用します。

Trace Wrap関数 (汎用)

特定のドメインに属さない汎用追跡に使用します。

import "github.com/whatap/go-api/trace"

// Wrap - (T, error)を返す汎用関数
result, err := trace.Wrap(ctx, "ThirdParty.Calculate", func() (int, error) {
    return thirdPartyLib.Calculate(input)
})

// WrapError - errorのみ返す
err := trace.WrapError(ctx, "FileProcessor.Process", func() error {
    return processFile(path)
})

// WrapVoid - 戻り値なし
trace.WrapVoid(ctx, "Cleanup.Execute", func() {
    cleanup()
})

SQL Wrap関数

HookをサポートしないDBライブラリ (Aerospike、一部NoSQLなど) の計測に便利です。

import "github.com/whatap/go-api/sql"

// Wrap - (T, error)を返すクエリ
record, err := sql.Wrap(ctx, "aerospike://host:3000", "GET ns/set", func() (*aero.Record, error) {
    return client.Get(policy, key)
})

// WrapError - errorのみ返すクエリ (INSERT, UPDATE, DELETE)
err := sql.WrapError(ctx, "aerospike://host:3000", "PUT ns/set", func() error {
    return client.Put(policy, key, bins)
})

// WrapP - パラメータ追跡を含む
rows, err := sql.WrapP(ctx, "mysql://host:3306", "SELECT * FROM users WHERE id = ?",
    []interface{}{userId},
    func() (*sql.Rows, error) {
        return db.Query("SELECT * FROM users WHERE id = ?", userId)
    },
)

// WrapOpen - DB接続追跡
db, err := sql.WrapOpen(ctx, "mysql://host:3306", func() (*sql.DB, error) {
    return sql.Open("mysql", dsn)
})

HTTP Wrap関数

外部HTTP API呼び出し計測に使用します。

import "github.com/whatap/go-api/httpc"

// Wrap - (T, error)を返す
resp, err := httpc.Wrap(ctx, "https://api.payment.com/charge", func() (*PaymentResp, error) {
    return paymentClient.Charge(amount)
})

// WrapError - errorのみ返す
err := httpc.WrapError(ctx, "https://api.example.com/webhook", func() error {
    return sendWebhook(payload)
})

// WrapWithStatus - HTTPステータスコードを含む
resp, status, err := httpc.WrapWithStatus(ctx, "https://api.example.com/data",
    func() (*Response, int, error) {
        resp, err := client.Get(url)
        if resp != nil {
            return resp, resp.StatusCode, err
        }
        return nil, 0, err
    },
)

Method Wrap関数

ユーザー定義メソッド/関数追跡に使用します。

import "github.com/whatap/go-api/method"

// Wrap - (T, error)を返す
order, err := method.Wrap(ctx, "OrderService.ProcessOrder", func() (*Order, error) {
    return s.processOrderInternal(orderID)
})

// WrapError - errorのみ返す
err := method.WrapError(ctx, "OrderService.ValidateOrder", func() error {
    return s.validateOrder(order)
})

// WrapVoid - 戻り値なし
method.WrapVoid(ctx, "CacheService.Invalidate", func() {
    s.cache.Delete(key)
})

Wrap関数API要約

パッケージ	関数	説明
`trace`	`Wrap[T]`	汎用 (T, error)返す
`trace`	`WrapError`	汎用 errorのみ返す
`trace`	`WrapVoid`	汎用戻り値なし
`sql`	`Wrap[T]`	(T, error)を返すクエリ
`sql`	`WrapError`	errorのみ返すクエリ
`sql`	`WrapP[T]`	パラメータ追跡を含む
`sql`	`WrapErrorP`	パラメータ + errorのみ
`sql`	`WrapOpen[T]`	DB接続追跡
`httpc`	`Wrap[T]`	HTTP呼び出し
`httpc`	`WrapError`	errorのみ返す
`httpc`	`WrapWithStatus[T]`	ステータスコードを含む
`method`	`Wrap[T]`	メソッド追跡
`method`	`WrapError`	errorのみ返す
`method`	`WrapVoid`	戻り値なし

ログ収集

エージェント設定

logsink_enabled=true              # ログ収集有効化 (デフォルト: false)
logsink_trace_enabled=true        # トランザクション連携 (デフォルト: true)
logsink_zip_enabled=true          # 圧縮転送 (デフォルト: true)

TraceLogWriter (推奨)

logsink.GetTraceLogWriter()を使用すると、ログとトランザクションを連携できます。ログに@txid、@mtid、@gidフィールドが自動的に追加されます。

func GetTraceLogWriter(w io.Writer) io.Writer
func GetTraceLogWriterWithCategory(w io.Writer, category string) io.Writer

変更案内: 既存のGetWriterHookStdout()、GetWriterHookStderr()の代わりにGetTraceLogWriter(os.Stdout)、GetTraceLogWriter(os.Stderr)の使用を推奨します。

既存API (互換性維持)

func GetWriterHookStdout() io.Writer  // → GetTraceLogWriter(os.Stdout)推奨
func GetWriterHookStderr() io.Writer  // → GetTraceLogWriter(os.Stderr)推奨

logパッケージ例

import (
    "log"
    "os"
    "github.com/whatap/go-api/logsink"
    "github.com/whatap/go-api/trace"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // 推奨: TraceLogWriterを使用
    log.SetOutput(logsink.GetTraceLogWriter(os.Stderr))

    // 既存方式 (互換性維持)
    // log.SetOutput(logsink.GetWriterHookStderr())

    log.Println("Application started")
}

go.uber.org/zap例

import (
    "os"
    "github.com/whatap/go-api/logsink"
    "github.com/whatap/go-api/trace"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // TraceLogWriterでラップ
    writer := logsink.GetTraceLogWriter(os.Stdout)

    consoleCore := zapcore.NewCore(
        zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig()),
        zapcore.AddSync(writer),
        zap.InfoLevel,
    )
    logger := zap.New(consoleCore)
    logger.Info("logger started")
}

sirupsen/logrus例

import (
    "os"
    log "github.com/sirupsen/logrus"
    "github.com/whatap/go-api/logsink"
    "github.com/whatap/go-api/trace"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // TraceLogWriterでラップ
    log.SetOutput(logsink.GetTraceLogWriter(os.Stderr))
    log.Info("Log message")
}

Webフレームワーク計測

instrumentationパッケージを使用すると、主要なWebフレームワークに対する自動追跡が可能です。

Gin

import (
    "github.com/gin-gonic/gin"
    "github.com/whatap/go-api/instrumentation/github.com/gin-gonic/gin/whatapgin"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    r := gin.Default()
    r.Use(whatapgin.Middleware())

    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "hello"})
    })
    r.Run(":8080")
}

Echo v4

import (
    "github.com/labstack/echo/v4"
    "github.com/whatap/go-api/instrumentation/github.com/labstack/echo/v4/whatapecho"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    e := echo.New()
    e.Use(whatapecho.Middleware())

    e.GET("/hello", func(c echo.Context) error {
        return c.JSON(200, map[string]string{"message": "hello"})
    })
    e.Start(":8080")
}

Fiber v2

import (
    "github.com/gofiber/fiber/v2"
    "github.com/whatap/go-api/instrumentation/github.com/gofiber/fiber/v2/whatapfiber"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    app := fiber.New()
    app.Use(whatapfiber.Middleware())

    app.Get("/hello", func(c *fiber.Ctx) error {
        return c.JSON(fiber.Map{"message": "hello"})
    })
    app.Listen(":8080")
}

Chi v5

import (
    "net/http"
    "github.com/go-chi/chi/v5"
    "github.com/whatap/go-api/instrumentation/github.com/go-chi/chi/whatapchi"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    r := chi.NewRouter()
    r.Use(whatapchi.Middleware)

    r.Get("/hello", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello"))
    })
    http.ListenAndServe(":8080", r)
}

Gorilla Mux

import (
    "net/http"
    "github.com/gorilla/mux"
    "github.com/whatap/go-api/instrumentation/github.com/gorilla/mux/whatapmux"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    r := mux.NewRouter()
    r.Use(whatapmux.Middleware)

    r.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello"))
    })
    http.ListenAndServe(":8080", r)
}

FastHTTP

import (
    "github.com/valyala/fasthttp"
    "github.com/whatap/go-api/instrumentation/github.com/valyala/fasthttp/whatapfasthttp"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    handler := func(ctx *fasthttp.RequestCtx) {
        ctx.WriteString("hello")
    }

    fasthttp.ListenAndServe(":8080", whatapfasthttp.Middleware(handler))
}

net/httpハンドラーラッピング

import (
    "net/http"
    "github.com/whatap/go-api/instrumentation/net/http/whataphttp"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // HandleFuncラッピング
    http.HandleFunc("/api", whataphttp.Func(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello"))
    }))

    // Handlerラッピング
    http.Handle("/handler", whataphttp.Handler(myHandler))

    http.ListenAndServe(":8080", nil)
}

database/sql計測 (whatapsql)

database/sqlパッケージをラップして自動的にSQLクエリを追跡します。

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/whatap/go-api/instrumentation/database/sql/whatapsql"
    "github.com/whatap/go-api/trace"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // sql.Openの代わりにwhatapsql.Openを使用
    db, err := whatapsql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    // その後、db.Query、db.Execなどが自動的に追跡される
    rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE id = ?", 1)
}

OpenContext (トランザクションコンテキスト連携)

// トランザクションコンテキストと連携
db, err := whatapsql.OpenContext(ctx, "mysql", dsn)

sqlx計測

import (
    "github.com/whatap/go-api/instrumentation/github.com/jmoiron/sqlx/whatapsqlx"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // sqlx.Openの代わりにwhatapsqlx.Openを使用
    db, err := whatapsqlx.Open("mysql", dsn)

    // sqlx.Connectの代わりにwhatapsqlx.Connectを使用
    db, err := whatapsqlx.Connect("postgres", dsn)
}

GORM計測

gorm.io/gorm (GORM v2)

import (
    "gorm.io/driver/mysql"
    "github.com/whatap/go-api/instrumentation/github.com/go-gorm/gorm/whatapgorm"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // gorm.Openの代わりにwhatapgorm.Openを使用
    db, err := whatapgorm.Open(mysql.Open(dsn), &gorm.Config{})
}

github.com/jinzhu/gorm (GORM v1)

import (
    "github.com/whatap/go-api/instrumentation/github.com/jinzhu/gorm/whatapgorm"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    db, err := whatapgorm.Open("mysql", dsn)
}

Redis計測

go-redis v9

import (
    "github.com/whatap/go-api/instrumentation/github.com/redis/go-redis/v9/whatapgoredis"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // redis.NewClientの代わりにwhatapgoredis.NewClientを使用
    rdb := whatapgoredis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // redis.NewClusterClient
    cluster := whatapgoredis.NewClusterClient(&redis.ClusterOptions{
        Addrs: []string{"localhost:7000", "localhost:7001"},
    })
}

go-redis v8

import (
    "github.com/whatap/go-api/instrumentation/github.com/go-redis/redis/v8/whatapgoredis"
)

// v9と同じ使用方法
rdb := whatapgoredis.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

Redigo

import (
    "github.com/whatap/go-api/instrumentation/github.com/gomodule/redigo/whatapredigo"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // redis.Dialの代わりにwhatapredigo.Dialを使用
    conn, err := whatapredigo.Dial("tcp", "localhost:6379")
    defer conn.Close()

    // 一般的なredisコマンドを使用
    conn.Do("SET", "key", "value")
}

MongoDB計測

import (
    "go.mongodb.org/mongo-driver/mongo"
    "github.com/whatap/go-api/instrumentation/go.mongodb.org/mongo-driver/mongo/whatapmongo"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // mongo.Connectの代わりにwhatapmongo.Connectを使用
    client, err := whatapmongo.Connect(ctx, options.Client().ApplyURI("mongodb://localhost:27017"))
    defer client.Disconnect(ctx)

    collection := client.Database("test").Collection("users")
    collection.FindOne(ctx, bson.M{"name": "john"})
}

gRPC計測

サーバー側

import (
    "google.golang.org/grpc"
    "github.com/whatap/go-api/instrumentation/google.golang.org/grpc/whatapgrpc"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    // Interceptorを追加
    server := grpc.NewServer(
        grpc.UnaryInterceptor(whatapgrpc.UnaryServerInterceptor()),
        grpc.StreamInterceptor(whatapgrpc.StreamServerInterceptor()),
    )

    // サービス登録およびサーバー起動
    pb.RegisterMyServiceServer(server, &myService{})
    server.Serve(lis)
}

クライアント側

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    conn, err := grpc.Dial("localhost:50051",
        grpc.WithInsecure(),
        grpc.WithUnaryInterceptor(whatapgrpc.UnaryClientInterceptor()),
        grpc.WithStreamInterceptor(whatapgrpc.StreamClientInterceptor()),
    )
    defer conn.Close()

    client := pb.NewMyServiceClient(conn)
    resp, err := client.MyMethod(ctx, &pb.Request{})
}

Kafka計測 (Sarama)

import (
    "github.com/IBM/sarama"
    "github.com/whatap/go-api/instrumentation/github.com/IBM/sarama/whatapsarama"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    config := sarama.NewConfig()

    // Producerラッピング
    producer, err := sarama.NewSyncProducer(brokers, config)
    wrappedProducer := whatapsarama.WrapSyncProducer(producer)

    // Consumerラッピング
    consumer, err := sarama.NewConsumer(brokers, config)
    wrappedConsumer := whatapsarama.WrapConsumer(consumer)
}

Kubernetes client-go計測

import (
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
    "github.com/whatap/go-api/instrumentation/k8s.io/client-go/kubernetes/whatapkubernetes"
)

func main() {
    trace.Init(nil)
    defer trace.Shutdown()

    config, err := rest.InClusterConfig()
    if err != nil {
        panic(err)
    }

    // configラッピング
    config = whatapkubernetes.WrapConfig(config)

    clientset, err := kubernetes.NewForConfig(config)
    // その後、Kubernetes API呼び出しが自動的に追跡される
}

Instrumentationパッケージ要約

分類	パッケージ	Importパス
Webフレームワーク	Gin	`github.com/whatap/go-api/instrumentation/github.com/gin-gonic/gin/whatapgin`
	Echo v4	`github.com/whatap/go-api/instrumentation/github.com/labstack/echo/v4/whatapecho`
	Fiber v2	`github.com/whatap/go-api/instrumentation/github.com/gofiber/fiber/v2/whatapfiber`
	Chi	`github.com/whatap/go-api/instrumentation/github.com/go-chi/chi/whatapchi`
	Gorilla Mux	`github.com/whatap/go-api/instrumentation/github.com/gorilla/mux/whatapmux`
	FastHTTP	`github.com/whatap/go-api/instrumentation/github.com/valyala/fasthttp/whatapfasthttp`
	net/http	`github.com/whatap/go-api/instrumentation/net/http/whataphttp`
データベース	database/sql	`github.com/whatap/go-api/instrumentation/database/sql/whatapsql`
	sqlx	`github.com/whatap/go-api/instrumentation/github.com/jmoiron/sqlx/whatapsqlx`
	GORM v2	`github.com/whatap/go-api/instrumentation/github.com/go-gorm/gorm/whatapgorm`
	GORM v1	`github.com/whatap/go-api/instrumentation/github.com/jinzhu/gorm/whatapgorm`
Redis	go-redis v9	`github.com/whatap/go-api/instrumentation/github.com/redis/go-redis/v9/whatapgoredis`
	go-redis v8	`github.com/whatap/go-api/instrumentation/github.com/go-redis/redis/v8/whatapgoredis`
	Redigo	`github.com/whatap/go-api/instrumentation/github.com/gomodule/redigo/whatapredigo`
NoSQL	MongoDB	`github.com/whatap/go-api/instrumentation/go.mongodb.org/mongo-driver/mongo/whatapmongo`
RPC	gRPC	`github.com/whatap/go-api/instrumentation/google.golang.org/grpc/whatapgrpc`
メッセージキュー	Sarama (IBM)	`github.com/whatap/go-api/instrumentation/github.com/IBM/sarama/whatapsarama`
	Sarama (Shopify)	`github.com/whatap/go-api/instrumentation/github.com/Shopify/sarama/whatapsarama`
クラウド	Kubernetes	`github.com/whatap/go-api/instrumentation/k8s.io/client-go/kubernetes/whatapkubernetes`

はじめに​

Init, Shutdown​

Context管理​

トランザクション生成​

トランザクション追跡​

Webトランザクション追跡​

一般トランザクション追跡​

トランザクションAPI​

DB接続およびSQL追跡​

DB Connection追跡​

SQL Query追跡​

Prepared Statement追跡​

database/sqlパッケージの活用​

SQL API​

HTTPリクエスト追跡​

HTTP Transport RoundTrip​

HTTP API​

マルチトランザクション追跡 (分散追跡)​

エージェント設定​

Request Header処理​

Header情報の取得および追加​

自動Header追加​

関数追跡​

関数追跡API​

Wrap関数 (Go 1.18+ Generics)​

Trace Wrap関数 (汎用)​

SQL Wrap関数​

HTTP Wrap関数​

Method Wrap関数​

Wrap関数API要約​

ログ収集​

エージェント設定​

TraceLogWriter (推奨)​

既存API (互換性維持)​

logパッケージ例​

go.uber.org/zap例​

sirupsen/logrus例​

Webフレームワーク計測​

Gin​

Echo v4​

Fiber v2​

Chi v5​

Gorilla Mux​

FastHTTP​

net/httpハンドラーラッピング​

database/sql計測 (whatapsql)​

OpenContext (トランザクションコンテキスト連携)​

sqlx計測​

GORM計測​

gorm.io/gorm (GORM v2)​

github.com/jinzhu/gorm (GORM v1)​

Redis計測​

go-redis v9​

go-redis v8​

Redigo​

MongoDB計測​

gRPC計測​

サーバー側​

クライアント側​

Kafka計測 (Sarama)​

Kubernetes client-go計測​

Instrumentationパッケージ要約​

はじめに

Init, Shutdown

Context管理

トランザクション生成

トランザクション追跡

Webトランザクション追跡

一般トランザクション追跡

トランザクションAPI

DB接続およびSQL追跡

DB Connection追跡

SQL Query追跡

Prepared Statement追跡

database/sqlパッケージの活用

SQL API

HTTPリクエスト追跡

HTTP Transport RoundTrip

HTTP API

マルチトランザクション追跡 (分散追跡)

エージェント設定

Request Header処理

Header情報の取得および追加

自動Header追加

関数追跡

関数追跡API

Wrap関数 (Go 1.18+ Generics)

Trace Wrap関数 (汎用)

SQL Wrap関数

HTTP Wrap関数

Method Wrap関数

Wrap関数API要約

ログ収集

エージェント設定

TraceLogWriter (推奨)

既存API (互換性維持)

logパッケージ例

go.uber.org/zap例

sirupsen/logrus例

Webフレームワーク計測

Gin

Echo v4

Fiber v2

Chi v5

Gorilla Mux

FastHTTP

net/httpハンドラーラッピング

database/sql計測 (whatapsql)

OpenContext (トランザクションコンテキスト連携)

sqlx計測

GORM計測

gorm.io/gorm (GORM v2)

github.com/jinzhu/gorm (GORM v1)

Redis計測

go-redis v9

go-redis v8

Redigo

MongoDB計測

gRPC計測

サーバー側

クライアント側

Kafka計測 (Sarama)

Kubernetes client-go計測

Instrumentationパッケージ要約