[FSSDK-11184] Update: Send CMAB uuid in impression events (#458)

* update: integrate CMAB components into OptimizelyFactory

* update: add cmab_service parameter to Optimizely constructor for CMAB support

* update: add docstring to DefaultCmabService class for improved documentation

* update: implement CMAB support in bucketer and decision service, revert OptimizelyFactory

* linting fix

* update: add cmab_uuid handling in DecisionService and related tests

* - updated function bucket_to_entity_id
- test_optimizely.py fixed to expect new Decision objects

* update: add None parameter to Decision constructor in user context tests

* update: enhance CMAB decision handling and add related tests

* update: fix logger message formatting in CMAB experiment tests

* mypy fix

* update: refine traffic allocation type hints and key naming in bucketer and decision service

* update: remove unused import of cast in bucketer.py

* update: fix return type for numeric_metric_value in get_numeric_value and ensure key is of bytes type in hash128

* update: specify type hint for numeric_metric_value in get_numeric_value function

* update: fix logger reference in DefaultCmabClient initialization and add __init__.py for cmab module

* update: enhance error logging for CMAB fetch failures with detailed messages and add a test for handling 500 errors

* update: enhance decision result handling by introducing VariationResult and updating get_variation return type to include detailed error information

* update: refactor get_variation return structure and change tests accordingly

* -Error propagated to optimizely.py
-test cases changed to handle return type dicts of DecisionResult and VariationResult

* update: add cmab_uuid parameter to impression events

* update: add None parameter to impression events in decision tests

* update: modify get_variation to return VariationResult and adjust related logic for improved variation handling

* update: unit test fixes

* update: include CMAB UUID in activation and add corresponding tests

* update: add tests for get_variation with and without CMAB UUID

* Revert "update: unit test fixes"

This reverts commit d2fc631.

* Revert "update: modify get_variation to return VariationResult and adjust related logic for improved variation handling"

This reverts commit b901c5f.

* update: make cmab_uuid parameter optional in _send_impression_event method

* chore: trigger CI by turning on python flag

* update: new class method to handle optimizely error decisions

* fix unit test

* fix: update error logging format for CMAB fetch failures

* chore: trigger CI

* update: enhance decision service to handle error states and improve bucketing logic

* update: remove debug print statement from Optimizely class

* update: enhance bucketing logic to support CMAB traffic allocations

* update: improve error logging for CMAB decision fetch failures

* update: improve logging and error handling in bucketer and decision service

* update: add test for CMAB UUID handling in decision events. Removed two redundant tests on legacy api.

* update: enhance CMAB UUID handling in decide method and verify dispatched events

Author: FarhanAnjum-opti

optimizely/event/event_factory.py

@@ -123,7 +123,9 @@ def _create_visitor(cls, event: Optional[user_event.UserEvent], logger: Logger)
                 experiment_layerId = event.experiment.layerId
                 experiment_id = event.experiment.id
 
-            metadata = payload.Metadata(event.flag_key, event.rule_key, event.rule_type, variation_key, event.enabled)
+            metadata = payload.Metadata(event.flag_key, event.rule_key,
+                                        event.rule_type, variation_key,
+                                        event.enabled, event.cmab_uuid)
             decision = payload.Decision(experiment_layerId, experiment_id, variation_id, metadata)
             snapshot_event = payload.SnapshotEvent(
                 experiment_layerId, event.uuid, cls.ACTIVATE_EVENT_KEY, event.timestamp,

optimizely/event/payload.py

@@ -81,12 +81,15 @@ def __init__(self, campaign_id: str, experiment_id: str, variation_id: str, meta
 class Metadata:
     """ Class respresenting Metadata. """
 
-    def __init__(self, flag_key: str, rule_key: str, rule_type: str, variation_key: str, enabled: bool):
+    def __init__(self, flag_key: str, rule_key: str, rule_type: str,
+                 variation_key: str, enabled: bool, cmab_uuid: Optional[str] = None):
         self.flag_key = flag_key
         self.rule_key = rule_key
         self.rule_type = rule_type
         self.variation_key = variation_key
         self.enabled = enabled
+        if cmab_uuid:
+            self.cmab_uuid = cmab_uuid
 
 
 class Snapshot:

optimizely/event/user_event.py

@@ -70,7 +70,8 @@ def __init__(
         rule_key: str,
         rule_type: str,
         enabled: bool,
-        bot_filtering: Optional[bool] = None
+        bot_filtering: Optional[bool] = None,
+        cmab_uuid: Optional[str] = None
     ):
         super().__init__(event_context, user_id, visitor_attributes, bot_filtering)
         self.experiment = experiment
@@ -79,6 +80,7 @@ def __init__(
         self.rule_key = rule_key
         self.rule_type = rule_type
         self.enabled = enabled
+        self.cmab_uuid = cmab_uuid
 
 
 class ConversionEvent(UserEvent):

optimizely/event/user_event_factory.py

@@ -40,7 +40,8 @@ def create_impression_event(
         rule_type: str,
         enabled: bool,
         user_id: str,
-        user_attributes: Optional[UserAttributes]
+        user_attributes: Optional[UserAttributes],
+        cmab_uuid: Optional[str]
     ) -> Optional[user_event.ImpressionEvent]:
         """ Create impression Event to be sent to the logging endpoint.
 
@@ -90,6 +91,7 @@ def create_impression_event(
             rule_type,
             enabled,
             project_config.get_bot_filtering_value(),
+            cmab_uuid,
         )
 
     @classmethod

optimizely/optimizely.py

@@ -15,6 +15,7 @@
 
 from typing import TYPE_CHECKING, Any, Optional
 
+
 from . import decision_service
 from . import entities
 from . import event_builder
@@ -260,7 +261,7 @@ def _validate_user_inputs(
     def _send_impression_event(
         self, project_config: project_config.ProjectConfig, experiment: Optional[entities.Experiment],
         variation: Optional[entities.Variation], flag_key: str, rule_key: str, rule_type: str,
-        enabled: bool, user_id: str, attributes: Optional[UserAttributes]
+        enabled: bool, user_id: str, attributes: Optional[UserAttributes], cmab_uuid: Optional[str] = None
     ) -> None:
         """ Helper method to send impression event.
 
@@ -280,7 +281,9 @@ def _send_impression_event(
 
         variation_id = variation.id if variation is not None else None
         user_event = user_event_factory.UserEventFactory.create_impression_event(
-            project_config, experiment, variation_id, flag_key, rule_key, rule_type, enabled, user_id, attributes
+            project_config, experiment, variation_id,
+            flag_key, rule_key, rule_type,
+            enabled, user_id, attributes, cmab_uuid
         )
 
         if user_event is None:
@@ -719,6 +722,8 @@ def is_feature_enabled(self, feature_key: str, user_id: str, attributes: Optiona
         user_context = OptimizelyUserContext(self, self.logger, user_id, attributes, False)
 
         decision = self.decision_service.get_variation_for_feature(project_config, feature, user_context)['decision']
+        cmab_uuid = decision.cmab_uuid
+
         is_source_experiment = decision.source == enums.DecisionSources.FEATURE_TEST
         is_source_rollout = decision.source == enums.DecisionSources.ROLLOUT
 
@@ -729,7 +734,7 @@ def is_feature_enabled(self, feature_key: str, user_id: str, attributes: Optiona
         if (is_source_rollout or not decision.variation) and project_config.get_send_flag_decisions_value():
             self._send_impression_event(
                 project_config, decision.experiment, decision.variation, feature.key, decision.experiment.key if
-                decision.experiment else '', str(decision.source), feature_enabled, user_id, attributes
+                decision.experiment else '', str(decision.source), feature_enabled, user_id, attributes, cmab_uuid
             )
 
         # Send event if Decision came from an experiment.
@@ -740,7 +745,7 @@ def is_feature_enabled(self, feature_key: str, user_id: str, attributes: Optiona
             }
             self._send_impression_event(
                 project_config, decision.experiment, decision.variation, feature.key, decision.experiment.key,
-                str(decision.source), feature_enabled, user_id, attributes
+                str(decision.source), feature_enabled, user_id, attributes, cmab_uuid
             )
 
         if feature_enabled:
@@ -1193,7 +1198,9 @@ def _create_optimizely_decision(
                                             flag_decision.variation,
                                             flag_key, rule_key or '',
                                             str(decision_source), feature_enabled,
-                                            user_id, attributes)
+                                            user_id, attributes,
+                                            flag_decision.cmab_uuid
+                                            )
 
                 decision_event_dispatched = True
 

tests/test_event_factory.py

@@ -113,6 +113,7 @@ def test_create_impression_event(self):
                 False,
                 'test_user',
                 None,
+                None
             )
 
         log_event = EventFactory.create_log_event(event_obj, self.logger)
@@ -177,6 +178,7 @@ def test_create_impression_event__with_attributes(self):
                 True,
                 'test_user',
                 {'test_attribute': 'test_value'},
+                None
             )
 
         log_event = EventFactory.create_log_event(event_obj, self.logger)
@@ -239,6 +241,7 @@ def test_create_impression_event_when_attribute_is_not_in_datafile(self):
                 True,
                 'test_user',
                 {'do_you_know_me': 'test_value'},
+                None
             )
 
         log_event = EventFactory.create_log_event(event_obj, self.logger)
@@ -394,6 +397,7 @@ def test_create_impression_event__with_user_agent_when_bot_filtering_is_enabled(
                 False,
                 'test_user',
                 {'$opt_user_agent': 'Edge'},
+                None
             )
 
         log_event = EventFactory.create_log_event(event_obj, self.logger)
@@ -466,6 +470,7 @@ def test_create_impression_event__with_empty_attributes_when_bot_filtering_is_en
                 False,
                 'test_user',
                 None,
+                None
             )
 
         log_event = EventFactory.create_log_event(event_obj, self.logger)
@@ -544,6 +549,7 @@ def test_create_impression_event__with_user_agent_when_bot_filtering_is_disabled
                 True,
                 'test_user',
                 {'$opt_user_agent': 'Chrome'},
+                None
             )
 
         log_event = EventFactory.create_log_event(event_obj, self.logger)
@@ -920,3 +926,136 @@ def test_create_conversion_event__when_event_is_used_in_multiple_experiments(sel
         self._validate_event_object(
             log_event, EventFactory.EVENT_ENDPOINT, expected_params, EventFactory.HTTP_VERB, EventFactory.HTTP_HEADERS,
         )
+
+    def test_create_impression_event_with_cmab_uuid(self):
+        """ Test that create_impression_event creates LogEvent object with CMAB UUID in metadata. """
+
+        expected_params = {
+            'account_id': '12001',
+            'project_id': '111001',
+            'visitors': [
+                {
+                    'visitor_id': 'test_user',
+                    'attributes': [],
+                    'snapshots': [
+                        {
+                            'decisions': [
+                                {'variation_id': '111129', 'experiment_id': '111127', 'campaign_id': '111182',
+                                 'metadata': {'flag_key': '',
+                                              'rule_key': 'rule_key',
+                                              'rule_type': 'experiment',
+                                              'variation_key': 'variation',
+                                              'enabled': False,
+                                              'cmab_uuid': 'test-cmab-uuid-123'
+                                              }
+                                 }
+                            ],
+                            'events': [
+                                {
+                                    'timestamp': 42123,
+                                    'entity_id': '111182',
+                                    'uuid': 'a68cf1ad-0393-4e18-af87-efe8f01a7c9c',
+                                    'key': 'campaign_activated',
+                                }
+                            ],
+                        }
+                    ],
+                }
+            ],
+            'client_name': 'python-sdk',
+            'client_version': version.__version__,
+            'enrich_decisions': True,
+            'anonymize_ip': False,
+            'revision': '42',
+        }
+
+        with mock.patch('time.time', return_value=42.123), mock.patch(
+            'uuid.uuid4', return_value='a68cf1ad-0393-4e18-af87-efe8f01a7c9c'
+        ):
+            event_obj = UserEventFactory.create_impression_event(
+                self.project_config,
+                self.project_config.get_experiment_from_key('test_experiment'),
+                '111129',
+                '',
+                'rule_key',
+                'experiment',
+                False,
+                'test_user',
+                None,
+                'test-cmab-uuid-123'  # cmab_uuid parameter
+            )
+
+        log_event = EventFactory.create_log_event(event_obj, self.logger)
+
+        self._validate_event_object(
+            log_event, EventFactory.EVENT_ENDPOINT, expected_params, EventFactory.HTTP_VERB, EventFactory.HTTP_HEADERS,
+        )
+
+    def test_create_impression_event_without_cmab_uuid(self):
+        """ Test that create_impression_event creates LogEvent object without CMAB UUID when not provided. """
+
+        expected_params = {
+            'account_id': '12001',
+            'project_id': '111001',
+            'visitors': [
+                {
+                    'visitor_id': 'test_user',
+                    'attributes': [],
+                    'snapshots': [
+                        {
+                            'decisions': [
+                                {
+                                    'variation_id': '111129', 'experiment_id': '111127', 'campaign_id': '111182',
+                                    'metadata': {
+                                        'flag_key': '',
+                                        'rule_key': 'rule_key',
+                                        'rule_type': 'experiment',
+                                        'variation_key': 'variation',
+                                        'enabled': False
+                                    }
+                                }
+                            ],
+                            'events': [
+                                {
+                                    'timestamp': 42123,
+                                    'entity_id': '111182',
+                                    'uuid': 'a68cf1ad-0393-4e18-af87-efe8f01a7c9c',
+                                    'key': 'campaign_activated',
+                                }
+                            ],
+                        }
+                    ],
+                }
+            ],
+            'client_name': 'python-sdk',
+            'client_version': version.__version__,
+            'enrich_decisions': True,
+            'anonymize_ip': False,
+            'revision': '42',
+        }
+
+        with mock.patch('time.time', return_value=42.123), mock.patch(
+            'uuid.uuid4', return_value='a68cf1ad-0393-4e18-af87-efe8f01a7c9c'
+        ):
+            event_obj = UserEventFactory.create_impression_event(
+                self.project_config,
+                self.project_config.get_experiment_from_key('test_experiment'),
+                '111129',
+                '',
+                'rule_key',
+                'experiment',
+                False,
+                'test_user',
+                None,
+                None  # No cmab_uuid
+            )
+
+        log_event = EventFactory.create_log_event(event_obj, self.logger)
+
+        # Verify no cmab_uuid in metadata
+        metadata = log_event.params['visitors'][0]['snapshots'][0]['decisions'][0]['metadata']
+        self.assertNotIn('cmab_uuid', metadata)
+
+        self._validate_event_object(
+            log_event, EventFactory.EVENT_ENDPOINT, expected_params, EventFactory.HTTP_VERB, EventFactory.HTTP_HEADERS,
+        )

tests/test_optimizely.py

@@ -5750,3 +5750,77 @@ def test_decide_returns_error_decision_when_decision_service_fails(self):
             self.assertIsNone(decision.rule_key)
             self.assertEqual(decision.flag_key, 'test_feature_in_experiment')
             self.assertIn('CMAB service failed to fetch decision', decision.reasons)
+
+    def test_decide_includes_cmab_uuid_in_dispatched_event(self):
+        """Test that decide dispatches event with correct CMAB UUID."""
+        import copy
+        from typing import List
+        config_dict = copy.deepcopy(self.config_dict_with_features)
+        config_dict['experiments'][0]['cmab'] = {'attributeIds': ['808797688', '808797689'], 'trafficAllocation': 4000}
+        config_dict['experiments'][0]['trafficAllocation'] = []
+
+        class TestEventDispatcher:
+            """Custom event dispatcher for testing that captures dispatched events."""
+
+            def __init__(self):
+                self.dispatched_events: List[event_builder.Event] = []
+
+            def dispatch_event(self, event: event_builder.Event) -> None:
+                """Capture the event instead of actually dispatching it."""
+                self.dispatched_events.append(event)
+
+        test_dispatcher = TestEventDispatcher()
+
+        opt_obj = optimizely.Optimizely(json.dumps(config_dict), event_dispatcher=test_dispatcher)
+        user_context = opt_obj.create_user_context('test_user')
+        project_config = opt_obj.config_manager.get_config()
+
+        # Mock decision service to return a CMAB result
+        expected_cmab_uuid = 'uuid-cmab'
+        mock_experiment = project_config.get_experiment_from_key('test_experiment')
+        mock_variation = project_config.get_variation_from_id('test_experiment', '111129')
+
+        # Create decision with CMAB UUID
+        decision_with_cmab = decision_service.Decision(
+            mock_experiment,
+            mock_variation,
+            enums.DecisionSources.FEATURE_TEST,
+            expected_cmab_uuid
+        )
+
+        # Mock the decision service method that's actually called by decide
+        with mock.patch.object(
+            opt_obj.decision_service, 'get_variations_for_feature_list',
+            return_value=[{
+                'decision': decision_with_cmab,
+                'reasons': [],
+                'error': False
+            }]
+        ):
+            # Call decide
+            decision = user_context.decide('test_feature_in_experiment')
+
+            # Verify the decision contains the expected information
+            self.assertTrue(decision.enabled)
+            self.assertEqual(decision.variation_key, 'variation')
+            self.assertEqual(decision.rule_key, 'test_experiment')
+            self.assertEqual(decision.flag_key, 'test_feature_in_experiment')
+
+        # Verify an event was dispatched
+        time.sleep(0.1)
+        self.assertEqual(len(test_dispatcher.dispatched_events), 1)
+
+        dispatched_event = test_dispatcher.dispatched_events[0]
+
+        # Verify the structure exists before accessing
+        self.assertIn('visitors', dispatched_event.params)
+        self.assertTrue(len(dispatched_event.params['visitors']) > 0)
+        self.assertIn('snapshots', dispatched_event.params['visitors'][0])
+        self.assertTrue(len(dispatched_event.params['visitors'][0]['snapshots']) > 0)
+        self.assertIn('decisions', dispatched_event.params['visitors'][0]['snapshots'][0])
+        self.assertTrue(len(dispatched_event.params['visitors'][0]['snapshots'][0]['decisions']) > 0)
+
+        # Get the metadata and assert CMAB UUID
+        metadata = dispatched_event.params['visitors'][0]['snapshots'][0]['decisions'][0]['metadata']
+        self.assertIn('cmab_uuid', metadata)
+        self.assertEqual(metadata['cmab_uuid'], expected_cmab_uuid)