added latency and statusCode checks for monitoring tool on account, transfer and verify services

Author: korneliosyaovi

rave_python/rave_account.py

@@ -44,9 +44,7 @@ def charge(self, accountDetails, hasFailed=False):
 
         # setting the endpoint
         endpoint = self._baseUrl + self._endpointMap['account']['charge']
-        # tracking_endpoint = self._trackingMap
-        # tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Initiate Account charge"}
-        # tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+        feature_name = "Initiate-Account-charge"
 
         # It is faster to just update rather than check if it is already present
         accountDetails.update({'payment_type': 'account'})
@@ -57,8 +55,9 @@ def charge(self, accountDetails, hasFailed=False):
         # Checking for required account components
         requiredParameters = ['accountbank', 'accountnumber', 'amount', 'email', 'phonenumber', 'IP']
 
-        return super().charge(accountDetails, requiredParameters, endpoint)
+        return super().charge(feature_name, accountDetails, requiredParameters, endpoint)
 
     def verify(self, txRef):
         endpoint = self._baseUrl + self._endpointMap['account']['verify']
-        return super().verify(txRef, endpoint)
+        feature_name = "Account-charge-verify"
+        return super().verify(feature_name, txRef, endpoint)

rave_python/rave_transfer.py

@@ -47,13 +47,8 @@ def _handleBulkResponse(self, response, bulkDetails):
 
     def initiate(self, transferDetails):
 
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Initiate-Transfer"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
 
         ## feature logic
-        
         # Performing shallow copy of transferDetails to avoid public exposing payload with secret key
         transferDetails = copy.copy(transferDetails)
 
@@ -74,17 +69,24 @@ def initiate(self, transferDetails):
 
         endpoint = self._baseUrl + self._endpointMap["transfer"]["initiate"]
         response = requests.post(endpoint, headers=headers, data=json.dumps(transferDetails))
+
+        if response.ok == False:
+            #feature logging
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Initiate-Transfer-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": "Initiate-Transfer","message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
         return self._handleInitiateResponse(response, transferDetails)
 
 
 
     def bulk(self, bulkDetails):
 
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Initiate-bulk-Transfer"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-        
         # feature logic
         bulkDetails = copy.copy(bulkDetails)
 
@@ -104,11 +106,24 @@ def bulk(self, bulkDetails):
             'content-type': 'application/json',
         }
         response = requests.post(endpoint, headers=headers, data=json.dumps(bulkDetails))
+        
+        if response.ok == False:
+            #feature logging
+            tracking_endpoint = self._trackingMap
+            responseTime = response.elapsed.total_seconds()
+            tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Initiate-Bulk-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": "Initiate-Bulk","message": responseTime}
+            tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
+
         return self._handleBulkResponse(response, bulkDetails)
 
 
     # This makes and handles all requests pertaining to the status of your transfer or account
-    def _handleTransferStatusRequests(self, endpoint, isPostRequest=False, data=None):
+    def _handleTransferStatusRequests(self, endpoint, feature_name, isPostRequest=False, data=None):
 
         # Request headers
         headers = {
@@ -129,52 +144,43 @@ def _handleTransferStatusRequests(self, endpoint, isPostRequest=False, data=None
 
         # Checks if it returns a 2xx code
         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))
             return {"error": False, "returnedData": responseJson}
         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}
             raise TransferFetchError({"error": True, "returnedData": responseJson })
 
     # Not elegant but supports python 2 and 3
     def fetch(self, reference=None):
 
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Fetch-Transfer"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-        
         #feature logic
+        label = "Fetch-Transfer"
         endpoint = self._baseUrl + self._endpointMap["transfer"]["fetch"] + "?seckey="+self._getSecretKey()+'&reference='+str(reference)
-        return self._handleTransferStatusRequests(endpoint)
+        return self._handleTransferStatusRequests(label, endpoint)
 
     def all(self):
 
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "List-all-Transfers"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-
         #feature logic
+        label = "List-all-Transfers"
         endpoint = self._baseUrl + self._endpointMap["transfer"]["fetch"] + "?seckey="+self._getSecretKey()
-        return self._handleTransferStatusRequests(endpoint)
+        return self._handleTransferStatusRequests(label, endpoint)
 
     def getFee(self, currency=None):
 
-        # feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Get-Transfer-fee-by-Currency"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-        
         # feature logic
+        label = "Get-Transfer-fee-by-Currency"
         endpoint = self._baseUrl + self._endpointMap["transfer"]["fee"] + "?seckey="+self._getSecretKey() + "&currency="+str(currency)
-        return self._handleTransferStatusRequests(endpoint)
+        return self._handleTransferStatusRequests(label, endpoint)
 
     def getBalance(self, currency):
 
-        # feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "Get-Balance-fee-by-Currency"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
-        
         # feature logic
+        label = "Get-Balance-fee-by-Currency"
         if not currency: # i made currency compulsory because if it is not assed in, an error message is returned from the server
             raise IncompletePaymentDetailsError("currency", ["currency"])
         endpoint =  self._baseUrl + self._endpointMap["transfer"]["balance"] 
@@ -183,7 +189,7 @@ def getBalance(self, currency):
             "currency": currency
         }
 
-        return self._handleTransferStatusRequests(endpoint, data=data, isPostRequest=True)
+        return self._handleTransferStatusRequests(label, endpoint, data=data, isPostRequest=True)
 
 
 

rave_python/rave_verify.py

@@ -34,7 +34,7 @@ def _preliminaryResponseChecks(self, response, TypeOfErrorToRaise, name):
     #     else:
     #         raise CardCreationError({"error": True, "data": responseJson["data"]})
 
-    def _handleVerifyStatusRequests(self, endpoint, isPostRequest=False, data=None):
+    def _handleVerifyStatusRequests(self, endpoint, feature_name, isPostRequest=False, data=None):
         self.headers = {
             'content-type' : 'application/json'
         }
@@ -51,19 +51,25 @@ def _handleVerifyStatusRequests(self, endpoint, isPostRequest=False, data=None):
             raise ServerError({"error": True, "errMsg": response.text})
 
         if response.ok:
+            #feature logging
+            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))
             return {"error": False, "returnedData": responseJson}
         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))
+
             raise BVNFetchError({"error": True, "returnedData": responseJson })
 
     def bvnVerify(self, bvn):
-        
-        #feature logging
-        tracking_endpoint = self._trackingMap
-        tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.5", "title": "Incoming call","message": "BVN-verification"}
-        tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
 
         # feature logic
         if not bvn:
             return "BVN was not supplied. Kindly supply one"
+        feature_name = "BVN-verification"
         endpoint = self._baseUrl + self._endpointMap["bvn"]["verify"] +str(bvn)+"?seckey=" + self._getSecretKey()
-        return self._handleVerifyStatusRequests(endpoint)
+        return self._handleVerifyStatusRequests(endpoint, feature_name)

rave_python/rave_zbmobile.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": "mobilemoneyzambia", "country":"NG", "is_mobile_money_ug":"1", "currency":"ZMW", "network": "MTN"})
@@ -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(ZBMobile, self).charge(accountDetails, requiredParameters, endpoint)
+        return super(ZBMobile, self).charge(feature_name, accountDetails, requiredParameters, endpoint)