merged with dev

Author: Matias Melograno

CHANGES.txt

@@ -1,3 +1,5 @@
+8.1.0 (May, 2019)
+ - Added properties to track method.
 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):
@@ -154,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:
@@ -247,7 +247,7 @@ def get_treatments_with_config(self, key, features, attributes=None):
                 bulk_impressions.append(impression)
                 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
@@ -260,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.
@@ -287,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,
@@ -327,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.
 
@@ -343,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
@@ -361,15 +362,21 @@ def track(self, key, traffic_type, event_type, value=None):
         )
 
         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,
+        )])

splitio/client/factory.py

@@ -16,7 +16,7 @@
 from splitio.client import util
 from splitio.client.listener import ImpressionListenerWrapper
 
-#Storage
+# Storage
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
     InMemoryImpressionStorage, InMemoryEventStorage, InMemoryTelemetryStorage
 from splitio.storage.adapters import redis
@@ -65,10 +65,10 @@ class TimeoutException(Exception):
     pass
 
 
-class SplitFactory(object):  #pylint: disable=too-many-instance-attributes
+class SplitFactory(object):  # pylint: disable=too-many-instance-attributes
     """Split Factory/Container class."""
 
-    def __init__(  #pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments
             self,
             apikey,
             storages,
@@ -233,7 +233,7 @@ def _wrap_impression_listener(listener, metadata):
     return None
 
 
-def _build_in_memory_factory(api_key, config, sdk_url=None, events_url=None):  #pylint: disable=too-many-locals
+def _build_in_memory_factory(api_key, config, sdk_url=None, events_url=None):  # pylint: disable=too-many-locals
     """Build and return a split factory tailored to the supplied config."""
     if not input_validator.validate_factory_instantiation(api_key):
         return None
@@ -314,6 +314,9 @@ def _build_in_memory_factory(api_key, config, sdk_url=None, events_url=None):  #
     tasks['events'].start()
     tasks['telemetry'].start()
 
+    storages['events'].set_queue_full_hook(tasks['events'].flush)
+    storages['impressions'].set_queue_full_hook(tasks['impressions'].flush)
+
     def split_ready_task():
         """Wait for splits to be ready and start fetching segments."""
         splits_ready_flag.wait()

splitio/client/input_validator.py

@@ -18,6 +18,7 @@
 _LOGGER = logging.getLogger(__name__)
 MAX_LENGTH = 250
 EVENT_TYPE_PATTERN = r'^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$'
+MAX_PROPERTIES_LENGTH_BYTES = 32768
 
 
 def _get_first_split_sdk_call():
@@ -33,9 +34,10 @@ def _get_first_split_sdk_call():
         if calls:
             return calls[-1]
         return unknown_method
-    except Exception:  #pylint: disable=broad-except
+    except Exception:  # pylint: disable=broad-except
         return unknown_method
 
+
 def _check_not_null(value, name, operation):
     """
     Check if value is null.
@@ -390,7 +392,7 @@ def validate_manager_feature_name(feature_name, should_validate_existance, split
     return feature_name
 
 
-def validate_features_get_treatments(features, should_validate_existance=False, split_storage=None):  #pylint: disable=invalid-name
+def validate_features_get_treatments(features, should_validate_existance=False, split_storage=None):  # pylint: disable=invalid-name
     """
     Check if features is valid for get_treatments.
 
@@ -476,7 +478,7 @@ def validate_apikey_type(segment_api):
     """
     api_messages_filter = _ApiLogFilter()
     try:
-        segment_api._logger.addFilter(api_messages_filter)  #pylint: disable=protected-access
+        segment_api._logger.addFilter(api_messages_filter)  # pylint: disable=protected-access
         segment_api.fetch_segment('__SOME_INVALID_SEGMENT__', -1)
     except APIException as exc:
         if exc.status_code == 403:
@@ -485,7 +487,7 @@ def validate_apikey_type(segment_api):
                           + 'console that is of type sdk')
             return False
     finally:
-        segment_api._logger.removeFilter(api_messages_filter)  #pylint: disable=protected-access
+        segment_api._logger.removeFilter(api_messages_filter)  # pylint: disable=protected-access
 
     # True doesn't mean that the APIKEY is right, only that it's not of type "browser"
     return True
@@ -497,10 +499,6 @@ def validate_factory_instantiation(apikey):
 
     :param apikey: str
     :type apikey: str
-    :param config: dict
-    :type config: dict
-    :param segment_api: Segment API client
-    :type segment_api: splitio.api.segments.SegmentsAPI
     :return: bool
     :rtype: True|False
     """
@@ -511,3 +509,56 @@ def validate_factory_instantiation(apikey):
        (not _check_string_not_empty(apikey, 'apikey', 'factory_instantiation')):
         return False
     return True
+
+
+def valid_properties(properties):
+    """
+    Check if properties is a valid dict and returns the properties
+    that will be sent to the track method, avoiding unexpected types.
+
+    :param properties: dict
+    :type properties: dict
+    :return: tuple
+    :rtype: (bool,dict,int)
+    """
+    size = 1024  # We assume 1kb events without properties (750 bytes avg measured)
+
+    if properties is None:
+        return True, None, size
+    if not isinstance(properties, dict):
+        _LOGGER.error('track: properties must be of type dictionary.')
+        return False, None, 0
+
+    valid_properties = dict()
+
+    for property, element in six.iteritems(properties):
+        if not isinstance(property, six.string_types):  # Exclude property if is not string
+            continue
+
+        valid_properties[property] = None
+        size += len(property)
+
+        if element is None:
+            continue
+
+        if not isinstance(element, six.string_types) and not isinstance(element, Number) \
+           and not isinstance(element, bool):
+            _LOGGER.warning('Property %s is of invalid type. Setting value to None', element)
+            element = None
+
+        valid_properties[property] = element
+
+        if isinstance(element, six.string_types):
+            size += len(element)
+
+        if size > MAX_PROPERTIES_LENGTH_BYTES:
+            _LOGGER.error(
+                'The maximum size allowed for the properties is 32768 bytes. ' +
+                'Current one is ' + str(size) + ' bytes. Event not queued'
+            )
+            return False, None, size
+
+    if len(valid_properties.keys()) > 300:
+        _LOGGER.warning('Event has more than 300 properties. Some of them will be trimmed' +
+                        ' when processed')
+    return True, valid_properties if len(valid_properties) else None, size

splitio/engine/evaluator.py

@@ -7,7 +7,7 @@
 CONTROL = 'control'
 
 
-class Evaluator(object):  #pylint: disable=too-few-public-methods
+class Evaluator(object):  # pylint: disable=too-few-public-methods
     """Split Evaluator class."""
 
     def __init__(self, split_storage, segment_storage, splitter):

splitio/models/events.py

@@ -14,4 +14,10 @@
     'event_type_id',
     'value',
     'timestamp',
+    'properties',
+])
+
+EventWrapper = namedtuple('EventWrapper', [
+    'event',
+    'size',
 ])