vwo-sdk 1.30.0 → 1.37.1

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'
@@ -33,14 +33,14 @@ class VWO
       include VWO::CONSTANTS
       include VWO::Utils::UUID
 
-      FILE = FileNameEnum::VariationDecider
+      FILE = FileNameEnum::VARIATION_DECIDER
 
       # Initializes various services
       # @param[Hash] -   Settings file
       # @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
@@ -66,43 +66,17 @@ class VWO
 
         return unless campaign
 
-        is_campaign_part_of_group = @settings_file && is_part_of_group(@settings_file, campaign["id"])
+        is_campaign_part_of_group = @settings_file && part_of_group?(@settings_file, campaign['id'])
 
         @has_stored_variation = false
-        decision = {
-          :campaign_id => campaign['id'],
-          :campaign_key => campaign_key,
-          :campaign_type => campaign['type'],
-        # campaign segmentation conditions
-          :custom_variables => custom_variables,
-        # event name
-          :event => Hooks::DECISION_TYPES['CAMPAIGN_DECISION'],
-        # goal tracked in case of track API
-          :goal_identifier => goal_identifier,
-        # campaign whitelisting flag
-          :is_forced_variation_enabled => campaign['isForcedVariationEnabled'] ? campaign['isForcedVariationEnabled'] : false,
-          :sdk_version => SDK_VERSION,
-        # API name which triggered the event
-          :source => api_name,
-        # Passed in API
-          :user_id => user_id,
-        # Campaign Whitelisting conditions
-          :variation_targeting_variables => variation_targeting_variables,
-          :is_user_whitelisted => false,
-          :from_user_storage_service => false,
-          :is_feature_enabled => true,
-        # VWO generated UUID based on passed UserId and Account ID
-          :vwo_user_id => generator_for(user_id, @settings_file['accountId'])
-        }
+        decision = initialize_decision_properties(user_id, campaign, api_name, custom_variables, variation_targeting_variables, goal_identifier)
 
-        if campaign.has_key?("name")
-          decision[:campaign_name] = campaign['name']
-        end
+        decision[:campaign_name] = campaign['name'] if campaign.key?('name')
 
         if is_campaign_part_of_group
-          group_id = @settings_file["campaignGroups"][campaign["id"].to_s]
+          group_id = @settings_file['campaignGroups'][campaign['id'].to_s]
           decision[:group_id] = group_id
-          group_name = @settings_file["groups"][group_id.to_s]["name"]
+          group_name = @settings_file['groups'][group_id.to_s]['name']
           decision[:group_name] = group_name
         end
 
@@ -110,189 +84,250 @@ 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 campaign.key?('isAlwaysCheckSegment')
+          is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name)
+          return get_variation_if_presegmentation_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
-          variation = variation.dup  # deep copy
-        end
+          variation = variation.dup if variation # deep copy
 
-        if variation
-          if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
-            variation['goal_identifier'] = user_campaign_map['goal_identifier']
-          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
-            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
+            variation['goal_identifier'] = user_campaign_map['goal_identifier'] if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
+            @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']
+            decision = add_variation_to_decision_properties(decision, campaign, variation)
+            @hooks_manager.execute(decision)
+            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'
-              )
-            )
-            return
+            return if campaign_not_activated?(user_id, campaign_key, api_name)
           end
         end
 
         # Pre-segmentation
-        is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
+        is_presegmentation = 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
+        return nil unless is_presegmentation_and_traffic_passed
 
         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
+            if whitelisting_or_storage_for_grouped_campaigns?(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true)
               @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"]
-              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
+            return if meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign)
+
+            variation = get_variation_allotted(user_id, campaign, true)
+            return nil unless variation && variation['name']
+
+            save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name']
           end
         end
 
-        if variation.nil?
-          variation = get_variation_allotted(user_id, campaign)
+        variation ||= get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        return unless variation
 
-          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)
-            )
-          end
+        decision = add_variation_to_decision_properties(decision, campaign, variation)
+        @hooks_manager.execute(decision)
+        variation
+      end
+
+      def campaign_not_activated?(user_id, campaign_key, api_name)
+        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
+            }
+          )
+
+          @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 true
+        end
+        false
+      end
+
+      def meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign)
+        unless winner_campaign && winner_campaign['id'] == campaign['id']
+          @logger.log(
+            LogLevelEnum::INFO,
+            'MEG_CALLED_CAMPAIGN_NOT_WINNER',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign['key'],
+              '{userId}' => user_id,
+              '{groupName}' => group_name
+            }
+          )
+          return true
+        end
+        false
+      end
+
+      # Intitialize decision properties for hook manager
+      #
+      # @param[String]          :user_id                          The unique ID assigned to User
+      # @param[Hash]            :campaign                         Campaign hash itself
+      # @param[String]          :api_name                         Name of the current api call
+      # @param[String]          :goal_identifier                  The unique campaign's goal identifier
+      # @param[Hash]            :custom_variables                 Key/value pair for segmentation
+      # @param[Hash]            :variation_targeting_variables    Key/value pair for whitelisting
+      # @return[Hash]                                             Decision properties for the callback by hook manager
+      def initialize_decision_properties(user_id, campaign, api_name, custom_variables = {}, variation_targeting_variables = {}, goal_identifier = '')
+        {
+          campaign_id: campaign['id'],
+          campaign_key: campaign['key'],
+          campaign_type: campaign['type'],
+          # campaign segmentation conditions
+          custom_variables: custom_variables,
+          # event name
+          event: Hooks::DECISION_TYPES['CAMPAIGN_DECISION'],
+          # goal tracked in case of track API
+          goal_identifier: goal_identifier,
+          # campaign whitelisting flag
+          is_forced_variation_enabled: campaign['isForcedVariationEnabled'] || false,
+          sdk_version: SDK_VERSION,
+          # API name which triggered the event
+          source: api_name,
+          # Passed in API
+          user_id: user_id,
+          # Campaign Whitelisting conditions
+          variation_targeting_variables: variation_targeting_variables,
+          is_user_whitelisted: false,
+          from_user_storage_service: false,
+          is_feature_enabled: true,
+          # VWO generated UUID based on passed UserId and Account ID
+          vwo_user_id: generator_for(user_id, @settings_file['accountId'])
+        }
+      end
+
+      # Add variation details to decision properties for hook manager
+      #
+      # @param[Hash]            :campaign                  Campaign details
+      # @param[Hash]            :variation                 Variation assigned to user
+      # @param[Hash]            :decision                  Decision properties
+      # @return[Hash]           :decision                  Decision properties
+      def add_variation_to_decision_properties(decision, campaign, variation)
+        if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
+          decision[:variation_name] = variation['name']
+          decision[:variation_id] = variation['id']
+        end
+        decision[:is_feature_enabled] = variation['isFeatureEnabled'] if campaign['type'] == CampaignTypes::FEATURE_TEST
+        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_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        return nil unless is_presegmentation
 
+        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
-          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
+          decision = add_variation_to_decision_properties(decision, campaign, variation)
           @hooks_manager.execute(decision)
         end
         variation
@@ -309,37 +344,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
-          )
-          variation
+        if @bucketer.user_part_of_campaign?(user_id, campaign, true)
+          get_variation_of_campaign_for_user(user_id, campaign, disable_logs)
+
         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 +379,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
 
@@ -402,11 +421,12 @@ class VWO
       # @param[Boolean]             :disable_logs       optional: disable logs if True
       # @return[Boolean]                                true if found otherwise false
 
-      def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal_identifier, disable_logs = false)
+      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),
+            'USER_STORAGE_SERVICE_NOT_CONFIGURED',
+            { '{file}' => FILE },
             disable_logs
           )
           return false
@@ -415,40 +435,41 @@ class VWO
         new_campaign_user_mapping['campaign_key'] = campaign_key
         new_campaign_user_mapping['user_id'] = user_id
         new_campaign_user_mapping['variation_name'] = variation_name
-        if !goal_identifier.empty?
-          new_campaign_user_mapping['goal_identifier'] = goal_identifier
-        end
+        new_campaign_user_mapping['goal_identifier'] = goal_identifier unless goal_identifier.empty?
 
         @user_storage_service.set(new_campaign_user_mapping)
 
         @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
       end
 
+      def update_goal_identifier(user_id, campaign, variation, goal_identifier)
+        updated_goal_identifier = variation['goal_identifier']
+        updated_goal_identifier += VWO_DELIMITER + goal_identifier
+        save_user_storage(user_id, campaign['key'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name']
+      end
+
       private
 
       # Evaluate all the variations in the campaign to find
@@ -462,20 +483,18 @@ class VWO
       #
       # @return[Hash]
 
-      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'])
+      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'], true)
           if variation_targeting_variables.nil?
             variation_targeting_variables = { _vwo_user_id: vwo_user_id }
           else
             variation_targeting_variables[:_vwo_user_id] = vwo_user_id
           end
+        elsif variation_targeting_variables.nil?
+          variation_targeting_variables = { _vwo_user_id: user_id }
         else
-          if variation_targeting_variables.nil?
-            variation_targeting_variables = { _vwo_user_id: user_id }
-          else
-            variation_targeting_variables[:_vwo_user_id] = user_id
-          end
+          variation_targeting_variables[:_vwo_user_id] = user_id
         end
         targeted_variations = []
 
@@ -490,36 +509,37 @@ 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}' => if status == StatusEnum::PASSED
+                                   campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : "#{variation['name']} and hence becomes part of the rollout"
+                                 else
+                                   ''
+                                 end
+              },
               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 +561,8 @@ class VWO
             targeted_variations_deep_clone,
             @bucketer.get_bucket_value_for_user(
               user_id,
-              campaign
+              campaign,
+              disable_logs
             )
           )
         else
@@ -570,7 +591,7 @@ class VWO
       end
 
       def scale_campaigns_weight(campaigns)
-        normalize_weight = 100/campaigns.length
+        normalize_weight = 100 / campaigns.length
         campaigns.each do |campaign|
           campaign['weight'] = normalize_weight
         end
@@ -587,28 +608,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
@@ -623,21 +652,10 @@ class VWO
       #
       # @return[Object, nil]      if found then variation settings object otherwise None
 
-      def get_stored_variation(user_id, campaign_key, user_campaign_map, disable_logs = false)
+      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']
-        @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,
@@ -655,66 +673,58 @@ class VWO
       # @param[Boolean] :disable_logs                       optional: disable logs if True
       #
       # @return[Boolean]
-      def check_presegmentation(campaign, user_id, custom_variables, api_name, disable_logs = false)
+      def 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
+          custom_variables ||= {}
+          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,11 +739,11 @@ 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'] || presegmentation?(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true)
             eligible_campaigns.push(campaign)
           end
         end
-        return eligible_campaigns
+        eligible_campaigns
       end
 
       # Finds and returns the winner campaign from eligible_campaigns list.
@@ -743,14 +753,12 @@ class VWO
       #
       # @return[Hash]
       def get_winner_campaign(user_id, eligible_campaigns, group_id)
-        if eligible_campaigns.length == 1
-          return eligible_campaigns[0]
-        end
+        return eligible_campaigns[0] if eligible_campaigns.length == 1
 
         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)
+        @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns)
       end
 
       # Get campaign keys of all eligible Campaigns.
@@ -761,7 +769,7 @@ class VWO
       def get_eligible_campaigns_key(eligible_campaigns)
         eligible_campaigns_key = []
         eligible_campaigns.each do |campaign|
-          eligible_campaigns_key.push(campaign["key"])
+          eligible_campaigns_key.push(campaign['key'])
         end
         eligible_campaigns_key
       end
@@ -775,9 +783,7 @@ class VWO
       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.push(campaign["key"])
-          end
+          non_eligible_campaigns_key.push(campaign['key']) unless eligible_campaigns.include? campaign
         end
         non_eligible_campaigns_key
       end
@@ -792,54 +798,54 @@ class VWO
       # @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)
+      def 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
+          next unless called_campaign['id'] != campaign['id']
+
+          targeted_variation = evaluate_whitelisting(
+            user_id,
+            campaign,
+            '',
+            campaign['key'],
+            variation_targeting_variables,
+            true
+          )
+          next unless targeted_variation
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign['key'],
+              '{userId}' => user_id,
+              '{groupName}' => group_name,
+              '{type}' => 'whitelisting'
+            },
+            disable_logs
+          )
+          return true
         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
+          next unless called_campaign['id'] != campaign['id']
+
+          user_storage_data = get_user_storage(user_id, campaign['key'], true)
+          next unless user_storage_data
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign['key'],
+              '{userId}' => user_id,
+              '{groupName}' => group_name,
+              '{type}' => 'user storag'
+            },
+            disable_logs
+          )
+          return true
         end
         false
       end
@@ -872,28 +878,21 @@ 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 || {},
+              '{status}' => status,
+              '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
+              '{variation}' => status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT ? "for variation:#{variation['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']
-              end
-            end
+            decision = add_variation_to_decision_properties(decision, campaign, variation)
             decision[:is_user_whitelisted] = true
             @hooks_manager.execute(decision)
           end
@@ -901,20 +900,20 @@ 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
         nil
       end
-
     end
   end
 end