tencent cloud

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")
}

import (
	"github.com/redis/go-redis/v9"
	"github.com/redis/go-redis/extra/redisotel/v9"
)

var rdb *redis.Client

// InitRedis initializing Redis client.
func InitRedis() *redis.Client {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",
		Password: "",  // no password
	})
	if err := redisotel.InstrumentTracing(rdb); err != nil {
		panic(err)
	}
	if err := redisotel.InstrumentMetrics(rdb); err != nil {
		panic(err)
	}
	return rdb
}

func redisRequest(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	rdb := InitRedis()
	val, err := rdb.Get(ctx, "foo").Result()
	if err != nil {
		log.Printf("redis err......")
		panic(err)
	}
	fmt.Println("redis res: ", val)
}

import (
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"gorm.io/plugin/opentelemetry/tracing"
)

var GormDB *gorm.DB

type TableDemo struct {
	ID    int    gorm:"column:id"
	Value string gorm:"column:value"
}

func InitGorm() {
	var err error

	dsn := "root:4T$er3deffYuD#9Q@tcp(127.0.0.1:3306)/db_demo?charset=utf8mb4&parseTime=True&loc=Local"
	GormDB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
		NamingStrategy: schema.NamingStrategy{
			SingularTable: true, // Use singular table names.
		},
	})
	if err != nil {
		panic(err)
	}
    // Add tracing reporting logic.
    //Fill in DBName based on actual conditions. In the APM topology diagram, identify the node using the DBName field. In this example, use mockdb-mysql.
	if err = GormDB.Use(tracing.NewPlugin(tracing.WithoutMetrics(),tracing.WithDBName("mockdb-mysql"))); err != nil {
		panic(err)
	}
}

func gormRequest(ctx context.Context) {
    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)
}

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

func internalInvoke(r *http.Request) {
    // Create an Internal Span.
	_, span := tracer.Start(r.Context(), "internalInvoke")
	defer span.End()
 
    // Business logic is omitted.
 
    // Set Span Attributes.
	span.SetAttributes(attribute.KeyValue{
		Key:   "label-key-1",
		Value: attribute.StringValue("label-value-1"),
	})
}