Send event on feature access (#75)

aliabbasrizvi · web-flow · commit 70e1d440c7bf · 2017-09-01T10:20:05.000+05:30
diff --git a/optimizely/decision_service.py b/optimizely/decision_service.py
@@ -12,6 +12,7 @@
 # limitations under the License.
 
 import sys
+from collections import namedtuple
 
 from . import bucketer
 from .helpers import audience as audience_helper
@@ -21,6 +22,9 @@
 from .user_profile import UserProfile
 
 
+Decision = namedtuple('Decision', 'experiment variation')
+
+
 class DecisionService(object):
   """ Class encapsulating all decision related capabilities. """
 
@@ -86,7 +90,7 @@ def get_variation(self, experiment, user_id, attributes, ignore_user_profile=Fal
     Fifth, bucket the user and return the variation.
 
     Args:
-      experiment_key: Experiment for which user variation needs to be determined.
+      experiment: Experiment for which user variation needs to be determined.
       user_id: ID for user.
       attributes: Dict representing user attributes.
       ignore_user_profile: True to ignore the user profile lookup. Defaults to False.
@@ -156,7 +160,7 @@ def get_variation(self, experiment, user_id, attributes, ignore_user_profile=Fal
     return None
 
   def get_variation_for_rollout(self, rollout, user_id, attributes=None):
-    """ Determine which variation the user is in for a given rollout.
+    """ Determine which experiment/variation the user is in for a given rollout.
     Returns the variation of the first experiment the user qualifies for.
 
     Args:
@@ -165,7 +169,7 @@ def get_variation_for_rollout(self, rollout, user_id, attributes=None):
       attributes: Dict representing user attributes.
 
     Returns:
-      Variation the user should see. None if the user is not in any of the rollout's targeting rules.
+      Decision namedtuple consisting of experiment and variation for the user.
     """
 
     # Go through each experiment in order and try to get the variation for the user
@@ -186,7 +190,7 @@ def get_variation_for_rollout(self, rollout, user_id, attributes=None):
         if variation:
           self.logger.log(enums.LogLevels.DEBUG,
                           'User "%s" is in variation %s of experiment %s.' % (user_id, variation.key, experiment.key))
-          return variation
+          return Decision(experiment, variation)
         else:
           # Evaluate no further rules
           self.logger.log(enums.LogLevels.DEBUG,
@@ -203,22 +207,23 @@ def get_variation_for_rollout(self, rollout, user_id, attributes=None):
         if variation:
           self.logger.log(enums.LogLevels.DEBUG,
                           'User "%s" meets conditions for targeting rule "Everyone Else".' % user_id)
-          return variation
+          return Decision(everyone_else_experiment, variation)
 
-    return None
+    return Decision(None, None)
 
   def get_variation_for_feature(self, feature, user_id, attributes=None):
-    """ Returns the variation the user is bucketed in for the given feature.
+    """ Returns the experiment/variation the user is bucketed in for the given feature.
 
     Args:
       feature: Feature for which we are determining if it is enabled or not for the given user.
       user_id: ID for user.
       attributes: Dict representing user attributes.
 
     Returns:
-      Variation that the user is bucketed in. None if the user is not in any variation.
+      Decision namedtuple consisting of experiment and variation for the user.
     """
 
+    experiment = None
     variation = None
 
     # First check if the feature is in a mutex group
@@ -249,9 +254,9 @@ def get_variation_for_feature(self, feature, user_id, attributes=None):
     # Next check if user is part of a rollout
     if not variation and feature.rolloutId:
       rollout = self.config.get_rollout_from_id(feature.rolloutId)
-      variation = self.get_variation_for_rollout(rollout, user_id, attributes)
+      return self.get_variation_for_rollout(rollout, user_id, attributes)
 
-    return variation
+    return Decision(experiment, variation)
 
   def get_experiment_in_group(self, group, user_id):
     """ Determine which experiment in the group the user is bucketed into.
diff --git a/optimizely/optimizely.py b/optimizely/optimizely.py
@@ -152,6 +152,31 @@ def _get_decisions(self, event, user_id, attributes):
 
     return decisions
 
+  def _send_impression_event(self, experiment, variation, user_id, attributes):
+    """ Helper method to send impression event.
+
+    Args:
+      experiment: Experiment for which impression event is being sent.
+      variation: Variation picked for user for the given experiment.
+      user_id: ID for user.
+      attributes: Dict representing user attributes and values which need to be recorded.
+    """
+
+    impression_event = self.event_builder.create_impression_event(experiment,
+                                                                  variation.id,
+                                                                  user_id,
+                                                                  attributes)
+
+    self.logger.log(enums.LogLevels.DEBUG,
+                    'Dispatching impression event to URL %s with params %s.' % (impression_event.url,
+                                                                                impression_event.params))
+
+    try:
+      self.event_dispatcher.dispatch_event(impression_event)
+    except:
+      error = sys.exc_info()[1]
+      self.logger.log(enums.LogLevels.ERROR, 'Unable to dispatch impression event. Error: %s' % str(error))
+
   def activate(self, experiment_key, user_id, attributes=None):
     """ Buckets visitor and sends impression event to Optimizely.
 
@@ -175,19 +200,12 @@ def activate(self, experiment_key, user_id, attributes=None):
       self.logger.log(enums.LogLevels.INFO, 'Not activating user "%s".' % user_id)
       return None
 
-    # Create and dispatch impression event
     experiment = self.config.get_experiment_from_key(experiment_key)
     variation = self.config.get_variation_from_key(experiment_key, variation_key)
-    impression_event = self.event_builder.create_impression_event(experiment, variation.id, user_id, attributes)
+
+    # Create and dispatch impression event
     self.logger.log(enums.LogLevels.INFO, 'Activating user "%s" in experiment "%s".' % (user_id, experiment.key))
-    self.logger.log(enums.LogLevels.DEBUG,
-                    'Dispatching impression event to URL %s with params %s.' % (impression_event.url,
-                                                                                impression_event.params))
-    try:
-      self.event_dispatcher.dispatch_event(impression_event)
-    except:
-      error = sys.exc_info()[1]
-      self.logger.log(enums.LogLevels.ERROR, 'Unable to dispatch impression event. Error: %s' % str(error))
+    self._send_impression_event(experiment, variation, user_id, attributes)
 
     return variation.key
 
@@ -297,9 +315,13 @@ def is_feature_enabled(self, feature_key, user_id, attributes=None):
     if not feature:
       return False
 
-    variation = self.decision_service.get_variation_for_feature(feature, user_id, attributes)
-    if variation:
+    decision = self.decision_service.get_variation_for_feature(feature, user_id, attributes)
+    if decision.variation:
       self.logger.log(enums.LogLevels.INFO, 'Feature "%s" is enabled for user "%s".' % (feature_key, user_id))
+      self._send_impression_event(decision.experiment,
+                                  decision.variation,
+                                  user_id,
+                                  attributes)
       return True
 
     self.logger.log(enums.LogLevels.INFO, 'Feature "%s" is not enabled for user "%s".' % (feature_key, user_id))
diff --git a/tests/test_decision_service.py b/tests/test_decision_service.py
@@ -14,6 +14,7 @@
 import json
 import mock
 
+from optimizely import decision_service
 from optimizely import entities
 from optimizely import optimizely
 from optimizely import user_profile
@@ -343,7 +344,8 @@ def test_get_variation_for_rollout__returns_none_if_no_experiments(self, mock_lo
     """ Test that get_variation_for_rollout returns None if there are no experiments (targeting rules). """
 
     no_experiment_rollout = self.project_config.get_rollout_from_id('201111')
-    self.assertIsNone(self.decision_service.get_variation_for_rollout(no_experiment_rollout, 'test_user'))
+    self.assertEqual(decision_service.Decision(None, None),
+                     self.decision_service.get_variation_for_rollout(no_experiment_rollout, 'test_user'))
 
     # Assert no log messages were generated
     self.assertEqual(0, mock_logging.call_count)
@@ -356,7 +358,8 @@ def test_get_variation_for_rollout__skips_to_everyone_else_rule(self, mock_loggi
 
     with mock.patch('optimizely.helpers.audience.is_user_in_experiment', return_value=True) as mock_audience_check,\
       mock.patch('optimizely.bucketer.Bucketer.bucket', return_value=None):
-      self.assertIsNone(self.decision_service.get_variation_for_rollout(rollout, 'test_user'))
+      self.assertEqual(decision_service.Decision(None, None),
+                       self.decision_service.get_variation_for_rollout(rollout, 'test_user'))
 
     # Check that after first experiment, it skips to the last experiment to check
     self.assertEqual(
@@ -378,7 +381,8 @@ def test_get_variation_for_rollout__returns_none_for_user_not_in_rollout(self, m
     rollout = self.project_config.get_rollout_from_id('211111')
 
     with mock.patch('optimizely.helpers.audience.is_user_in_experiment', return_value=False) as mock_audience_check:
-      self.assertIsNone(self.decision_service.get_variation_for_rollout(rollout, 'test_user'))
+      self.assertEqual(decision_service.Decision(None, None),
+                       self.decision_service.get_variation_for_rollout(rollout, 'test_user'))
 
     # Check that all experiments in rollout layer were checked
     self.assertEqual(
@@ -399,11 +403,12 @@ def test_get_variation_for_feature__returns_variation_for_feature_in_experiment(
 
     feature = self.project_config.get_feature_from_key('test_feature_in_experiment')
 
+    expected_experiment = self.project_config.get_experiment_from_key('test_experiment')
     expected_variation = self.project_config.get_variation_from_id('test_experiment', '111129')
-    with mock.patch(
-      'optimizely.decision_service.DecisionService.get_variation',
-      return_value=expected_variation) as mock_decision:
-      self.assertEqual(expected_variation, self.decision_service.get_variation_for_feature(feature, 'user1'))
+    with mock.patch('optimizely.decision_service.DecisionService.get_variation',
+                    return_value=expected_variation) as mock_decision:
+      self.assertEqual(decision_service.Decision(expected_experiment, expected_variation),
+                       self.decision_service.get_variation_for_feature(feature, 'user1'))
 
     mock_decision.assert_called_once_with(
       self.project_config.get_experiment_from_key('test_experiment'), 'user1', None
@@ -436,12 +441,14 @@ def test_get_variation_for_feature__returns_variation_if_user_not_in_experiment_
 
     feature = self.project_config.get_feature_from_key('test_feature_in_experiment_and_rollout')
 
+    expected_experiment = self.project_config.get_experiment_from_key('211127')
     expected_variation = self.project_config.get_variation_from_id('211127', '211129')
     with mock.patch(
       'optimizely.helpers.audience.is_user_in_experiment',
       side_effect=[False, True]) as mock_audience_check, \
       mock.patch('optimizely.bucketer.Bucketer.bucket', return_value=expected_variation):
-      self.assertEqual(expected_variation, self.decision_service.get_variation_for_feature(feature, 'user1'))
+      self.assertEqual(decision_service.Decision(expected_experiment, expected_variation),
+                       self.decision_service.get_variation_for_feature(feature, 'user1'))
 
     self.assertEqual(2, mock_audience_check.call_count)
     mock_audience_check.assert_any_call(self.project_config,
@@ -453,21 +460,20 @@ def test_get_variation_for_feature__returns_variation_for_feature_in_group(self,
     """ Test that get_variation_for_feature returns the variation of
      the experiment the user is bucketed in the feature's group. """
 
-    opt_obj = optimizely.Optimizely(json.dumps(self.config_dict_with_features))
-    project_config = opt_obj.config
-    decision_service = opt_obj.decision_service
-    feature = project_config.get_feature_from_key('test_feature_in_group')
+    feature = self.project_config.get_feature_from_key('test_feature_in_group')
 
-    expected_variation = project_config.get_variation_from_id('group_exp_1', '28901')
+    expected_experiment = self.project_config.get_experiment_from_key('group_exp_1')
+    expected_variation = self.project_config.get_variation_from_id('group_exp_1', '28901')
     with mock.patch(
       'optimizely.decision_service.DecisionService.get_experiment_in_group',
-      return_value=project_config.get_experiment_from_key('group_exp_1')) as mock_get_experiment_in_group, \
+      return_value=self.project_config.get_experiment_from_key('group_exp_1')) as mock_get_experiment_in_group, \
       mock.patch('optimizely.decision_service.DecisionService.get_variation',
                  return_value=expected_variation) as mock_decision:
-      self.assertEqual(expected_variation, decision_service.get_variation_for_feature(feature, 'user1'))
+      self.assertEqual(decision_service.Decision(expected_experiment, expected_variation),
+                       self.decision_service.get_variation_for_feature(feature, 'user1'))
 
-    mock_get_experiment_in_group.assert_called_once_with(project_config.get_group('19228'), 'user1')
-    mock_decision.assert_called_once_with(project_config.get_experiment_from_key('group_exp_1'), 'user1', None)
+    mock_get_experiment_in_group.assert_called_once_with(self.project_config.get_group('19228'), 'user1')
+    mock_decision.assert_called_once_with(self.project_config.get_experiment_from_key('group_exp_1'), 'user1', None)
 
   def test_get_variation_for_feature__returns_none_for_user_not_in_group(self, _):
     """ Test that get_variation_for_feature returns None for
@@ -478,7 +484,8 @@ def test_get_variation_for_feature__returns_none_for_user_not_in_group(self, _):
     with mock.patch('optimizely.decision_service.DecisionService.get_experiment_in_group',
                     return_value=None) as mock_get_experiment_in_group, \
       mock.patch('optimizely.decision_service.DecisionService.get_variation') as mock_decision:
-      self.assertIsNone(self.decision_service.get_variation_for_feature(feature, 'user1'))
+      self.assertEqual(decision_service.Decision(None, None),
+                       self.decision_service.get_variation_for_feature(feature, 'user1'))
 
     mock_get_experiment_in_group.assert_called_once_with(self.project_config.get_group('19228'), 'user1')
     self.assertFalse(mock_decision.called)
@@ -487,9 +494,11 @@ def test_get_variation_for_feature__returns_none_for_user_not_in_experiment(self
     """ Test that get_variation_for_feature returns None for user not in the associated experiment. """
 
     feature = self.project_config.get_feature_from_key('test_feature_in_experiment')
+    expected_experiment = self.project_config.get_experiment_from_key('test_experiment')
 
     with mock.patch('optimizely.decision_service.DecisionService.get_variation', return_value=None) as mock_decision:
-      self.assertIsNone(self.decision_service.get_variation_for_feature(feature, 'user1'))
+      self.assertEqual(decision_service.Decision(expected_experiment, None),
+                       self.decision_service.get_variation_for_feature(feature, 'user1'))
 
     mock_decision.assert_called_once_with(
       self.project_config.get_experiment_from_key('test_experiment'), 'user1', None
@@ -500,10 +509,12 @@ def test_get_variation_for_feature__returns_none_for_user_in_group_experiment_no
     not targeting a feature, then None is returned. """
 
     feature = self.project_config.get_feature_from_key('test_feature_in_group')
+    expected_experiment = self.project_config.get_experiment_from_key('group_exp_2')
 
     with mock.patch('optimizely.decision_service.DecisionService.get_experiment_in_group',
                     return_value=self.project_config.get_experiment_from_key('group_exp_2')) as mock_decision:
-      self.assertIsNone(self.decision_service.get_variation_for_feature(feature, 'user_1'))
+      self.assertEqual(decision_service.Decision(expected_experiment, None),
+                       self.decision_service.get_variation_for_feature(feature, 'user_1'))
 
     mock_decision.assert_called_once_with(self.project_config.get_group('19228'), 'user_1')
 
diff --git a/tests/test_optimizely.py b/tests/test_optimizely.py
