added latency and status code to monitoring params

Author: korneliosyaovi

rave_python/rave_bills.py

@@ -41,13 +41,25 @@ def _handleCreateResponse(self, response, details):
     #function to create a Bill
     #Params: details - a dict containing service, service_method, service_version, service_channel and service_payload
     def create(self, details):
+        
         # Performing shallow copy of planDetails to avoid public exposing payload with secret key
         details = copy.copy(details)
         details.update({"seckey": self._getSecretKey()})
-
         requiredParameters = ["service", "service_method", "service_version", "service_channel"]
         checkIfParametersAreComplete(requiredParameters, details)
-
         endpoint = self._baseUrl + self._endpointMap["bills"]["create"]
         response = requests.post(endpoint, headers=self.headers, data=json.dumps(details))
+
+        # feature logging
+        if response.ok == False:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Create-Bills-error", "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+        else:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Create-Bills", "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+
         return self._handleCreateResponse(response, details)

rave_python/rave_card.py

@@ -93,6 +93,7 @@ def charge(self, cardDetails, hasFailed=False, chargeWithToken=False):
             hasFailed (bool) -- This indicates whether the request had previously failed for timeout handling
         """
         # setting the endpoint
+        feature_name = "Initiate-Card-charge"
         if not chargeWithToken:
             endpoint = self._baseUrl + self._endpointMap["card"]["charge"]
             requiredParameters = ["cardno", "cvv", "expirymonth", "expiryyear", "amount", "email", "IP", "phonenumber", "firstname", "lastname"]
@@ -111,17 +112,18 @@ def charge(self, cardDetails, hasFailed=False, chargeWithToken=False):
         if not ("txRef" in cardDetails):
             cardDetails.update({"txRef":generateTransactionReference()})
 
-        
-        return super(Card, self).charge(cardDetails, requiredParameters, endpoint)
+        return super(Card, self).charge(feature_name, cardDetails, requiredParameters, endpoint)
 
 
     def validate(self, flwRef, otp):
+        feature_name = "Validate-Card-charge"
         endpoint = self._baseUrl + self._endpointMap["card"]["validate"]
-        return super(Card, self).validate(flwRef, otp, endpoint)
+        return super(Card, self).validate(feature_name, flwRef, otp, endpoint)
 
     def verify(self, txRef):
+        feature_name = "Verify-Card-charge"
         endpoint = self._baseUrl + self._endpointMap["card"]["verify"]
-        return super(Card, self).verify(txRef, endpoint)
+        return super(Card, self).verify(feature_name, txRef, endpoint)
 
 
 

rave_python/rave_francophone.py

@@ -49,6 +49,7 @@ def charge(self, accountDetails, hasFailed=False):
             hasFailed (boolean) -- This is a flag to determine if the attempt had previously failed due to a timeout\n
         """
 
+        feature_name = "Initiate-Francophone-mobile-money-charge"
         endpoint = self._baseUrl + self._endpointMap["account"]["charge"]
         # It is faster to add boilerplate than to check if each one is present
         accountDetails.update({"payment_type": "mobilemoneyfrancophone", "is_mobile_money_franco":"1"})
@@ -62,4 +63,4 @@ def charge(self, accountDetails, hasFailed=False):
         # Checking for required account components
         # requiredParameters = ["amount", "email", "phonenumber", "IP", "redirect_url"]
         requiredParameters = ["amount"]
-        return super(Francophone, self).charge(accountDetails, requiredParameters, endpoint)
+        return super(Francophone, self).charge(feature_name, accountDetails, requiredParameters, endpoint)

rave_python/rave_ghmobile.py

@@ -1,6 +1,6 @@
 from rave_python.rave_payment import Payment
 from rave_python.rave_misc import generateTransactionReference
-import json
+import json, requests
 
 class GhMobile(Payment):
 
@@ -10,17 +10,18 @@ def __init__(self, publicKey, secretKey, production, usingEnv):
 
     # Charge mobile money function
     def charge(self, accountDetails, hasFailed=False):
+        
         """ This is the ghMobile charge call.
              Parameters include:\n
             accountDetails (dict) -- These are the parameters passed to the function for processing\n
             hasFailed (boolean) -- This is a flag to determine if the attempt had previously failed due to a timeout\n
         """
-
+        
         endpoint = self._baseUrl + self._endpointMap["account"]["charge"]
+        feature_name = "Initiate-Ghana-mobile-money-charge"
 
         # It is faster to add boilerplate than to check if each one is present
         accountDetails.update({"payment_type": "mobilemoneygh", "country":"GH", "is_mobile_money_gh":"1", "currency":"GHS"})
-        
         # If transaction reference is not set 
         if not ("txRef" in accountDetails):
             accountDetails.update({"txRef": generateTransactionReference()})
@@ -30,5 +31,5 @@ def charge(self, accountDetails, hasFailed=False):
 
         # Checking for required account components
         requiredParameters = ["amount", "email", "phonenumber", "network", "IP", "redirect_url"]
-        return super(GhMobile, self).charge(accountDetails, requiredParameters, endpoint)
+        return super(GhMobile, self).charge(feature_name, accountDetails, requiredParameters, endpoint)
 

rave_python/rave_mpesa.py

@@ -16,14 +16,9 @@ def charge(self, accountDetails, hasFailed=False):
             accountDetails (dict) -- These are the parameters passed to the function for processing\n
             hasFailed (boolean) -- This is a flag to determine if the attempt had previously failed due to a timeout\n
         """
-        
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Initiate-Mpesa-charge"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-        
         ## feature logic
         # Setting the endpoint
+        feature_name = "Initiate-Mpesa-charge"
         endpoint = self._baseUrl + self._endpointMap["account"]["charge"]
         # Adding boilerplate mpesa requirements
         accountDetails.update({"payment_type": "mpesa", "country":"KE", "is_mpesa":"1", "is_mpesa_lipa":"1", "currency":"KES"})
@@ -36,9 +31,10 @@ def charge(self, accountDetails, hasFailed=False):
 
         # Checking for required account components
         requiredParameters = ["amount", "email", "phonenumber", "IP"]
-        res = super(Mpesa, self).charge(accountDetails, requiredParameters, endpoint, isMpesa=True)
+        res = super(Mpesa, self).charge(feature_name, accountDetails, requiredParameters, endpoint, isMpesa=True)
         return res
 
     def verify(self, txRef):
+        feature_name = "Verify-Mpesa_charge"
         endpoint = self._baseUrl + self._endpointMap["account"]["verify"]
-        return super(Mpesa, self).verify(txRef, endpoint)
+        return super(Mpesa, self).verify(feature_name, txRef, endpoint)

rave_python/rave_payment.py

@@ -174,7 +174,7 @@ def _handleValidateResponse(self, response, flwRef, request=None):
 
 
     # Charge function (hasFailed is a flag that indicates there is a timeout), shouldReturnRequest indicates whether to send the request back to the _handleResponses function
-    def charge(self, paymentDetails, requiredParameters, endpoint, shouldReturnRequest=False, isMpesa=False):
+    def charge(self, feature_name, paymentDetails, requiredParameters, endpoint, shouldReturnRequest=False, isMpesa=False):
         """ This is the base charge call. It is usually overridden by implementing classes.\n
              Parameters include:\n
             paymentDetails (dict) -- These are the parameters passed to the function for processing\n
@@ -213,6 +213,18 @@ def charge(self, paymentDetails, requiredParameters, endpoint, shouldReturnReque
                 "alg": "3DES-24"
             }
             response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
+            
+            #feature logging
+            if response.ok:
+                tracking_endpoint = self._trackingMap
+                responseTime = response.elapsed.total_seconds()
+                tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name, "message": responseTime}
+                tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+            else:
+                tracking_endpoint = self._trackingMap
+                responseTime = response.elapsed.total_seconds()
+                tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name + "-error", "message": responseTime}
+                tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
 
         if shouldReturnRequest:
             if isMpesa:
@@ -222,9 +234,10 @@ def charge(self, paymentDetails, requiredParameters, endpoint, shouldReturnReque
             if isMpesa:
                 return self._handleChargeResponse(response, paymentDetails["txRef"], paymentDetails, True)
             return self._handleChargeResponse(response, paymentDetails["txRef"])
+        
 
 
-    def validate(self, flwRef, otp, endpoint=None):
+    def validate(self, feature_name, flwRef, otp, endpoint=None):
         """ This is the base validate call.\n
              Parameters include:\n
             flwRef (string) -- This is the flutterwave reference returned from a successful charge call. You can access this from action["flwRef"] returned from the charge call\n
@@ -247,10 +260,23 @@ def validate(self, flwRef, otp, endpoint=None):
         }
 
         response = requests.post(endpoint, headers = headers, data=json.dumps(payload))
+
+        #feature logging
+        if response.ok:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name, "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+        else:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name + "-error", "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+
         return self._handleValidateResponse(response, flwRef)
 
     # Verify charge
-    def verify(self, txRef, endpoint=None):
+    def verify(self, feature_name, txRef, endpoint=None):
         """ This is used to check the status of a transaction.\n
              Parameters include:\n
             txRef (string) -- This is the transaction reference that you passed to your charge call. If you didn't define a reference, you can access the auto-generated one from payload["txRef"] or action["txRef"] from the charge call\n
@@ -269,10 +295,23 @@ def verify(self, txRef, endpoint=None):
             "SECKEY": self._getSecretKey()
         }
         response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
+
+        #feature logging
+        if response.ok:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name, "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+        else:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name + "-error", "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+
         return self._handleVerifyResponse(response, txRef)
 
     #Refund call
-    def refund(self, flwRef):
+    def refund(self, feature_name, flwRef):
         """ This is used to refund a transaction from any of Rave's component objects.\n 
              Parameters include:\n
             flwRef (string) -- This is the flutterwave reference returned from a successful call from any component. You can access this from action["flwRef"] returned from the charge call
@@ -288,6 +327,18 @@ def refund(self, flwRef):
 
         response = requests.post(endpoint, headers = headers, data=json.dumps(payload))
 
+        #feature logging
+        if response.ok:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name, "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+        else:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": feature_name + "-error", "message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+
         try:
             responseJson = response.json()
         except ValueError:

rave_python/rave_rwmobile.py

@@ -17,12 +17,8 @@ def charge(self, accountDetails, hasFailed=False):
             hasFailed (boolean) -- This is a flag to determine if the attempt had previously failed due to a timeout\n
         """
 
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Initiate-Zambia-mobile-money-charge"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-
         #feature logic
+        feature_name = "Initiate-Zambia-mobile-money-charge" 
         endpoint = self._baseUrl + self._endpointMap["account"]["charge"]
         # It is faster to add boilerplate than to check if each one is present
         accountDetails.update({"payment_type": "mobilemoneygh", "country":"NG", "is_mobile_money_gh":"1", "currency":"RWF", "network": "RWF"})
@@ -34,5 +30,5 @@ def charge(self, accountDetails, hasFailed=False):
             accountDetails.update({"orderRef": generateTransactionReference()})
         # Checking for required account components
         requiredParameters = ["amount", "email", "phonenumber", "network", "IP", "redirect_url"]
-        return super(RWMobile, self).charge(accountDetails, requiredParameters, endpoint)
+        return super(RWMobile, self).charge(feature_name, accountDetails, requiredParameters, endpoint)
 

rave_python/rave_ugmobile.py

@@ -7,7 +7,6 @@ class UGMobile(Payment):
     def __init__(self, publicKey, secretKey, production, usingEnv):
         super(UGMobile, self).__init__(publicKey, secretKey, production, usingEnv)
 
-
     # Charge mobile money function
     def charge(self, accountDetails, hasFailed=False):
 
@@ -16,13 +15,9 @@ def charge(self, accountDetails, hasFailed=False):
             accountDetails (dict) -- These are the parameters passed to the function for processing\n
             hasFailed (boolean) -- This is a flag to determine if the attempt had previously failed due to a timeout\n
         """
-
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Initiate-Uganda-mobile-money-charge"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
 
         ## feature logic
+        feature_name = "Initiate-Uganda-mobile-money-charge"
         endpoint = self._baseUrl + self._endpointMap["account"]["charge"]
         # It is faster to add boilerplate than to check if each one is present
         accountDetails.update({"payment_type": "mobilemoneyuganda", "country":"NG", "is_mobile_money_ug":"1", "currency":"UGX", "network": "UGX"})
@@ -34,5 +29,5 @@ def charge(self, accountDetails, hasFailed=False):
             accountDetails.update({"orderRef": generateTransactionReference()})
         # Checking for required account components
         requiredParameters = ["amount", "email", "phonenumber", "network", "IP"]
-        return super(UGMobile, self).charge(accountDetails, requiredParameters, endpoint)
+        return super(UGMobile, self).charge(feature_name, accountDetails, requiredParameters, endpoint)
 

rave_python/rave_virtualaccount.py

@@ -59,11 +59,6 @@ def _handleCreateResponse(self, response, accountDetails):
     #function to create a virtual card 
     #Params: cardDetails - a dict containing email, is_permanent, frequency, duration, narration
     def create(self, accountDetails):
-        
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Create-virtual-account"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
 
         # feature logic
         accountDetails = copy.copy(accountDetails)
@@ -72,4 +67,17 @@ def create(self, accountDetails):
         checkIfParametersAreComplete(requiredParameters, accountDetails)
         endpoint = self._baseUrl + self._endpointMap["virtual_account"]["create"]
         response = requests.post(endpoint, headers=self.headers, data=json.dumps(accountDetails))
+
+        #feature logging
+        if response.ok == False:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Create-virtual-account-error","message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+        else:
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Create-virtual-account","message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+
         return self._handleCreateResponse(response, accountDetails)