package main

import (
   "context"
   "errors"
   "go.opentelemetry.io/otel"
   "go.opentelemetry.io/otel/attribute"
   "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
   "go.opentelemetry.io/otel/propagation"
   "go.opentelemetry.io/otel/sdk/resource"
   "go.opentelemetry.io/otel/sdk/trace"
   sdktrace "go.opentelemetry.io/otel/sdk/trace"
   "log"
)

func setupOTelSDK(ctx context.Context) (*trace.TracerProvider, error) {
   opts := []otlptracegrpc.Option{
      otlptracegrpc.WithEndpoint("<endpoint>"), // <endpoint>替换为上报地址
      otlptracegrpc.WithInsecure(),
   }
   exporter, err := otlptracegrpc.New(ctx, opts...)
   if err != nil {
      log.Fatal(err)
   }
   r, err := resource.New(ctx, []resource.Option{
      resource.WithAttributes(
         attribute.KeyValue{Key: "token", Value: "<token>"}, // <token>替换为业务系统Token
         attribute.KeyValue{Key: "service.name", Value: "<servceName>"}, // <serviceName>替换为应用名
         attribute.KeyValue{Key: "host.name", Value: "<hostName>"}, // <hostName>替换为IP地址
      ),
   }...)
   if err != nil {
      log.Fatal(err)
   }
   tp := sdktrace.NewTracerProvider(
      sdktrace.WithSampler(sdktrace.AlwaysSample()),
      sdktrace.WithBatcher(exporter),
      sdktrace.WithResource(r),
   )
   otel.SetTracerProvider(tp)
   otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
   return tp, nil
}

package main

import (
   "context"
   "errors"
   "fmt"
   "log"
   "net"
   "net/http"
   "os"
   "os/signal"
   "time"
   "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

func main() {
   if err := run(); err != nil {
      log.Fatalln(err)
   }
}

func run() (err error) {
   ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
   defer stop()

   // 初始化 SDK
   otelShutdown, err := setupOTelSDK(ctx)
   if err != nil {
      return
   }
   // 优雅关闭
   defer func() {
      err = errors.Join(err, otelShutdown(context.Background()))
   }()

   // 启动HTTP服务
   srv := &http.Server{
      Addr:         ":8080",
      BaseContext:  func(_ net.Listener) context.Context { return ctx },
      ReadTimeout:  time.Second,
      WriteTimeout: 10 * time.Second,
      Handler:      newHTTPHandler(),
   }
   srvErr := make(chan error, 1)
   go func() {
      srvErr <- srv.ListenAndServe()
   }()
 
   select {
   case err = <-srvErr:
     return
   case <-ctx.Done():
      stop()
   }

   err = srv.Shutdown(context.Background())
   return
}

func newHTTPHandler() http.Handler {
   mux := http.NewServeMux()

   handleFunc := func(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) {
      // 对HTTP路由进行埋点
      handler := otelhttp.WithRouteTag(pattern, http.HandlerFunc(handlerFunc))
      mux.Handle(pattern, handler)
   }

   // 注册接口
   handleFunc("/simple", simpleIOHandler)

   // 对所有接口进行埋点增强
   handler := otelhttp.NewHandler(mux, "/")
   return handler
}

func simpleIOHandler(w http.ResponseWriter, r *http.Request) {
   io.WriteString(w, "ok")
}

func entryFunc(w http.ResponseWriter, r *http.Request) {
    _, span := tracer.Start(r.Context(), "entryFunc", trace.WithSpanKind(trace.SpanKindServer)) // server span
    defer span.End()
	internalInvoke(r)
	io.WriteString(w, "ok")
}

func internalInvoke(r *http.Request) {
    // 创建一个 Internal Span
	_, span := tracer.Start(r.Context(), "internalInvoke", trace.WithSpanKind(trace.SpanKindInternal)) // internal span
	defer span.End()
 
    // 业务逻辑省略
}

func clientInvoke(ctx context.Context) {
    _, span := tracer.Start(ctx, "child", trace.WithSpanKind(trace.SpanKindClient))
    defer span.End()
    _, err := http.Get("https://www.example.com")
    if err != nil {
        fmt.Println("err occurred when call extrnal api: ", err)
        return
    }
}

func internalInvoke(ctx context.Context) {
    spanCtx := trace.SpanContextFromContext(ctx) // 获取当前 span 的上下文
    if spanCtx.HasTraceID() {
        traceID := spanCtx.TraceID()
        fmt.Println(traceID.String())
    }
    if spanCtx.HasSpanID() {
        spanID := spanCtx.SpanID()
        fmt.Println(spanID.String())
    }
    // 业务逻辑省略
}

func gormRequest(ctx context.Context) {
    span := trace.SpanFromContext(ctx) // 获取当前的 span 对象
    if span == nil {
        fmt.Println("no active span detected")
        return
    }
    span.SetAttributes(
        attribute.String("key1", "value1"),
        attribute.Int64("key2", 123),
    )

    var val string
    if err := gormclient.GormDB.WithContext(ctx).Model(&gormclient.TableDemo{}).Where("id = ?", 1).Pluck("value", &val).Error; err != nil {
                panic(err)
    }
    fmt.Println("MySQL query result: ", val)
}