vwo-sdk 1.30.0 → 1.35.0

data/lib/vwo/core/variation_decider.rb

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative '../logger'
 require_relative '../enums'
 require_relative '../utils/campaign'
 require_relative '../services/segment_evaluator'
 require_relative '../utils/validations'
+require_relative '../utils/log_message'
 require_relative 'bucketer'
 require_relative '../constants'
 require_relative '../services/hooks_manager'
@@ -40,7 +40,7 @@ class VWO
       # @param[Class] -  Class instance having the capability of
       #                  get and save.
       def initialize(settings_file, user_storage_service = nil, options = {})
-        @logger = VWO::Logger.get_instance
+        @logger = VWO::Utils::Logger
         @user_storage_service = user_storage_service
         @bucketer = VWO::Core::Bucketer.new
         @settings_file = settings_file
@@ -110,78 +110,84 @@ class VWO
         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)
-
-        if variation
-          variation = variation.dup  # deep copy
-        end
+        if campaign.has_key?("isAlwaysCheckSegment")
+          is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
+          return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        else
+          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)
 
-        if variation
-          if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
-            variation['goal_identifier'] = user_campaign_map['goal_identifier']
+          if variation
+            variation = variation.dup  # deep copy
           end
-          @has_stored_variation = true
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::GOT_STORED_VARIATION,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              variation_name: variation['name']
-            )
-          )
-          decision[:from_user_storage_service] = !!variation['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']
-              end
+            if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
+              variation['goal_identifier'] = user_campaign_map['goal_identifier']
             end
-            @hooks_manager.execute(decision)
-          end
-          return variation
-        else
-          @logger.log(
-            LogLevelEnum::DEBUG,
-            format(
-              LogMessageEnum::DebugMessages::NO_STORED_VARIATION,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id
+            @has_stored_variation = true
+            @logger.log(
+              LogLevelEnum::INFO,
+              'GOT_STORED_VARIATION',
+              {
+                '{file}' => FILE,
+                '{campaignKey}' => campaign_key,
+                '{userId}' => user_id,
+                '{variationName}' => variation['name']
+              }
             )
-          )
-
-          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
+            decision[:from_user_storage_service] = !!variation['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']
+                end
+              end
+              @hooks_manager.execute(decision)
+            end
+            return variation
+          else
             @logger.log(
               LogLevelEnum::DEBUG,
-              format(
-                LogMessageEnum::DebugMessages::CAMPAIGN_NOT_ACTIVATED,
-                file: FILE,
-                campaign_key: campaign_key,
-                user_id: user_id,
-                api_name: api_name
-              )
+              'USER_STORAGE_SERVICE_NO_STORED_DATA',
+              {
+                '{file}' => FILE,
+                '{campaignKey}' => campaign_key,
+                '{userId}' => user_id
+              }
             )
-
-            @logger.log(
-              LogLevelEnum::INFO,
-              format(
-                LogMessageEnum::InfoMessages::CAMPAIGN_NOT_ACTIVATED,
-                file: FILE,
-                campaign_key: campaign_key,
-                user_id: user_id,
-                api_name: api_name,
-                reason: api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
+  
+            if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
+              @logger.log(
+                LogLevelEnum::WARNING,
+                'CAMPAIGN_NOT_ACTIVATED',
+                {
+                  '{file}' => FILE,
+                  '{campaignKey}' => campaign_key,
+                  '{userId}' => user_id,
+                  '{api}' => api_name
+                }
               )
-            )
-            return
+  
+              @logger.log(
+                LogLevelEnum::INFO,
+                'CAMPAIGN_NOT_ACTIVATED',
+                {
+                  '{file}' => FILE,
+                  '{campaignKey}' => campaign_key,
+                  '{userId}' => user_id,
+                  '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
+                }
+              )
+              return
+            end
           end
         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)
@@ -191,61 +197,57 @@ class VWO
 
         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
-                )
+                'MEG_CALLED_CAMPAIGN_NOT_WINNER',
+                {
+                  '{file}' => FILE,
+                  '{campaignKey}' => campaign_key,
+                  '{userId}' => user_id,
+                  '{groupName}' => 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
-              )
+              'MEG_ELIGIBLE_CAMPAIGNS',
+              {
+                '{file}' => FILE,
+                '{userId}' => user_id,
+                '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(","),
+                '{inEligibleText}' => non_eligible_campaigns_key ? ("campaigns:" + non_eligible_campaigns_key.join("'")) : "no campaigns",
+                '{groupName}' => group_name
+              }
             )
 
             @logger.log(
               LogLevelEnum::INFO,
-              format(
-                LogMessageEnum::InfoMessages::GOT_ELIGIBLE_CAMPAIGNS,
-                file: FILE,
-                user_id: user_id,
-                no_of_eligible_campaigns: eligible_campaigns.length,
-                no_of_group_campaigns: group_campaigns.length,
-                group_name: group_name
-              )
+              'MEG_ELIGIBLE_CAMPAIGNS',
+              {
+                '{file}' => FILE,
+                '{userId}' => user_id,
+                '{noOfEligibleCampaigns}' => eligible_campaigns.length,
+                '{noOfGroupCampaigns}' => group_campaigns.length,
+                '{groupName}' => group_name
+              }
             )
 
             winner_campaign = get_winner_campaign(user_id, eligible_campaigns, group_id)
             @logger.log(
               LogLevelEnum::INFO,
-              format(
-                LogMessageEnum::InfoMessages::GOT_WINNER_CAMPAIGN,
-                file: FILE,
-                user_id: user_id,
-                campaign_key: winner_campaign["key"],
-                group_name: group_name
-              )
+              'MEG_GOT_WINNER_CAMPAIGN',
+              {
+                '{file}' => FILE,
+                '{userId}' => user_id,
+                '{campaignKey}' => winner_campaign["key"],
+                '{groupName}' => group_name,
+              }
             )
 
             if winner_campaign && winner_campaign["id"] == campaign["id"]
@@ -258,31 +260,61 @@ class VWO
             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
-                )
+                'MEG_CALLED_CAMPAIGN_NOT_WINNER',
+                {
+                  '{file}' => FILE,
+                  '{campaignKey}' => campaign_key,
+                  '{userId}' => user_id,
+                  '{groupName}' => group_name,
+                }
               )
               return nil
             end
           end
         end
 
-        if variation.nil?
-          variation = get_variation_allotted(user_id, campaign)
-
-          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)
-            )
+        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']
+            end
           end
+          @hooks_manager.execute(decision)
+          return variation
+        end
+
+        return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+      end
 
+      # Get variation by murmur logic if pre segmentation pass
+      #
+      # @param[Boolean] :is_presegmentation     The unique key assigned to User
+      # @param[Hash]    :campaign               Campaign hash for Unique campaign key
+      # @param[String]  :user_id                the unique ID assigned to User
+      # @param[String]  :goal_identifier        goal Identifier used in track API
+      # @param[Hash]    :decision               data containing campaign info passed to hooks manager
+      #
+      # @return[Hash]
+      def get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        unless is_presegmentation
+          return nil
+        end
+        campaign_key = campaign['key']
+        variation = get_variation_allotted(user_id, campaign)
+        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,
+            'DECISION_NO_VARIATION_ALLOTED',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign_key,
+              '{userId}' => user_id
+            }
+          )
         end
 
         if variation
@@ -309,37 +341,29 @@ class VWO
         unless valid_value?(user_id)
           @logger.log(
             LogLevelEnum::ERROR,
-            format(LogMessageEnum::ErrorMessages::INVALID_USER_ID, file: FILE, user_id: user_id, method: 'get_variation_alloted')
+            'USER_ID_INVALID',
+            {
+              '{file}' => FILE,
+              '{userId}' => user_id
+            },
+            disable_logs
           )
           return
         end
 
-        if @bucketer.user_part_of_campaign?(user_id, campaign)
-          variation = get_variation_of_campaign_for_user(user_id, campaign)
-          @logger.log(
-            LogLevelEnum::DEBUG,
-            format(
-              LogMessageEnum::DebugMessages::GOT_VARIATION_FOR_USER,
-              file: FILE,
-              variation_name: variation['name'],
-              user_id: user_id,
-              campaign_key: campaign['key'],
-              method: 'get_variation_allotted'
-            ),
-            disable_logs
-          )
+        if @bucketer.user_part_of_campaign?(user_id, campaign, true)
+          variation = get_variation_of_campaign_for_user(user_id, campaign, disable_logs)
           variation
         else
           # not part of campaign
           @logger.log(
-            LogLevelEnum::DEBUG,
-            format(
-              LogMessageEnum::DebugMessages::USER_NOT_PART_OF_CAMPAIGN,
-              file: FILE,
-              user_id: user_id,
-              campaign_key: nil,
-              method: 'get_variation_allotted'
-            ),
+            LogLevelEnum::INFO,
+            'USER_NOT_PART_OF_CAMPAIGN',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => nil,
+              '{userId}' => user_id
+            },
             disable_logs
           )
           nil
@@ -352,44 +376,36 @@ class VWO
       # @param[Hash]                :campaign     The Campaign of which user is to be made a part of
       # @return[Hash]                         Variation allotted to User
 
-      def get_variation_of_campaign_for_user(user_id, campaign)
-        unless campaign
-          @logger.log(
-            LogLevelEnum::ERROR,
-            format(
-              LogMessageEnum::ErrorMessages::INVALID_CAMPAIGN,
-              file: FILE,
-              method: 'get_variation_of_campaign_for_user'
-            )
-          )
-          return nil
-        end
-
-        variation = @bucketer.bucket_user_to_variation(user_id, campaign)
+      def get_variation_of_campaign_for_user(user_id, campaign, disable_logs = false)
+        variation = @bucketer.bucket_user_to_variation(user_id, campaign, disable_logs)
 
         if variation && variation['name']
           @logger.log(
             LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::GOT_VARIATION_FOR_USER,
-              file: FILE,
-              variation_name: variation['name'],
-              user_id: user_id,
-              campaign_key: campaign['key']
-            )
+            'USER_VARIATION_ALLOCATION_STATUS',
+            {
+              '{file}' => FILE,
+              '{status}' => variation ? 'got variation:' + variation['name'] : 'did not get any variation',
+              '{userId}' => user_id,
+              '{campaignKey}' => campaign['key']
+            },
+            disable_logs
           )
           return variation
         end
 
-        @logger.log(
-          LogLevelEnum::INFO,
-          format(
-            LogMessageEnum::InfoMessages::USER_GOT_NO_VARIATION,
-            file: FILE,
-            user_id: user_id,
-            campaign_key: campaign['key']
+        if campaign
+          @logger.log(
+            LogLevelEnum::INFO,
+            'DECISION_NO_VARIATION_ALLOTED',
+            {
+              '{file}' => FILE,
+              '{userId}' => user_id,
+              '{campaignKey}' => campaign['key']
+            },
+            disable_logs
           )
-        )
+        end
         nil
       end
 
@@ -406,7 +422,8 @@ class VWO
         unless @user_storage_service
           @logger.log(
             LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE),
+            'USER_STORAGE_SERVICE_NOT_CONFIGURED',
+            {'{file}' => FILE},
             disable_logs
           )
           return false
@@ -423,27 +440,24 @@ class VWO
 
         @logger.log(
           LogLevelEnum::INFO,
-          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
-          ),
+          'SETTING_DATA_USER_STORAGE_SERVICE',
+          {
+            '{file}' => FILE,
+            '{userId}' => user_id,
+            '{campaignKey}' => campaign_key
+          },
           disable_logs
         )
         true
-      rescue StandardError
+      rescue StandardError => e
         @logger.log(
           LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id),
+          'USER_STORAGE_SERVICE_SET_FAILED',
+          {
+            '{file}' => FILE,
+            '{userId}' => user_id,
+            '{error}' => e.message
+          },
           disable_logs
         )
         false
@@ -464,7 +478,7 @@ class VWO
 
       def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
         if campaign.key?('isUserListEnabled') && campaign["isUserListEnabled"]
-          vwo_user_id = generator_for(user_id, @settings_file['accountId'])
+          vwo_user_id = generator_for(user_id, @settings_file['accountId'], true)
           if variation_targeting_variables.nil?
             variation_targeting_variables = { _vwo_user_id: vwo_user_id }
           else
@@ -490,36 +504,33 @@ class VWO
               status = StatusEnum::FAILED
             end
             @logger.log(
-              LogLevelEnum::DEBUG,
-              format(
-                LogMessageEnum::DebugMessages::SEGMENTATION_STATUS,
-                file: FILE,
-                campaign_key: campaign_key,
-                user_id: user_id,
-                status: status,
-                custom_variables: variation_targeting_variables,
-                variation_name: status == StatusEnum::PASSED ? (campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : "for " + variation['name']) : '',
-                segmentation_type: SegmentationTypeEnum::WHITELISTING,
-                api_name: api_name
-              ),
+              LogLevelEnum::INFO,
+              'SEGMENTATION_STATUS',
+              {
+                '{file}' => FILE,
+                '{campaignKey}' => campaign_key,
+                '{userId}' => user_id,
+                '{customVariables}' => variation_targeting_variables,
+                '{status}' => status,
+                '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
+                '{variation}' => status == StatusEnum::PASSED ? (campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : variation['name'] + ' and hence becomes part of the rollout') : '',
+              },
               disable_logs
             )
           else
             @logger.log(
               LogLevelEnum::DEBUG,
-              format(
-                LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
-                file: FILE,
-                campaign_key: campaign_key,
-                user_id: user_id,
-                api_name: api_name,
-                variation: variation['name']
-              ),
+              'SEGMENTATION_SKIPPED',
+              {
+                '{file}' => FILE,
+                '{campaignKey}' => campaign_key,
+                '{userId}' => user_id,
+                '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : 'for variation:' + variation['name']
+              },
               disable_logs
             )
           end
         end
-
         if targeted_variations.length > 1
           targeted_variations_deep_clone = Marshal.load(Marshal.dump(targeted_variations))
           scale_variation_weights(targeted_variations_deep_clone)
@@ -541,7 +552,8 @@ class VWO
             targeted_variations_deep_clone,
             @bucketer.get_bucket_value_for_user(
               user_id,
-              campaign
+              campaign,
+              disable_logs
             )
           )
         else
@@ -587,28 +599,36 @@ class VWO
         unless @user_storage_service
           @logger.log(
             LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_LOOKUP, file: FILE),
+            'USER_STORAGE_SERVICE_NOT_CONFIGURED',
+            {'{file}' => FILE},
             disable_logs
           )
           return false
         end
 
         data = @user_storage_service.get(user_id, campaign_key)
-        @logger.log(
-          LogLevelEnum::INFO,
-          format(
-            LogMessageEnum::InfoMessages::LOOKING_UP_USER_STORAGE_SERVICE,
-            file: FILE,
-            user_id: user_id,
-            status: data.nil? ? 'Not Found' : 'Found'
-          ),
-          disable_logs
-        )
+        if data
+          @logger.log(
+            LogLevelEnum::INFO,
+            'GETTING_DATA_USER_STORAGE_SERVICE',
+            {
+              '{file}' => FILE,
+              '{userId}' => user_id,
+              '{campaignKey}' => campaign_key
+            },
+            disable_logs
+          )
+        end
         data
-      rescue StandardError
+      rescue StandardError => e
         @logger.log(
           LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::LOOK_UP_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id),
+          'USER_STORAGE_SERVICE_GET_FAILED',
+          {
+            '{file}' => FILE,
+            '{userId}' => user_id,
+            '{error}' => e.message
+          },
           disable_logs
         )
         false
@@ -627,17 +647,6 @@ class VWO
         return unless user_campaign_map['campaign_key'] == campaign_key
 
         variation_name = user_campaign_map['variation_name']
-        @logger.log(
-          LogLevelEnum::DEBUG,
-          format(
-            LogMessageEnum::DebugMessages::GETTING_STORED_VARIATION,
-            file: FILE,
-            campaign_key: campaign_key,
-            user_id: user_id,
-            variation_name: variation_name
-          ),
-          disable_logs
-        )
 
         get_campaign_variation(
           @settings_file,
@@ -662,59 +671,53 @@ class VWO
 
         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
+          response = @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables, disable_logs)
           @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
-            ),
+            'SEGMENTATION_STATUS',
+            {
+              '{file}' => FILE,
+              '{userId}' => user_id,
+              '{status}' => response ? 'passed' : 'failed',
+              '{campaignKey}' => campaign_key,
+              '{customVariables}' => custom_variables,
+              '{segmentationType}' => 'pre-segmentation',
+              '{variation}' => ''
+            },
             disable_logs
           )
+          return response
         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: ''
-            ),
+            LogLevelEnum::DEBUG,
+            'SEGMENTATION_SKIPPED',
+            {
+              '{file}' => FILE,
+              '{userId}' => user_id,
+              '{campaignKey}' => campaign_key,
+              '{variation}' => ''
+            },
             disable_logs
           )
         end
         true
+      rescue StandardError => e
+        @logger.log(
+          LogLevelEnum::ERROR,
+          'SEGMENTATION_ERROR',
+          {
+            '{file}' => FILE,
+            '{userId}' => user_id,
+            '{campaignKey}' => campaign_key,
+            '{variation}' => '',
+            '{customVariables}' => custom_variables,
+            '{err}' => e.message
+          },
+          disable_logs
+        )
+        false
       end
 
       # Finds and returns eligible campaigns from group_campaigns.
@@ -729,7 +732,7 @@ class VWO
         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)
+          if called_campaign["id"] == campaign["id"] || check_presegmentation(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true)
             eligible_campaigns.push(campaign)
           end
         end
@@ -806,14 +809,14 @@ class VWO
             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"
-                ),
+                'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
+                {
+                  '{file}' => FILE,
+                  '{campaignKey}' => campaign["key"],
+                  '{userId}' => user_id,
+                  '{groupName}' => group_name,
+                  '{type}' => "whitelisting"
+                },
                 disable_logs
               )
               return true
@@ -827,14 +830,14 @@ class VWO
             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"
-                ),
+                'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
+                {
+                  '{file}' => FILE,
+                  '{campaignKey}' => campaign["key"],
+                  '{userId}' => user_id,
+                  '{groupName}' => group_name,
+                  '{type}' => "user storag"
+                },
                 disable_logs
               )
               return true
@@ -872,17 +875,16 @@ class VWO
 
           @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_targeting_variables : {},
-              variation_name: (status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT) ? "and #{variation['name']} is Assigned" : ' ',
-              segmentation_type: SegmentationTypeEnum::WHITELISTING,
-              api_name: api_name
-            ),
+            'SEGMENTATION_STATUS',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign_key,
+              '{userId}' => user_id,
+              '{customVariables}' => variation_targeting_variables ? variation_targeting_variables : {},
+              '{status}' => status,
+              '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
+              '{variation}' => (status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT) ? "for variation:#{variation['name']}" : ' '
+            },
             disable_logs
           )
 
@@ -901,14 +903,15 @@ class VWO
           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
-            ),
+            LogLevelEnum::DEBUG,
+            'WHITELISTING_SKIPPED',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign_key,
+              '{userId}' => user_id,
+              '{reason}' => '',
+              '{variation}' => ''
+            },
             disable_logs
           )
         end