Use separate services for external integrations

saleor/payment/gateways/adyen/plugin.py

@@ -3,6 +3,8 @@
 from urllib.parse import urlencode
 
 import Adyen
+import opentracing
+import opentracing.tags
 from django.contrib.auth.hashers import make_password
 from django.contrib.sites.models import Site
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
@@ -226,10 +228,16 @@ def webhook(self, request: WSGIRequest, path: str, previous_value) -> HttpRespon
         if path.startswith(WEBHOOK_PATH):
             return handle_webhook(request, config)
         elif path.startswith(ADDITIONAL_ACTION_PATH):
-            return handle_additional_actions(
-                request,
-                self.adyen.checkout.payments_details,
-            )
+            with opentracing.global_tracer().start_active_span(
+                "adyen.checkout.payment_details"
+            ) as scope:
+                span = scope.span
+                span.set_tag(opentracing.tags.COMPONENT, "payment")
+                span.set_tag("service.name", "adyen")
+                return handle_additional_actions(
+                    request,
+                    self.adyen.checkout.payments_details,
+                )
         return HttpResponseNotFound()
 
     def _get_gateway_config(self) -> GatewayConfig:
@@ -265,7 +273,13 @@ def get_payment_gateway_for_checkout(
         request = request_data_for_gateway_config(
             checkout, config.connection_params["merchant_account"]
         )
-        response = api_call(request, self.adyen.checkout.payment_methods)
+        with opentracing.global_tracer().start_active_span(
+            "adyen.checkout.payment_methods"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "adyen")
+            response = api_call(request, self.adyen.checkout.payment_methods)
         return PaymentGateway(
             id=self.PLUGIN_ID,
             name=self.PLUGIN_NAME,
@@ -314,7 +328,13 @@ def process_payment(
             merchant_account=self.config.connection_params["merchant_account"],
             native_3d_secure=self.config.connection_params["enable_native_3d_secure"],
         )
-        result = api_call(request_data, self.adyen.checkout.payments)
+        with opentracing.global_tracer().start_active_span(
+            "adyen.checkout.payments"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "adyen")
+            result = api_call(request_data, self.adyen.checkout.payments)
         result_code = result.message["resultCode"].strip().lower()
         is_success = result_code not in FAILED_STATUSES
         adyen_auto_capture = self.config.connection_params["adyen_auto_capture"]
@@ -384,7 +404,13 @@ def _process_additional_action(self, payment_information: "PaymentData", kind: s
         if not additional_data:
             raise PaymentError("Unable to finish the payment.")
 
-        result = api_call(additional_data, self.adyen.checkout.payments_details)
+        with opentracing.global_tracer().start_active_span(
+            "adyen.checkout.payment_details"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "adyen")
+            result = api_call(additional_data, self.adyen.checkout.payments_details)
         result_code = result.message["resultCode"].strip().lower()
         is_success = result_code not in FAILED_STATUSES
         action_required = "action" in result.message
@@ -530,7 +556,13 @@ def refund_payment(
             merchant_account=self.config.connection_params["merchant_account"],
             token=transaction.token,
         )
-        result = api_call(request, self.adyen.payment.refund)
+        with opentracing.global_tracer().start_active_span(
+            "adyen.payment.refund"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "adyen")
+            result = api_call(request, self.adyen.payment.refund)
 
         amount = payment_information.amount
         currency = payment_information.currency
@@ -596,7 +628,13 @@ def void_payment(
             merchant_account=self.config.connection_params["merchant_account"],
             token=payment_information.token,  # type: ignore
         )
-        result = api_call(request, self.adyen.payment.cancel)
+        with opentracing.global_tracer().start_active_span(
+            "adyen.payment.cancel"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "adyen")
+            result = api_call(request, self.adyen.payment.cancel)
 
         return GatewayResponse(
             is_success=True,

saleor/payment/gateways/adyen/utils/common.py

@@ -4,6 +4,8 @@
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
 
 import Adyen
+import opentracing
+import opentracing.tags
 from babel.numbers import get_currency_precision
 from django.conf import settings
 from django_countries.fields import Country
@@ -360,7 +362,13 @@ def call_capture(
         merchant_account=merchant_account,
         token=token,
     )
-    return api_call(request, adyen_client.payment.capture)
+    with opentracing.global_tracer().start_active_span(
+        "adyen.payment.capture"
+    ) as scope:
+        span = scope.span
+        span.set_tag(opentracing.tags.COMPONENT, "payment")
+        span.set_tag("service.name", "adyen")
+        return api_call(request, adyen_client.payment.capture)
 
 
 def request_for_payment_cancel(

saleor/payment/gateways/braintree/__init__.py

@@ -1,6 +1,8 @@
 from typing import Dict, List, Optional
 
 import braintree as braintree_sdk
+import opentracing
+import opentracing.tags
 from django.core.exceptions import ImproperlyConfigured
 
 from ... import TransactionKind
@@ -107,10 +109,16 @@ def get_client_token(
     config: GatewayConfig, token_config: Optional[TokenConfig] = None
 ) -> str:
     gateway = get_braintree_gateway(**config.connection_params)
-    if not token_config:
-        return gateway.client_token.generate()
-    parameters = create_token_params(config, token_config)
-    return gateway.client_token.generate(parameters)
+    with opentracing.global_tracer().start_active_span(
+        "braintree.client_token.generate"
+    ) as scope:
+        span = scope.span
+        span.set_tag(opentracing.tags.COMPONENT, "payment")
+        span.set_tag("service.name", "braintree")
+        if not token_config:
+            return gateway.client_token.generate()
+        parameters = create_token_params(config, token_config)
+        return gateway.client_token.generate(parameters)
 
 
 def create_token_params(config: GatewayConfig, token_config: TokenConfig) -> dict:
@@ -163,42 +171,61 @@ def transaction_for_new_customer(
     payment_information: PaymentData, config: GatewayConfig
 ):
     gateway = get_braintree_gateway(**config.connection_params)
-    return gateway.transaction.sale(
-        {
-            "amount": str(payment_information.amount),
-            "payment_method_nonce": payment_information.token,
-            "options": {
-                "submit_for_settlement": config.auto_capture,
-                "store_in_vault_on_success": payment_information.reuse_source,
-                "three_d_secure": {"required": config.require_3d_secure},
-            },
-            **get_customer_data(payment_information),
-        }
-    )
+
+    with opentracing.global_tracer().start_active_span(
+        "braintree.transaction.sale"
+    ) as scope:
+        span = scope.span
+        span.set_tag(opentracing.tags.COMPONENT, "payment")
+        span.set_tag("service.name", "braintree")
+        return gateway.transaction.sale(
+            {
+                "amount": str(payment_information.amount),
+                "payment_method_nonce": payment_information.token,
+                "options": {
+                    "submit_for_settlement": config.auto_capture,
+                    "store_in_vault_on_success": payment_information.reuse_source,
+                    "three_d_secure": {"required": config.require_3d_secure},
+                },
+                **get_customer_data(payment_information),
+            }
+        )
 
 
 def transaction_for_existing_customer(
     payment_information: PaymentData, config: GatewayConfig
 ):
     gateway = get_braintree_gateway(**config.connection_params)
-    return gateway.transaction.sale(
-        {
-            "amount": str(payment_information.amount),
-            "customer_id": payment_information.customer_id,
-            "options": {"submit_for_settlement": config.auto_capture},
-            **get_customer_data(payment_information),
-        }
-    )
+    with opentracing.global_tracer().start_active_span(
+        "braintree.transaction.sale"
+    ) as scope:
+        span = scope.span
+        span.set_tag(opentracing.tags.COMPONENT, "payment")
+        span.set_tag("service.name", "braintree")
+        return gateway.transaction.sale(
+            {
+                "amount": str(payment_information.amount),
+                "customer_id": payment_information.customer_id,
+                "options": {"submit_for_settlement": config.auto_capture},
+                **get_customer_data(payment_information),
+            }
+        )
 
 
 def capture(payment_information: PaymentData, config: GatewayConfig) -> GatewayResponse:
     gateway = get_braintree_gateway(**config.connection_params)
 
     try:
-        result = gateway.transaction.submit_for_settlement(
-            transaction_id=payment_information.token,
-            amount=str(payment_information.amount),
-        )
+        with opentracing.global_tracer().start_active_span(
+            "braintree.transaction.submit_for_settlement"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "braintree")
+            result = gateway.transaction.submit_for_settlement(
+                transaction_id=payment_information.token,
+                amount=str(payment_information.amount),
+            )
     except braintree_sdk.exceptions.NotFoundError:
         raise BraintreeException(DEFAULT_ERROR_MESSAGE)
 
@@ -223,7 +250,13 @@ def void(payment_information: PaymentData, config: GatewayConfig) -> GatewayResp
     gateway = get_braintree_gateway(**config.connection_params)
 
     try:
-        result = gateway.transaction.void(transaction_id=payment_information.token)
+        with opentracing.global_tracer().start_active_span(
+            "braintree.transaction.void"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "braintree")
+            result = gateway.transaction.void(transaction_id=payment_information.token)
     except braintree_sdk.exceptions.NotFoundError:
         raise BraintreeException(DEFAULT_ERROR_MESSAGE)
 
@@ -248,10 +281,16 @@ def refund(payment_information: PaymentData, config: GatewayConfig) -> GatewayRe
     gateway = get_braintree_gateway(**config.connection_params)
 
     try:
-        result = gateway.transaction.refund(
-            transaction_id=payment_information.token,
-            amount_or_options=str(payment_information.amount),
-        )
+        with opentracing.global_tracer().start_active_span(
+            "braintree.transaction.refund"
+        ) as scope:
+            span = scope.span
+            span.set_tag(opentracing.tags.COMPONENT, "payment")
+            span.set_tag("service.name", "braintree")
+            result = gateway.transaction.refund(
+                transaction_id=payment_information.token,
+                amount_or_options=str(payment_information.amount),
+            )
     except braintree_sdk.exceptions.NotFoundError:
         raise BraintreeException(DEFAULT_ERROR_MESSAGE)
 
@@ -283,7 +322,13 @@ def list_client_sources(
     config: GatewayConfig, customer_id: str
 ) -> List[CustomerSource]:
     gateway = get_braintree_gateway(**config.connection_params)
-    customer = gateway.customer.find(customer_id)
+    with opentracing.global_tracer().start_active_span(
+        "braintree.customer.find"
+    ) as scope:
+        span = scope.span
+        span.set_tag(opentracing.tags.COMPONENT, "payment")
+        span.set_tag("service.name", "braintree")
+        customer = gateway.customer.find(customer_id)
     if not customer:
         return []
     return [

saleor/payment/gateways/razorpay/__init__.py

@@ -3,6 +3,8 @@
 from decimal import Decimal
 from typing import Dict
 
+import opentracing
+import opentracing.tags
 import razorpay
 import razorpay.errors
 
@@ -96,9 +98,15 @@ def capture(payment_information: PaymentData, config: GatewayConfig) -> GatewayR
 
     if not error:
         try:
-            response = razorpay_client.payment.capture(
-                payment_information.token, razorpay_amount
-            )
+            with opentracing.global_tracer().start_active_span(
+                "razorpay.payment.capture"
+            ) as scope:
+                span = scope.span
+                span.set_tag(opentracing.tags.COMPONENT, "payment")
+                span.set_tag("service.name", "razorpay")
+                response = razorpay_client.payment.capture(
+                    payment_information.token, razorpay_amount
+                )
             clean_razorpay_response(response)
         except RAZORPAY_EXCEPTIONS as exc:
             error = get_error_message_from_razorpay_error(exc)
@@ -136,9 +144,15 @@ def refund(payment_information: PaymentData, config: GatewayConfig) -> GatewayRe
         razorpay_client = get_client(**config.connection_params)
         razorpay_amount = get_amount_for_razorpay(payment_information.amount)
         try:
-            response = razorpay_client.payment.refund(
-                payment_information.token, razorpay_amount
-            )
+            with opentracing.global_tracer().start_active_span(
+                "razorpay.payment.refund"
+            ) as scope:
+                span = scope.span
+                span.set_tag(opentracing.tags.COMPONENT, "payment")
+                span.set_tag("service.name", "razorpay")
+                response = razorpay_client.payment.refund(
+                    payment_information.token, razorpay_amount
+                )
             clean_razorpay_response(response)
         except RAZORPAY_EXCEPTIONS as exc:
             error = get_error_message_from_razorpay_error(exc)