merged with dev

Author: Matias Melograno

CHANGES.txt

@@ -1,3 +1,7 @@
+8.1.3 (Oct XX, 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.2 (Jul 19, 2019)
  - Validated TLS support for redis connections
  - Fixed traffic type count issue

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:
@@ -29,7 +29,7 @@ except TimeoutException:
     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/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/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

@@ -68,9 +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
         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

splitio/storage/__init__.py

@@ -5,6 +5,7 @@
 
 from six import add_metaclass
 
+
 @add_metaclass(abc.ABCMeta)
 class SplitStorage(object):
     """Split storage interface implemented as an abstract class."""
@@ -21,6 +22,18 @@ def get(self, split_name):
         """
         pass
 
+    @abc.abstractmethod
+    def fetch_many(self, split_names):
+        """
+        Retrieve splits.
+
+        :param split_names: Names of the features to fetch.
+        :type split_names: list(str)
+
+        :rtype: dict
+        """
+        pass
+
     @abc.abstractmethod
     def put(self, split):
         """

splitio/storage/inmemmory.py

@@ -36,6 +36,18 @@ def get(self, split_name):
         with self._lock:
             return self._splits.get(split_name)
 
+    def fetch_many(self, split_names):
+        """
+        Retrieve splits.
+
+        :param split_names: Names of the features to fetch.
+        :type split_name: list(str)
+
+        :return: A dict with split objects parsed from queue.
+        :rtype: dict(split_name, splitio.models.splits.Split)
+        """
+        return {split_name: self.get(split_name) for split_name in split_names}
+
     def put(self, split):
         """
         Store a split.