feat: getFlag Batching

Author: Abhi591

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.15.0] - 2025-11-20
+
+### Added
+
+- Added batch event processing to optimize network calls during GetFlag operations. Multiple impression events are now collected and sent in a single batch request
+
 ## [1.14.0] - 2025-11-17
 
 ### Added

setup.py

@@ -121,7 +121,7 @@ def run(self):
 
 setup(
     name="vwo-fme-python-sdk",
-    version="1.14.0",
+    version="1.15.0",
     description="VWO Feature Management and Experimentation SDK for Python",
     long_description=long_description,
     long_description_content_type="text/markdown",

vwo/api/get_flag_api.py

@@ -33,7 +33,10 @@
 )
 from ..utils.rule_evaluation_util import evaluate_rule
 from ..utils.decision_util import evaluate_traffic_and_get_variation
-from ..utils.impression_util import create_and_send_impression_for_variation_shown
+from ..utils.impression_util import (
+    send_impression_for_variation_shown_batch,
+    send_impression_for_variation_shown,
+)
 from ..models.user.get_flag import GetFlag
 from ..services.storage_service import StorageService
 from ..decorators.storage_decorator import StorageDecorator
@@ -42,6 +45,9 @@
 from ..packages.logger.enums.log_level_enum import LogLevelEnum
 from ..constants.Constants import Constants
 from ..utils.debugger_service_util import send_debug_event_to_vwo
+from ..utils.network_util import get_track_user_payload_data
+from ..enums.event_enum import EventEnum
+from ..services.settings_manager import SettingsManager
 
 
 class GetFlagApi:
@@ -87,6 +93,7 @@ def get(
         stored_data = StorageDecorator().get_feature_from_storage(
             feature_key, context, storage_service
         )
+        batchPayload = []
 
         if stored_data and stored_data.get("experimentVariationId"):
             if "experimentKey" in stored_data:
@@ -153,24 +160,36 @@ def get(
             rollout_rules_to_evaluate: List[CampaignModel] = []
 
             for rule in roll_out_rules:
-                pre_segmentation_result, whitelisted_object, updated_decision = (
-                    evaluate_rule(
-                        settings,
-                        feature,
-                        rule,
-                        context,
-                        self._evaluated_feature_map,
-                        {},
-                        storage_service,
-                        decision,
-                    )
+                (
+                    pre_segmentation_result,
+                    whitelisted_object,
+                    updated_decision,
+                    payload,
+                ) = evaluate_rule(
+                    settings,
+                    feature,
+                    rule,
+                    context,
+                    self._evaluated_feature_map,
+                    {},
+                    storage_service,
+                    decision,
                 )
-
                 decision.update(updated_decision)
 
                 if pre_segmentation_result:
                     rollout_rules_to_evaluate.append(rule)
 
+                    if (
+                        SettingsManager.get_instance().is_gateway_service_provided
+                        and payload is not None
+                        and len(payload) > 0
+                    ):
+                        send_impression_for_variation_shown(payload, context)
+                    else:
+                        if payload is not None and len(payload) > 0:
+                            batchPayload.append(payload)
+
                     self._evaluated_feature_map[feature_key] = {
                         "rolloutId": rule.get_id(),
                         "rolloutKey": rule.get_key(),
@@ -194,13 +213,23 @@ def get(
                     self._update_integrations_decision_object(
                         rollout_rules_to_evaluate[0], variation, decision
                     )
-                    create_and_send_impression_for_variation_shown(
+
+                    payload = get_track_user_payload_data(
                         settings,
+                        EventEnum.VWO_VARIATION_SHOWN.value,
                         rollout_rules_to_evaluate[0].get_id(),
                         variation.get_id(),
                         context,
-                        feature_key,
                     )
+                    if (
+                        SettingsManager.get_instance().is_gateway_service_provided
+                        and payload is not None
+                        and len(payload) > 0
+                    ):
+                        send_impression_for_variation_shown(payload, context)
+                    else:
+                        if payload is not None and len(payload) > 0:
+                            batchPayload.append(payload)
 
         if not roll_out_rules:
             LogManager.get_instance().debug(
@@ -215,17 +244,20 @@ def get(
             meg_group_winner_campaigns = {}
 
             for rule in experiment_rules:
-                pre_segmentation_result, whitelisted_object, updated_decision = (
-                    evaluate_rule(
-                        settings,
-                        feature,
-                        rule,
-                        context,
-                        self._evaluated_feature_map,
-                        meg_group_winner_campaigns,
-                        storage_service,
-                        decision,
-                    )
+                (
+                    pre_segmentation_result,
+                    whitelisted_object,
+                    updated_decision,
+                    payload,
+                ) = evaluate_rule(
+                    settings,
+                    feature,
+                    rule,
+                    context,
+                    self._evaluated_feature_map,
+                    meg_group_winner_campaigns,
+                    storage_service,
+                    decision,
                 )
 
                 decision.update(updated_decision)
@@ -234,6 +266,16 @@ def get(
                     if whitelisted_object is None:
                         experiment_rules_to_evaluate.append(rule)
                     else:
+                        if (
+                            SettingsManager.get_instance().is_gateway_service_provided
+                            and payload is not None
+                            and len(payload) > 0
+                        ):
+                            send_impression_for_variation_shown(payload, context)
+                        else:
+                            if payload is not None and len(payload) > 0:
+                                batchPayload.append(payload)
+
                         self._get_flag_response.set_is_enabled(True)
                         self._get_flag_response.set_variables(
                             whitelisted_object["variation"].get_variables()
@@ -263,13 +305,23 @@ def get(
                     self._update_integrations_decision_object(
                         experiment_rules_to_evaluate[0], variation, decision
                     )
-                    create_and_send_impression_for_variation_shown(
+
+                    payload = get_track_user_payload_data(
                         settings,
+                        EventEnum.VWO_VARIATION_SHOWN.value,
                         experiment_rules_to_evaluate[0].get_id(),
                         variation.get_id(),
                         context,
-                        feature_key,
                     )
+                    if (
+                        SettingsManager.get_instance().is_gateway_service_provided
+                        and payload is not None
+                        and len(payload) > 0
+                    ):
+                        send_impression_for_variation_shown(payload, context)
+                    else:
+                        if payload is not None and len(payload) > 0:
+                            batchPayload.append(payload)
 
         if self._get_flag_response.is_enabled():
             StorageDecorator().set_data_in_storage(
@@ -310,14 +362,26 @@ def get(
                 )
             )
 
-            create_and_send_impression_for_variation_shown(
+            payload = get_track_user_payload_data(
                 settings,
+                EventEnum.VWO_VARIATION_SHOWN.value,
                 feature.get_impact_campaign().get_campaign_id(),
-                (
-                    2 if self._get_flag_response.is_enabled() else 1
-                ),  # 2 is for Variation (flag enabled), 1 is for Control (flag disabled)
-                context,
-                feature_key,
+                (2 if self._get_flag_response.is_enabled() else 1),
+                context
+            )
+            if (
+                SettingsManager.get_instance().is_gateway_service_provided
+                and payload is not None
+                and len(payload) > 0
+            ):
+                send_impression_for_variation_shown(payload, context)
+            else:
+                if payload is not None and len(payload) > 0:
+                    batchPayload.append(payload)
+
+        if not SettingsManager.get_instance().is_gateway_service_provided:
+            send_impression_for_variation_shown_batch(
+                batchPayload, settings.get_account_id(), settings.get_sdk_key()
             )
 
         return self._get_flag_response

vwo/constants/Constants.py

@@ -17,7 +17,7 @@ class Constants:
     # TODO: read from setup.py
     sdk_meta = {
         "name": "vwo-fme-python-sdk",
-        "version": "1.14.0"
+        "version": "1.15.0"
     }
 
     # Constants

vwo/utils/campaign_util.py

@@ -53,7 +53,7 @@ def set_variation_allocation(campaign: CampaignModel) -> None:
             LogManager.get_instance().info(
                 info_messages.get("VARIATION_RANGE_ALLOCATION").format(
                     variationKey=variation.get_name(),
-                    campaignKey=campaign.get_rule_key(),
+                    campaignKey=campaign.get_key(),
                     variationWeight=variation.get_weight(),
                     startRange=variation.get_start_range_variation(),
                     endRange=variation.get_end_range_variation(),
@@ -452,7 +452,7 @@ def _handle_rollout_campaign(campaign: CampaignModel) -> None:
         LogManager.get_instance().info(
             info_messages.get("VARIATION_RANGE_ALLOCATION").format(
                 variationKey=variation.get_name(),
-                campaignKey=campaign.get_rule_key(),
+                campaignKey=campaign.get_key(),
                 variationWeight=variation.get_weight(),
                 startRange=1,
                 endRange=end_range,

vwo/utils/impression_util.py

@@ -13,51 +13,31 @@
 # limitations under the License.
 
 
-from ..models.settings.settings_model import SettingsModel
 from ..models.user.context_model import ContextModel
 from ..utils.network_util import (
     get_events_base_properties,
-    get_track_user_payload_data,
     send_post_api_request,
+    send_post_batch_request,
 )
 from ..enums.event_enum import EventEnum
-from ..utils.campaign_util import (
-    get_campaign_key_from_campaign_id,
-    get_variation_name_from_campaign_id_and_variation_id,
-    get_campaign_type_from_campaign_id,
-)
-from ..constants.Constants import Constants
+from ..packages.network_layer.manager.network_manager import NetworkManager
 
 
 # The function that creates and sends an impression for a variation shown event
-def create_and_send_impression_for_variation_shown(
-    settings: SettingsModel, campaign_id: int, variation_id: int, context: ContextModel, feature_key: str
-):
+def send_impression_for_variation_shown(payload: dict, context: ContextModel):
+    """
+    Sends an impression for a variation shown event.
+    :param payload: The payload containing the event data
+    :param context: The context of the user
+    """
     from ..vwo_client import VWOClient
+
     # Get base properties for the event
     properties = get_events_base_properties(
         EventEnum.VWO_VARIATION_SHOWN.value,
         visitor_user_agent=context.get_user_agent(),
         ip_address=context.get_ip_address(),
     )
-    # Construct payload data for tracking the user
-    payload = get_track_user_payload_data(
-        settings,
-        EventEnum.VWO_VARIATION_SHOWN.value,
-        campaign_id,
-        variation_id,
-        context,
-    )
-
-    campaign_key_with_feaure_key = get_campaign_key_from_campaign_id(settings, campaign_id)
-    variation_name = get_variation_name_from_campaign_id_and_variation_id(settings, campaign_id, variation_id)
-    campaign_type = get_campaign_type_from_campaign_id(settings, campaign_id)
-    campaign_key = None
-    if feature_key == campaign_key_with_feaure_key:
-        campaign_key = Constants.IMPACT_ANALYSIS
-    else:
-        feature_key_with_underscore = feature_key + "_"
-        campaign_key = campaign_key_with_feaure_key.split(feature_key_with_underscore)[1]
 
     vwo_instance = VWOClient.get_instance()
 
@@ -67,9 +47,37 @@ def create_and_send_impression_for_variation_shown(
         vwo_instance.batch_event_queue.enqueue(payload)
     else:
         # Send the event immediately if batch events are not enabled
-        send_post_api_request(properties, payload, context.get_id(), feature_info={
-            "campaign_key": campaign_key,
-            "variation_name": variation_name,
-            "campaign_type": campaign_type,
-            "feature_key": feature_key,
-        })
+        send_post_api_request(properties, payload, context.get_id())
+
+def send_impression_for_variation_shown_batch(
+    batch_payload: dict, account_id: int, sdk_key: str
+):
+    """
+    Sends an impression for a variation shown event in batch.
+    :param batch_payload: The batch payload containing all events from getFlag for a single user
+    :param account_id: The account ID
+    :param sdk_key: The SDK key
+    """
+    from ..vwo_client import VWOClient
+
+    vwo_instance = VWOClient.get_instance()
+    if vwo_instance.batch_event_queue is not None:
+        # batch_payload - contains all events from getFlag for a single user
+        # add each event to the batch queue
+        for payload in batch_payload:
+            vwo_instance.batch_event_queue.enqueue(payload)
+    else:
+        # Send the batch events immediately if batch events are not enabled
+        network_instance = NetworkManager.get_instance()
+
+        # Create a method to send the request
+        def send_batch_request():
+            send_post_batch_request(batch_payload, account_id, sdk_key)
+
+        # check if threading is enabled
+        if network_instance.should_use_threading:
+            # execute the request in a background thread
+            network_instance.execute_in_background(send_batch_request)
+        else:
+            # execute the request immediately
+            send_batch_request()