Add: User/Company sampling for outgoing events

Keyur · Keyur · commit 6ed0d93c8146 · 2019-12-20T11:04:53.000-08:00
Add: User/Company sampling for outgoing events
Add: Weight field to event
Refactor: Update moesifapi version to 1.3.2
Bump version to 0.2.0
diff --git a/moesifpythonrequest/app_config/__init__.py b/moesifpythonrequest/app_config/__init__.py
diff --git a/moesifpythonrequest/app_config/app_config.py b/moesifpythonrequest/app_config/app_config.py
@@ -0,0 +1,45 @@
+from datetime import datetime
+from moesifapi.exceptions.api_exception import *
+import json
+
+
+# Application Configuration
+class AppConfig:
+
+    def get_config(self, api_client, debug):
+        """Get Config"""
+        try:
+            config_api_response = api_client.get_app_config()
+            return config_api_response
+        except APIException as inst:
+            if 401 <= inst.response_code <= 403:
+                print("Unauthorized access getting application configuration. Please check your Appplication Id.")
+            if debug:
+                print("Error getting application configuration, with status code:")
+                print(inst.response_code)
+
+    def parse_configuration(self, config, debug):
+        """Parse configuration object and return Etag, sample rate and last updated time"""
+        try:
+            return config.headers.get("X-Moesif-Config-ETag"), json.loads(config.raw_body).get('sample_rate', 100), datetime.utcnow()
+        except:
+            if debug:
+                print('Error while parsing the configuration object, setting the sample rate to default')
+            return None, 100, datetime.utcnow()
+
+    def get_sampling_percentage(self, config, user_id, company_id):
+        """Get sampling percentage"""
+
+        config_body = json.loads(config.raw_body)
+
+        user_sample_rate = config_body.get('user_sample_rate', None)
+
+        company_sample_rate = config_body.get('company_sample_rate', None)
+
+        if user_id and user_sample_rate and user_id in user_sample_rate:
+            return user_sample_rate[user_id]
+
+        if company_id and company_sample_rate and company_id in company_sample_rate:
+            return company_sample_rate[company_id]
+
+        return config_body.get('sample_rate', 100)
diff --git a/moesifpythonrequest/global_variables.py b/moesifpythonrequest/global_variables.py
@@ -1,4 +1,5 @@
 """This module is to declare global objects."""
+from datetime import datetime
 
 # Configuration Options
 global moesif_options
@@ -11,3 +12,27 @@
 # Patch Flag
 global MOESIF_PATCH
 MOESIF_PATCH = False
+
+# MoesifAPI Client
+global api_client
+api_client = None
+
+# App Config class
+global app_config
+app_config = None
+
+# App Config
+global config
+config = None
+
+# App Config sampling percentage
+global sampling_percentage
+sampling_percentage = 100
+
+# App Config eTag
+global config_etag
+config_etag = None
+
+# App Config last updated time
+global last_updated_time
+last_updated_time = datetime.utcnow()
diff --git a/moesifpythonrequest/patch_request/patch_request.py b/moesifpythonrequest/patch_request/patch_request.py
@@ -3,7 +3,7 @@
 from ..utility_function.utility_function import UtilityFunction
 from ..outgoing_recorder.outgoing_recorder import OutgoingRecorder
 import requests
-from .. import global_variables
+from .. import global_variables as gv
 from requests import sessions
 
 
@@ -38,10 +38,10 @@ def new_session_function(session, method, url, params=None, data=None, headers=N
             end_time = utility_function.get_current_time()
 
             if not utility_function.is_moesif(headers, url):
-                generated_recorder = outgoing_recorder.prepare_recorder(global_variables.moesif_options, response.request, response, start_time, end_time)
+                generated_recorder = outgoing_recorder.prepare_recorder(gv.moesif_options, response.request, response, start_time, end_time)
 
                 if isinstance(generated_recorder, EventModel):
-                    moesif_response = recorder(global_variables.moesif_options.get('APPLICATION_ID'), generated_recorder)
+                    moesif_response = recorder(generated_recorder)
 
             return response
 
diff --git a/moesifpythonrequest/send_moesif/send_moesif.py b/moesifpythonrequest/send_moesif/send_moesif.py
@@ -1,44 +1,63 @@
 # Import Libraries
 from moesifapi.exceptions.api_exception import APIException
-from moesifapi.moesif_api_client import MoesifAPIClient, Configuration
-from .. import global_variables
+from .. import global_variables as gv
+from datetime import datetime, timedelta
 import threading
+import random
+import math
 
 
 class SendMoesif():
     # Function to send event to Moesif
-    def send_event(self, application_id, event_model):
-        if global_variables.moesif_options.get('LOCAL_DEBUG', False):
-            Configuration.BASE_URI = global_variables.moesif_options.get('LOCAL_MOESIF_BASEURL', 'https://api.moesif.net')
-
-        client = MoesifAPIClient(application_id)
-        api_client = client.api
+    def send_event(self, event_model):
         try:
-            if global_variables.DEBUG:
+            if gv.DEBUG:
                 print('Calling API to create event')
-            api_client.create_event(event_model)
-            if global_variables.DEBUG:
-                print("sent done")
+            event_api_response = gv.api_client.create_event(event_model)
+            event_response_config_etag = event_api_response.get("X-Moesif-Config-ETag")
+
+            if event_response_config_etag is not None \
+                    and gv.config_etag is not None \
+                    and gv.config_etag != event_response_config_etag \
+                    and datetime.utcnow() > gv.last_updated_time + timedelta(minutes=5):
+                try:
+                    gv.config = gv.app_config.get_config(gv.api_client, gv.DEBUG)
+                    self.config_etag, self.sampling_percentage, self.last_updated_time = gv.app_config.parse_configuration(
+                        gv.config, gv.DEBUG)
+                except:
+                    if gv.DEBUG:
+                        print('Error while updating the application configuration')
+            if gv.DEBUG:
+                print("Event sent successfully")
         except APIException as inst:
             if 401 <= inst.response_code <= 403:
                 print("Unauthorized access sending event to Moesif. Please check your Appplication Id.")
-            if global_variables.DEBUG:
+            if gv.DEBUG:
                 print("Error sending event to Moesif, with status code:")
                 print(inst.response_code)
 
     # Function to send event async
-    def send_moesif_async(self, applicaiton_id, event_model):
+    def send_moesif_async(self, event_model):
         try:
-            mask_event_model = global_variables.moesif_options.get('MASK_EVENT_MODEL', None)
+            mask_event_model = gv.moesif_options.get('MASK_EVENT_MODEL', None)
             if mask_event_model is not None:
-                if global_variables.DEBUG:
+                if gv.DEBUG:
                     print('Masking the event')
                 event_model = mask_event_model(event_model)
         except:
-            if global_variables.DEBUG:
+            if gv.DEBUG:
                 print("Can not execute MASK_EVENT_MODEL function. Please check moesif settings.")
 
-        sending_background_thread = threading.Thread(target=self.send_event, args=(applicaiton_id, event_model,))
-        if global_variables.DEBUG:
-            print('Staring a new thread')
-        sending_background_thread.start()
+        random_percentage = random.random() * 100
+        gv.sampling_percentage = gv.app_config.get_sampling_percentage(gv.config, event_model.user_id, event_model.company_id)
+
+        if gv.sampling_percentage >= random_percentage:
+            event_model.weight = 1 if gv.sampling_percentage == 0 else math.floor(100 / gv.sampling_percentage)
+            sending_background_thread = threading.Thread(target=self.send_event, args=(event_model,))
+            if gv.DEBUG:
+                print('Staring a new thread')
+            sending_background_thread.start()
+        else:
+            if gv.DEBUG:
+                print('Skipped Event due to sampling percentage: ' + str(
+                    gv.sampling_percentage) + ' and random percentage: ' + str(random_percentage))
diff --git a/moesifpythonrequest/start_capture/start_capture.py b/moesifpythonrequest/start_capture/start_capture.py
@@ -1,26 +1,49 @@
 # Import Libraries
-from .. import global_variables
+from .. import global_variables as gv
 from ..patch_request.patch_request import PatchRequest
 from ..send_moesif.send_moesif import SendMoesif
-
+from ..app_config.app_config import AppConfig
+from moesifapi.moesif_api_client import MoesifAPIClient, Configuration
 
 class StartCapture():
 
     # Start capturing the outgoing requests
     def start_capture_outgoing(self, options):
 
         # Check if the moesif_options are of dict type
-        global_variables.moesif_options = options
-        global_variables.DEBUG = global_variables.moesif_options.get('LOCAL_DEBUG', False)
+        gv.moesif_options = options
+        gv.DEBUG = gv.moesif_options.get('LOCAL_DEBUG', False)
 
-        if global_variables.MOESIF_PATCH:
+        if gv.MOESIF_PATCH:
             print('Already started patching the outgoing requests')
         else:
             print('Starting to patch the outgoing requests')
 
-            global_variables.MOESIF_PATCH = True
+            gv.MOESIF_PATCH = True
             # Create an instance of the class
             patch_instance = PatchRequest()
             send_async = SendMoesif()
+            gv.app_config = AppConfig()
+
+            if gv.DEBUG:
+                Configuration.BASE_URI = gv.moesif_options.get('LOCAL_MOESIF_BASEURL', 'https://api.moesif.net')
+
+            # Get the MoesifAPI client
+            if gv.moesif_options.get('APPLICATION_ID', None):
+                gv.api_client = MoesifAPIClient(gv.moesif_options.get('APPLICATION_ID')).api
+            else:
+                raise Exception('Moesif Application ID is required in moesif options')
+
+            # Get the application config
+            gv.config = gv.app_config.get_config(gv.api_client, gv.DEBUG)
+
+            # Parse the application config
+            try:
+                if gv.config:
+                    gv.config_etag, gv.sampling_percentage, gv.last_updated_time = gv.app_config.parse_configuration(
+                        gv.config, gv.DEBUG)
+            except:
+                if gv.DEBUG:
+                    print('Error while parsing application configuration on initialization')
 
             _unpatch = patch_instance.patch(send_async.send_moesif_async)
diff --git a/requirements.txt b/requirements.txt
@@ -1,2 +1,2 @@
 requests==2.20.0
-moesifapi==1.3.1
+moesifapi==1.3.2
diff --git a/setup.py b/setup.py
@@ -28,7 +28,7 @@
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version='0.1.12',
+    version='0.2.0',
 
     description='Moesif Python request',
     long_description=long_description,

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`requests==2.20.0`
`2`		`-moesifapi==1.3.1`
	`2`	`+moesifapi==1.3.2`