:sparkles: logger in charge for each provider

cmd/app/main.go

···
 	defer logger.Sync()
 
 	providers := providers.NewUseProviders([]providers.Provider{
-		providers.NewBraintreeProvider("http://" + getEnv("BRAINTREE_URL", "localhost:8001")),
-		providers.NewStripeProvider("http://" + getEnv("STRIPE_URL", "localhost:8002")),
+		providers.NewBraintreeProvider("http://"+getEnv("BRAINTREE_URL", "localhost:8001"), logger),
+		providers.NewStripeProvider("http://"+getEnv("STRIPE_URL", "localhost:8002"), logger),
 	}, logger)
 	paymentsService := service.NewPaymentService(providers)
 

internal/providers/braintree.go

···
 
 	"github.com/Tulkdan/payment-gateway/internal/domain"
 	"github.com/google/uuid"
+	"go.uber.org/zap"
 )
 
 type BraintreeProvider struct {
-	Url string
+	Url    string
+	logger *zap.Logger
 }
 
-func NewBraintreeProvider(url string) *BraintreeProvider {
-	return &BraintreeProvider{Url: url}
+func NewBraintreeProvider(url string, logger *zap.Logger) *BraintreeProvider {
+	return &BraintreeProvider{Url: url, logger: logger.Named("BraintreeProvider")}
 }
 
 type BraintreeChargeCard struct {
···
 }
 
 func (b *BraintreeProvider) Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error) {
+	url := b.Url + "/transactions"
+
+	b.logger.Debug("Making request to charge",
+		zap.String("url", url))
+
 	body := b.createChargeBody(request)
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, b.Url+"/charges", bytes.NewBuffer(body))
 	if err != nil {

internal/providers/braintree_test.go

···
 	"github.com/Tulkdan/payment-gateway/internal/domain"
 	"github.com/Tulkdan/payment-gateway/internal/providers"
 	"github.com/google/uuid"
+	"go.uber.org/zap"
 )
 
 func TestBraintree(t *testing.T) {
 	t.Run("should make request to url", func(t *testing.T) {
+		logger, _ := zap.NewDevelopment()
+		defer logger.Sync()
+
 		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())
···
 			CardId:         cardId,
 		}
 
-		provider := providers.NewBraintreeProvider(server.URL)
+		provider := providers.NewBraintreeProvider(server.URL, logger)
 		response, err := provider.Charge(ctx, charge)
 
 		if err != nil {

internal/providers/provider.go

···
 func ConfigurableUseProvider(providers []Provider, logger *zap.Logger, timeout time.Duration) *UseProviders {
 	return &UseProviders{
 		providers: providers,
-		logger:    logger,
+		logger:    logger.Named("UseProviders"),
 		timeout:   timeout,
 	}
 }

internal/providers/provider_test.go

···
 	})
 
 	t.Run("should make request for second provider when first provider timeouts", func(t *testing.T) {
-		logger, _ := zap.NewProduction()
+		logger, _ := zap.NewDevelopment()
 		defer logger.Sync()
 
 		spyFirst := &SpyProvider{Timeout: 20 * time.Millisecond, Response: &domain.Provider{Description: "First"}}
···
 	})
 
 	t.Run("should return error when all providers timeout", func(t *testing.T) {
-		logger, _ := zap.NewProduction()
+		logger, _ := zap.NewDevelopment()
 		defer logger.Sync()
 
 		spyFirst := &SpyProvider{Timeout: 20 * time.Millisecond, Response: &domain.Provider{Description: "First"}}

internal/providers/stripe.go

···
 
 	"github.com/Tulkdan/payment-gateway/internal/domain"
 	"github.com/google/uuid"
+	"go.uber.org/zap"
 )
 
 type StripeProvider struct {
-	Url string
+	Url    string
+	logger *zap.Logger
 }
 
-func NewStripeProvider(url string) *StripeProvider {
-	return &StripeProvider{Url: url}
+func NewStripeProvider(url string, logger *zap.Logger) *StripeProvider {
+	return &StripeProvider{Url: url, logger: logger.Named("StripeProvider")}
 }
 
 type StripeChargeCard struct {
···
 	Card        StripeChargeCard `json:"card"`
 }
 
-func (b *StripeProvider) Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error) {
-	body := b.createChargeBody(request)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, b.Url+"/transactions", bytes.NewBuffer(body))
+func (s *StripeProvider) Charge(ctx context.Context, request *domain.Payment) (*domain.Provider, error) {
+	url := s.Url + "/transactions"
+
+	s.logger.Debug("Making request to charge",
+		zap.String("url", url))
+
+	body := s.createChargeBody(request)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(body))
 	if err != nil {
 		return nil, err
 	}
···
 	}
 	defer response.Body.Close()
 
-	return b.responseCharge(response)
+	return s.responseCharge(response)
 }
 
-func (b *StripeProvider) createChargeBody(request *domain.Payment) []byte {
+func (s *StripeProvider) createChargeBody(request *domain.Payment) []byte {
 	toSend := &StripeCharge{
 		Amount:      request.Amount,
 		Currency:    request.Currency,
···
 	CardId         uuid.UUID `json:"cardId"`
 }
 
-func (b *StripeProvider) responseCharge(response *http.Response) (*domain.Provider, error) {
+func (s *StripeProvider) responseCharge(response *http.Response) (*domain.Provider, error) {
 	var data StripeChargeResponse
 	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
 		return nil, err

internal/providers/stripe_test.go

···
 	"github.com/Tulkdan/payment-gateway/internal/domain"
 	"github.com/Tulkdan/payment-gateway/internal/providers"
 	"github.com/google/uuid"
+	"go.uber.org/zap"
 )
 
 func TestStripe(t *testing.T) {
 	t.Run("should make request to url", func(t *testing.T) {
+		logger, _ := zap.NewDevelopment()
+		defer logger.Sync()
+
 		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())
···
 			CardId:         cardId,
 		}
 
-		provider := providers.NewStripeProvider(server.URL)
+		provider := providers.NewStripeProvider(server.URL, logger)
 		response, err := provider.Charge(ctx, charge)
 
 		if err != nil {