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>"), // Replace <endpoint> with the reporting address
      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>"}, // Replace <token> with the business system Token
         attribute.KeyValue{Key: "service.name", Value: "<servceName>"}, // Replace <serviceName> with the application name
         attribute.KeyValue{Key: "host.name", Value: "<hostName>"}, // Replace <hostName> with the IP address
      ),
   }...)
   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()

   // Initialize SDK
   otelShutdown, err := setupOTelSDK(ctx)
   if err != nil {
      return
   }
   // Graceful shutdown
   defer func() {
      err = errors.Join(err, otelShutdown(context.Background()))
   }()

   // Start HTTP service
   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 routes Event Tracking
      handler := otelhttp.WithRouteTag(pattern, http.HandlerFunc(handlerFunc))
      mux.Handle(pattern, handler)
   }

   // Register APIs
   handleFunc("/simple", simpleIOHandler)

   // Enhanced Event Tracking for all APIs
   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) {
    create Internal Span
	_, span := tracer.Start(r.Context(), "internalInvoke", trace.WithSpanKind(trace.SpanKindInternal)) // internal span
	defer span.End()
 
    // business logic omitted
}

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) // Retrieve current span context
    if spanCtx.HasTraceID() {
        traceID := spanCtx.TraceID()
        fmt.Println(traceID.String())
    }
    if spanCtx.HasSpanID() {
        spanID := spanCtx.SpanID()
        fmt.Println(spanID.String())
    }
    // business logic omitted
}

func gormRequest(ctx context.Context) {
    span := trace.SpanFromContext(ctx) // Retrieve current span object
    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)
}