vwo-sdk 1.16.0 → 1.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '084660e0c3fcb3c07826944ba8d83988711b59165ea54a54b1e47042a889bbf5'
-  data.tar.gz: 62c4ae889870a381d2973967412f0916baa0d25ce377604aa096c5f4dd0a8e79
+  metadata.gz: 84d01560f605a69e8ed011a19ba4e3aae0f67341fd653a562d817801d6a55073
+  data.tar.gz: b1355bef1b2b095774c702a6757c1a7141e2cf9758d0a1b8a0510111a8ee597a
 SHA512:
-  metadata.gz: 67fd788b416ac54e9d27999ca757662eb88a123a804ccf3c93538e58787a3fd1181686543a7abdbb94dbd7d66f5d1c63421ae21d1b3e794b93cff6951355fdd2
-  data.tar.gz: 7950a38da6e5993575ff46e1c1ba2f901d98fa4112e54070297c78846e2b29eacdae4042c51d03f1e9e8b05d55aa4e60b698fa70af43c7d1ae2167953aaaec6c
+  metadata.gz: cc2c8a411e3c0a674ab2bc00e540b3e49a8dd943ec50aa04fba04839ef6f3e255fc275529f872aa5ca73dfe893cb43e8853a0875cc3dda9330554b6491590947
+  data.tar.gz: 5482e79564a365ec8fe4012b25997096352129e915daca28774c790c416a528302ea1f0bb685ef559b9ee0846b0229957a8f6ab77008f4e48222a7cae5892699

data/lib/abc.txt

@@ -0,0 +1,28 @@
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS

data/lib/vwo/constants.rb

@@ -19,6 +19,7 @@ class VWO
     SEED_VALUE = 1
     MAX_TRAFFIC_PERCENT = 100
     MAX_TRAFFIC_VALUE = 10_000
+    MAX_RANGE = 10000
     STATUS_RUNNING = 'RUNNING'
     # rubocop:disable Style/ExpandPathArguments
     LIBRARY_PATH =  File.expand_path('../..', __FILE__)
@@ -26,7 +27,7 @@ class VWO
     HTTP_PROTOCOL = 'http://'
     HTTPS_PROTOCOL = 'https://'
     URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
-    SDK_VERSION = '1.16.0'
+    SDK_VERSION = '1.22.0'
     SDK_NAME = 'ruby'
     VWO_DELIMITER = '_vwo_'
     MAX_EVENTS_PER_REQUEST = 5000

data/lib/vwo/core/bucketer.rb

@@ -60,7 +60,7 @@ class VWO
         end
 
         traffic_allocation = campaign['percentTraffic']
-        value_assigned_to_user = get_bucket_value_for_user(user_id)
+        value_assigned_to_user = get_bucket_value_for_user(user_id, campaign)
         is_user_part = (value_assigned_to_user != 0) && value_assigned_to_user <= traffic_allocation
         @logger.log(
           LogLevelEnum::INFO,
@@ -94,7 +94,11 @@ class VWO
           return
         end
 
-        hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
+        user_id_for_hash_value = user_id
+        if campaign[:isBucketingSeedEnabled]
+          user_id_for_hash_value = campaign[:id].to_s + "_" + user_id
+        end
+        hash_value = MurmurHash3::V32.str_hash(user_id_for_hash_value, SEED_VALUE) & U_MAX_32_BIT
         normalize = MAX_TRAFFIC_VALUE.to_f / campaign['percentTraffic']
         multiplier = normalize / 100
         bucket_value = get_bucket_value(
@@ -136,10 +140,17 @@ class VWO
       # User by hashing the userId by murmurHash and scaling it down.
       #
       # @param[String]    :user_id    The unique ID assigned to User
+      # @param[String]    :campaign   Campaign data
       # @return[Integer]              The bucket Value allotted to User
       #                               (between 1 to $this->$MAX_TRAFFIC_PERCENT)
-      def get_bucket_value_for_user(user_id)
-        hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
+      def get_bucket_value_for_user(user_id, campaign = {}, group_id = nil, disable_logs = false)
+        user_id_for_hash_value = user_id
+        if group_id
+          user_id_for_hash_value = group_id.to_s + "_" + user_id
+        elsif campaign[:isBucketingSeedEnabled]
+          user_id_for_hash_value = campaign[:id].to_s + "_" + user_id
+        end
+        hash_value = MurmurHash3::V32.str_hash(user_id_for_hash_value, SEED_VALUE) & U_MAX_32_BIT
         bucket_value = get_bucket_value(hash_value, MAX_TRAFFIC_PERCENT)
 
         @logger.log(
@@ -150,7 +161,8 @@ class VWO
             hash_value: hash_value,
             bucket_value: bucket_value,
             user_id: user_id
-          )
+          ),
+          disable_logs
         )
         bucket_value
       end
@@ -168,6 +180,22 @@ class VWO
         multiplied_value = (max_value * ratio + 1) * multiplier
         multiplied_value.to_i
       end
+
+      # Returns a campaign by checking the Start and End Bucket Allocations of each campaign.
+      #
+      # @param[Integer]     :range_for_campaigns       the bucket value of the user
+      # @param[Hash]        :campaigns                 The bucket Value of the user
+      # @return[Hash|nil]
+      #
+      def get_campaign_using_range(range_for_campaigns, campaigns)
+        range_for_campaigns = range_for_campaigns * 100
+        campaigns.each do |campaign|
+          if campaign["max_range"] && campaign["max_range"] >= range_for_campaigns && campaign["min_range"] <= range_for_campaigns
+            return campaign
+          end
+        end
+        nil
+      end
     end
   end
 end

data/lib/vwo/core/variation_decider.rb

@@ -66,6 +66,8 @@ class VWO
 
         return unless campaign
 
+        is_campaign_part_of_group = @settings_file && is_part_of_group(@settings_file, campaign["id"])
+
         @has_stored_variation = false
         decision = {
           :campaign_id => campaign['id'],
@@ -93,62 +95,17 @@ class VWO
           :vwo_user_id => generator_for(user_id, @settings_file['accountId'])
         }
 
-        if campaign['isForcedVariationEnabled']
-          variation = evaluate_whitelisting(
-            user_id,
-            campaign,
-            api_name,
-            campaign_key,
-            variation_targeting_variables
-          )
-          status = if variation
-                     StatusEnum::PASSED
-                   else
-                     StatusEnum::FAILED
-                   end
-
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::SEGMENTATION_STATUS,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              status: status,
-              custom_variables: variation_targeting_variables,
-              variation_name: status == StatusEnum::PASSED ? "and #{variation['name']} is Assigned" : ' ',
-              segmentation_type: SegmentationTypeEnum::WHITELISTING,
-              api_name: api_name
-            )
-          )
-
-          if variation
-            if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
-              decision[:variation_name] = variation['name']
-              decision[:variation_id] = variation['id']
-              if campaign['type'] == CampaignTypes::FEATURE_TEST
-                decision[:is_feature_enabled] = variation['isFeatureEnabled']
-              elsif campaign['type'] == CampaignTypes::VISUAL_AB
-                decision[:is_user_whitelisted] = !!variation['name']
-              end
-            end
-            @hooks_manager.execute(decision)
-          end
-
-          return variation if variation && variation['name']
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::WHITELISTING_SKIPPED,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              api_name: api_name
-            )
-          )
+        if is_campaign_part_of_group
+          group_id = @settings_file["campaignGroups"][campaign["id"].to_s]
+          decision[:group_id] = group_id
+          group_name = @settings_file["groups"][group_id.to_s]["name"]
+          decision[:group_name] = group_name
         end
 
+        # evaluate whitelisting
+        variation = get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, true)
+        return variation if variation && variation['name']
+
         user_campaign_map = get_user_storage(user_id, campaign_key)
         variation = get_stored_variation(user_id, campaign_key, user_campaign_map) if valid_hash?(user_campaign_map)
 
@@ -194,8 +151,7 @@ class VWO
             )
           )
 
-          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) &&
-            @user_storage_service && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT
+          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
             @logger.log(
               LogLevelEnum::DEBUG,
               format(
@@ -223,82 +179,106 @@ class VWO
         end
 
         # Pre-segmentation
+        is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
+        is_presegmentation_and_traffic_passed = is_presegmentation && @bucketer.user_part_of_campaign?(user_id, campaign)
+        unless is_presegmentation_and_traffic_passed
+          return nil
+        end
 
-        segments = get_segments(campaign)
-        is_valid_segments = valid_value?(segments)
+        if is_presegmentation_and_traffic_passed && is_campaign_part_of_group
+          group_campaigns = get_group_campaigns(@settings_file, group_id)
+
+          if group_campaigns
+            is_any_campaign_whitelisted_or_stored = check_whitelisting_or_storage_for_grouped_campaigns(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true)
+
+            if is_any_campaign_whitelisted_or_stored
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::CALLED_CAMPAIGN_NOT_WINNER,
+                  file: FILE,
+                  campaign_key: campaign_key,
+                  user_id: user_id,
+                  group_name: group_name
+                )
+              )
+              return nil
+            end
+
+            eligible_campaigns = get_eligible_campaigns(user_id, group_campaigns, campaign, custom_variables)
+            non_eligible_campaigns_key = get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns)
+
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::DebugMessages::GOT_ELIGIBLE_CAMPAIGNS,
+                file: FILE,
+                user_id: user_id,
+                eligible_campaigns_key: get_eligible_campaigns_key(eligible_campaigns).join(","),
+                ineligible_campaigns_log_text: non_eligible_campaigns_key ? ("campaigns:" + non_eligible_campaigns_key.join("'")) : "no campaigns",
+                group_name: group_name
+              )
+            )
 
-        if is_valid_segments
-          unless custom_variables
             @logger.log(
               LogLevelEnum::INFO,
               format(
-                LogMessageEnum::InfoMessages::NO_CUSTOM_VARIABLES,
+                LogMessageEnum::InfoMessages::GOT_ELIGIBLE_CAMPAIGNS,
                 file: FILE,
-                campaign_key: campaign_key,
                 user_id: user_id,
-                api_name: api_name
+                no_of_eligible_campaigns: eligible_campaigns.length,
+                no_of_group_campaigns: group_campaigns.length,
+                group_name: group_name
               )
             )
-            custom_variables = {}
-          end
-          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+
+            winner_campaign = get_winner_campaign(user_id, eligible_campaigns, group_id)
             @logger.log(
               LogLevelEnum::INFO,
               format(
-                LogMessageEnum::InfoMessages::USER_FAILED_SEGMENTATION,
-                file: FileNameEnum::SegmentEvaluator,
+                LogMessageEnum::InfoMessages::GOT_WINNER_CAMPAIGN,
+                file: FILE,
                 user_id: user_id,
-                campaign_key: campaign_key,
-                custom_variables: custom_variables
+                campaign_key: winner_campaign["key"],
+                group_name: group_name
               )
             )
-            return
+
+            if winner_campaign && winner_campaign["id"] == campaign["id"]
+              variation = get_variation_allotted(user_id, campaign, true)
+              if variation && variation['name']
+                save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name']
+              else
+                return nil
+              end
+            else
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::CALLED_CAMPAIGN_NOT_WINNER,
+                  file: FILE,
+                  campaign_key: campaign_key,
+                  user_id: user_id,
+                  group_name: group_name
+                )
+              )
+              return nil
+            end
           end
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::USER_PASSED_SEGMENTATION,
-              file: FileNameEnum::SegmentEvaluator,
-              user_id: user_id,
-              campaign_key: campaign_key,
-              custom_variables: custom_variables
-            )
-          )
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              api_name: api_name,
-              variation: ''
-            )
-          )
         end
 
-        variation = get_variation_allotted(user_id, campaign)
-
-        if variation && variation['name']
-          save_user_storage(user_id, campaign_key, variation['name'], goal_identifier) if variation['name']
+        if variation.nil?
+          variation = get_variation_allotted(user_id, campaign)
 
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::VARIATION_ALLOCATED,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              variation_name: variation['name'],
-              campaign_type: campaign['type']
+          if variation && variation['name']
+            save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier) if variation['name']
+          else
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: user_id)
             )
-          )
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: user_id)
-          )
+          end
+
         end
 
         if variation
@@ -321,7 +301,7 @@ class VWO
       #
       # @return[Hash]
 
-      def get_variation_allotted(user_id, campaign)
+      def get_variation_allotted(user_id, campaign, disable_logs = false)
         unless valid_value?(user_id)
           @logger.log(
             LogLevelEnum::ERROR,
@@ -341,7 +321,8 @@ class VWO
               user_id: user_id,
               campaign_key: campaign['key'],
               method: 'get_variation_allotted'
-            )
+            ),
+            disable_logs
           )
           variation
         else
@@ -354,7 +335,8 @@ class VWO
               user_id: user_id,
               campaign_key: nil,
               method: 'get_variation_allotted'
-            )
+            ),
+            disable_logs
           )
           nil
         end
@@ -413,13 +395,15 @@ class VWO
       # @param[String]              :campaign_key       Unique campaign identifier
       # @param[String]              :variation_name     Variation identifier
       # @param[String]              :goal_identifier    The unique campaign's goal identifier
+      # @param[Boolean]             :disable_logs       optional: disable logs if True
       # @return[Boolean]                                true if found otherwise false
 
-      def save_user_storage(user_id, campaign_key, variation_name, goal_identifier)
+      def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal_identifier, disable_logs = false)
         unless @user_storage_service
           @logger.log(
             LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE),
+            disable_logs
           )
           return false
         end
@@ -435,13 +419,28 @@ class VWO
 
         @logger.log(
           LogLevelEnum::INFO,
-          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id)
+          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id),
+          disable_logs
+        )
+
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::VARIATION_ALLOCATED,
+            file: FILE,
+            campaign_key: campaign_key,
+            user_id: user_id,
+            variation_name: variation_name,
+            campaign_type: campaign_type
+          ),
+          disable_logs
         )
         true
       rescue StandardError
         @logger.log(
           LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id),
+          disable_logs
         )
         false
       end
@@ -455,10 +454,11 @@ class VWO
       # @param[String]  :api_name                           The key Passed to identify the calling API
       # @param[String]  :campaign_key                       Unique campaign key
       # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
       #
       # @return[Hash]
 
-      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {})
+      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
         if variation_targeting_variables.nil?
           variation_targeting_variables = { '_vwo_user_id' => user_id }
         else
@@ -470,7 +470,7 @@ class VWO
           segments = get_segments(variation)
           is_valid_segments = valid_value?(segments)
           if is_valid_segments
-            if @segment_evaluator.evaluate(campaign_key, user_id, segments, variation_targeting_variables)
+            if @segment_evaluator.evaluate(campaign_key, user_id, segments, variation_targeting_variables, disable_logs)
               targeted_variations.push(variation)
               status = StatusEnum::PASSED
             else
@@ -488,7 +488,8 @@ class VWO
                 variation_name: variation['name'],
                 segmentation_type: SegmentationTypeEnum::WHITELISTING,
                 api_name: api_name
-              )
+              ),
+              disable_logs
             )
           else
             @logger.log(
@@ -500,7 +501,8 @@ class VWO
                 user_id: user_id,
                 api_name: api_name,
                 variation: variation['name']
-              )
+              ),
+              disable_logs
             )
           end
         end
@@ -525,7 +527,8 @@ class VWO
           whitelisted_variation = @bucketer.get_variation(
             targeted_variations_deep_clone,
             @bucketer.get_bucket_value_for_user(
-              user_id
+              user_id,
+              campaign
             )
           )
         else
@@ -553,18 +556,26 @@ class VWO
         end
       end
 
+      def scale_campaigns_weight(campaigns)
+        normalize_weight = 100/campaigns.length
+        campaigns.each do |campaign|
+          campaign['weight'] = normalize_weight
+        end
+      end
       # Get the UserStorageData after looking up into get method
       # Being provided via UserStorageService
       #
       # @param[String]: Unique user identifier
       # @param[String]: Unique campaign key
+      # @param[Boolean] :disable_logs if True
       # @return[Hash|Boolean]: user_storage data
 
-      def get_user_storage(user_id, campaign_key)
+      def get_user_storage(user_id, campaign_key, disable_logs = false)
         unless @user_storage_service
           @logger.log(
             LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_LOOKUP, file: FILE)
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_LOOKUP, file: FILE),
+            disable_logs
           )
           return false
         end
@@ -577,13 +588,15 @@ class VWO
             file: FILE,
             user_id: user_id,
             status: data.nil? ? 'Not Found' : 'Found'
-          )
+          ),
+          disable_logs
         )
         data
       rescue StandardError
         @logger.log(
           LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::LOOK_UP_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+          format(LogMessageEnum::ErrorMessages::LOOK_UP_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id),
+          disable_logs
         )
         false
       end
@@ -593,10 +606,11 @@ class VWO
       # @param[String]            :user_id
       # @param[String]            :campaign_key campaign identified
       # @param[Hash]              :user_campaign_map BucketMap consisting of stored user variation
+      # @param[Boolean] :disable_logs if True
       #
       # @return[Object, nil]      if found then variation settings object otherwise None
 
-      def get_stored_variation(user_id, campaign_key, user_campaign_map)
+      def get_stored_variation(user_id, campaign_key, user_campaign_map, disable_logs = false)
         return unless user_campaign_map['campaign_key'] == campaign_key
 
         variation_name = user_campaign_map['variation_name']
@@ -608,7 +622,8 @@ class VWO
             campaign_key: campaign_key,
             user_id: user_id,
             variation_name: variation_name
-          )
+          ),
+          disable_logs
         )
 
         get_campaign_variation(
@@ -617,6 +632,277 @@ class VWO
           variation_name
         )
       end
+
+      # this function check whether pre-segmentation is passed or not
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :campaign                           Campaign hash for Unique campaign key
+      # @param[Hash]    :custom_variables                   Key/value pair for segmentation
+      # @param[String]  :api_name                           The key Passed to identify the calling API
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
+      #
+      # @return[Boolean]
+      def check_presegmentation(campaign, user_id, custom_variables, api_name, disable_logs = false)
+        campaign_key = campaign['key']
+        segments = get_segments(campaign)
+        is_valid_segments = valid_value?(segments)
+
+        if is_valid_segments
+          unless custom_variables
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(
+                LogMessageEnum::InfoMessages::NO_CUSTOM_VARIABLES,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name
+              ),
+              disable_logs
+            )
+            custom_variables = {}
+          end
+          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables, disable_logs)
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(
+                LogMessageEnum::InfoMessages::USER_FAILED_SEGMENTATION,
+                file: FileNameEnum::SegmentEvaluator,
+                user_id: user_id,
+                campaign_key: campaign_key,
+                custom_variables: custom_variables
+              ),
+              disable_logs
+            )
+            return false
+          end
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::USER_PASSED_SEGMENTATION,
+              file: FileNameEnum::SegmentEvaluator,
+              user_id: user_id,
+              campaign_key: campaign_key,
+              custom_variables: custom_variables
+            ),
+            disable_logs
+          )
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              api_name: api_name,
+              variation: ''
+            ),
+            disable_logs
+          )
+        end
+        true
+      end
+
+      # Finds and returns eligible campaigns from group_campaigns.
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :called_campaign                    campaign for which api is called
+      # @param[Array]   :group_campaigns                    campaigns part of group
+      # @param[String]  :custom_variables                   Key/value pair for segmentation
+      #
+      # @return[Array]
+      def get_eligible_campaigns(user_id, group_campaigns, called_campaign, custom_variables)
+        eligible_campaigns = []
+
+        group_campaigns.each do |campaign|
+          if called_campaign["id"] == campaign["id"] || check_presegmentation(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign)
+            eligible_campaigns.append(campaign)
+          end
+        end
+        return eligible_campaigns
+      end
+
+      # Finds and returns the winner campaign from eligible_campaigns list.
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Array]   :eligible_campaigns                 campaigns part of group which were eligible to be winner
+      #
+      # @return[Hash]
+      def get_winner_campaign(user_id, eligible_campaigns, group_id)
+        if eligible_campaigns.length == 1
+          return eligible_campaigns[0]
+        end
+
+        eligible_campaigns = scale_campaigns_weight(eligible_campaigns)
+        eligible_campaigns = set_campaign_allocation(eligible_campaigns)
+        bucket_value = @bucketer.get_bucket_value_for_user(user_id, {}, group_id, true)
+        return @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns)
+      end
+
+      # Get campaign keys of all eligible Campaigns.
+      #
+      # @param[Array]   :eligible_campaigns                 campaigns part of group which were eligible to be winner
+      #
+      # @return[Array]
+      def get_eligible_campaigns_key(eligible_campaigns)
+        eligible_campaigns_key = []
+        eligible_campaigns.each do |campaign|
+          eligible_campaigns_key.append(campaign["key"])
+        end
+        eligible_campaigns_key
+      end
+
+      # Get campaign keys of all non eligible Campaigns.
+      #
+      # @param[Array]   :eligible_campaigns                 campaigns part of group which were eligible to be winner
+      # @param[Array]   :group_campaigns                    campaigns part of group
+      #
+      # @return[Array]
+      def get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns)
+        non_eligible_campaigns_key = []
+        group_campaigns.each do |campaign|
+          unless eligible_campaigns.include? campaign
+            non_eligible_campaigns_key.append(campaign["key"])
+          end
+        end
+        non_eligible_campaigns_key
+      end
+
+      # Checks if any other campaign in groupCampaigns satisfies whitelisting or is in user storage.
+      #
+      # @param[String]  :user_id                            the unique ID assigned to User
+      # @param[Hash]    :called_campaign                    campaign for which api is called
+      # @param[Array]   :group_campaigns                    campaigns part of group
+      # @param[String]  :group_name                         group name
+      # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
+      # @return[Boolean]
+
+      def check_whitelisting_or_storage_for_grouped_campaigns(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false)
+        group_campaigns.each do |campaign|
+          if called_campaign["id"] != campaign["id"]
+            targeted_variation = evaluate_whitelisting(
+              user_id,
+              campaign,
+              '',
+              campaign["key"],
+              variation_targeting_variables,
+              true
+            )
+            if targeted_variation
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::OTHER_CAMPAIGN_SATISFIES_WHITELISTING_OR_STORAGE,
+                  file: FILE,
+                  campaign_key: campaign["key"],
+                  user_id: user_id,
+                  group_name: group_name,
+                  type: "whitelisting"
+                ),
+                disable_logs
+              )
+              return true
+            end
+          end
+        end
+
+        group_campaigns.each do |campaign|
+          if called_campaign["id"] != campaign["id"]
+            user_storage_data = get_user_storage(user_id, campaign["key"], true)
+            if user_storage_data
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::OTHER_CAMPAIGN_SATISFIES_WHITELISTING_OR_STORAGE,
+                  file: FILE,
+                  campaign_key: campaign["key"],
+                  user_id: user_id,
+                  group_name: group_name,
+                  type: "user storage"
+                ),
+                disable_logs
+              )
+              return true
+            end
+          end
+        end
+        false
+      end
+
+      # Get variation if whitelisting passes
+      #
+      # @param[String]  :user_id                            the unique ID assigned to User
+      # @param[Hash]    :campaign                           campaign for which checking whitelisting
+      # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      # @param[String]  :api_name                           The key Passed to identify the calling API
+      # @param[Hash]    :decision                           data containing campaign info passed to hooks manager
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
+      # @return[Hash]
+      def get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, disable_logs = false)
+        campaign_key = campaign['key']
+        if campaign['isForcedVariationEnabled']
+          variation = evaluate_whitelisting(
+            user_id,
+            campaign,
+            api_name,
+            campaign_key,
+            variation_targeting_variables,
+            disable_logs
+          )
+          status = if variation
+                     StatusEnum::PASSED
+                   else
+                     StatusEnum::FAILED
+                   end
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::SEGMENTATION_STATUS,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              status: status,
+              custom_variables: variation_targeting_variables,
+              variation_name: status == StatusEnum::PASSED ? "and #{variation['name']} is Assigned" : ' ',
+              segmentation_type: SegmentationTypeEnum::WHITELISTING,
+              api_name: api_name
+            ),
+            disable_logs
+          )
+
+          if variation
+            if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
+              decision[:variation_name] = variation['name']
+              decision[:variation_id] = variation['id']
+              if campaign['type'] == CampaignTypes::FEATURE_TEST
+                decision[:is_feature_enabled] = variation['isFeatureEnabled']
+              elsif campaign['type'] == CampaignTypes::VISUAL_AB
+                decision[:is_user_whitelisted] = !!variation['name']
+              end
+            end
+            @hooks_manager.execute(decision)
+          end
+
+          return variation if variation && variation['name']
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::WHITELISTING_SKIPPED,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              api_name: api_name
+            ),
+            disable_logs
+          )
+        end
+        nil
+      end
+
     end
   end
 end

data/lib/vwo/enums.rb

@@ -113,6 +113,7 @@ class VWO
         BULK_NOT_PROCESSED = "(%<file>s): Batch events couldn't be received by VWO. Calling Flush Callback with error and data."
         BEFORE_FLUSHING = '(%<file>s): Flushing events queue %<manually>s having %<length>s events %<timer>s queue summary: %<queue_metadata>s'
         EVENT_BATCHING_INSUFFICIENT = '(%<file>s): %<key>s not provided, assigning default value'
+        GOT_ELIGIBLE_CAMPAIGNS = "(%<file>s): Campaigns:%<eligible_campaigns_key>s are eligible, %<ineligible_campaigns_log_text>s are ineligible from the Group:%<group_name>s for the User ID:%<user_id>s"
       end
 
       # Info Messages
@@ -152,9 +153,13 @@ class VWO
         CAMPAIGN_NOT_ACTIVATED = '(%<file>s): Activate the campaign:%<campaign_key>s for User ID:%<user_id>s to %<reason>s.'
         GOAL_ALREADY_TRACKED = '(%<file>s): Goal:%<goal_identifier>s of Campaign:%<campaign_key>s for User ID:%<user_id>s has already been tracked earlier. Skipping now'
         USER_ALREADY_TRACKED = '(%<file>s): User ID:%<user_id>s for Campaign:%<campaign_key>s has already been tracked earlier for "%<api_name>s" API. Skipping now'
-        API_CALLED = '(%<file>s): API: {api_name} called for UserId:%<user_id>s'
+        API_CALLED = '(%<file>s): API: %<api_name>s called for UserId:%<user_id>s'
         BULK_IMPRESSION_SUCCESS = '(%<file>s): Impression event - %<end_point>s was successfully received by VWO having accountId:%<a>s'
         AFTER_FLUSHING = '(%<file>s): Events queue having %<length>s events has been flushed %<manually>s queue summary: %<queue_metadata>s'
+        GOT_WINNER_CAMPAIGN = "(%<file>s): Campaign:%<campaign_key>s is selected from the mutually exclusive group:%<group_name>s for the User ID:%<user_id>s"
+        GOT_ELIGIBLE_CAMPAIGNS = "(%<file>s): Got %<no_of_eligible_campaigns>s eligible winners out of %<no_of_group_campaigns>s from the Group:%<group_name>s and for User ID:%<user_id>s"
+        CALLED_CAMPAIGN_NOT_WINNER = "(%<file>s): Campaign:%<campaign_key>s does not qualify from the mutually exclusive group:%<group_name>s for User ID:%<user_id>s"
+        OTHER_CAMPAIGN_SATISFIES_WHITELISTING_OR_STORAGE = "(%<file>s): Campaign:%<campaign_key>s of Group:%<group_name>s satisfies %<type>s for User ID:%<user_id>s"
       end
 
       # Warning Messages

data/lib/vwo/logger.rb

@@ -28,8 +28,10 @@ class VWO
     end
 
     # Override this method to handle logs in a custom manner
-    def log(level, message)
-      @@logger_instance.log(level, message)
+    def log(level, message, disable_logs = false)
+      unless disable_logs
+        @@logger_instance.log(level, message)
+      end
     end
 
     def instance

data/lib/vwo/schemas/settings_file.rb

@@ -91,6 +91,7 @@ class VWO
                 '$ref' => '#/definitions/variables_schema'
               }
             },
+            isBucketingSeedEnabled: ['boolean'],
             minItems: 2
           }
         },

data/lib/vwo/services/segment_evaluator.rb

@@ -63,10 +63,11 @@ class VWO
       # @param[String]                  :user_id              Unique user identifier
       # @param[Hash]                    :dsl                  Segments provided in the settings_file
       # @param[Hash]                    :custom_variables     Custom variables provided in the apis
+      # @param[Boolean]                 :disable_logs         disable logs if True
       #
       # @return[Boolean]                true if user passed pre-segmentation, else false
       #
-      def evaluate(campaign_key, user_id, dsl, custom_variables)
+      def evaluate(campaign_key, user_id, dsl, custom_variables, disable_logs = false)
         result = evaluate_util(dsl, custom_variables) if valid_value?(dsl)
         result
       rescue StandardError => e
@@ -79,7 +80,8 @@ class VWO
             campaign_key: campaign_key,
             custom_variables: custom_variables,
             error_message: e
-          )
+          ),
+          disable_logs
         )
         false
       end

data/lib/vwo/utils/campaign.rb

@@ -57,6 +57,26 @@ class VWO
         end
       end
 
+      # Sets campaign allocation range in the provided campaigns list
+      #
+      # @param [Array]: Array of Campaigns
+      def set_campaign_allocation(campaigns)
+        current_allocation = 0
+        campaigns.each do |campaign|
+          step_factor = get_variation_bucketing_range(campaign['weight'])
+          if step_factor > 0
+            start_range = current_allocation + 1
+            end_range = current_allocation + step_factor
+            campaign['min_range'] = start_range
+            campaign['max_range'] = end_range
+            current_allocation += step_factor
+          else
+            campaign['min_range'] = -1
+            campaign['max_range'] = -1
+          end
+        end
+      end
+
       # Returns goal from given campaign_key and gaol_identifier.
       # @param[String]            :campaign             Campaign object
       # @param[String]            :goal_identifier      Goal identifier
@@ -249,6 +269,44 @@ class VWO
         return campaign
       end
 
+      # Checks whether a campaign is part of a group.
+      #
+      #  @param[Hash]       :settings_file          Settings file for the project
+      #  @param[Integer]     :campaign_id            Id of campaign which is to be checked
+      #  @return[Boolean]
+      def is_part_of_group(settings_file, campaign_id)
+        if settings_file["campaignGroups"] && (settings_file["campaignGroups"].has_key?(campaign_id.to_s))
+          return true
+        end
+        false
+      end
+
+      # Returns campaigns which are part of given group using group_id.
+      #
+      #  @param[Hash]       :settings_file          Settings file for the project
+      #  @param[Integer]    :group_id               id of group whose campaigns are to be return
+      #  @return[Array]
+      def get_group_campaigns(settings_file, group_id)
+        group_campaign_ids = []
+        group_campaigns = []
+        groups = settings_file["groups"]
+
+        if groups && groups.has_key?(group_id.to_s)
+          group_campaign_ids = groups[group_id.to_s]["campaigns"]
+        end
+
+        if group_campaign_ids
+          group_campaign_ids.each do |campaign_id|
+            settings_file["campaigns"].each do |campaign|
+              if campaign["id"] == campaign_id && campaign["status"] == STATUS_RUNNING
+                group_campaigns.append(campaign)
+              end
+            end
+          end
+        end
+        group_campaigns
+      end
+
     end
   end
 end

data/lib/vwo.rb

@@ -413,7 +413,6 @@ class VWO
           )
         end
       end
-      variation['name']
     else
       @logger.log(
         LogLevelEnum::INFO,
@@ -425,8 +424,8 @@ class VWO
           api_name: ApiMethods::ACTIVATE
         )
       )
-      nil
     end
+    variation['name']
   rescue StandardError => e
     @logger.log(
       LogLevelEnum::ERROR,
@@ -676,7 +675,7 @@ class VWO
           if !identifiers.include? goal_identifier
             updated_goal_identifier = variation['goal_identifier']
             updated_goal_identifier += VWO_DELIMITER + goal_identifier
-            @variation_decider.save_user_storage(user_id, campaign['key'], variation['name'], updated_goal_identifier) if variation['name']
+            @variation_decider.save_user_storage(user_id, campaign['key'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name']
             # set variation at user storage
           elsif !should_track_returning_user
             @logger.log(
@@ -870,80 +869,85 @@ class VWO
     return false unless variation
 
     # if campaign type is feature_test Send track call to server
-    if campaign_type == CampaignTypes::FEATURE_TEST
-      if is_eligible_to_send_impression(should_track_returning_user)
-        if defined?(@batch_events)
-          impression = create_bulk_event_impression(
-            @settings_file,
-            campaign['id'],
-            variation['id'],
-            user_id
-          )
-          @batch_events_queue.enqueue(impression)
-        else
-          impression = create_impression(
-            @settings_file,
-            campaign['id'],
-            variation['id'],
-            user_id,
-            @sdk_key,
-            goal_id: nil,
-            revenue: nil,
-            usage_stats: @usage_stats.usage_stats
-          )
 
-          @event_dispatcher.dispatch(impression)
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_IMPRESSION,
-              file: FILE,
-              campaign_id: impression[:experiment_id],
-              sdk_key: @sdk_key,
-              account_id: impression[:account_id],
-              variation_id: impression[:combination]
-            )
-          )
-        end
-        result = variation['isFeatureEnabled']
-        if result
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::FEATURE_ENABLED_FOR_USER,
-              file: FILE,
-              user_id: user_id,
-              feature_key: campaign_key,
-              api_name: ApiMethods::IS_FEATURE_ENABLED
-            )
-          )
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::FEATURE_NOT_ENABLED_FOR_USER,
-              file: FILE,
-              user_id: user_id,
-              feature_key: campaign_key,
-              api_name: ApiMethods::IS_FEATURE_ENABLED
-            )
-          )
-        end
-        return result
+    if is_eligible_to_send_impression(should_track_returning_user)
+      if defined?(@batch_events)
+        impression = create_bulk_event_impression(
+          @settings_file,
+          campaign['id'],
+          variation['id'],
+          user_id
+        )
+        @batch_events_queue.enqueue(impression)
       else
+        impression = create_impression(
+          @settings_file,
+          campaign['id'],
+          variation['id'],
+          user_id,
+          @sdk_key,
+          nil,
+          nil,
+          usage_stats: @usage_stats.usage_stats
+        )
+
+        @event_dispatcher.dispatch(impression)
         @logger.log(
           LogLevelEnum::INFO,
           format(
-            LogMessageEnum::InfoMessages::USER_ALREADY_TRACKED,
+            LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_IMPRESSION,
             file: FILE,
-            user_id: user_id,
-            campaign_key: campaign_key,
-            api_name: ApiMethods::IS_FEATURE_ENABLED
+            campaign_id: impression[:experiment_id],
+            sdk_key: @sdk_key,
+            account_id: impression[:account_id],
+            variation_id: impression[:combination]
           )
         )
       end
+
+    else
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::USER_ALREADY_TRACKED,
+          file: FILE,
+          user_id: user_id,
+          campaign_key: campaign_key,
+          api_name: ApiMethods::IS_FEATURE_ENABLED
+        )
+      )
     end
-    true
+    if campaign_type == CampaignTypes::FEATURE_ROLLOUT
+      result = true
+    else
+      result = variation['isFeatureEnabled']
+    end
+
+    if result
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::FEATURE_ENABLED_FOR_USER,
+          file: FILE,
+          user_id: user_id,
+          feature_key: campaign_key,
+          api_name: ApiMethods::IS_FEATURE_ENABLED
+        )
+      )
+    else
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::FEATURE_NOT_ENABLED_FOR_USER,
+          file: FILE,
+          user_id: user_id,
+          feature_key: campaign_key,
+          api_name: ApiMethods::IS_FEATURE_ENABLED
+        )
+      )
+    end
+
+    result
   rescue StandardError => e
     @logger.log(
       LogLevelEnum::ERROR,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vwo-sdk
 version: !ruby/object:Gem::Version
-  version: 1.16.0
+  version: 1.22.0
 platform: ruby
 authors:
 - VWO
@@ -87,6 +87,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/abc.txt
 - lib/vwo.rb
 - lib/vwo/constants.rb
 - lib/vwo/core/bucketer.rb