Merge pull request #138 from splitio/feature/input-validation-v2-traffic-types

Feature/input validation v2 traffic types

Author: mredolatti

splitio/client/client.py

@@ -337,7 +337,13 @@ 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)
 
         if key is None or event_type is None or traffic_type is None or value is False:

splitio/client/input_validator.py

@@ -288,12 +288,16 @@ def validate_track_key(key):
     return key_str
 
 
-def validate_traffic_type(traffic_type):
+def validate_traffic_type(traffic_type, should_validate_existance, split_storage):
     """
     Check if traffic_type is valid for track.
 
     :param traffic_type: traffic_type to be checked
     :type traffic_type: str
+    :param should_validate_existance: Whether to check for existante in the split storage.
+    :type should_validate_existance: bool
+    :param split_storage: Split storage.
+    :param split_storage: splitio.storages.SplitStorage
     :return: traffic_type
     :rtype: str|None
     """
@@ -305,6 +309,15 @@ def validate_traffic_type(traffic_type):
         _LOGGER.warning('track: %s should be all lowercase - converting string to lowercase.',
                         traffic_type)
         traffic_type = traffic_type.lower()
+
+    if should_validate_existance and not split_storage.is_valid_traffic_type(traffic_type):
+        _LOGGER.warning(
+            'track: Traffic Type %s does not have any corresponding Splits in this environment, '
+            'make sure you\'re tracking your events to a valid traffic type defined '
+            'in the Split console.',
+            traffic_type
+        )
+
     return traffic_type
 
 

splitio/storage/__init__.py

@@ -83,6 +83,19 @@ def get_all_splits(self):
         """
         pass
 
+    @abc.abstractmethod
+    def is_valid_traffic_type(self, traffic_type_name):
+        """
+        Return whether the traffic type exists in at least one split in cache.
+
+        :param traffic_type_name: Traffic type to validate.
+        :type traffic_type_name: str
+
+        :return: True if the traffic type is valid. False otherwise.
+        :rtype: bool
+        """
+        pass
+
     def get_segment_names(self):
         """
         Return a set of all segments referenced by splits in storage.

splitio/storage/inmemmory.py

@@ -3,6 +3,8 @@
 
 import logging
 import threading
+from collections import Counter
+
 from six.moves import queue
 from splitio.models.segments import Segment
 from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage, \
@@ -18,6 +20,7 @@ def __init__(self):
         self._lock = threading.RLock()
         self._splits = {}
         self._change_number = -1
+        self._traffic_types = Counter()
 
     def get(self, split_name):
         """
@@ -40,6 +43,7 @@ def put(self, split):
         """
         with self._lock:
             self._splits[split.name] = split
+            self._increase_traffic_type_count(split.traffic_type_name)
 
     def remove(self, split_name):
         """
@@ -52,13 +56,15 @@ def remove(self, split_name):
         :rtype: bool
         """
         with self._lock:
-            try:
-                self._splits.pop(split_name)
-                return True
-            except KeyError:
+            split = self._splits.get(split_name)
+            if not split:
                 self._logger.warning("Tried to delete nonexistant split %s. Skipping", split_name)
                 return False
 
+            self._splits.pop(split_name)
+            self._decrease_traffic_type_count(split.traffic_type_name)
+            return True
+
     def get_change_number(self):
         """
         Retrieve latest split change number.
@@ -98,6 +104,38 @@ def get_all_splits(self):
         with self._lock:
             return list(self._splits.values())
 
+    def is_valid_traffic_type(self, traffic_type_name):
+        """
+        Return whether the traffic type exists in at least one split in cache.
+
+        :param traffic_type_name: Traffic type to validate.
+        :type traffic_type_name: str
+
+        :return: True if the traffic type is valid. False otherwise.
+        :rtype: bool
+        """
+        with self._lock:
+            return traffic_type_name in self._traffic_types
+
+    def _increase_traffic_type_count(self, traffic_type_name):
+        """
+        Increase by one the count for a specific traffic type name.
+
+        :param traffic_type_name: Traffic type to increase the count.
+        :type traffic_type_name: str
+        """
+        self._traffic_types.update([traffic_type_name])
+
+    def _decrease_traffic_type_count(self, traffic_type_name):
+        """
+        Decrease by one the count for a specific traffic type name.
+
+        :param traffic_type_name: Traffic type to decrease the count.
+        :type traffic_type_name: str
+        """
+        self._traffic_types.subtract([traffic_type_name])
+        self._traffic_types += Counter()
+
 
 class InMemorySegmentStorage(SegmentStorage):
     """In-memory implementation of a segment storage."""

splitio/storage/redis.py

@@ -16,6 +16,7 @@ class RedisSplitStorage(SplitStorage):
 
     _SPLIT_KEY = 'SPLITIO.split.{split_name}'
     _SPLIT_TILL_KEY = 'SPLITIO.splits.till'
+    _TRAFFIC_TYPE_KEY = 'SPLITIO.trafficType.{traffic_type_name}'
 
     def __init__(self, redis_client):
         """
@@ -39,6 +40,18 @@ def _get_key(self, split_name):
         """
         return self._SPLIT_KEY.format(split_name=split_name)
 
+    def _get_traffic_type_key(self, traffic_type_name):
+        """
+        Use the provided split_name to build the appropriate redis key.
+
+        :param split_name: Name of the split to interact with in redis.
+        :type split_name: str
+
+        :return: Redis key.
+        :rtype: str.
+        """
+        return self._TRAFFIC_TYPE_KEY.format(traffic_type_name=traffic_type_name)
+
     def get(self, split_name):
         """
         Retrieve a split.
@@ -57,6 +70,25 @@ def get(self, split_name):
             self._logger.debug('Error: ', exc_info=True)
             return None
 
+    def is_valid_traffic_type(self, traffic_type_name):
+        """
+        Return whether the traffic type exists in at least one split in cache.
+
+        :param traffic_type_name: Traffic type to validate.
+        :type traffic_type_name: str
+
+        :return: True if the traffic type is valid. False otherwise.
+        :rtype: bool
+        """
+        try:
+            raw = self._redis.get(self._get_traffic_type_key(traffic_type_name))
+            count = json.loads(raw) if raw else 0
+            return count > 0
+        except RedisAdapterException:
+            self._logger.error('Error fetching split from storage')
+            self._logger.debug('Error: ', exc_info=True)
+            return False
+
     def put(self, split):
         """
         Store a split.