add regex-sampling (#17)

Author: HzANut

moesifpythonrequest/app_config/app_config.py

@@ -1,10 +1,14 @@
 from datetime import datetime
 from moesifapi.exceptions.api_exception import *
 import json
+from .regex_config_helper import RegexConfigHelper
 
 
 # Application Configuration
 class AppConfig:
+    def __init__(self):
+        self.regex_config_helper = RegexConfigHelper()
+        return
 
     def get_config(self, api_client, debug):
         """Get Config"""
@@ -27,19 +31,36 @@ def parse_configuration(self, config, 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):
+    def get_sampling_percentage(self, event_data, config, user_id, company_id):
         """Get sampling percentage"""
 
-        config_body = json.loads(config.raw_body)
+        if config is not None:
+            try:
+                config_body = json.loads(config.raw_body)
 
-        user_sample_rate = config_body.get('user_sample_rate', None)
+                user_sample_rate = config_body.get('user_sample_rate', None)
 
-        company_sample_rate = config_body.get('company_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]
+                regex_config = config_body.get('regex_config', None)
 
-        if company_id and company_sample_rate and company_id in company_sample_rate:
-            return company_sample_rate[company_id]
+                if regex_config:
+                    config_mapping = self.regex_config_helper.prepare_config_mapping(event_data)
+                    regex_sample_rate = self.regex_config_helper.fetch_sample_rate_on_regex_match(regex_config, config_mapping)
+                    if regex_sample_rate:
+                        return regex_sample_rate
 
-        return config_body.get('sample_rate', 100)
+                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)
+
+            except Exception as e:
+                print("Error while parsing user or company sample rate")
+                print(e)
+
+        # Use default
+        return 100

moesifpythonrequest/app_config/regex_config_helper.py

@@ -0,0 +1,98 @@
+import re
+
+
+class RegexConfigHelper:
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def prepare_config_mapping(cls, event):
+        """
+        Function to prepare config mapping
+        Args:
+            event: Event to be logged
+        Return:
+            regex_config: Regex config mapping
+        """
+        regex_config = {}
+
+        # Config mapping for request.verb
+        if event.request.verb:
+            regex_config["request.verb"] = event.request.verb
+
+        # Config mapping for request.uri
+        if event.request.uri:
+            extracted = re.match(r"http[s]*://[^/]+(/[^?]+)", event.request.uri)
+            if extracted is not None:
+                route_mapping = extracted.group(1)
+            else:
+                route_mapping = '/'
+            regex_config["request.route"] = route_mapping
+
+        # Config mapping for request.ip_address
+        if event.request.ip_address:
+            regex_config["request.ip_address"] = event.request.ip_address
+
+        # Config mapping for response.status
+        if event.response.status:
+            regex_config["response.status"] = event.response.status
+
+        return regex_config
+
+    @classmethod
+    def regex_match(cls, event_value, condition_value):
+        """
+        Function to perform the regex matching with event value and condition value
+        Args:
+            event_value: Value associated with event (request)
+            condition_value: Value associated with the regex config condition
+        Return:
+             regex_matched: Regex matched value to determine if the regex match was successful
+        """
+        extracted = re.search(condition_value, event_value)
+        if extracted is not None:
+            return extracted.group(0)
+
+    def fetch_sample_rate_on_regex_match(self, regex_configs, config_mapping):
+        """
+        Function to fetch the sample rate and determine if request needs to be block or not
+        Args:
+            regex_configs: Regex configs
+            config_mapping: Config associated with the request
+        Return:
+            sample_rate: Sample rate
+        """
+        # Iterate through the list of regex configs
+        for regex_rule in regex_configs:
+            # Fetch the sample rate
+            sample_rate = regex_rule["sample_rate"]
+            # Fetch the conditions
+            conditions = regex_rule["conditions"]
+            # Bool flag to determine if the regex conditions are matched
+            regex_matched = None
+            # Create a table to hold the conditions mapping (path and value)
+            condition_table = {}
+            # Iterate through the regex rule conditions and map the path and value
+            for condition in conditions:
+                # Add condition path -> value to the condition table
+                condition_table[condition["path"]] = condition["value"]
+            # Iterate through conditions table and perform `and` operation between each conditions
+            for path, values in condition_table.items():
+                # Check if the path exists in the request config mapping
+                if config_mapping[path]:
+                    # Fetch the value of the path in request config mapping
+                    event_data = config_mapping[path]
+                    # Perform regex matching with event value
+                    regex_matched = self.regex_match(event_data, values)
+                else:
+                    # Path does not exists in request config mapping, so no need to match regex condition rule
+                    regex_matched = False
+                # If one of the rule does not match, skip the condition & avoid matching other rules for the same condition
+                if not regex_matched:
+                    break
+            # If regex conditions matched, return sample rate
+            if regex_matched:
+                return sample_rate
+        # If regex conditions are not matched, return sample rate as None and will use default sample rate
+        return None

moesifpythonrequest/send_moesif/send_moesif.py

@@ -49,7 +49,7 @@ def send_moesif_async(self, event_model):
                 print("Can not execute MASK_EVENT_MODEL function. Please check moesif settings.")
 
         random_percentage = random.random() * 100
-        gv.sampling_percentage = gv.app_config.get_sampling_percentage(gv.config, event_model.user_id, event_model.company_id)
+        gv.sampling_percentage = gv.app_config.get_sampling_percentage(event_model, 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)

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.2.0',
+    version='0.3.0',
 
     description='Moesif Python request',
     long_description=long_description,