Merge pull request #41 from splitio/development

Development

Author: sarrubia

CHANGES.txt

@@ -0,0 +1,6 @@
+2.1.0
+ - Added enabled labels
+ - Added impressions by sdk and version including bucketing key
+2.0.5
+ - Added SDK Factory Method with Manager API and Sdk Client
+ - Added Bucketing key support

setup.py

@@ -26,7 +26,7 @@
       tests_require=tests_require,
       extras_require={
           'test': tests_require,
-          'redis': ['redis>=2.6', 'jsonpickle>=0.9.3']
+          'redis': ['redis>=2.10.5', 'jsonpickle>=0.9.3']
       },
       setup_requires=['nose'],
       classifiers=[

splitio/clients.py

@@ -2,8 +2,7 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 import logging
-
-import arrow
+import time
 
 from os.path import expanduser, join
 from random import randint
@@ -37,12 +36,13 @@ def __init__(self, matching_key, bucketing_key):
         self.bucketing_key = bucketing_key
 
 class Client(object):
-    def __init__(self):
+    def __init__(self, labels_enabled=True):
         """Basic interface of a Client. Specific implementations need to override the
         get_split_fetcher method (and optionally the get_splitter method).
         """
         self._logger = logging.getLogger(self.__class__.__name__)
         self._splitter = Splitter()
+        self._labels_enabled = labels_enabled
 
     def get_split_fetcher(self):  # pragma: no cover
         """Get the split fetcher implementation. Subclasses need to override this method.
@@ -89,20 +89,21 @@ def get_treatment(self, key, feature, attributes=None):
         if key is None or feature is None:
             return CONTROL
 
-        start = arrow.utcnow().timestamp * 1000
+        start = int(round(time.time() * 1000))
 
         matching_key = None
         bucketing_key = None
         if isinstance(key, Key):
             matching_key = key.matching_key
             bucketing_key = key.bucketing_key
         else:
-            matching_key = key
-            bucketing_key = key
+            matching_key = str(key)
+            bucketing_key = None
 
         try:
             label = ''
             _treatment = CONTROL
+            _change_number = -1
 
             #Fetching Split definition
             split = self.get_split_fetcher().fetch(feature)
@@ -112,19 +113,20 @@ def get_treatment(self, key, feature, attributes=None):
                 label = Label.SPLIT_NOT_FOUND
                 _treatment = CONTROL
             else:
+                _change_number = split.change_number
                 if split.killed:
                     label = Label.KILLED
                     _treatment = split.default_treatment
                 else:
-                    treatment = self._get_treatment_for_split(split, matching_key, bucketing_key, attributes)
+                    treatment, label = self._get_treatment_for_split(split, matching_key, bucketing_key, attributes)
                     if treatment is None:
                         label = Label.NO_CONDITION_MATCHED
                         _treatment = split.default_treatment
                     else:
                         _treatment = treatment
 
             impression = self._build_impression(matching_key, feature, _treatment, label,
-                                                self.get_split_fetcher().change_number, bucketing_key, start)
+                                                _change_number, bucketing_key, start)
             self._record_stats(impression, start, SDK_GET_TREATMENT)
             return _treatment
         except:
@@ -140,12 +142,16 @@ def get_treatment(self, key, feature, attributes=None):
             return CONTROL
 
     def _build_impression(self, matching_key, feature_name, treatment, label, change_number, bucketing_key, time):
+
+        if not self._labels_enabled:
+            label = None
+
         return Impression(matching_key=matching_key, feature_name=feature_name, treatment=treatment, label=label,
                                     change_number=change_number, bucketing_key=bucketing_key, time=time)
 
     def _record_stats(self, impression, start, operation):
         try:
-            end = arrow.utcnow().timestamp * 1000
+            end = int(round(time.time() * 1000))
             self.get_treatment_log().log(impression)
             self.get_metrics().time(operation, end - start)
         except:
@@ -164,13 +170,15 @@ def _get_treatment_for_split(self, split, matching_key, bucketing_key, attribute
         :return: The treatment for the key and split
         :rtype: str
         """
+        if bucketing_key is None:
+            bucketing_key = matching_key
 
         for condition in split.conditions:
             if condition.matcher.match(matching_key, attributes=attributes):
-                return self.get_splitter().get_treatment(bucketing_key, split.seed, condition.partitions)
+                return self.get_splitter().get_treatment(bucketing_key, split.seed, condition.partitions), condition.label
 
         # No condition matches
-        return None
+        return None, None
 
 
 def randomize_interval(value):
@@ -214,7 +222,11 @@ def __init__(self, api_key, config=None, sdk_api_base_url=None, events_api_base_
         :param events_api_base_url: An override for the default events base URL.
         :type events_api_base_url: str
         """
-        super(SelfRefreshingClient, self).__init__()
+        labels_enabled = True
+        if config is not None and 'labelsEnabled' in config:
+            labels_enabled = config['labelsEnabled']
+
+        super(SelfRefreshingClient, self).__init__(labels_enabled)
 
         self._api_key = api_key
         self._sdk_api_base_url = sdk_api_base_url
@@ -484,11 +496,11 @@ def get_metrics(self):
 
 
 class RedisClient(Client):
-    def __init__(self, redis):
+    def __init__(self, redis, labels_enabled=True):
         """A Client implementation that uses Redis as its backend.
         :param redis: A redis client
         :type redis: StrctRedis"""
-        super(RedisClient, self).__init__()
+        super(RedisClient, self).__init__(labels_enabled)
 
         split_cache = RedisSplitCache(redis)
         split_fetcher = CacheBasedSplitFetcher(split_cache)
@@ -678,4 +690,12 @@ def get_redis_client(api_key, **kwargs):
         return LocalhostEnvironmentClient(**kwargs)
 
     redis = get_redis(config)
-    return RedisClient(redis)
+
+    if 'labelsEnabled' in config:
+        redis_client = RedisClient(redis, config['labelsEnabled'])
+    else:
+        redis_client = RedisClient(redis)
+
+    return redis_client
+
+

splitio/config.py

@@ -31,7 +31,26 @@
     'ready': 0,
     'redisHost': 'localhost',
     'redisPort': 6379,
-    'redisDb': 0
+    'redisDb': 0,
+    'redisPassword': None,
+    'redisSocketTimeout': None,
+    'redisSocketConnectTimeout': None,
+    'redisSocketKeepalive': None,
+    'redisSocketKeepaliveOptions': None,
+    'redisConnectionPool': None,
+    'redisUnixSocketPath': None,
+    'redisEncoding': 'utf-8',
+    'redisEncodingErrors': 'strict',
+    'redisCharset': None,
+    'redisErrors': None,
+    'redisDecodeResponses': False,
+    'redisRetryOnTimeout': False,
+    'redisSsl': False,
+    'redisSslKeyfile': None,
+    'redisSslCertfile': None,
+    'redisSslCertReqs': None,
+    'redisSslCaCerts': None,
+    'redisMaxConnections': None
 }
 
 MAX_INTERVAL = 180

splitio/impressions.py

@@ -29,7 +29,8 @@ def build_impressions_data(impressions):
                     'treatment': impression.treatment,
                     'time': impression.time,
                     'changeNumber': impression.change_number,
-                    'label': impression.label
+                    'label': impression.label,
+                    'bucketingKey': impression.bucketing_key
                 }
                 for impression in feature_impressions
             ]
@@ -48,12 +49,12 @@ class Label(object):
     # Condition: No condition matched
     # Treatment: Default Treatment
     # Label: no condition matched
-    NO_CONDITION_MATCHED = 'no condition matched'
+    NO_CONDITION_MATCHED = 'no rule matched'
 
     #Condition: Split definition was not found
     #Treatment: control
     #Label: split not found
-    SPLIT_NOT_FOUND = 'split not found'
+    SPLIT_NOT_FOUND = 'rules not found'
 
     # Condition: There was an exception
     # Treatment: control

splitio/redis_support.py

@@ -340,7 +340,8 @@ def add_impression(self, impression):
                             'treatment':impression.treatment,
                             'time':impression.time,
                             'changeNumber':impression.change_number,
-                            'label':impression.label
+                            'label':impression.label,
+                            'bucketingKey':impression.bucketing_key
                             }
         self._redis.sadd(self._IMPRESSIONS_KEY.format(feature_name=impression.feature_name), encode(cache_impression))
 
@@ -378,12 +379,16 @@ def fetch_all_and_clear(self):
                 if 'changeNumber' in impression_decoded:
                     change_number = impression_decoded['changeNumber']
 
+                bucketing_key = ''
+                if 'bucketingKey' in impression_decoded:
+                    bucketing_key = impression_decoded['bucketingKey']
+
                 impression_tuple = Impression(matching_key=impression_decoded['keyName'],
                                               feature_name=feature_name,
                                               treatment=impression_decoded['treatment'],
                                               label=label,
                                               change_number=change_number,
-                                              bucketing_key='',
+                                              bucketing_key=bucketing_key,
                                               time=impression_decoded['time']
                                               )
                 impressions_list.append(impression_tuple)
@@ -638,7 +643,7 @@ def __init__(self, segment_cache):
 
     def _parse_split(self, split, block_until_ready=False):
         return RedisSplit(split['name'], split['seed'], split['killed'], split['defaultTreatment'],
-                          split['trafficTypeName'], segment_cache=self._segment_cache)
+                          split['trafficTypeName'], split['status'], split['changeNumber'], segment_cache=self._segment_cache)
 
     def _parse_matcher_in_segment(self, partial_split, matcher, block_until_ready=False, *args,
                                   **kwargs):
@@ -650,7 +655,7 @@ def _parse_matcher_in_segment(self, partial_split, matcher, block_until_ready=Fa
 
 
 class RedisSplit(Split):
-    def __init__(self, name, seed, killed, default_treatment, traffic_type_name, conditions=None, segment_cache=None):
+    def __init__(self, name, seed, killed, default_treatment, traffic_type_name, status, change_number, conditions=None, segment_cache=None):
         """A split implementation that mantains a reference to the segment cache so segments can
         be easily pickled and unpickled.
         :param name: Name of the feature
@@ -666,7 +671,7 @@ def __init__(self, name, seed, killed, default_treatment, traffic_type_name, con
         :param segment_cache: A segment cache
         :type segment_cache: SegmentCache
         """
-        super(RedisSplit, self).__init__(name, seed, killed, default_treatment, traffic_type_name, conditions)
+        super(RedisSplit, self).__init__(name, seed, killed, default_treatment, traffic_type_name, status, change_number, conditions)
         self._segment_cache = segment_cache
 
     @property
@@ -710,7 +715,7 @@ def get_redis(config):
     :return: A redis client
     """
     if 'redisFactory' in config:
-        redis_factory = import_from_string(config['redisFactory'])
+        redis_factory = import_from_string(config['redisFactory'],'redisFactory')
         return redis_factory()
 
     return default_redis_factory(config)
@@ -726,5 +731,34 @@ def default_redis_factory(config):
     host = config.get('redisHost', 'localhost')
     port = config.get('redisPort', 6379)
     db = config.get('redisDb', 0)
-    redis = StrictRedis(host=host, port=port, db=db)
+    password = config.get('redisPassword', None)
+    socket_timeout = config.get('redisSocketTimeout', None)
+    socket_connect_timeout = config.get('redisSocketConnectTimeout', None)
+    socket_keepalive = config.get('redisSocketKeepalive', None)
+    socket_keepalive_options = config.get('redisSocketKeepaliveOptions', None)
+    connection_pool = config.get('redisConnectionPool', None)
+    unix_socket_path = config.get('redisUnixSocketPath', None)
+    encoding = config.get('redisEncoding', 'utf-8')
+    encoding_errors = config.get('redisEncodingErrors', 'strict')
+    charset = config.get('redisCharset', None)
+    errors = config.get('redisErrors', None)
+    decode_responses = config.get('redisDecodeResponses', False)
+    retry_on_timeout = config.get('redisRetryOnTimeout', False)
+    ssl = config.get('redisSsl', False)
+    ssl_keyfile = config.get('redisSslKeyfile', None)
+    ssl_certfile = config.get('redisSslCertfile', None)
+    ssl_cert_reqs = config.get('redisSslCertReqs', None)
+    ssl_ca_certs = config.get('redisSslCaCerts', None)
+    max_connections = config.get('redisMaxConnections', None)
+
+    redis = StrictRedis(host=host, port=port, db=db, password=password, socket_timeout=socket_timeout,
+                 socket_connect_timeout=socket_connect_timeout,
+                 socket_keepalive=socket_keepalive, socket_keepalive_options=socket_keepalive_options,
+                 connection_pool=connection_pool, unix_socket_path=unix_socket_path,
+                 encoding=encoding, encoding_errors=encoding_errors,
+                 charset=charset, errors=errors,
+                 decode_responses=decode_responses, retry_on_timeout=retry_on_timeout,
+                 ssl=ssl, ssl_keyfile=ssl_keyfile, ssl_certfile=ssl_certfile,
+                 ssl_cert_reqs=ssl_cert_reqs, ssl_ca_certs=ssl_ca_certs,
+                 max_connections=max_connections)
     return redis