:OpenTelemetry を使用した Golang トレースデータの取り込み

取り込みフロー

1. OpenTelemetry プロバイダーを初期化します。

2. 半自動取り込みの条件が満たされているかどうかを判断します。

   • 条件が満たされている場合は、半自動メソッドを使用してトレースデータを取り込みます。

     半自動メソッドでカバーされていないシナリオでは、手動メソッドを使用します。

   • 条件が満たされていない場合は、手動メソッドを使用してトレースデータを取り込みます。

ステップ 1： OpenTelemetry プロバイダーの初期化

ステップ 2： データの取り込み

• (推奨) 半自動取り込み

  OpenTelemetry は、多くの一般的なライブラリに対して自動イベントトラッキングを提供します。アプリケーションがこれらのライブラリを使用している場合、対応する自動イベントトラッキングソリューションを使用してデータを取り込むことができます。サポートされているライブラリのリストについては、「Golang 自動イベントトラッキングソリューション」をご参照ください。

  • net/http の取り込み

    次の例は、go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.37.0 に基づいています。詳細については、「otel-http-example」をご参照ください。

    次のコードの変数を要件に合わせて置き換えてください。変数の説明については、「変数の説明」をご参照ください。

    package main
    
    import (
        "fmt"
        "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
        "go.opentelemetry.io/otel/attribute"
        "go.opentelemetry.io/otel/metric/global"
        "io"
        "net/http"
        "time"
    
        "github.com/aliyun-sls/opentelemetry-go-provider-sls/provider"
    
        "go.opentelemetry.io/otel/trace"
    )
    
    func main() {
    
        slsConfig, err := provider.NewConfig(provider.WithServiceName("${service}"),
            provider.WithServiceNamespace("${service.namespace}"),
            provider.WithServiceVersion("${version}"),
            provider.WithTraceExporterEndpoint("${endpoint}"),
            provider.WithMetricExporterEndpoint("${endpoint}"),
            provider.WithSLSConfig("${project}", "${instance}", "${access-key-id}", "${access-key-secret}"))
        // 初期化に失敗した場合、panic() を使用してプログラムを終了します。他のエラー処理メソッドも使用できます。
        if err != nil {
            panic(err)
        }
        if err := provider.Start(slsConfig); err != nil {
            panic(err)
        }
        defer provider.Shutdown(slsConfig)
    
        // アプリケーションのメトリックデータを分析するには、関連するメトリックを登録します。
        labels := []attribute.KeyValue{
            attribute.String("label1", "value1"),
        }
        meter := global.Meter("aliyun.sls")
        sayDavidCount, _ := meter.Int64Counter("say_david_count")
    
        helloHandler := func(w http.ResponseWriter, req *http.Request) {
            if time.Now().Unix()%10 == 0 {
                _, _ = io.WriteString(w, "Hello, world!\n")
            } else {
                // イベントを記録するには、コンテキストからスパンを取得し、イベントを追加します。
                ctx := req.Context()
                span := trace.SpanFromContext(ctx)
                span.AddEvent("say : Hello, I am david", trace.WithAttributes(attribute.KeyValue{
                    Key:   "label-key-1",
                    Value: attribute.StringValue("label-value-1"),
                }))
    
                _, _ = io.WriteString(w, "Hello, I am david!\n")
                sayDavidCount.Add(req.Context(), 1, labels...)
            }
        }
    
        // otel net/http の自動インジェクションを使用するには、http.Handler を otelhttp.NewHandler でラップするだけです。
        otelHandler := otelhttp.NewHandler(http.HandlerFunc(helloHandler), "Hello")
    
        http.Handle("/hello", otelHandler)
        fmt.Println("Now listen port 8080, you can visit 127.0.0.1:8080/hello .")
        err = http.ListenAndServe(":8080", nil)
        if err != nil {
            panic(err)
        }
    }
                                

  • mux の取り込み

    次の例は、go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.37.0 に基づいています。API は後のバージョンで変更される可能性があります。最新の例については、「otel-mux-example」をご参照ください。

    次のコードの変数を要件に合わせて置き換えてください。変数の説明については、「変数の説明」をご参照ください。

    package main
    
    import (
        "context"
        "fmt"
        "go.opentelemetry.io/otel/attribute"
        "go.opentelemetry.io/otel/metric/global"
        "net/http"
    
        "github.com/aliyun-sls/opentelemetry-go-provider-sls/provider"
    
        "github.com/gorilla/mux"
        "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
        "go.opentelemetry.io/otel/trace"
    )
    
    func main() {
    
        slsConfig, err := provider.NewConfig(provider.WithServiceName("${service}"),
            provider.WithServiceNamespace("${service.namespace}"),
            provider.WithServiceVersion("${version}"),
            provider.WithTraceExporterEndpoint("${endpoint}"),
            provider.WithMetricExporterEndpoint("${endpoint}"),
            provider.WithSLSConfig("${project}", "${instance}", "${access-key-id}", "${access-key-secret}"))
        // 初期化に失敗した場合、panic() を使用してプログラムを終了します。他のエラー処理メソッドも使用できます。
        if err != nil {
            panic(err)
        }
        if err := provider.Start(slsConfig); err != nil {
            panic(err)
        }
        defer provider.Shutdown(slsConfig)
    
        // アプリケーションのメトリックデータを分析するには、関連するメトリックを登録します。
        labels := []attribute.KeyValue{
            attribute.String("label1", "value1"),
        }
        meter := global.Meter("aliyun.sls")
        callUsersCount, _ := meter.Int64Counter("call_users_count")
    
        r := mux.NewRouter()
        r.Use(otelmux.Middleware("my-server"))
        r.HandleFunc("/users/{id:[0-9]+}", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            vars := mux.Vars(r)
            id := vars["id"]
            callUsersCount.Add(r.Context(), 1, labels...)
            name := getUser(r.Context(), id)
            reply := fmt.Sprintf("user %s (id %s)\n", name, id)
            _, _ = w.Write(([]byte)(reply))
        }))
        http.Handle("/", r)
        fmt.Println("Now listen port 8080, you can visit 127.0.0.1:8080/users/xxx .")
        _ = http.ListenAndServe(":8080", nil)
    }
    
    func getUser(ctx context.Context, id string) string {
        if id == "123" {
            return "otelmux tester"
        }
        // イベントを記録するには、コンテキストからスパンを取得し、イベントを追加します。
        span := trace.SpanFromContext(ctx)
        span.AddEvent("unknown user id : "+id, trace.WithAttributes(attribute.KeyValue{
            Key:   "label-key-1",
            Value: attribute.StringValue("label-value-1"),
        }))
        return "unknown"
    }
                                

• 手動取り込み

  次のコードの変数を要件に合わせて置き換えてください。変数の説明については、「変数の説明」をご参照ください。

  // Copyright The AliyunSLS Authors
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //     http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  package main
  
  import (
      "context"
      "errors"
      "fmt"
      "go.opentelemetry.io/otel/attribute"
      "go.opentelemetry.io/otel/metric/global"
      "go.opentelemetry.io/otel/metric/instrument"
      "math/rand"
      "time"
  
      "github.com/aliyun-sls/opentelemetry-go-provider-sls/provider"
  
      "go.opentelemetry.io/otel"
      "go.opentelemetry.io/otel/codes"
      "go.opentelemetry.io/otel/trace"
  )
  
  func main() {
      slsConfig, err := provider.NewConfig(provider.WithServiceName("payment"),
          provider.WithServiceVersion("v0.1.0"),
          provider.WithTraceExporterEndpoint("stdout"),
          provider.WithMetricExporterEndpoint("stdout"),
          provider.WithSLSConfig("test-project", "test-otel", "access-key-id", "access-key-secret"))
      // 初期化に失敗した場合、panic() を使用してプログラムを終了します。他のエラー処理メソッドも使用できます。
      if err != nil {
          panic(err)
      }
      if err := provider.Start(slsConfig); err != nil {
          panic(err)
      }
      defer provider.Shutdown(slsConfig)
  
      mockTrace()
      mockMetrics()
  }
  
  func mockMetrics() {
      // タグ情報を追加します。
      labels := []attribute.KeyValue{
          attribute.String("label1", "value1"),
      }
  
      meter := global.Meter("ex.com/basic")
  
      meter.Float64ObservableCounter("randval", instrument.WithFloat64Callback(func(ctx context.Context, observer instrument.Float64Observer) error {
          observer.Observe(rand.Float64(), labels...)
          return nil
      }))
  
      temperature, _ := meter.Float64Counter("temperature")
      interrupts, _ := meter.Int64Counter("interrupts")
  
      ctx := context.Background()
  
      for {
          temperature.Add(ctx, 100+10*rand.NormFloat64(), labels...)
          interrupts.Add(ctx, int64(rand.Intn(100)), labels...)
  
          time.Sleep(time.Second * time.Duration(rand.Intn(10)))
      }
  }
  
  func mockTrace() {
  
      tracer := otel.Tracer("ex.com/basic")
  
      ctx0 := context.Background()
  
      ctx1, finish1 := tracer.Start(ctx0, "foo")
      defer finish1.End()
  
      ctx2, finish2 := tracer.Start(ctx1, "bar")
      defer finish2.End()
  
      ctx3, finish3 := tracer.Start(ctx2, "baz")
      defer finish3.End()
  
      ctx := ctx3
      getSpan(ctx)
      addAttribute(ctx)
      addEvent(ctx)
      recordException(ctx)
      createChild(ctx, tracer)
  }
  
  // getting the current span の例
  // 現在のスパンを取得します。
  func getSpan(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      fmt.Printf("current span: %v\n", span)
  }
  
  // adding an attribute to a span の例
  // スパンに属性を追加します。
  func addAttribute(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      span.SetAttributes(attribute.KeyValue{
          Key:   "label-key-1",
          Value: attribute.StringValue("label-value-1")})
  }
  
  // adding an event to a span の例
  // スパンにイベントを追加します。
  func addEvent(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      span.AddEvent("event1", trace.WithAttributes(
          attribute.String("event-attr1", "event-string1"),
          attribute.Int64("event-attr2", 10)))
  }
  
  // recording an exception の例
  // スパンの結果とエラーメッセージを記録します。
  func recordException(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      span.RecordError(errors.New("exception has occurred"))
      span.SetStatus(codes.Error, "internal error")
  }
  
  // creating a child span の例
  // 子スパンを作成します。
  func createChild(ctx context.Context, tracer trace.Tracer) {
      // span := trace.SpanFromContext(ctx)
      _, childSpan := tracer.Start(ctx, "child")
      defer childSpan.End()
      fmt.Printf("child span: %v\n", childSpan)
  }