Merge pull request #156 from splitio/development

Development

Author: mmelograno

CHANGES.txt

@@ -1,3 +1,7 @@
+8.1.4 (Oct 14, 2019)
+ - Added logic to fetch multiple splits at once on get_treatments/get_treatments_with_config.
+ - Added flag `ipAddressesEnabled` into config to enable/disable sending machineName and machineIp when data is posted in headers.
+
 8.1.3 (Oct 4, 2019)
  - Fixed race condition related to segment fetching and SDK_READY event
 

README.md

@@ -7,7 +7,7 @@ This SDK is designed to work with Split, the platform for controlled rollouts, w
 [![Twitter Follow](https://img.shields.io/twitter/follow/splitsoftware.svg?style=social&label=Follow&maxAge=1529000)](https://twitter.com/intent/follow?screen_name=splitsoftware)
 
 ## Compatibility
-This SDK is compatible with Python 2.7 and higher.
+This SDK is compatible with **Python 2.7 and higher**.
 
 ## Getting started
 Below is a simple example that describes the instantiation and most basic usage of our SDK:
@@ -22,14 +22,20 @@ factory = get_factory('YOUR_SDK_TYPE_API_KEY', config=config)
 try:
     factory.block_until_ready(5) # wait up to 5 seconds
     split = factory.client()
-    print(split.get_treatment('CUSTOMER_ID', 'SPLIT_NAME'))
+    treatment = split.get_treatment('CUSTOMER_ID', 'SPLIT_NAME')
+    if treatment == "on": 
+        # insert code here to show on treatment
+    elif treatment == "off":
+        # insert code here to show off treatment
+    else:
+        # insert your control treatment code here
 except TimeoutException:
     # Now the user can choose whether to abort the whole execution, or just keep going
     # without a ready client, which if configured properly, should become ready at some point.
     pass
 ```
 
-Please refer to [our official docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK)) to learn about all the functionality provided by our SDK and the configuration options available for tailoring it to your current application setup.
+Please refer to [our official docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK) to learn about all the functionality provided by our SDK and the configuration options available for tailoring it to your current application setup.
 
 ## Submitting issues
 The Split team monitors all issues submitted to this [issue tracker](https://github.com/splitio/python-client/issues). We encourage you to use this issue tracker to submit any bug reports, feedback, and feature enhancements. We'll do our best to respond in a timely manner.

splitio/api/__init__.py

@@ -1,5 +1,6 @@
 """Split API module."""
 
+
 class APIException(Exception):
     """Exception to raise when an API call fails."""
 
@@ -28,4 +29,6 @@ def headers_from_metadata(sdk_metadata):
         'SplitSDKVersion': sdk_metadata.sdk_version,
         'SplitSDKMachineIP': sdk_metadata.instance_ip,
         'SplitSDKMachineName': sdk_metadata.instance_name
+    } if sdk_metadata.instance_ip != 'NA' and sdk_metadata.instance_ip != 'unknown' else {
+        'SplitSDKVersion': sdk_metadata.sdk_version,
     }

splitio/client/client.py

@@ -96,14 +96,13 @@ def _evaluate_if_ready(self, matching_key, bucketing_key, feature, attributes=No
                 }
             }
 
-        return self._evaluator.evaluate_treatment(
+        return self._evaluator.evaluate_feature(
             feature,
             matching_key,
             bucketing_key,
             attributes
         )
 
-
     def get_treatment_with_config(self, key, feature, attributes=None):
         """
         Get the treatment and config for a feature and key, with optional dictionary of attributes.
@@ -131,7 +130,7 @@ def get_treatment_with_config(self, key, feature, attributes=None):
             feature = input_validator.validate_feature_name(
                 feature,
                 self.ready,
-                self._factory._get_storage('splits')  #pylint: disable=protected-access
+                self._factory._get_storage('splits')  # pylint: disable=protected-access
             )
 
             if (matching_key is None and bucketing_key is None) \
@@ -193,6 +192,24 @@ def get_treatment(self, key, feature, attributes=None):
         treatment, _ = self.get_treatment_with_config(key, feature, attributes)
         return treatment
 
+    def _evaluate_features_if_ready(self, matching_key, bucketing_key, features, attributes=None):
+        if not self.ready:
+            return {
+                feature: {
+                    'treatment': CONTROL,
+                    'configurations': None,
+                    'impression': {'label': Label.NOT_READY, 'change_number': None}
+                }
+                for feature in features
+            }
+
+        return self._evaluator.evaluate_features(
+            features,
+            matching_key,
+            bucketing_key,
+            attributes
+        )
+
     def get_treatments_with_config(self, key, features, attributes=None):
         """
         Evaluate multiple features and return a dict with feature -> (treatment, config).
@@ -233,39 +250,47 @@ def get_treatments_with_config(self, key, features, attributes=None):
         bulk_impressions = []
         treatments = {name: (CONTROL, None) for name in missing}
 
-        for feature in features:
+        try:
+            evaluations = self._evaluate_features_if_ready(matching_key, bucketing_key,
+                                                           list(features), attributes)
+
+            for feature in features:
+                try:
+                    result = evaluations[feature]
+                    impression = self._build_impression(matching_key,
+                                                        feature,
+                                                        result['treatment'],
+                                                        result['impression']['label'],
+                                                        result['impression']['change_number'],
+                                                        bucketing_key,
+                                                        start)
+
+                    bulk_impressions.append(impression)
+                    treatments[feature] = (result['treatment'], result['configurations'])
+
+                except Exception:  # pylint: disable=broad-except
+                    self._logger.error('get_treatments: An exception occured when evaluating '
+                                       'feature ' + feature + ' returning CONTROL.')
+                    treatments[feature] = CONTROL, None
+                    self._logger.debug('Error: ', exc_info=True)
+                    continue
+
+            # Register impressions
             try:
-                result = self._evaluate_if_ready(matching_key, bucketing_key, feature, attributes)
-                impression = self._build_impression(matching_key,
-                                                    feature,
-                                                    result['treatment'],
-                                                    result['impression']['label'],
-                                                    result['impression']['change_number'],
-                                                    bucketing_key,
-                                                    start)
-
-                bulk_impressions.append(impression)
-                treatments[feature] = (result['treatment'], result['configurations'])
-
+                if bulk_impressions:
+                    self._record_stats(bulk_impressions, start, self._METRIC_GET_TREATMENTS)
+                    for impression in bulk_impressions:
+                        self._send_impression_to_listener(impression, attributes)
             except Exception:  # pylint: disable=broad-except
-                self._logger.error('get_treatments: An exception occured when evaluating '
-                                   'feature ' + feature + ' returning CONTROL.')
-                treatments[feature] = CONTROL, None
+                self._logger.error('get_treatments: An exception when trying to store '
+                                   'impressions.')
                 self._logger.debug('Error: ', exc_info=True)
-                continue
 
-        # Register impressions
-        try:
-            if bulk_impressions:
-                self._record_stats(bulk_impressions, start, self._METRIC_GET_TREATMENTS)
-                for impression in bulk_impressions:
-                    self._send_impression_to_listener(impression, attributes)
+            return treatments
         except Exception:  # pylint: disable=broad-except
-            self._logger.error('get_treatments: An exception when trying to store '
-                               'impressions.')
+            self._logger.error('Error getting treatment for features')
             self._logger.debug('Error: ', exc_info=True)
-
-        return treatments
+        return input_validator.generate_control_treatments(list(features))
 
     def get_treatments(self, key, features, attributes=None):
         """
@@ -354,11 +379,11 @@ def track(self, key, traffic_type, event_type, value=None, properties=None):
 
         key = input_validator.validate_track_key(key)
         event_type = input_validator.validate_event_type(event_type)
-        should_validate_existance = self.ready and self._factory._apikey != 'localhost' #pylint: disable=protected-access
+        should_validate_existance = self.ready and self._factory._apikey != 'localhost'  # pylint: disable=protected-access
         traffic_type = input_validator.validate_traffic_type(
             traffic_type,
             should_validate_existance,
-            self._factory._get_storage('splits'), #pylint: disable=protected-access
+            self._factory._get_storage('splits'),  # pylint: disable=protected-access
         )
 
         value = input_validator.validate_value(value)

splitio/client/config.py

@@ -16,6 +16,7 @@
     'eventsBulkSize': 5000,
     'eventsQueueSize': 10000,
     'labelsEnabled': True,
+    'ipAddressesEnabled': True,
     'impressionListener': None,
     'redisHost': 'localhost',
     'redisPort': 6379,

splitio/client/manager.py

@@ -18,7 +18,7 @@ def __init__(self, factory):
         """
         self._logger = logging.getLogger(self.__class__.__name__)
         self._factory = factory
-        self._storage = factory._get_storage('splits')  #pylint: disable=protected-access
+        self._storage = factory._get_storage('splits')  # pylint: disable=protected-access
 
     def split_names(self):
         """

splitio/client/util.py

@@ -17,7 +17,7 @@ def _get_ip():
         # doesn't even have to be reachable
         sock.connect(('10.255.255.255', 1))
         ip_address = sock.getsockname()[0]
-    except Exception:  #pylint: disable=broad-except
+    except Exception:  # pylint: disable=broad-except
         ip_address = 'unknown'
     finally:
         sock.close()
@@ -28,6 +28,16 @@ def _get_hostname(ip_address):
     return 'unknown' if ip_address == 'unknown' else 'ip-' + ip_address.replace('.', '-')
 
 
+def _get_hostname_and_ip(config):
+    if config.get('ipAddressesEnabled') is False:
+        return 'NA', 'NA'
+    ip_from_config = config.get('machineIp')
+    machine_from_config = config.get('machineName')
+    ip_address = ip_from_config if ip_from_config is not None else _get_ip()
+    hostname = machine_from_config if machine_from_config is not None else _get_hostname(ip_address)
+    return ip_address, hostname
+
+
 def get_metadata(config):
     """
     Gather SDK metadata and return a tuple with such info.
@@ -39,10 +49,7 @@ def get_metadata(config):
     :rtype: SdkMetadata
     """
     version = 'python-%s' % __version__
-    ip_from_config = config.get('machineIp')
-    machine_from_config = config.get('machineName')
-    ip_address = ip_from_config if ip_from_config is not None else _get_ip()
-    hostname = machine_from_config if machine_from_config is not None else _get_hostname(ip_address)
+    ip_address, hostname = _get_hostname_and_ip(config)
     return SdkMetadata(version, hostname, ip_address)
 
 
@@ -61,7 +68,7 @@ def get_calls(classes_filter=None):
             inspect.getframeinfo(frame[0]).function
             for frame in inspect.stack()
             if classes_filter is None
-            or 'self' in frame[0].f_locals and frame[0].f_locals['self'].__class__.__name__ in classes_filter  #pylint: disable=line-too-long
+            or 'self' in frame[0].f_locals and frame[0].f_locals['self'].__class__.__name__ in classes_filter  # pylint: disable=line-too-long
         ]
-    except Exception:  #pylint: disable=broad-except
+    except Exception:  # pylint: disable=broad-except
         return []

splitio/engine/evaluator.py

@@ -1,5 +1,6 @@
 """Split evaluator module."""
 import logging
+import six
 from splitio.models.grammar.condition import ConditionType
 from splitio.models.impressions import Label
 
@@ -25,8 +26,7 @@ def __init__(self, split_storage, segment_storage, splitter):
         self._segment_storage = segment_storage
         self._splitter = splitter
 
-    def evaluate_treatment(self, feature, matching_key,
-                           bucketing_key, attributes=None):
+    def _evaluate_treatment(self, feature, matching_key, bucketing_key, attributes, split):
         """
         Evaluate the user submitted data against a feature and return the resulting treatment.
 
@@ -42,20 +42,19 @@ def evaluate_treatment(self, feature, matching_key,
         :param attributes: An optional dictionary of attributes
         :type attributes: dict
 
+        :param split: Split object
+        :type attributes: splitio.models.splits.Split|None
+
         :return: The treatment for the key and split
         :rtype: object
         """
         label = ''
         _treatment = CONTROL
         _change_number = -1
 
-        # Fetching Split definition
-        split = self._split_storage.get(feature)
-
         if split is None:
             self._logger.warning('Unknown or invalid feature: %s', feature)
             label = Label.SPLIT_NOT_FOUND
-            _treatment = CONTROL
         else:
             _change_number = split.change_number
             if split.killed:
@@ -83,6 +82,70 @@ def evaluate_treatment(self, feature, matching_key,
             }
         }
 
+    def evaluate_feature(self, feature, matching_key, bucketing_key, attributes=None):
+        """
+        Evaluate the user submitted data against a feature and return the resulting treatment.
+
+        :param feature: The feature for which to get the treatment
+        :type feature:  str
+
+        :param matching_key: The matching_key for which to get the treatment
+        :type matching_key: str
+
+        :param bucketing_key: The bucketing_key for which to get the treatment
+        :type bucketing_key: str
+
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: The treatment for the key and split
+        :rtype: object
+        """
+        # Fetching Split definition
+        split = self._split_storage.get(feature)
+
+        # Calling evaluation
+        evaluation = self._evaluate_treatment(feature, matching_key,
+                                              bucketing_key, attributes, split)
+
+        return evaluation
+
+    def evaluate_features(self, features, matching_key, bucketing_key, attributes=None):
+        """
+        Evaluate the user submitted data against multiple features and return the resulting
+        treatment.
+
+        :param features: The features for which to get the treatments
+        :type feature:  list(str)
+
+        :param matching_key: The matching_key for which to get the treatment
+        :type matching_key: str
+
+        :param bucketing_key: The bucketing_key for which to get the treatment
+        :type bucketing_key: str
+
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: The treatments for the key and splits
+        :rtype: object
+        """
+        evaluations = dict()
+
+        # Fetching Split definition
+        splits = self._split_storage.fetch_many(features)
+        # Calling evaluations
+        for feature in features:
+            split = splits[feature]
+            evaluations[feature] = self._evaluate_treatment(feature, matching_key,
+                                                            bucketing_key, attributes, split)
+        return evaluations
+        return {
+            feature: self._evaluate_treatment(feature, matching_key,
+                                              bucketing_key, attributes, split)
+            for (feature, split) in six.iteritems(self._split_storage.fetch_many(features))
+        }
+
     def _get_treatment_for_split(self, split, matching_key, bucketing_key, attributes=None):
         """
         Evaluate the feature considering the conditions.

splitio/models/grammar/matchers/misc.py

@@ -41,7 +41,7 @@ def _match(self, key, attributes=None, context=None):
 
         bucketing_key = context.get('bucketing_key')
 
-        result = evaluator.evaluate_treatment(self._split_name, key, bucketing_key, attributes)
+        result = evaluator.evaluate_feature(self._split_name, key, bucketing_key, attributes)
         return result['treatment'] in self._treatments
 
     def _add_matcher_specific_properties_to_json(self):

splitio/models/impressions.py

@@ -19,7 +19,7 @@
 )
 
 
-class Label(object):  #pylint: disable=too-few-public-methods
+class Label(object):  # pylint: disable=too-few-public-methods
     """Impressions labels."""
 
     # Condition: Split Was Killed