Google Cloud Observability in Go / GREE BizCenにおける実装事例

    // exporterの作成
    exporter, err = otlptracegrpc.New(ctxTimeout, otlptracegrpc.WithGRPCConn(conn))
 
    // TracerProviderの作成
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithSampler(sdktrace.TraceIDRatioBased(cfg.TraceSamplingRatio)),
		sdktrace.WithResource(res),
		sdktrace.WithBatcher(exporter),
	)
 
    // グローバルTracerProviderとして設定
    otel.SetTracerProvider(tp)
 
    // Propagatorの設定
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
		gcppropagator.CloudTraceOneWayPropagator{},
		propagation.TraceContext{},
		propagation.Baggage{},
	))

	ctx, span := tracer.Start(ctx, spanName,
		trace.WithSpanKind(trace.SpanKindServer),
		trace.WithAttributes(attribute.String("component", "controller")),
	)
	defer span.End()
	span.SetAttributes(attribute.String("method", "GET"))
	span.SetAttributes(attribute.String("path", "/api/v1/users"))
    span.SetAttributes(attribute.String("status", 200))
 

	ctx, span := tracer.Start(ctx, spanName,
		trace.WithSpanKind(trace.SpanKindInternal),
		trace.WithAttributes(attribute.String("component", "usecase")),
	)
	defer span.End()
	span.SetAttributes(attribute.String("id", id))
	span.SetAttributes(attribute.String("unit_price", unit_price))
	span.SetAttributes(attribute.String("amount", amount))

	ctx, span := tracer.Start(ctx, spanName,
		trace.WithSpanKind(trace.SpanKindClient),
		trace.WithAttributes(attribute.String("component", "repository")),
	)
	defer span.End()
	span.SetAttributes(attribute.String("db.statement", stmt.SQL))

	if err != nil {
		span.RecordError(err)
	}

	opts := &slog.HandlerOptions{
		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
			// Cloud Logging形式への変換
			return cloudLoggingReplaceAttr(groups, a)
		},
	}
 
	// Cloud Logging用ハンドラーの作成
	handler := NewCloudLoggingHandler(opts, config.ProjectID)
	logger := slog.New(handler)
 

// Cloud Logging形式に属性キーを変換する関数
func cloudLoggingReplaceAttr(groups []string, a slog.Attr) slog.Attr {
    switch a.Key {
    case "msg", "message":
        a.Key = "message"
    case "level":
        // levelの値をCloud Loggingのseverityに変換
        if level, ok := a.Value.Any().(slog.Level); ok {
            var severity string
            switch {
            case level < slog.LevelInfo:
                severity = "DEBUG"
            case level < slog.LevelWarn:
                severity = "INFO"
            case level < slog.LevelError:
                severity = "WARNING"
            default:
                severity = "ERROR"
            }
            a.Key = "severity"
            a.Value = slog.StringValue(severity)
        }
    case "time":
        if t, ok := a.Value.Any().(time.Time); ok {
            a.Key = "timestamp"
            a.Value = slog.StringValue(t.Format(time.RFC3339Nano))
        }
    case "source":
        // ソースコード情報をCloud Logging形式に変換
        if source, ok := a.Value.Any().(string); ok {
            parts := strings.Split(source, ":")
            sourceLocation := make(map[string]string)
            if len(parts) >= 1 {
                sourceLocation["file"] = parts[0]
            }
            if len(parts) >= 2 {
                sourceLocation["line"] = parts[1]
            }
            if len(parts) >= 3 {
                sourceLocation["function"] = parts[2]
            }
 
            a.Key = "logging.googleapis.com/sourceLocation"
            a.Value = slog.AnyValue(sourceLocation)
        }
    }
    return a
}

// Handle implements slog.Handler
func (h *cloudLoggingHandler) Handle(ctx context.Context, record slog.Record) error {
    // OpenTelemetryからトレース情報を取得
    span := trace.SpanFromContext(ctx)
    if span.SpanContext().IsValid() {
        traceID := span.SpanContext().TraceID().String()
        spanID := span.SpanContext().SpanID().String()
 
        // ProjectIDが設定されていて、トレースIDが有効な場合
        if h.projectID != "" && traceID != "" {
            // Cloud Logging形式のトレース値を構築
            gcpTrace := fmt.Sprintf("projects/%s/traces/%s", h.projectID, traceID)
            record.AddAttrs(slog.String("logging.googleapis.com/trace", gcpTrace))
        }
 
        // SpanIDをログに追加
        if spanID != "" {
            record.AddAttrs(slog.String("logging.googleapis.com/spanId", spanID))
        }
    }
 
    return h.handler.Handle(ctx, record)
}

slog.InfoContext(ctx, "User operation completed",
    "userID", "12345",
    "operation", "purchase",
    "amount", 10000)

func InitMeter(ctx context.Context, cfg Config) (*MeterProvider, error) {
    ...
	exporter, err = otlpmetricgrpc.New(ctxTimeout, otlpmetricgrpc.WithGRPCConn(conn))
 
	// Create meter provider with the exporter
	mp := metric.NewMeterProvider(
		metric.WithResource(res),
		metric.WithReader(
			metric.NewPeriodicReader(
				exporter,
				metric.WithInterval(30*time.Second), // Report metrics every 30 seconds
			),
		),
	)
 
	// Set the global meter provider
	otel.SetMeterProvider(mp)
}