Merge pull request #143 from splitio/development

Development

Author: mmelograno

CHANGES.txt

@@ -1,3 +1,6 @@
+8.1.0 (3 Jun, 2019)
+ - Added properties to track method.
+ - Input Validation: added validation for traffic types, split names and multiple factory instantiation.
 8.0.0 (Apr 24, 2019)
  - Full SDK Refactor/rewrite.
  - New block until ready behaviour.

splitio/api/events.py

@@ -7,7 +7,7 @@
 from splitio.api.client import HttpClientException
 
 
-class EventsAPI(object):  #pylint: disable=too-few-public-methods
+class EventsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the events API."""
 
     def __init__(self, http_client, apikey, sdk_metadata):
@@ -43,7 +43,8 @@ def _build_bulk(events):
                 'trafficTypeName': event.traffic_type_name,
                 'eventTypeId': event.event_type_id,
                 'value': event.value,
-                'timestamp': event.timestamp
+                'timestamp': event.timestamp,
+                'properties': event.properties,
             }
             for event in events
         ]

splitio/api/impressions.py

@@ -9,7 +9,7 @@
 from splitio.api.client import HttpClientException
 
 
-class ImpressionsAPI(object): # pylint: disable=too-few-public-methods
+class ImpressionsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the impressions API."""
 
     def __init__(self, client, apikey, sdk_metadata):

splitio/client/client.py

@@ -8,13 +8,13 @@
 from splitio.engine.evaluator import Evaluator, CONTROL
 from splitio.engine.splitters import Splitter
 from splitio.models.impressions import Impression, Label
-from splitio.models.events import Event
+from splitio.models.events import Event, EventWrapper
 from splitio.models.telemetry import get_latency_bucket_index
 from splitio.client import input_validator
 from splitio.client.listener import ImpressionListenerException
 
 
-class Client(object):  #pylint: disable=too-many-instance-attributes
+class Client(object):  # pylint: disable=too-many-instance-attributes
     """Entry point for the split sdk."""
 
     _METRIC_GET_TREATMENT = 'sdk.getTreatment'
@@ -41,11 +41,11 @@ def __init__(self, factory, labels_enabled=True, impression_listener=None):
         self._impression_listener = impression_listener
 
         self._splitter = Splitter()
-        self._split_storage = factory._get_storage('splits')  #pylint: disable=protected-access
-        self._segment_storage = factory._get_storage('segments')  #pylint: disable=protected-access
-        self._impressions_storage = factory._get_storage('impressions')  #pylint: disable=protected-access
-        self._events_storage = factory._get_storage('events')  #pylint: disable=protected-access
-        self._telemetry_storage = factory._get_storage('telemetry')  #pylint: disable=protected-access
+        self._split_storage = factory._get_storage('splits')  # pylint: disable=protected-access
+        self._segment_storage = factory._get_storage('segments')  # pylint: disable=protected-access
+        self._impressions_storage = factory._get_storage('impressions')  # pylint: disable=protected-access
+        self._events_storage = factory._get_storage('events')  # pylint: disable=protected-access
+        self._telemetry_storage = factory._get_storage('telemetry')  # pylint: disable=protected-access
         self._evaluator = Evaluator(self._split_storage, self._segment_storage, self._splitter)
 
     def destroy(self):
@@ -85,6 +85,25 @@ def _send_impression_to_listener(self, impression, attributes):
                 )
                 self._logger.debug('Error', exc_info=True)
 
+    def _evaluate_if_ready(self, matching_key, bucketing_key, feature, attributes=None):
+        if not self.ready:
+            return {
+                'treatment': CONTROL,
+                'configurations': None,
+                'impression': {
+                    'label': Label.NOT_READY,
+                    'change_number': None
+                }
+            }
+
+        return self._evaluator.evaluate_treatment(
+            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.
@@ -109,19 +128,18 @@ def get_treatment_with_config(self, key, feature, attributes=None):
             start = int(round(time.time() * 1000))
 
             matching_key, bucketing_key = input_validator.validate_key(key)
-            feature = input_validator.validate_feature_name(feature)
+            feature = input_validator.validate_feature_name(
+                feature,
+                self.ready,
+                self._factory._get_storage('splits')  #pylint: disable=protected-access
+            )
 
             if (matching_key is None and bucketing_key is None) \
                     or feature is None \
                     or not input_validator.validate_attributes(attributes):
                 return CONTROL, None
 
-            result = self._evaluator.evaluate_treatment(
-                feature,
-                matching_key,
-                bucketing_key,
-                attributes
-            )
+            result = self._evaluate_if_ready(matching_key, bucketing_key, feature, attributes)
 
             impression = self._build_impression(
                 matching_key,
@@ -136,7 +154,7 @@ def get_treatment_with_config(self, key, feature, attributes=None):
             self._record_stats(impression, start, self._METRIC_GET_TREATMENT)
             self._send_impression_to_listener(impression, attributes)
             return result['treatment'], result['configurations']
-        except Exception:  #pylint: disable=broad-except
+        except Exception:  # pylint: disable=broad-except
             self._logger.error('Error getting treatment for feature')
             self._logger.debug('Error: ', exc_info=True)
             try:
@@ -204,34 +222,32 @@ def get_treatments_with_config(self, key, features, attributes=None):
         if input_validator.validate_attributes(attributes) is False:
             return input_validator.generate_control_treatments(features)
 
-        features = input_validator.validate_features_get_treatments(features)
+        features, missing = input_validator.validate_features_get_treatments(
+            features,
+            self.ready,
+            self._factory._get_storage('splits')  # pylint: disable=protected-access
+        )
         if features is None:
             return {}
 
         bulk_impressions = []
-        treatments = {}
+        treatments = {name: (CONTROL, None) for name in missing}
 
         for feature in features:
             try:
-                treatment = self._evaluator.evaluate_treatment(
-                    feature,
-                    matching_key,
-                    bucketing_key,
-                    attributes
-                )
-
+                result = self._evaluate_if_ready(matching_key, bucketing_key, feature, attributes)
                 impression = self._build_impression(matching_key,
                                                     feature,
-                                                    treatment['treatment'],
-                                                    treatment['impression']['label'],
-                                                    treatment['impression']['change_number'],
+                                                    result['treatment'],
+                                                    result['impression']['label'],
+                                                    result['impression']['change_number'],
                                                     bucketing_key,
                                                     start)
 
                 bulk_impressions.append(impression)
-                treatments[feature] = (treatment['treatment'], treatment['configurations'])
+                treatments[feature] = (result['treatment'], result['configurations'])
 
-            except Exception:  #pylint: disable=broad-except
+            except Exception:  # pylint: disable=broad-except
                 self._logger.error('get_treatments: An exception occured when evaluating '
                                    'feature ' + feature + ' returning CONTROL.')
                 treatments[feature] = CONTROL, None
@@ -244,14 +260,13 @@ def get_treatments_with_config(self, key, features, attributes=None):
                 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
+        except Exception:  # pylint: disable=broad-except
             self._logger.error('get_treatments: An exception when trying to store '
                                'impressions.')
             self._logger.debug('Error: ', exc_info=True)
 
         return treatments
 
-
     def get_treatments(self, key, features, attributes=None):
         """
         Evaluate multiple features and return a dictionary with all the feature/treatments.
@@ -271,7 +286,7 @@ def get_treatments(self, key, features, attributes=None):
         with_config = self.get_treatments_with_config(key, features, attributes)
         return {feature: result[0] for (feature, result) in six.iteritems(with_config)}
 
-    def _build_impression(  #pylint: disable=too-many-arguments
+    def _build_impression(  # pylint: disable=too-many-arguments
             self,
             matching_key,
             feature_name,
@@ -311,11 +326,11 @@ def _record_stats(self, impressions, start, operation):
             else:
                 self._impressions_storage.put(impressions)
             self._telemetry_storage.inc_latency(operation, get_latency_bucket_index(end - start))
-        except Exception:  #pylint: disable=broad-except
+        except Exception:  # pylint: disable=broad-except
             self._logger.error('Error recording impressions and metrics')
             self._logger.debug('Error: ', exc_info=True)
 
-    def track(self, key, traffic_type, event_type, value=None):
+    def track(self, key, traffic_type, event_type, value=None, properties=None):
         """
         Track an event.
 
@@ -327,6 +342,8 @@ def track(self, key, traffic_type, event_type, value=None):
         :type event_type: str
         :param value: (Optional) value associated to the event
         :type value: Number
+        :param properties: (Optional) properties associated to the event
+        :type properties: dict
 
         :return: Whether the event was created or not.
         :rtype: bool
@@ -337,17 +354,29 @@ def track(self, key, traffic_type, event_type, value=None):
 
         key = input_validator.validate_track_key(key)
         event_type = input_validator.validate_event_type(event_type)
-        traffic_type = input_validator.validate_traffic_type(traffic_type)
+        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
+        )
+
         value = input_validator.validate_value(value)
+        valid, properties, size = input_validator.valid_properties(properties)
 
-        if key is None or event_type is None or traffic_type is None or value is False:
+        if key is None or event_type is None or traffic_type is None or value is False \
+           or valid is False:
             return False
 
         event = Event(
             key=key,
             traffic_type_name=traffic_type,
             event_type_id=event_type,
             value=value,
-            timestamp=int(time.time()*1000)
+            timestamp=int(time.time()*1000),
+            properties=properties,
         )
-        return self._events_storage.put([event])
+        return self._events_storage.put([EventWrapper(
+            event=event,
+            size=size,
+        )])