How do I distribute tracing between 2 Go microservices using Opentelemetry & Otelgin ?

[chachachoco]

Please help, I've come across Otelhttp examples, but I couldn't find examples with Otelgin.

Microservice 1

import (
	"encoding/json"
	"log"

	"github.com/gin-gonic/gin"
	"github.com/go-resty/resty/v2"
	"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/sdk/resource"
	tracesdk "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
	"go.opentelemetry.io/otel/trace"
)

type Result struct {
	Message string
}

func TracerProvider() (*tracesdk.TracerProvider, error) {
	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
	exporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
	if err != nil {
		log.Fatal(err)
	}

	tp := tracesdk.NewTracerProvider(
		tracesdk.WithSampler(tracesdk.AlwaysSample()),
		tracesdk.WithBatcher(exporter),
		tracesdk.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceNameKey.String("microservice-1"),
			semconv.ServiceVersionKey.String("0.0.1"),
			attribute.String("environment", "test"),
		)),
	)

	otel.SetTracerProvider(tp)
	return tp, nil
}

func main() {
        _, err := TracerProvider()
	        if err != nil {
		        log.Fatal(err)
	        }	
        resty := resty.New()

	router := gin.Default()
	router.Use(otelgin.Middleware("microservice-1"))
	{
		
		router.GET("/ping", func(c *gin.Context) {
                    result := Result{}
		    req := resty.R().SetHeader("Content-Type", "application/json")
		    ctx := req.Context()
		    span := trace.SpanFromContext(ctx)

		   defer span.End()

		  otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))
		  resp, _ := req.Get("http://localhost:8088/pong")

		json.Unmarshal([]byte(resp.String()), &result)
			c.IndentedJSON(200, gin.H{
				"message": result.Message,
			})
		})
	}
	router.Run(":8085")

}

Microservice 2
TracerProvider func is the same as Microservice 1

func main() {
          _, err := TracerProvider()
	          if err != nil {
		          log.Fatal(err)
	          }
	router := gin.Default()
	router.Use(otelgin.Middleware("microservice-2"))
	{
		router.GET("/pong", func(c *gin.Context) {
			ctx := c.Request.Context()
			span := trace.SpanFromContext(otel.GetTextMapPropagator().Extract(ctx, propagation.HeaderCarrier(c.Request.Header)))
			defer span.End()

			c.IndentedJSON(200, gin.H{
				"message": "pong",
			})
		})
	}
	router.Run(":8088")

}

[chachachoco]

After I changed my inject context to c.Request.Context(), it works. I was injecting the wrong context. I was injecting Resty context instead of Gin context.