Gopher

Chanwit Piromplad TonPC64

Gopher

Hello 👋 , I am 👨‍💻 from 🇹🇭

TonPC64 / handler-with-producer.go

Created February 24, 2022 14:54

	func handler(c *gin.Context) {
	tracer := otel.GetTracerProvider().Tracer("gin-hander")
	ctx, span := tracer.Start(c.Request.Context(), "handler-span")
	defer span.End()

	fmt.Println(c.Request.Header)

	rand.Seed(time.Now().Unix())
	msg := sarama.ProducerMessage{
	Topic: "example-topic",

TonPC64 / init-producer.go

Created February 24, 2022 14:52

	func init() {
	config := sarama.NewConfig()
	config.Version = sarama.V2_5_0_0
	// So we can know the partition and offset of messages.
	config.Producer.Return.Successes = true

	var err error
	producer, err = sarama.NewAsyncProducer([]string{"kafka:9092"}, config)
	if err != nil {
	log.Fatal().Err(err).Msg("Failed to start Sarama producer")

TonPC64 / consumer-handler.go

Created February 24, 2022 14:51

	func printMessage(msg *sarama.ConsumerMessage) {
	// Extract tracing info from message
	ctx := otel.GetTextMapPropagator().Extract(context.Background(), otelsarama.NewConsumerMessageCarrier(msg))

	tr := otel.GetTracerProvider().Tracer("consumer")
	_, span := tr.Start(ctx, "consume message", trace.WithAttributes(
	semconv.MessagingOperationProcess,
	))
	defer span.End()

TonPC64 / consumer-main.go

Created February 24, 2022 14:50

	func main() {
	startConsumerGroup([]string{"kafka:9092"})

	select {}
	}

	func startConsumerGroup(brokerList []string) {
	consumerGroupHandler := Consumer{}
	// Wrap instrumentation
	handler := otelsarama.WrapConsumerGroupHandler(&consumerGroupHandler)

TonPC64 / grpc-client.go

Created February 24, 2022 14:49

	func callSayHello(ctx context.Context, c api.HelloServiceClient) {
	md := metadata.Pairs(
	"timestamp", time.Now().Format(time.StampNano),
	)

	ctx = metadata.NewOutgoingContext(ctx, md)
	response, err := c.SayHello(ctx, &api.HelloRequest{Greeting: "World"})
	if err != nil {
	log.Fatalf("Error when calling SayHello: %s", err)
	}

TonPC64 / echo-with-grpc-client.go

Created February 24, 2022 14:48

	var grpcClient api.HelloServiceClient

	func main() {
	var conn *grpc.ClientConn
	conn, err := grpc.Dial("host.docker.internal:6565", grpc.WithTransportCredentials(insecure.NewCredentials()),
	grpc.WithUnaryInterceptor(otelgrpc.UnaryClientInterceptor()),
	grpc.WithStreamInterceptor(otelgrpc.StreamClientInterceptor()),
	)

	if err != nil {

TonPC64 / grpc-function-sayhello.go

Created February 24, 2022 14:46

	func (s server) SayHello(ctx context.Context, in api.HelloRequest) (*api.HelloResponse, error) {
	tracer := otel.GetTracerProvider().Tracer("webserver-grpc")
	_, span := tracer.Start(ctx, "SayHello-span")
	defer span.End()

	fmt.Println(ctx)
	log.Printf("Received: %v\n", in.GetGreeting())
	time.Sleep(50 * time.Millisecond)

	return &api.HelloResponse{Reply: "Hello " + in.Greeting}, nil

TonPC64 / grpc-server.go

Created February 24, 2022 14:43

	type server struct {
	api.HelloServiceServer
	}

	func (s server) SayHello(ctx context.Context, in api.HelloRequest) (*api.HelloResponse, error) {
	tracer := otel.GetTracerProvider().Tracer("webserver-grpc")
	_, span := tracer.Start(ctx, "SayHello-span")
	defer span.End()

	fmt.Println(ctx)

TonPC64 / hello.proto

Created February 24, 2022 14:42

	syntax = "proto3";
	package api;

	option go_package = "../api";

	service HelloService {
	rpc SayHello (HelloRequest) returns (HelloResponse);
	}

	message HelloRequest {

TonPC64 / http-client.go

Last active February 24, 2022 14:41

	// create http client with transport for inject trace signal to http header automatically
	client := &http.Client{
	Transport: otelhttp.NewTransport(nil),
	}
	// create http request with context for inject trace signal to http header in request
	request, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://echo:8081", nil)
	if err != nil {
	// if error should set status to span
	span.RecordError(err)
	span.SetStatus(codes.Error, codes.Error.String())