:sparkles: creating request id middleware and passing context to functions and removed otel

cmd/app/main.go

···
 
 import (
 	"context"
-	"errors"
 	"os"
 	"os/signal"
 
-	"github.com/Tulkdan/payment-gateway/internal/lib"
 	"github.com/Tulkdan/payment-gateway/internal/providers"
 	"github.com/Tulkdan/payment-gateway/internal/service"
 	"github.com/Tulkdan/payment-gateway/internal/web"
···
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
 	defer stop()
 
-	otelShutdown, err := lib.SetupOTelSDK(ctx)
-	if err != nil {
-		return
-	}
-
-	defer func() {
-		err = errors.Join(err, otelShutdown(context.Background()))
-	}()
-
 	providers := providers.NewUseProviders([]providers.Provider{
 		providers.NewBraintreeProvider(getEnv("BRAINTREE_URL", "localhost:8001")),
 		providers.NewStripeProvider(getEnv("STRIPE_URL", "localhost:8002")),
···
 	}()
 
 	select {
-	case err = <-srvErr:
+	case <-srvErr:
 		return
 	case <-ctx.Done():
 		stop()
 	}
 
-	err = server.Shutdown()
+	server.Shutdown()
 }

go.mod

···
 go 1.24.4
 
 require github.com/google/uuid v1.6.0
-
-require (
-	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/go-logr/logr v1.4.3 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/contrib/bridges/otelslog v0.12.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.13.0 // indirect
-	go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.37.0 // indirect
-	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0 // indirect
-	go.opentelemetry.io/otel/log v0.13.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk/log v0.13.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-)

go.sum

···
-github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
-github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
-github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
-github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/contrib/bridges/otelslog v0.12.0 h1:lFM7SZo8Ce01RzRfnUFQZEYeWRf/MtOA3A5MobOqk2g=
-go.opentelemetry.io/contrib/bridges/otelslog v0.12.0/go.mod h1:Dw05mhFtrKAYu72Tkb3YBYeQpRUJ4quDgo2DQw3No5A=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 h1:Hf9xI/XLML9ElpiHVDNwvqI0hIFlzV8dgIr35kV1kRU=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0/go.mod h1:NfchwuyNoMcZ5MLHwPrODwUF1HWCXWrL31s8gSAdIKY=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.13.0 h1:yEX3aC9KDgvYPhuKECHbOlr5GLwH6KTjLJ1sBSkkxkc=
-go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.13.0/go.mod h1:/GXR0tBmmkxDaCUGahvksvp66mx4yh5+cFXgSlhg0vQ=
-go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.37.0 h1:6VjV6Et+1Hd2iLZEPtdV7vie80Yyqf7oikJLjQ/myi0=
-go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.37.0/go.mod h1:u8hcp8ji5gaM/RfcOo8z9NMnf1pVLfVY7lBY2VOGuUU=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0 h1:SNhVp/9q4Go/XHBkQ1/d5u9P/U+L1yaGPoi0x+mStaI=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0/go.mod h1:tx8OOlGH6R4kLV67YaYO44GFXloEjGPZuMjEkaaqIp4=
-go.opentelemetry.io/otel/log v0.13.0 h1:yoxRoIZcohB6Xf0lNv9QIyCzQvrtGZklVbdCoyb7dls=
-go.opentelemetry.io/otel/log v0.13.0/go.mod h1:INKfG4k1O9CL25BaM1qLe0zIedOpvlS5Z7XgSbmN83E=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/sdk/log v0.13.0 h1:I3CGUszjM926OphK8ZdzF+kLqFvfRY/IIoFq/TjwfaQ=
-go.opentelemetry.io/otel/sdk/log v0.13.0/go.mod h1:lOrQyCCXmpZdN7NchXb6DOZZa1N5G1R2tm5GMMTpDBw=
-go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
-go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

internal/lib/openTelemetry.go

···
-package lib
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/exporters/stdout/stdoutlog"
-	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
-	"go.opentelemetry.io/otel/log/global"
-	"go.opentelemetry.io/otel/propagation"
-	"go.opentelemetry.io/otel/sdk/log"
-	"go.opentelemetry.io/otel/sdk/trace"
-)
-
-// setupOTelSDK bootstraps the OpenTelemetry pipeline.
-// If it does not return an error, make sure to call shutdown for proper cleanup.
-func SetupOTelSDK(ctx context.Context) (shutdown func(context.Context) error, err error) {
-	var shutdownFuncs []func(context.Context) error
-
-	// shutdown calls cleanup functions registered via shutdownFuncs.
-	// The errors from the calls are joined.
-	// Each registered cleanup will be invoked once.
-	shutdown = func(ctx context.Context) error {
-		var err error
-		for _, fn := range shutdownFuncs {
-			err = errors.Join(err, fn(ctx))
-		}
-		shutdownFuncs = nil
-		return err
-	}
-
-	// handleErr calls shutdown for cleanup and makes sure that all errors are returned.
-	handleErr := func(inErr error) {
-		err = errors.Join(inErr, shutdown(ctx))
-	}
-
-	// Set up propagator.
-	prop := newPropagator()
-	otel.SetTextMapPropagator(prop)
-
-	// Set up trace provider.
-	tracerProvider, err := newTracerProvider()
-	if err != nil {
-		handleErr(err)
-		return
-	}
-	shutdownFuncs = append(shutdownFuncs, tracerProvider.Shutdown)
-	otel.SetTracerProvider(tracerProvider)
-
-	// Set up logger provider.
-	loggerProvider, err := newLoggerProvider()
-	if err != nil {
-		handleErr(err)
-		return
-	}
-	shutdownFuncs = append(shutdownFuncs, loggerProvider.Shutdown)
-	global.SetLoggerProvider(loggerProvider)
-
-	return
-}
-
-func newPropagator() propagation.TextMapPropagator {
-	return propagation.NewCompositeTextMapPropagator(
-		propagation.TraceContext{},
-		propagation.Baggage{},
-	)
-}
-
-func newTracerProvider() (*trace.TracerProvider, error) {
-	traceExporter, err := stdouttrace.New(
-		stdouttrace.WithPrettyPrint())
-	if err != nil {
-		return nil, err
-	}
-
-	tracerProvider := trace.NewTracerProvider(
-		trace.WithBatcher(traceExporter,
-			// Default is 5s. Set to 1s for demonstrative purposes.
-			trace.WithBatchTimeout(time.Second)),
-	)
-	return tracerProvider, nil
-}
-
-func newLoggerProvider() (*log.LoggerProvider, error) {
-	logExporter, err := stdoutlog.New()
-	if err != nil {
-		return nil, err
-	}
-
-	loggerProvider := log.NewLoggerProvider(
-		log.WithProcessor(log.NewBatchProcessor(logExporter)),
-	)
-	return loggerProvider, nil
-}

internal/providers/braintree.go

···
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"net/http"
 
···
 	PaymentMethod BraintreeChargePaymentMethod `json:"paymentMethod"`
 }
 
-func (b BraintreeProvider) Charge(request *domain.Payment) (*domain.Provider, error) {
+func (b BraintreeProvider) Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error) {
 	body := b.createChargeBody(request)
-	response, err := http.Post(b.Url+"/charges", "application/json", bytes.NewBuffer(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, b.Url+"/charges", bytes.NewBuffer(body))
 	if err != nil {
 		return nil, err
 	}
 
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("transaction-id", ctx.Value("request-id").(string))
+
+	response, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
 	return b.responseCharge(response)
 }
 

internal/providers/braintree_test.go

···
 package providers_test
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
···
 	t.Run("should make request to url", func(t *testing.T) {
 		id, _ := uuid.Parse("2ee70bcb-5cb9-4412-a35f-c2a15fb88ef1")
 		cardId, _ := uuid.Parse("ed6ecd4c-81d5-4e63-bb12-99439ae559e7")
+		ctx := context.WithValue(t.Context(), "request-id", uuid.New().String())
+
 		serverResponse := &providers.BraintreeChargeResponse{
 			Id:             id,
 			CreatedAt:      time.Now().Format("YYYY-MM-DD"),
···
 		}
 
 		provider := providers.NewBraintreeProvider(server.URL)
-		response, err := provider.Charge(charge)
+		response, err := provider.Charge(ctx, charge)
 
 		if err != nil {
 			t.Fatalf("got an error but didn't want one %q", err)

internal/providers/provider.go

···
 package providers
 
 import (
+	"context"
 	"errors"
 	"time"
 
···
 var thirtySecondTimout = 30 * time.Second
 
 type Provider interface {
-	Charge(request *domain.Payment) (*domain.Provider, error)
+	Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error)
 }
 
 type UseProviders struct {
···
 	}
 }
 
-func (p *UseProviders) Payment(payment *domain.Payment) (*domain.Provider, error) {
+func (p *UseProviders) Payment(ctx context.Context, payment *domain.Payment) (*domain.Provider, error) {
 	var err error = nil
 
 	for _, provider := range p.providers {
 		select {
-		case data := <-charge(payment, provider):
+		case data := <-charge(ctx, payment, provider):
 			return data, nil
 		case <-time.After(p.timeout):
 			err = errors.New("Timeout")
···
 	return nil, err
 }
 
-func charge(charge *domain.Payment, provider Provider) chan *domain.Provider {
+func charge(ctx context.Context, charge *domain.Payment, provider Provider) chan *domain.Provider {
 	ch := make(chan *domain.Provider)
 
 	go func() {
-		response, err := provider.Charge(charge)
+		response, err := provider.Charge(ctx, charge)
 		if err != nil {
 			close(ch)
 			return

internal/providers/provider_test.go

···
 package providers_test
 
 import (
+	"context"
 	"testing"
 	"time"
 
···
 	Response *domain.Provider
 }
 
-func (s *SpyProvider) Charge(request *domain.Payment) (*domain.Provider, error) {
+func (s *SpyProvider) Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error) {
 	time.Sleep(s.Timeout)
 	s.Calls++
 
···
 		payment, _ := domain.NewPayment(1000, "R$", "", "card", domain.PaymentCard{Number: "", HolderName: "", CVV: "", ExpirationDate: "02/2025", Installments: 1})
 
 		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, 15*time.Millisecond)
-		data, err := useProvider.Payment(payment)
+		data, err := useProvider.Payment(context.Background(), payment)
 
 		if err != nil {
 			t.Fatal("Got error. didn't want one")
···
 		payment, _ := domain.NewPayment(1000, "R$", "", "card", domain.PaymentCard{Number: "", HolderName: "", CVV: "", ExpirationDate: "02/2025", Installments: 1})
 
 		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, 15*time.Millisecond)
-		data, err := useProvider.Payment(payment)
+		data, err := useProvider.Payment(context.Background(), payment)
 
 		if err != nil {
 			t.Fatal("Got error. didn't want one")
···
 		payment, _ := domain.NewPayment(1000, "R$", "", "card", domain.PaymentCard{Number: "", HolderName: "", CVV: "", ExpirationDate: "02/2025", Installments: 1})
 
 		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, 5*time.Millisecond)
-		data, err := useProvider.Payment(payment)
+		data, err := useProvider.Payment(context.Background(), payment)
 
 		if data != nil {
 			t.Fatalf("Got data but didn't expected one, got %q", data)

internal/providers/stripe.go

···
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"net/http"
 
···
 	Card        StripeChargeCard `json:"card"`
 }
 
-func (b StripeProvider) Charge(request *domain.Payment) (*domain.Provider, error) {
+func (b StripeProvider) Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error) {
 	body := b.createChargeBody(request)
-	response, err := http.Post(b.Url+"/transactions", "application/json", bytes.NewBuffer(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, b.Url+"/transactions", bytes.NewBuffer(body))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("transaction-id", ctx.Value("request-id").(string))
+
+	response, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
 	}

internal/providers/stripe_test.go

···
 package providers_test
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
···
 	t.Run("should make request to url", func(t *testing.T) {
 		id, _ := uuid.Parse("2ee70bcb-5cb9-4412-a35f-c2a15fb88ef1")
 		cardId, _ := uuid.Parse("ed6ecd4c-81d5-4e63-bb12-99439ae559e7")
+		ctx := context.WithValue(t.Context(), "request-id", uuid.New().String())
+
 		serverResponse := &providers.StripeChargeResponse{
 			Id:             id,
 			CreatedAt:      time.Now().Format("YYYY-MM-DD"),
···
 		}
 
 		provider := providers.NewStripeProvider(server.URL)
-		response, err := provider.Charge(charge)
+		response, err := provider.Charge(ctx, charge)
 
 		if err != nil {
 			t.Fatalf("got an error but didn't want one %q", err)

internal/service/payment_service.go

···
 		return nil, err
 	}
 
-	_, err = p.providers.Payment(payment)
+	_, err = p.providers.Payment(ctx, payment)
 	if err != nil {
 		return nil, err
 	}

internal/web/middleware/transactionId.go

···
+package middleware
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+func WithRequestId(next http.HandlerFunc) http.HandlerFunc {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := context.WithValue(r.Context(), "request-id", uuid.New().String())
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

internal/web/server.go

···
 
 	"github.com/Tulkdan/payment-gateway/internal/service"
 	"github.com/Tulkdan/payment-gateway/internal/web/handler"
-	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+	"github.com/Tulkdan/payment-gateway/internal/web/middleware"
 )
 
 type Server struct {
 	port   string
-	router http.Handler
+	router *http.ServeMux
 	server *http.Server
 
 	paymentsService *service.PaymentService
···
 func (s *Server) ConfigureRouter() {
 	mux := http.NewServeMux()
 
-	handleFunc := func(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) {
-		handler := otelhttp.WithRouteTag(pattern, http.HandlerFunc(handlerFunc))
-		mux.Handle(pattern, handler)
-	}
-
 	paymentsHandler := handler.NewPaymentsHandler(s.paymentsService)
 
-	handleFunc("POST /payments", paymentsHandler.Create)
+	mux.HandleFunc("POST /payments", middleware.WithRequestId(paymentsHandler.Create))
 	// r.HandleFunc("POST /refunds", func(http.ResponseWriter, *http.Request) {})
 	// r.HandleFunc("GET /payments/{id}", func(w http.ResponseWriter, r *http.Request) {
 	// id := r.PathValue("id")
 	// })
 
-	s.router = otelhttp.NewHandler(mux, "/")
+	s.router = mux
 }
 
 func (s *Server) Start(ctx context.Context) error {