tencent cloud

import (
 "context"
 "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"
 sdktrace "go.opentelemetry.io/otel/sdk/trace"
 "log"
 _ "os"
)
// Init configures an OpenTelemetry exporter and trace provider
func Init(ctx context.Context) *sdktrace.TracerProvider {
 //New otlp exporter
 opts := []otlptracegrpc.Option{
     // Configure the reporting address. If it has been configured in `config.yaml`, it can be ignored here.
     otlptracegrpc.WithEndpoint("{endpoint information}"), otlptracegrpc.WithInsecure(),
 }
 exporter, err := otlptracegrpc.New(ctx,opts...)
 if err != nil {
     log.Fatal(err)
 }
 // Set the reporting token in the resource, or directly configure the environment variable to set the token: OTEL_RESOURCE_ATTRIBUTES=token=xxxxxxxxx. If it has been configured in `config.yaml`, it can be ignored here.
 r,err := resource.New(ctx,[]resource.Option{
     resource.WithAttributes(attribute.KeyValue{Key: "token",Value: attribute.StringValue("{reporting token}"),}),
 }...)

 if err != nil{
     log.Fatal(err)
 }
 // Create a TracerProvider
 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
}

func main() {

 tp := trace.Init() // Perform initialization. The `Init` method is the aforementioned constructor.
 defer func() {
     if err := tp.Shutdown(context.Background()); err != nil {
         log.Printf("Error shutting down tracer provider: %v", err)
     }
 }()

 host := os.Getenv("grpc1")

 lis, err := net.Listen("tcp", host+":7778")
 if err != nil {
     log.Fatalf("failed to listen: %v", err)
 }

 s := grpc.NewServer(
     grpc.UnaryInterceptor(otelgrpc.UnaryServerInterceptor()),     // Set the interceptor for instrumentation
     grpc.StreamInterceptor(otelgrpc.StreamServerInterceptor()),
 )

 api.RegisterHelloServiceServer(s, &server{})   // Register the service. You can modify the specific service code as needed.
 reflection.Register(s)
 if err := s.Serve(lis); err != nil {
     log.Fatalf("failed to serve: %v", err)
 }
}

func main() {
 tp := trace.Init()    // Initialization
 fmt.Println("tp create success")
 defer func() {
     if err := tp.Shutdown(context.Background()); err != nil {
         log.Printf("Error shutting down tracer provider: %v", err)
     }
 }()
 fmt.Println("aaa")
 conn, err := grpc.DialContext(context.Background(), "localhost:7778", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock()) // Connection establishment
 fmt.Println("pro")
 if err != nil {
     log.Fatalf("did not connect: %v", err)
 }
 defer conn.Close()
 fmt.Println("conn")

 c := api.NewHelloServiceClient(conn)  // Client code

 for {
     callSayHelloClientStream(c)
     time.Sleep(100 * time.Millisecond)
 }