Go で OpenTelemetry トレーシングを導入して Cloud Trace に送る

go/
├── cmd/server/main.go              # エントリーポイント
├── config/config.go                # 設定管理
├── pkg/
│   ├── trace/
│   │   └── trace.go                # TracerProvider初期化 + ヘルパー
│   ├── logger/
│   │   └── logger.go               # トレースID付きログ出力
│   └── postgres/
│       └── postgres.go             # DB接続（otelpgx統合）
└── internal/
    ├── application/
    │   └── group_usecase.go        # ユースケース層のスパン
    └── presentation/api/
        └── middleware.go           # otelchiミドルウェア

// config/config.go
type Telemetry struct {
    ServiceName    string  `env:"OTEL_SERVICE_NAME" envDefault:"mahking-go"`
    ServiceVersion string  `env:"OTEL_SERVICE_VERSION" envDefault:"unknown"`
    Environment    string  `env:"OTEL_ENVIRONMENT" envDefault:"dev"`
    SampleRate     float64 `env:"OTEL_SAMPLE_RATE" envDefault:"1.0"`
}

package trace

import (
    "context"
    "fmt"

    texporter "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
    "go.opentelemetry.io/otel/trace"
)

type Config struct {
    ServiceName    string
    ServiceVersion string
    Environment    string
    SampleRate     float64
    ProjectID      string
    Debug          bool
}

func Init(ctx context.Context, cfg Config) (shutdown func(context.Context) error, err error) {
    // 1. Resource（サービス情報）の定義
    res, err := resource.Merge(
        resource.Default(),
        resource.NewSchemaless(
            semconv.ServiceName(cfg.ServiceName),
            semconv.ServiceVersion(cfg.ServiceVersion),
            semconv.DeploymentEnvironment(cfg.Environment),
        ),
    )
    if err != nil {
        return nil, fmt.Errorf("create resource: %w", err)
    }

    // 2. TracerProviderのオプション設定
    opts := []sdktrace.TracerProviderOption{
        sdktrace.WithResource(res),
        sdktrace.WithSampler(sdktrace.ParentBased(sdktrace.TraceIDRatioBased(cfg.SampleRate))),
    }

    // 3. 本番環境のみExporterを追加
    if !cfg.Debug {
        exporter, err := newExporter(cfg)
        if err != nil {
            return nil, fmt.Errorf("create exporter: %w", err)
        }
        opts = append(opts, sdktrace.WithBatcher(exporter))
    }

    // 4. TracerProviderの作成とグローバル登録
    tp := sdktrace.NewTracerProvider(opts...)

    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
        propagation.TraceContext{},
        propagation.Baggage{},
    ))

    return tp.Shutdown, nil
}

res, err := resource.Merge(
    resource.Default(),                // ホスト名やプロセスIDなどデフォルト情報
    resource.NewSchemaless(
        semconv.ServiceName(cfg.ServiceName),           // サービス名
        semconv.ServiceVersion(cfg.ServiceVersion),     // バージョン
        semconv.DeploymentEnvironment(cfg.Environment), // 環境
    ),
)

sdktrace.WithSampler(sdktrace.ParentBased(sdktrace.TraceIDRatioBased(cfg.SampleRate)))

if !cfg.Debug {
    exporter, err := newExporter(cfg)
    // ...
    opts = append(opts, sdktrace.WithBatcher(exporter))
}

func newExporter(cfg Config) (sdktrace.SpanExporter, error) {
    return texporter.New(texporter.WithProjectID(cfg.ProjectID))
}

otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
    propagation.TraceContext{},
    propagation.Baggage{},
))

func main() {
    ctx := context.Background()
    cnf := config.Get()
    logger.Init(cnf.GCP.ProjectID, cnf.Server.Debug)

    traceShutdown, err := pkgtrace.Init(ctx, pkgtrace.Config{
        ServiceName:    cnf.Telemetry.ServiceName,
        ServiceVersion: cnf.Telemetry.ServiceVersion,
        Environment:    cnf.Telemetry.Environment,
        SampleRate:     cnf.Telemetry.SampleRate,
        ProjectID:      cnf.GCP.ProjectID,
        Debug:          cnf.Server.Debug,
    })
    if err != nil {
        logger.FatalContext(ctx, fmt.Sprintf("trace init failed: %v", err))
    }
    defer func() {
        if err := traceShutdown(ctx); err != nil {
            logger.ErrorContext(ctx, fmt.Sprintf("trace shutdown failed: %v", err))
        }
    }()

    // ... サーバー起動
}

func StartSpan(ctx context.Context, name string, attrs ...attribute.KeyValue) context.Context {
    tr := otel.GetTracerProvider().Tracer(name)
    ctx, span := tr.Start(ctx, name)
    if len(attrs) > 0 {
        span.SetAttributes(attrs...)
    }
    return ctx
}

func EndSpan(ctx context.Context, err error) {
    span := trace.SpanFromContext(ctx)
    if err != nil {
        span.RecordError(err)
        span.SetStatus(codes.Error, err.Error())
    }
    span.End()
}

func (u *GroupUsecase) List(ctx context.Context) (res []appout.Group, err error) {
    ctx = pkgtrace.StartSpan(ctx, "GroupUsecase.List")
    defer func() { pkgtrace.EndSpan(ctx, err) }()

    groups, err := u.groupRepo.List(ctx)
    if err != nil {
        return nil, err
    }
    // ...
}

func (u *GroupUsecase) Create(ctx context.Context, in appin.CreateGroupWithRule) (res *appout.Group, err error) {
    ctx = pkgtrace.StartSpan(ctx, "GroupUsecase.Create")
    defer func() { pkgtrace.EndSpan(ctx, err) }()

    // ...
}

func registerMiddlewares(c chi.Router) {
    c.Use(middleware.Recoverer)
    c.Use(otelchi.Middleware("mahking-go", otelchi.WithChiRoutes(c)))

    c.Use(cors.Handler(cors.Options{
        // ...
    }))
}

func Connect(cnf DB) (*pgxpool.Pool, error) {
    cfg, err := pgxpool.ParseConfig(DSN(cnf))
    if err != nil {
        return nil, err
    }

    // ...

    cfg.ConnConfig.Tracer = otelpgx.NewTracer()
    cfg.PrepareConn = prepareSession
    cfg.AfterRelease = resetGroupSetting

    return pgxpool.NewWithConfig(context.Background(), cfg)
}

func prepareSession(ctx context.Context, conn *pgx.Conn) (bool, error) {
    // set_configはコネクション初期化用なのでトレース対象外にする
    noTraceCtx := trace.ContextWithSpan(ctx, trace.SpanFromContext(context.Background()))
    session := sessionFromContext(ctx)
    switch session.kind {
    case sessionKindGroup:
        if err := setGroupConfig(noTraceCtx, conn, session.groupID); err != nil {
            return false, err
        }
    default:
        if err := clearGroupConfig(noTraceCtx, conn); err != nil {
            return false, err
        }
    }
    return true, nil
}

HTTP Request: GET /groups
└── otelchi: GET /groups                    ← 自動（ミドルウェア）
    └── GroupUsecase.List                   ← 手動（StartSpan/EndSpan）
        └── pgx: SELECT * FROM groups      ← 自動（otelpgx）

// pkg/logger/logger.go
func traceAttrs(ctx context.Context) []slog.Attr {
    sc := trace.SpanFromContext(ctx).SpanContext()
    if !sc.IsValid() {
        return nil
    }

    return []slog.Attr{
        slog.String("logging.googleapis.com/trace",
            fmt.Sprintf("projects/%s/traces/%s", projectID, sc.TraceID().String())),
        slog.String("logging.googleapis.com/spanId", sc.SpanID().String()),
        slog.Bool("logging.googleapis.com/trace_sampled", sc.IsSampled()),
    }
}