vwo-sdk 1.5.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e24789df43b6c0c71d71f8211c44ffe12c113e91943b91f8de581214353ccce
-  data.tar.gz: 95ec02ba3df3e88f91bf3f49eb5ab3ab64302b2c664d4d3caa6f569f2e618952
+  metadata.gz: 2307340499cf5f0fd3fd13ab5025fc4892721123c82bc3df8eff266362d01c82
+  data.tar.gz: a0a3343ef9af102444cd9a6dd590937d5c737a3ed46765d3bd9cb8e18ceb41bf
 SHA512:
-  metadata.gz: 1dcc6b57a5fd35867d58d71f3f4b73b0da3ca73f01d009493f76b8981562e6d315f004a9095bcd20f230de1bf19559ac0a2ffefaa5befb72abae0e61de8fce6d
-  data.tar.gz: a7b154c4d9ae6c5b681c6cb27b231f3183a21c496e3eb5d33eecf81df0ca1d55922db127db37debe175aa060575f56dfe42ddbff29c0843e69839bcb57e4fc8c
+  metadata.gz: f1c28b3c5b86fa2b4488b5995a9931aaea708d1788f803c079f2fc5684fca81d82465f798e9653d227d448d6c08688791cf0740f774526ed38bd345e252b91fa
+  data.tar.gz: e4d2fcfca37407b7ed7ff008bc2d2d6b03e7f6bddd2f653825fd059306de36254ee4d46165e0973524e701d62e9a972c11a586089c5279027fb4ea5dc589060f

data/lib/vwo/constants.rb

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 Wingify Software Pvt. Ltd.
+# Copyright 2019-2021 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -26,20 +26,29 @@ class VWO
     HTTP_PROTOCOL = 'http://'
     HTTPS_PROTOCOL = 'https://'
     URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
-    SDK_VERSION = '1.5.0'
+    SDK_VERSION = '1.15.0'
     SDK_NAME = 'ruby'
+    VWO_DELIMITER = '_vwo_'
+    MAX_EVENTS_PER_REQUEST = 5000
+    MIN_EVENTS_PER_REQUEST = 1
+    DEFAULT_EVENTS_PER_REQUEST = 100
+    DEFAULT_REQUEST_TIME_INTERVAL = 600 # 10 * 60(secs) = 600 secs i.e. 10 minutes
+    MIN_REQUEST_TIME_INTERVAL = 2
 
     module ENDPOINTS
       BASE_URL = 'dev.visualwebsiteoptimizer.com'
-      ACCOUNT_SETTINGS = '/server-side/settings'
+      SETTINGS_URL = '/server-side/settings'
+      WEBHOOK_SETTINGS_URL = '/server-side/pull'
       TRACK_USER = '/server-side/track-user'
       TRACK_GOAL = '/server-side/track-goal'
       PUSH = '/server-side/push'
+      BATCH_EVENTS = '/server-side/batch-events'
     end
 
     module EVENTS
       TRACK_USER = 'track-user'
       TRACK_GOAL = 'track-goal'
+      PUSH = 'push'
     end
 
     module DATATYPE
@@ -61,6 +70,12 @@ class VWO
       BOOLEAN = 'boolean'
     end
 
+    module Hooks
+      DECISION_TYPES = {
+        'CAMPAIGN_DECISION' => 'CAMPAIGN_DECISION'
+      }
+    end
+
     RUBY_VARIABLE_TYPES = {
       'string' => [String],
       'integer' => [Integer],
@@ -68,6 +83,12 @@ class VWO
       'boolean' => [TrueClass, FalseClass]
     }
 
+    GOAL_TYPES = {
+      'REVENUE' => 'REVENUE_TRACKING',
+      'CUSTOM' => 'CUSTOM_GOAL',
+      'ALL' => 'ALL'
+    }
+
     module ApiMethods
       ACTIVATE = 'activate'
       GET_VARIATION_NAME = 'get_variation_name'
@@ -75,6 +96,8 @@ class VWO
       IS_FEATURE_ENABLED = 'is_feature_enabled'
       GET_FEATURE_VARIABLE_VALUE = 'get_feature_variable_value'
       PUSH = 'push'
+      GET_AND_UPDATE_SETTINGS_FILE = 'get_and_update_settings_file'
+      FLUSH_EVENTS = 'flush_events'
     end
 
     module PushApi

data/lib/vwo/core/bucketer.rb

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 Wingify Software Pvt. Ltd.
+# Copyright 2019-2021 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -116,11 +116,9 @@ class VWO
           )
         )
 
-        get_variation(campaign, bucket_value)
+        get_variation(campaign['variations'], bucket_value)
       end
 
-      private
-
       # Returns the Variation by checking the Start and End
       # Bucket Allocations of each Variation
       #
@@ -128,8 +126,8 @@ class VWO
       # @param[Integer]     :bucket_value   The bucket Value of the user
       # @return[Hash|nil]                   Variation data allotted to the user or None if not
       #
-      def get_variation(campaign, bucket_value)
-        campaign['variations'].find do |variation|
+      def get_variation(variations, bucket_value)
+        variations.find do |variation|
           (variation['start_variation_allocation']..variation['end_variation_allocation']).cover?(bucket_value)
         end
       end

data/lib/vwo/core/variation_decider.rb

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 Wingify Software Pvt. Ltd.
+# Copyright 2019-2021 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,15 +18,20 @@ require_relative '../utils/campaign'
 require_relative '../services/segment_evaluator'
 require_relative '../utils/validations'
 require_relative 'bucketer'
+require_relative '../constants'
+require_relative '../services/hooks_manager'
+require_relative '../utils/uuid'
 
 class VWO
   module Core
     class VariationDecider
-      attr_reader :user_storage_service
+      attr_reader :user_storage_service, :has_stored_variation, :hooks_manager
 
       include VWO::Enums
       include VWO::Utils::Campaign
       include VWO::Utils::Validations
+      include VWO::CONSTANTS
+      include VWO::Utils::UUID
 
       FILE = FileNameEnum::VariationDecider
 
@@ -34,15 +39,17 @@ class VWO
       # @param[Hash] -   Settings file
       # @param[Class] -  Class instance having the capability of
       #                  get and save.
-      def initialize(settings_file, user_storage_service = nil)
+      def initialize(settings_file, user_storage_service = nil, options = {})
         @logger = VWO::Logger.get_instance
         @user_storage_service = user_storage_service
         @bucketer = VWO::Core::Bucketer.new
         @settings_file = settings_file
         @segment_evaluator = VWO::Services::SegmentEvaluator.new
+        @hooks_manager = VWO::Services::HooksManager.new(options)
       end
 
       # Returns variation for the user for the passed campaign-key
+      # Check if Whitelisting is applicable, evaluate it, if any eligible variation is found,return, otherwise skip it
       # Check in User Storage, if user found, validate variation and return
       # Otherwise, proceed with variation assignment logic
       #
@@ -50,16 +57,110 @@ class VWO
       # @param[String]          :user_id             The unique ID assigned to User
       # @param[Hash]            :campaign            Campaign hash itself
       # @param[String]          :campaign_key        The unique ID of the campaign passed
+      # @param[String]          :goal_identifier     The unique campaign's goal identifier
       # @return[String,String]                       ({variation_id, variation_name}|Nil): Tuple of
       #                                              variation_id and variation_name if variation allotted, else nil
 
-      def get_variation(user_id, campaign, campaign_key, custom_variables = {})
+      def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = {}, variation_targeting_variables = {}, goal_identifier = '')
         campaign_key ||= campaign['key']
 
+        return unless campaign
+
+        @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'])
+        }
+
+        if campaign['isForcedVariationEnabled']
+          variation = evaluate_whitelisting(
+            user_id,
+            campaign,
+            api_name,
+            campaign_key,
+            variation_targeting_variables
+          )
+          status = if variation
+                     StatusEnum::PASSED
+                   else
+                     StatusEnum::FAILED
+                   end
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::SEGMENTATION_STATUS,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              status: status,
+              custom_variables: variation_targeting_variables,
+              variation_name: status == StatusEnum::PASSED ? "and #{variation['name']} is Assigned" : ' ',
+              segmentation_type: SegmentationTypeEnum::WHITELISTING,
+              api_name: api_name
+            )
+          )
+
+          if variation
+            if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
+              decision[:variation_name] = variation['name']
+              decision[:variation_id] = variation['id']
+              if campaign['type'] == CampaignTypes::FEATURE_TEST
+                decision[:is_feature_enabled] = variation['isFeatureEnabled']
+              elsif campaign['type'] == CampaignTypes::VISUAL_AB
+                decision[:is_user_whitelisted] = !!variation['name']
+              end
+            end
+            @hooks_manager.execute(decision)
+          end
+
+          return variation if variation && variation['name']
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::WHITELISTING_SKIPPED,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              api_name: api_name
+            )
+          )
+        end
+
         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 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(
@@ -70,11 +171,58 @@ class VWO
               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
+            )
+          )
+
+          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) &&
+            @user_storage_service && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::DebugMessages::CAMPAIGN_NOT_ACTIVATED,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name
+              )
+            )
+
+            @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
+          end
         end
 
         # Pre-segmentation
-        return unless campaign
 
         segments = get_segments(campaign)
         is_valid_segments = valid_value?(segments)
@@ -88,21 +236,44 @@ class VWO
                 file: FILE,
                 campaign_key: campaign_key,
                 user_id: user_id,
-                api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+                api_name: api_name
               )
             )
             custom_variables = {}
           end
-          return unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+            @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
+              )
+            )
+            return
+          end
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::USER_PASSED_SEGMENTATION,
+              file: FileNameEnum::SegmentEvaluator,
+              user_id: user_id,
+              campaign_key: campaign_key,
+              custom_variables: custom_variables
+            )
+          )
         else
           @logger.log(
             LogLevelEnum::INFO,
             format(
-              LogMessageEnum::InfoMessages::SKIPPING_PRE_SEGMENTATION,
+              LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
               file: FILE,
               campaign_key: campaign_key,
               user_id: user_id,
-              api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+              api_name: api_name,
+              variation: ''
             )
           )
         end
@@ -110,7 +281,7 @@ class VWO
         variation = get_variation_allotted(user_id, campaign)
 
         if variation && variation['name']
-          save_user_storage(user_id, campaign_key, variation['name']) if variation['name']
+          save_user_storage(user_id, campaign_key, variation['name'], goal_identifier) if variation['name']
 
           @logger.log(
             LogLevelEnum::INFO,
@@ -129,6 +300,17 @@ class VWO
             format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: 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
+          @hooks_manager.execute(decision)
+        end
         variation
       end
 
@@ -183,6 +365,7 @@ class VWO
       # @param[String]              :user_id      The unique ID assigned to a user
       # @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(
@@ -224,8 +407,152 @@ class VWO
         nil
       end
 
+      # If UserStorageService is provided, save the assigned variation
+      #
+      # @param[String]              :user_id            Unique user identifier
+      # @param[String]              :campaign_key       Unique campaign identifier
+      # @param[String]              :variation_name     Variation identifier
+      # @param[String]              :goal_identifier    The unique campaign's goal identifier
+      # @return[Boolean]                                true if found otherwise false
+
+      def save_user_storage(user_id, campaign_key, variation_name, goal_identifier)
+        unless @user_storage_service
+          @logger.log(
+            LogLevelEnum::DEBUG,
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
+          )
+          return false
+        end
+        new_campaign_user_mapping = {}
+        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
+
+        @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)
+        )
+        true
+      rescue StandardError
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+        )
+        false
+      end
+
       private
 
+      # Evaluate all the variations in the campaign to find
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :campaign                           Campaign hash for Unique campaign key
+      # @param[String]  :api_name                           The key Passed to identify the calling API
+      # @param[String]  :campaign_key                       Unique campaign key
+      # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      #
+      # @return[Hash]
+
+      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {})
+        if variation_targeting_variables.nil?
+          variation_targeting_variables = { '_vwo_user_id' => user_id }
+        else
+          variation_targeting_variables['_vwo_user_id'] = user_id
+        end
+        targeted_variations = []
+
+        campaign['variations'].each do |variation|
+          segments = get_segments(variation)
+          is_valid_segments = valid_value?(segments)
+          if is_valid_segments
+            if @segment_evaluator.evaluate(campaign_key, user_id, segments, variation_targeting_variables)
+              targeted_variations.push(variation)
+              status = StatusEnum::PASSED
+            else
+              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: variation['name'],
+                segmentation_type: SegmentationTypeEnum::WHITELISTING,
+                api_name: api_name
+              )
+            )
+          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']
+              )
+            )
+          end
+        end
+
+        if targeted_variations.length > 1
+          targeted_variations_deep_clone = Marshal.load(Marshal.dump(targeted_variations))
+          scale_variation_weights(targeted_variations_deep_clone)
+          current_allocation = 0
+          targeted_variations_deep_clone.each do |variation|
+            step_factor = get_variation_bucketing_range(variation['weight'])
+            if step_factor > 0
+              start_range = current_allocation + 1
+              end_range = current_allocation + step_factor
+              variation['start_variation_allocation'] = start_range
+              variation['end_variation_allocation'] = end_range
+              current_allocation += step_factor
+            else
+              variation['start_variation_allocation'] = -1
+              variation['end_variation_allocation'] = -1
+            end
+          end
+          whitelisted_variation = @bucketer.get_variation(
+            targeted_variations_deep_clone,
+            @bucketer.get_bucket_value_for_user(
+              user_id
+            )
+          )
+        else
+          whitelisted_variation = targeted_variations[0]
+        end
+        whitelisted_variation
+      end
+
+      # It extracts the weights from all the variations inside the campaign
+      # and scales them so that the total sum of eligible variations' weights become 100%
+      #
+      # 1. variations
+
+      def scale_variation_weights(variations)
+        total_weight = variations.reduce(0) { |final_weight, variation| final_weight + variation['weight'].to_f }
+        if total_weight == 0
+          weight = 100 / variations.length
+          variations.each do |variation|
+            variation['weight'] = weight
+          end
+        else
+          variations.each do |variation|
+            variation['weight'] = (variation['weight'] / total_weight) * 100
+          end
+        end
+      end
+
       # Get the UserStorageData after looking up into get method
       # Being provided via UserStorageService
       #
@@ -290,41 +617,6 @@ class VWO
           variation_name
         )
       end
-
-      # If UserStorageService is provided, save the assigned variation
-      #
-      # @param[String]              :user_id            Unique user identifier
-      # @param[String]              :campaign_key       Unique campaign identifier
-      # @param[String]              :variation_name     Variation identifier
-      # @return[Boolean]                                true if found otherwise false
-
-      def save_user_storage(user_id, campaign_key, variation_name)
-        unless @user_storage_service
-          @logger.log(
-            LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
-          )
-          return false
-        end
-        new_campaign_user_mapping = {}
-        new_campaign_user_mapping['campaign_key'] = campaign_key
-        new_campaign_user_mapping['user_id'] = user_id
-        new_campaign_user_mapping['variation_name'] = variation_name
-
-        @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)
-        )
-        true
-      rescue StandardError
-        @logger.log(
-          LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
-        )
-        false
-      end
     end
   end
 end