通过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)
  }