Updated evaluator

Author: chillaq

splitio/client/client.py

@@ -39,7 +39,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 +64,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):

splitio/engine/evaluator.py

@@ -20,14 +20,15 @@
 class Evaluator(object):  # pylint: disable=too-few-public-methods
     """Split Evaluator class."""
 
-    def __init__(self, splitter):
+    def __init__(self, splitter, fallback_treatments_configuration=None):
         """
         Construct a Evaluator instance.
 
         :param splitter: partition object.
         :type splitter: splitio.engine.splitters.Splitters
         """
         self._splitter = splitter
+        self._fallback_treatments_configuration = fallback_treatments_configuration
 
     def eval_many_with_context(self, key, bucketing, features, attrs, ctx):
         """
@@ -51,6 +52,7 @@ def eval_with_context(self, key, bucketing, feature_name, attrs, ctx):
         if not feature:
             _LOGGER.warning('Unknown or invalid feature: %s', feature)
             label = Label.SPLIT_NOT_FOUND
+            label, _treatment, config = self._get_fallback_treatment_and_label(feature_name, _treatment, label)            
         else:
             _change_number = feature.change_number
             if feature.killed:
@@ -59,17 +61,37 @@ def eval_with_context(self, key, bucketing, feature_name, attrs, ctx):
             else:
                 label, _treatment = self._check_prerequisites(feature, bucketing, key, attrs, ctx, label, _treatment)
                 label, _treatment = self._get_treatment(feature, bucketing, key, attrs, ctx, label, _treatment)
+            config = feature.get_configurations_for(_treatment) if feature else None
 
         return {
             'treatment': _treatment,
-            'configurations': feature.get_configurations_for(_treatment) if feature else None,
+            'configurations': config,
             'impression': {
                 'label': label,
                 'change_number': _change_number
             },
             'impressions_disabled': feature.impressions_disabled if feature else None
         }
 
+    def _get_fallback_treatment_and_label(self, feature_name, treatment, label):
+        if self._fallback_treatments_configuration == None or self._fallback_treatments_configuration.fallback_config == None:
+            return label, treatment, None
+        
+        if self._fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment != None and \
+            self._fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name) != None:
+            _LOGGER.debug('Using Fallback Treatment for feature: %s', feature_name)            
+            return self._fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).label_prefix + label, \
+                self._fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).treatment,  \
+                self._fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).config
+
+        if self._fallback_treatments_configuration.fallback_config.global_fallback_treatment != None:
+            _LOGGER.debug('Using Global Fallback Treatment.')            
+            return  self._fallback_treatments_configuration.fallback_config.global_fallback_treatment.label_prefix + label, \
+                self._fallback_treatments_configuration.fallback_config.global_fallback_treatment.treatment,  \
+                self._fallback_treatments_configuration.fallback_config.global_fallback_treatment.config
+        
+        return label, treatment, None
+    
     def _get_treatment(self, feature, bucketing, key, attrs, ctx, label, _treatment):
         if _treatment == CONTROL:
             treatment, label = self._treatment_for_flag(feature, key, bucketing, attrs, ctx)

splitio/models/fallback_treatment.py

@@ -18,6 +18,7 @@ def __init__(self, treatment, config=None):
         self._config = None
         if config != None:
             self._config = json.dumps(config)
+        self._label_prefix = "fallback - "
 
     @property
     def treatment(self):
@@ -27,4 +28,9 @@ def treatment(self):
     @property
     def config(self):
         """Return config."""
-        return self._config
+        return self._config
+    
+    @property
+    def label_prefix(self):
+        """Return label prefix."""
+        return self._label_prefix

tests/engine/test_evaluator.py

@@ -11,6 +11,8 @@
 from splitio.models.impressions import Label
 from splitio.models.grammar import condition
 from splitio.models import rule_based_segments
+from splitio.models.fallback_treatment import FallbackTreatment
+from splitio.models.fallback_config import FallbackConfig, FallbackTreatmentsConfiguration
 from splitio.engine import evaluator, splitters
 from splitio.engine.evaluator import EvaluationContext
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, InMemoryRuleBasedSegmentStorage, \
@@ -372,6 +374,54 @@ def test_prerequisites(self):
         ctx = evaluation_facctory.context_for('mauro@split.io', ['prereq_chain'])
         assert e.eval_with_context('mauro@split.io', 'mauro@split.io', 'prereq_chain', {'email': 'mauro@split.io'}, ctx)['treatment'] == "on_default"
 
+    def test_evaluate_treatment_with_fallback(self, mocker):
+        """Test that a evaluation return fallback treatment."""
+        splitter_mock = mocker.Mock(spec=splitters.Splitter)
+        logger_mock = mocker.Mock(spec=logging.Logger)
+        evaluator._LOGGER = logger_mock
+        mocked_split = mocker.Mock(spec=Split)
+        ctx = EvaluationContext(flags={'some': mocked_split}, segment_memberships=set(), rbs_segments={})
+        
+        # should use global fallback
+        logger_mock.reset_mock()
+        e = evaluator.Evaluator(splitter_mock, FallbackTreatmentsConfiguration(FallbackConfig(FallbackTreatment("off-global", {"prop":"val"}))))
+        result = e.eval_with_context('some_key', 'some_bucketing_key', 'some2', {}, ctx)
+        assert result['treatment'] == 'off-global'
+        assert result['configurations'] == '{"prop": "val"}'
+        assert result['impression']['label'] == "fallback - " + Label.SPLIT_NOT_FOUND
+        assert logger_mock.debug.mock_calls[0] == mocker.call("Using Global Fallback Treatment.")
+        
+
+        # should use by flag fallback
+        logger_mock.reset_mock()
+        e = evaluator.Evaluator(splitter_mock, FallbackTreatmentsConfiguration(FallbackConfig(None, {"some2": FallbackTreatment("off-some2", {"prop2":"val2"})})))
+        result = e.eval_with_context('some_key', 'some_bucketing_key', 'some2', {}, ctx)
+        assert result['treatment'] == 'off-some2'
+        assert result['configurations'] == '{"prop2": "val2"}'
+        assert result['impression']['label'] == "fallback - " + Label.SPLIT_NOT_FOUND
+        assert logger_mock.debug.mock_calls[0] == mocker.call("Using Fallback Treatment for feature: %s", "some2")
+
+        # should not use any fallback
+        e = evaluator.Evaluator(splitter_mock, FallbackTreatmentsConfiguration(FallbackConfig(None, {"some2": FallbackTreatment("off-some2", {"prop2":"val2"})})))
+        result = e.eval_with_context('some_key', 'some_bucketing_key', 'some3', {}, ctx)
+        assert result['treatment'] == 'control'
+        assert result['configurations'] == None
+        assert result['impression']['label'] == Label.SPLIT_NOT_FOUND
+
+        # should use by flag fallback
+        e = evaluator.Evaluator(splitter_mock, FallbackTreatmentsConfiguration(FallbackConfig(FallbackTreatment("off-global", {"prop":"val"}), {"some2": FallbackTreatment("off-some2", {"prop2":"val2"})})))
+        result = e.eval_with_context('some_key', 'some_bucketing_key', 'some2', {}, ctx)
+        assert result['treatment'] == 'off-some2'
+        assert result['configurations'] == '{"prop2": "val2"}'
+        assert result['impression']['label'] == "fallback - " + Label.SPLIT_NOT_FOUND
+
+        # should global flag fallback
+        e = evaluator.Evaluator(splitter_mock, FallbackTreatmentsConfiguration(FallbackConfig(FallbackTreatment("off-global", {"prop":"val"}), {"some2": FallbackTreatment("off-some2", {"prop2":"val2"})})))
+        result = e.eval_with_context('some_key', 'some_bucketing_key', 'some3', {}, ctx)
+        assert result['treatment'] == 'off-global'
+        assert result['configurations'] == '{"prop": "val"}'
+        assert result['impression']['label'] == "fallback - " + Label.SPLIT_NOT_FOUND
+
     @pytest.mark.asyncio
     async def test_evaluate_treatment_with_rbs_in_condition_async(self):
         e = evaluator.Evaluator(splitters.Splitter())