:sparkles: improved logs for request

cmd/app/main.go

···
 
 	logger, _ := zap.NewDevelopment()
 	defer logger.Sync()
-	sugar := logger.Sugar()
 
 	providers := providers.NewUseProviders([]providers.Provider{
 		providers.NewBraintreeProvider(getEnv("BRAINTREE_URL", "http://localhost:8001")),
 		providers.NewStripeProvider(getEnv("STRIPE_URL", "http://localhost:8002")),
-	}, sugar)
+	}, logger)
 	paymentsService := service.NewPaymentService(providers)
 
 	port := getEnv("PORT", "8000")
-	server := web.NewServer(paymentsService, port, sugar)
+	server := web.NewServer(paymentsService, port, logger)
 	server.ConfigureRouter()
 
 	srvErr := make(chan error, 1)

internal/providers/provider.go

···
 	"go.uber.org/zap"
 )
 
-var thirtySecondTimout = 30 * time.Second
+var thirtySecondTimout = 5 * time.Second
 
 type Provider interface {
 	GetName() string
···
 type UseProviders struct {
 	providers []Provider
 	timeout   time.Duration
-	logger    *zap.SugaredLogger
+	logger    *zap.Logger
 }
 
-func NewUseProviders(providers []Provider, logger *zap.SugaredLogger) *UseProviders {
+func NewUseProviders(providers []Provider, logger *zap.Logger) *UseProviders {
 	return ConfigurableUseProvider(providers, logger, thirtySecondTimout)
 }
 
-func ConfigurableUseProvider(providers []Provider, logger *zap.SugaredLogger, timeout time.Duration) *UseProviders {
+func ConfigurableUseProvider(providers []Provider, logger *zap.Logger, timeout time.Duration) *UseProviders {
 	return &UseProviders{
 		providers: providers,
 		logger:    logger,
···
 	for _, provider := range p.providers {
 		select {
 		case data := <-p.charge(ctx, payment, provider):
-			p.logger.Debugw("[Payment] Sending request successfully",
-				"provider", provider.GetName(),
-				"attempt", attempts)
+			p.logger.Debug("[Payment] Received request successfully",
+				zap.String("provider", provider.GetName()),
+				zap.Int("attempt", attempts))
 
 			return data, nil
 		case <-time.After(p.timeout):
-			p.logger.Errorw("[Payment] Timeout for provider to respond",
-				"provider", provider.GetName(),
-				"attempt", attempts)
+			p.logger.Error("[Payment] Timeout for provider to respond",
+				zap.String("provider", provider.GetName()),
+				zap.Int("attempt", attempts))
 
 			err = errors.New("Timeout")
 			continue

internal/providers/provider_test.go

···
 	t.Run("should make request for first provider", func(t *testing.T) {
 		logger, _ := zap.NewDevelopment()
 		defer logger.Sync()
-		sugar := logger.Sugar()
 
 		spyFirst := &SpyProvider{Timeout: 10 * time.Millisecond, Response: &domain.Provider{Description: "First"}}
 		spySecond := &SpyProvider{Timeout: 10 * time.Millisecond, Response: &domain.Provider{Description: "Second"}}
 
 		payment, _ := domain.NewPayment(1000, "R$", "", "card", domain.PaymentCard{Number: "", HolderName: "", CVV: "", ExpirationDate: "02/2025", Installments: 1})
 
-		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, sugar, 15*time.Millisecond)
+		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, logger, 15*time.Millisecond)
 		data, err := useProvider.Payment(context.Background(), payment)
 
 		if err != nil {
···
 	t.Run("should make request for second provider when first provider timeouts", func(t *testing.T) {
 		logger, _ := zap.NewProduction()
 		defer logger.Sync()
-		sugar := logger.Sugar()
 
 		spyFirst := &SpyProvider{Timeout: 20 * time.Millisecond, Response: &domain.Provider{Description: "First"}}
 		spySecond := &SpyProvider{Timeout: 10 * time.Millisecond, Response: &domain.Provider{Description: "Second"}}
 
 		payment, _ := domain.NewPayment(1000, "R$", "", "card", domain.PaymentCard{Number: "", HolderName: "", CVV: "", ExpirationDate: "02/2025", Installments: 1})
 
-		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, sugar, 15*time.Millisecond)
+		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, logger, 15*time.Millisecond)
 		data, err := useProvider.Payment(context.Background(), payment)
 
 		if err != nil {
···
 	t.Run("should return error when all providers timeout", func(t *testing.T) {
 		logger, _ := zap.NewProduction()
 		defer logger.Sync()
-		sugar := logger.Sugar()
 
 		spyFirst := &SpyProvider{Timeout: 20 * time.Millisecond, Response: &domain.Provider{Description: "First"}}
 		spySecond := &SpyProvider{Timeout: 20 * time.Millisecond, Response: &domain.Provider{Description: "Second"}}
 
 		payment, _ := domain.NewPayment(1000, "R$", "", "card", domain.PaymentCard{Number: "", HolderName: "", CVV: "", ExpirationDate: "02/2025", Installments: 1})
 
-		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, sugar, 5*time.Millisecond)
+		useProvider := providers.ConfigurableUseProvider([]providers.Provider{spyFirst, spySecond}, logger, 5*time.Millisecond)
 		data, err := useProvider.Payment(context.Background(), payment)
 
 		if data != nil {

internal/service/payment_service.go

···
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/Tulkdan/payment-gateway/internal/domain"
 	"github.com/Tulkdan/payment-gateway/internal/dto"
···
 		return nil, err
 	}
 
-	data, err := p.providers.Payment(ctx, payment)
+	_, err = p.providers.Payment(ctx, payment)
 	if err != nil {
 		return nil, err
 	}
-
-	fmt.Println(data)
 
 	return &dto.PaymentOutput{Message: "Processed successfully"}, nil
 }

internal/web/handler/payments_handler.go

···
 type PaymentsHandler struct {
 	paymentService *service.PaymentService
 
-	logger *zap.SugaredLogger
+	logger *zap.Logger
 }
 
-func NewPaymentsHandler(paymentsService *service.PaymentService, logger *zap.SugaredLogger) *PaymentsHandler {
+func NewPaymentsHandler(paymentsService *service.PaymentService, logger *zap.Logger) *PaymentsHandler {
 	return &PaymentsHandler{
 		paymentService: paymentsService,
 		logger:         logger.Named("PaymentHandler"),
···
 func (p *PaymentsHandler) Create(w http.ResponseWriter, r *http.Request) {
 	var body dto.PaymentInput
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		p.logger.Errorw("Body incomplete",
-			"error", err.Error(),
-			"requestId", r.Context().Value("request-id").(string))
+		p.logger.Error("Body incomplete",
+			zap.String("error", err.Error()),
+			zap.String("requestId", r.Context().Value("request-id").(string)))
 
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
···
 
 	response, err := p.paymentService.CreatePayment(r.Context(), body)
 	if err != nil {
-		p.logger.Errorw("Failed to create payment",
-			"error", err.Error(),
-			"requestId", r.Context().Value("request-id").(string))
+		p.logger.Error("Failed to create payment",
+			zap.String("error", err.Error()),
+			zap.String("requestId", r.Context().Value("request-id").(string)))
 
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
+
+	p.logger.Debug("Processed request",
+		zap.Any("response", response),
+		zap.String("requestId", r.Context().Value("request-id").(string)))
 
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusOK)

internal/web/server.go

···
 	port   string
 	router *http.ServeMux
 	server *http.Server
-	logger *zap.SugaredLogger
+	logger *zap.Logger
 
 	paymentsService *service.PaymentService
 }
 
-func NewServer(paymentsService *service.PaymentService, port string, logger *zap.SugaredLogger) *Server {
+func NewServer(paymentsService *service.PaymentService, port string, logger *zap.Logger) *Server {
 	return &Server{
 		port:            port,
 		paymentsService: paymentsService,

mocks/braintree.yml

···
       content-type: application/json
   response:
     - status: 200
-      latency: 5000
+      latency: 15000
       headers:
         content-type: application/json
         server: stubbedServer/4.2

mocks/stripe.yml

···
       content-type: application/json
   response:
     - status: 200
-      latency: 5000
+      latency: 500
       headers:
         content-type: application/json
         server: stubbedServer/4.2