vwo-sdk 1.14.0 → 1.22.0

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

@@ -54,7 +54,13 @@ class VWO
             },
             weight: {
               type: %w[number string]
-            }
+            },
+           variables: {
+             type: 'array',
+             items: {
+               '$ref' => '#/definitions/variables_schema'
+             }
+           }
           },
           required: %w[id name weight]
         },
@@ -79,9 +85,34 @@ class VWO
                 '$ref' => '#/definitions/campaign_variation_schema'
               }
             },
+            variables: {
+              type: 'array',
+              items: {
+                '$ref' => '#/definitions/variables_schema'
+              }
+            },
+            isBucketingSeedEnabled: ['boolean'],
             minItems: 2
           }
         },
+        variables_schema: {
+          type: 'object',
+          properties: {
+            id: {
+              type: %w[number string]
+            },
+            key: {
+              type: ['string']
+            },
+            type: {
+              type: ['string']
+            },
+            value: {
+              type: %w[number string boolean double object]
+            }
+          },
+          required: %w[id key type value]
+        },
         required: %w[
           id
           key

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
@@ -190,7 +210,7 @@ class VWO
             end
             goal = get_campaign_goal(campaign, goal_identifier)
             if validate_goal(goal, goal_type_to_track)
-              campaigns.append(campaign)
+              campaigns.push(campaign)
             end
           end
         end
@@ -215,7 +235,7 @@ class VWO
 
           campaign = get_campaign_for_campaign_key_and_goal(campaign_key, settings_file, goal_identifier, goal_type_to_track)
           if campaign
-            campaigns.append(campaign)
+            campaigns.push(campaign)
           end
         end
         campaigns
@@ -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/utils/feature.rb

@@ -38,6 +38,8 @@ class VWO
         return value.to_f if variable_type == VariableTypes::DOUBLE
 
         return !value || value == 0 ? false : true if variable_type == VariableTypes.BOOLEAN
+
+        return value if variable_type == VariableTypes::JSON
       rescue StandardError => _e
         VWO::Logger.get_instance.log(
           LogLevelEnum::ERROR,

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,
@@ -437,7 +436,7 @@ class VWO
         exception: e
       )
     )
-    nil
+    e
   end
 
   # This API method: Gets the variation name assigned for the
@@ -563,10 +562,11 @@ class VWO
   # @param[String]                      :campaign_key     Unique campaign key
   # @param[String]                      :user_id          ID assigned to a user
   # @param[String]                      :goal_identifier  Unique campaign's goal identifier
-  # @param[Array|Hash]                  :args             Contains revenue value and custom variables
+  # @param[Hash]                        :options             Contains revenue value and custom variables
   # @param[Numeric|String]              :revenue_value    It is the revenue generated on triggering the goal
   #
-  def track(campaign_key, user_id, goal_identifier, *args)
+
+  def track(campaign_key, user_id, goal_identifier, options = {})
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -579,18 +579,11 @@ class VWO
       return false
     end
 
-    if args[0].is_a?(Hash)
-      revenue_value = args[0]['revenue_value'] || args[0][:revenue_value]
-      custom_variables = args[0]['custom_variables'] || args[0][:custom_variables]
-      variation_targeting_variables = args[0]['variation_targeting_variables'] || args[0][:variation_targeting_variables]
-      should_track_returning_user = get_should_track_returning_user(args[0])
-      goal_type_to_track = get_goal_type_to_track(args[0])
-    elsif args.is_a?(Array)
-      revenue_value = args[0]
-      custom_variables = nil
-      should_track_returning_user = @should_track_returning_user
-      goal_type_to_track = @goal_type_to_track
-    end
+    revenue_value = options['revenue_value'] || options[:revenue_value]
+    custom_variables = options['custom_variables'] || options[:custom_variables]
+    variation_targeting_variables = options['variation_targeting_variables'] || options[:variation_targeting_variables]
+    should_track_returning_user = get_should_track_returning_user(options)
+    goal_type_to_track = get_goal_type_to_track(options)
 
     # Check for valid args
     unless (valid_string?(campaign_key) || campaign_key.is_a?(Array) || campaign_key.nil?) && valid_string?(user_id) && valid_string?(goal_identifier) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
@@ -617,147 +610,149 @@ class VWO
 
     result = {}
     campaigns.each do |campaign|
-      campaign_type = campaign['type']
+      begin
+        campaign_type = campaign['type']
 
-      if campaign_type == CampaignTypes::FEATURE_ROLLOUT
-        @logger.log(
-          LogLevelEnum::ERROR,
-          format(
-            LogMessageEnum::ErrorMessages::INVALID_API,
-            file: FILE,
-            api_name: ApiMethods::TRACK,
-            user_id: user_id,
-            campaign_key: campaign['key'],
-            campaign_type: campaign_type
-          )
-        )
-        result[campaign['key']] = false
-        next
-      end
-
-      variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::TRACK, campaign['key'], custom_variables, variation_targeting_variables, goal_identifier)
-
-      if variation
-        goal = get_campaign_goal(campaign, goal_identifier)
-        if goal.nil? || !goal["id"]
-          @logger.log(
-            LogLevelEnum::ERROR,
-            format(
-              LogMessageEnum::ErrorMessages::TRACK_API_GOAL_NOT_FOUND,
-              file: FILE,
-              goal_identifier: goal_identifier,
-              user_id: user_id,
-              campaign_key: campaign['key'],
-              api_name: ApiMethods::TRACK
-            )
-          )
-          result[campaign['key']] = false
-          next
-        elsif goal['type'] == GoalTypes::REVENUE && !valid_value?(revenue_value)
+        if campaign_type == CampaignTypes::FEATURE_ROLLOUT
           @logger.log(
             LogLevelEnum::ERROR,
             format(
-              LogMessageEnum::ErrorMessages::TRACK_API_REVENUE_NOT_PASSED_FOR_REVENUE_GOAL,
+              LogMessageEnum::ErrorMessages::INVALID_API,
               file: FILE,
+              api_name: ApiMethods::TRACK,
               user_id: user_id,
-              goal_identifier: goal_identifier,
               campaign_key: campaign['key'],
-              api_name: ApiMethods::TRACK
+              campaign_type: campaign_type
             )
           )
           result[campaign['key']] = false
           next
-        elsif goal['type'] == GoalTypes::CUSTOM
-          revenue_value = nil
         end
 
-        if variation['goal_identifier']
-          identifiers = variation['goal_identifier'].split(VWO_DELIMITER)
-        else
-          variation['goal_identifier'] = ''
-          identifiers = []
-        end
+        variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::TRACK, campaign['key'], custom_variables, variation_targeting_variables, goal_identifier)
 
-        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']
-          # set variation at user storage
-        elsif !should_track_returning_user
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::GOAL_ALREADY_TRACKED,
-              file: FILE,
-              user_id: user_id,
-              campaign_key: campaign['key'],
-              goal_identifier: goal_identifier,
-              api_name: ApiMethods::TRACK
+        if variation
+          goal = get_campaign_goal(campaign, goal_identifier)
+          if goal.nil? || !goal["id"]
+            @logger.log(
+              LogLevelEnum::ERROR,
+              format(
+                LogMessageEnum::ErrorMessages::TRACK_API_GOAL_NOT_FOUND,
+                file: FILE,
+                goal_identifier: goal_identifier,
+                user_id: user_id,
+                campaign_key: campaign['key'],
+                api_name: ApiMethods::TRACK
+              )
             )
-          )
-          result[campaign['key']] = false
-          next
-        end
-
-        if defined?(@batch_events)
-          impression = create_bulk_event_impression(
-            @settings_file,
-            campaign['id'],
-            variation['id'],
-            user_id,
-            goal['id'],
-            revenue_value
-          )
-          @batch_events_queue.enqueue(impression)
-        else
-          impression = create_impression(
-            @settings_file,
-            campaign['id'],
-            variation['id'],
-            user_id,
-            @sdk_key,
-            goal['id'],
-            revenue_value
-          )
-          if @event_dispatcher.dispatch(impression)
+            result[campaign['key']] = false
+            next
+          elsif goal['type'] == GoalTypes::REVENUE && !valid_value?(revenue_value)
             @logger.log(
-              LogLevelEnum::INFO,
+              LogLevelEnum::ERROR,
               format(
-                LogMessageEnum::InfoMessages::IMPRESSION_SUCCESS,
+                LogMessageEnum::ErrorMessages::TRACK_API_REVENUE_NOT_PASSED_FOR_REVENUE_GOAL,
                 file: FILE,
-                sdk_key: @sdk_key,
-                account_id: @account_id,
-                campaign_id: campaign['id'],
-                variation_id: variation['id'],
-                end_point: EVENTS::TRACK_GOAL
+                user_id: user_id,
+                goal_identifier: goal_identifier,
+                campaign_key: campaign['key'],
+                api_name: ApiMethods::TRACK
               )
             )
+            result[campaign['key']] = false
+            next
+          elsif goal['type'] == GoalTypes::CUSTOM
+            revenue_value = nil
+          end
+
+          if variation['goal_identifier']
+            identifiers = variation['goal_identifier'].split(VWO_DELIMITER)
+          else
+            variation['goal_identifier'] = ''
+            identifiers = []
+          end
+
+          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'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name']
+            # set variation at user storage
+          elsif !should_track_returning_user
             @logger.log(
               LogLevelEnum::INFO,
               format(
-                LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_IMPRESSION,
+                LogMessageEnum::InfoMessages::GOAL_ALREADY_TRACKED,
                 file: FILE,
-                sdk_key: @sdk_key,
-                campaign_id: impression[:experiment_id],
-                account_id: impression[:account_id],
-                variation_id: impression[:combination]
+                user_id: user_id,
+                campaign_key: campaign['key'],
+                goal_identifier: goal_identifier,
+                api_name: ApiMethods::TRACK
               )
             )
+            result[campaign['key']] = false
+            next
+          end
+
+          if defined?(@batch_events)
+            impression = create_bulk_event_impression(
+              @settings_file,
+              campaign['id'],
+              variation['id'],
+              user_id,
+              goal['id'],
+              revenue_value
+            )
+            @batch_events_queue.enqueue(impression)
+          else
+            impression = create_impression(
+              @settings_file,
+              campaign['id'],
+              variation['id'],
+              user_id,
+              @sdk_key,
+              goal['id'],
+              revenue_value
+            )
+            if @event_dispatcher.dispatch(impression)
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::IMPRESSION_SUCCESS,
+                  file: FILE,
+                  sdk_key: @sdk_key,
+                  account_id: @account_id,
+                  campaign_id: campaign['id'],
+                  variation_id: variation['id'],
+                  end_point: EVENTS::TRACK_GOAL
+                )
+              )
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_IMPRESSION,
+                  file: FILE,
+                  sdk_key: @sdk_key,
+                  campaign_id: impression[:experiment_id],
+                  account_id: impression[:account_id],
+                  variation_id: impression[:combination]
+                )
+              )
+            end
           end
+          result[campaign['key']] = true
+          next
         end
-        result[campaign['key']] = true
-        next
-      end
-      result[campaign['key']] = false
-    rescue StandardError => e
-      @logger.log(
-        LogLevelEnum::ERROR,
-        format(
-          e.message,
-          file: FILE,
-          exception: e
+        result[campaign['key']] = false
+      rescue StandardError => e
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(
+            e.message,
+            file: FILE,
+            exception: e
+          )
         )
-      )
+      end
     end
 
     if result.length() == 0
@@ -874,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,