Update client class

Author: chillaq

splitio/client/client.py

@@ -2,13 +2,15 @@
 import logging
 import json
 from collections import namedtuple
+import copy
 
 from splitio.engine.evaluator import Evaluator, CONTROL, EvaluationDataFactory, AsyncEvaluationDataFactory
 from splitio.engine.splitters import Splitter
 from splitio.models.impressions import Impression, Label, ImpressionDecorated
 from splitio.models.events import Event, EventWrapper
 from splitio.models.telemetry import get_latency_bucket_index, MethodExceptionsAndLatencies
 from splitio.client import input_validator
+from splitio.client.util import get_fallback_treatment_and_label
 from splitio.util.time import get_current_epoch_time_ms, utctime_ms
 
 
@@ -39,7 +41,7 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         'impressions_disabled': False
     }
 
-    def __init__(self, factory, recorder, labels_enabled=True):
+    def __init__(self, factory, recorder, labels_enabled=True, fallback_treatments_configuration=None):
         """
         Construct a Client instance.
 
@@ -64,6 +66,7 @@ def __init__(self, factory, recorder, labels_enabled=True):
         self._evaluator = Evaluator(self._splitter)
         self._telemetry_evaluation_producer = self._factory._telemetry_evaluation_producer
         self._telemetry_init_producer = self._factory._telemetry_init_producer
+        self._fallback_treatments_configuration = fallback_treatments_configuration
 
     @property
     def ready(self):
@@ -203,11 +206,23 @@ def _validate_track(self, key, traffic_type, event_type, value=None, properties=
     def _get_properties(self, evaluation_options):
         return evaluation_options.properties if evaluation_options != None else None
 
+    def _get_fallback_treatment_with_config(self, treatment, feature):
+        label = ""
+        
+        label, treatment, config = get_fallback_treatment_and_label(self._fallback_treatments_configuration, 
+                                                                    feature, treatment, label, _LOGGER)
+        return treatment, config
+
+    def _get_fallback_eval_results(self, eval_result, feature):
+        result = copy.deepcopy(eval_result)
+        result["impression"]["label"], result["treatment"], result["configurations"] = get_fallback_treatment_and_label(self._fallback_treatments_configuration, 
+                                                                         feature, result["treatment"], result["impression"]["label"], _LOGGER)
+        return result
 
 class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
     """Entry point for the split sdk."""
 
-    def __init__(self, factory, recorder, labels_enabled=True):
+    def __init__(self, factory, recorder, labels_enabled=True, fallback_treatments_configuration=None):
         """
         Construct a Client instance.
 
@@ -222,7 +237,7 @@ def __init__(self, factory, recorder, labels_enabled=True):
 
         :rtype: Client
         """
-        ClientBase.__init__(self, factory, recorder, labels_enabled)
+        ClientBase.__init__(self, factory, recorder, labels_enabled, fallback_treatments_configuration)
         self._context_factory = EvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'), factory._get_storage('rule_based_segments'))
 
     def destroy(self):
@@ -254,10 +269,11 @@ def get_treatment(self, key, feature_flag_name, attributes=None, evaluation_opti
         try:
             treatment, _ = self._get_treatment(MethodExceptionsAndLatencies.TREATMENT, key, feature_flag_name, attributes, evaluation_options)
             return treatment
-
+    
         except:
             _LOGGER.error('get_treatment failed')
-            return CONTROL
+            treatment, _ = self._get_fallback_treatment_with_config(CONTROL, feature_flag_name)
+            return treatment
 
     def get_treatment_with_config(self, key, feature_flag_name, attributes=None, evaluation_options=None):
         """
@@ -282,8 +298,8 @@ def get_treatment_with_config(self, key, feature_flag_name, attributes=None, eva
 
         except Exception:
             _LOGGER.error('get_treatment_with_config failed')
-            return CONTROL, None
-
+            return self._get_fallback_treatment_with_config(CONTROL, feature_flag_name)
+            
     def _get_treatment(self, method, key, feature, attributes=None, evaluation_options=None):
         """
         Validate key, feature flag name and object, and get the treatment and config with an optional dictionary of attributes.
@@ -302,7 +318,7 @@ def _get_treatment(self, method, key, feature, attributes=None, evaluation_optio
         :rtype: dict
         """
         if not self._client_is_usable(): # not destroyed & not waiting for a fork
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(CONTROL, feature)
 
         start = get_current_epoch_time_ms()
         if not self.ready:
@@ -312,9 +328,10 @@ def _get_treatment(self, method, key, feature, attributes=None, evaluation_optio
         try:
             key, bucketing, feature, attributes, evaluation_options = self._validate_treatment_input(key, feature, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(CONTROL, feature)
 
-        result = self._NON_READY_EVAL_RESULT
+        result = self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, feature)
+        
         if self.ready:
             try:
                 ctx = self._context_factory.context_for(key, [feature])
@@ -324,15 +341,15 @@ def _get_treatment(self, method, key, feature, attributes=None, evaluation_optio
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 self._telemetry_evaluation_producer.record_exception(method)
-                result = self._FAILED_EVAL_RESULT
+                result = self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, feature)
 
         properties = self._get_properties(evaluation_options)
-        if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
+        if result['impression']['label'].find(Label.SPLIT_NOT_FOUND) == -1:
             impression_decorated = self._build_impression(key, bucketing, feature, result, properties)
             self._record_stats([(impression_decorated, attributes)], start, method)
 
         return result['treatment'], result['configurations']
-
+        
     def get_treatments(self, key, feature_flag_names, attributes=None, evaluation_options=None):
         """
         Evaluate multiple feature flags and return a dictionary with all the feature flag/treatments.
@@ -356,7 +373,7 @@ def get_treatments(self, key, feature_flag_names, attributes=None, evaluation_op
             return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
 
         except Exception:
-            return {feature: CONTROL for feature in feature_flag_names}
+            return {feature: self._get_fallback_treatment_with_config(CONTROL, feature)[0] for feature in feature_flag_names}
 
     def get_treatments_with_config(self, key, feature_flag_names, attributes=None, evaluation_options=None):
         """
@@ -380,7 +397,7 @@ def get_treatments_with_config(self, key, feature_flag_names, attributes=None, e
             return self._get_treatments(key, feature_flag_names, MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG, attributes, evaluation_options)
 
         except Exception:
-            return {feature: (CONTROL, None) for feature in feature_flag_names}
+            return {feature: (self._get_fallback_treatment_with_config(CONTROL, feature)) for feature in feature_flag_names}
 
     def get_treatments_by_flag_set(self, key, flag_set, attributes=None, evaluation_options=None):
         """
@@ -604,7 +621,7 @@ def _get_treatments(self, key, features, method, attributes=None, evaluation_opt
         """
         start = get_current_epoch_time_ms()
         if not self._client_is_usable():
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatments_configuration)
 
         if not self.ready:
             _LOGGER.error("Client is not ready - no calls possible")
@@ -613,9 +630,9 @@ def _get_treatments(self, key, features, method, attributes=None, evaluation_opt
         try:
             key, bucketing, features, attributes, evaluation_options = self._validate_treatments_input(key, features, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatments_configuration)
 
-        results = {n: self._NON_READY_EVAL_RESULT for n in features}
+        results = {n: self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, n) for n in features}
         if self.ready:
             try:
                 ctx = self._context_factory.context_for(key, features)
@@ -625,12 +642,12 @@ def _get_treatments(self, key, features, method, attributes=None, evaluation_opt
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 self._telemetry_evaluation_producer.record_exception(method)
-                results = {n: self._FAILED_EVAL_RESULT for n in features}
+                results = {n: self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, n) for n in features}
 
         properties = self._get_properties(evaluation_options)
         imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results, properties)
-            if i.Impression.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label.find(Label.SPLIT_NOT_FOUND) == -1
         ]
         self._record_stats(imp_decorated_attrs, start, method)
 
@@ -706,7 +723,7 @@ def track(self, key, traffic_type, event_type, value=None, properties=None):
 class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
     """Entry point for the split sdk."""
 
-    def __init__(self, factory, recorder, labels_enabled=True):
+    def __init__(self, factory, recorder, labels_enabled=True, fallback_treatments_configuration=None):
         """
         Construct a Client instance.
 
@@ -721,7 +738,7 @@ def __init__(self, factory, recorder, labels_enabled=True):
 
         :rtype: Client
         """
-        ClientBase.__init__(self, factory, recorder, labels_enabled)
+        ClientBase.__init__(self, factory, recorder, labels_enabled, fallback_treatments_configuration)
         self._context_factory = AsyncEvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'), factory._get_storage('rule_based_segments'))
 
     async def destroy(self):
@@ -756,7 +773,8 @@ async def get_treatment(self, key, feature_flag_name, attributes=None, evaluatio
 
         except:
             _LOGGER.error('get_treatment failed')
-            return CONTROL
+            treatment, _ = self._get_fallback_treatment_with_config(CONTROL, feature_flag_name)
+            return treatment
 
     async def get_treatment_with_config(self, key, feature_flag_name, attributes=None, evaluation_options=None):
         """
@@ -781,7 +799,7 @@ async def get_treatment_with_config(self, key, feature_flag_name, attributes=Non
 
         except Exception:
             _LOGGER.error('get_treatment_with_config failed')
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(CONTROL, feature_flag_name)
 
     async def _get_treatment(self, method, key, feature, attributes=None, evaluation_options=None):
         """
@@ -801,7 +819,7 @@ async def _get_treatment(self, method, key, feature, attributes=None, evaluation
         :rtype: dict
         """
         if not self._client_is_usable(): # not destroyed & not waiting for a fork
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(CONTROL, feature)
 
         start = get_current_epoch_time_ms()
         if not self.ready:
@@ -811,9 +829,9 @@ async def _get_treatment(self, method, key, feature, attributes=None, evaluation
         try:
             key, bucketing, feature, attributes, evaluation_options = self._validate_treatment_input(key, feature, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(CONTROL, feature)
 
-        result = self._NON_READY_EVAL_RESULT
+        result = self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, feature)
         if self.ready:
             try:
                 ctx = await self._context_factory.context_for(key, [feature])
@@ -823,10 +841,10 @@ async def _get_treatment(self, method, key, feature, attributes=None, evaluation
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 await self._telemetry_evaluation_producer.record_exception(method)
-                result = self._FAILED_EVAL_RESULT
+                result = self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, feature)
 
         properties = self._get_properties(evaluation_options)
-        if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
+        if result['impression']['label'].find(Label.SPLIT_NOT_FOUND) == -1:
             impression_decorated = self._build_impression(key, bucketing, feature, result, properties)
             await self._record_stats([(impression_decorated, attributes)], start, method)
         return result['treatment'], result['configurations']
@@ -854,7 +872,7 @@ async def get_treatments(self, key, feature_flag_names, attributes=None, evaluat
             return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
 
         except Exception:
-            return {feature: CONTROL for feature in feature_flag_names}
+            return {feature: self._get_fallback_treatment_with_config(CONTROL, feature)[0] for feature in feature_flag_names}
 
     async def get_treatments_with_config(self, key, feature_flag_names, attributes=None, evaluation_options=None):
         """
@@ -878,8 +896,7 @@ async def get_treatments_with_config(self, key, feature_flag_names, attributes=N
             return await self._get_treatments(key, feature_flag_names, MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG, attributes, evaluation_options)
 
         except Exception:
-            _LOGGER.error("AA", exc_info=True)
-            return {feature: (CONTROL, None) for feature in feature_flag_names}
+            return {feature: (self._get_fallback_treatment_with_config(CONTROL, feature)) for feature in feature_flag_names}
 
     async def get_treatments_by_flag_set(self, key, flag_set, attributes=None, evaluation_options=None):
         """
@@ -1017,7 +1034,7 @@ async def _get_treatments(self, key, features, method, attributes=None, evaluati
         """
         start = get_current_epoch_time_ms()
         if not self._client_is_usable():
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatments_configuration)
 
         if not self.ready:
             _LOGGER.error("Client is not ready - no calls possible")
@@ -1026,9 +1043,9 @@ async def _get_treatments(self, key, features, method, attributes=None, evaluati
         try:
             key, bucketing, features, attributes, evaluation_options = self._validate_treatments_input(key, features, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatments_configuration)
 
-        results = {n: self._NON_READY_EVAL_RESULT for n in features}
+        results = {n: self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, n) for n in features}
         if self.ready:
             try:
                 ctx = await self._context_factory.context_for(key, features)
@@ -1038,7 +1055,7 @@ async def _get_treatments(self, key, features, method, attributes=None, evaluati
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 await self._telemetry_evaluation_producer.record_exception(method)
-                results = {n: self._FAILED_EVAL_RESULT for n in features}
+                results = {n: self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, n) for n in features}
 
         properties = self._get_properties(evaluation_options)
         imp_decorated_attrs = [

splitio/client/input_validator.py

@@ -7,6 +7,7 @@
 
 from splitio.client.key import Key
 from splitio.client import client
+from splitio.client.util import get_fallback_treatment_and_label
 from splitio.engine.evaluator import CONTROL
 
 
@@ -501,7 +502,7 @@ def validate_feature_flags_get_treatments(  # pylint: disable=invalid-name
         valid_feature_flags.append(ff)
     return valid_feature_flags
 
-def generate_control_treatments(feature_flags):
+def generate_control_treatments(feature_flags, fallback_treatments_configuration):
     """
     Generate valid feature flags to control.
 
@@ -516,7 +517,13 @@ def generate_control_treatments(feature_flags):
     to_return = {}
     for feature_flag in feature_flags:
         if isinstance(feature_flag, str) and len(feature_flag.strip())> 0:
-            to_return[feature_flag] = (CONTROL, None)
+            treatment = CONTROL
+            config = None
+            label = ""
+            label, treatment, config = get_fallback_treatment_and_label(fallback_treatments_configuration, 
+                                                                         feature_flag, treatment, label, _LOGGER)
+            
+            to_return[feature_flag] = (treatment, config)
     return to_return
 
 

splitio/client/util.py

@@ -51,3 +51,22 @@ def get_metadata(config):
     version = 'python-%s' % __version__
     ip_address, hostname = _get_hostname_and_ip(config)
     return SdkMetadata(version, hostname, ip_address)
+
+def get_fallback_treatment_and_label(fallback_treatments_configuration, feature_name, treatment, label, _logger):
+    if fallback_treatments_configuration == None or fallback_treatments_configuration.fallback_config == None:
+        return label, treatment, None
+    
+    if fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment != None and \
+        fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name) != None:
+        _logger.debug('Using Fallback Treatment for feature: %s', feature_name)            
+        return fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).label_prefix + label, \
+            fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).treatment,  \
+            fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).config
+
+    if fallback_treatments_configuration.fallback_config.global_fallback_treatment != None:
+        _logger.debug('Using Global Fallback Treatment.')            
+        return  fallback_treatments_configuration.fallback_config.global_fallback_treatment.label_prefix + label, \
+            fallback_treatments_configuration.fallback_config.global_fallback_treatment.treatment,  \
+            fallback_treatments_configuration.fallback_config.global_fallback_treatment.config
+    
+    return label, treatment, None