通过OpenTelemetry接入Golang Trace数据

接入流程

1. 初始化OpenTelemetry Provider。

2. 判断是否符合半自动接入条件。

   • 如果符合，则您可以使用半自动方式接入Trace数据。

     当半自动方式无法覆盖您的所有场景时，余下场景您需要使用手动方式接入Trace数据。

   • 如果不符合，则您可以使用手动方式接入Trace数据。

步骤1：初始化OpenTelemetry Provider

步骤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)
    
        // 如果您需要分析应用中的指标数据，可以注册相关的Metric指标。
        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 {
                // 如果您需要记录一些事件，可以获取Context中的Span并添加Event。
                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的自动注入方式，只需要使用otelhttp.NewHandler包裹http.Handler。
        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 版本创建，新版本中接口可能出现一定的改动，最新示例请参见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)
    
        // 如果您需要分析应用中的指标数据，可以注册相关的Metric指标。
        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"
        }
        // 如果您需要记录一些事件，可以获取Context中的Span并添加Event。
        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)
  }
  
  // example of getting the current span
  // 获取当前的Span。
  func getSpan(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      fmt.Printf("current span: %v\n", span)
  }
  
  // example of adding an attribute to a span
  // 向Span中添加属性值。
  func addAttribute(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      span.SetAttributes(attribute.KeyValue{
          Key:   "label-key-1",
          Value: attribute.StringValue("label-value-1")})
  }
  
  // example of adding an event to a span
  // 向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)))
  }
  
  // example of recording an exception
  // 记录Span结果以及错误信息。
  func recordException(ctx context.Context) {
      span := trace.SpanFromContext(ctx)
      span.RecordError(errors.New("exception has occurred"))
      span.SetStatus(codes.Error, "internal error")
  }
  
  // example of creating a child span
  // 创建子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)
  }