vwo-sdk 1.23.2 → 1.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c878b24cefb4bf2da034a1dec355b96d38650c52018dc8516f7e324e8469ae0e
-  data.tar.gz: ea385bb48e6aebdc4975b08449161cd24dbf075dc582959492f8ff7d7bcc751f
+  metadata.gz: 83480c79432c0c6199e03e365b71fcf8b2e0ffaf89b976c94234b3bcfc54e931
+  data.tar.gz: a695f06bf66c0186c193b05b9d4a6a931c75b9398f260f7d733b57275a3bfedd
 SHA512:
-  metadata.gz: b424bfd4bc9eaab32001d67da2c5acb57b072ab935c9e4f24206ad9329e7a29f76d3498d497224e9adace85b2dcff0d37ade16e9864a651e02c434e8e788443c
-  data.tar.gz: e16e7e7e276fbb9ccbaa9c605e17790116b1e925a766a5f0252991c187a91bfaa4d00fa2ff1445d5cf98443e02e55fa7516845dce36974dd0e56301a86296e86
+  metadata.gz: 63572509c60e9e96c39775bab1fe0bea00dd0ca27f436c46055563886a66bca0d78b3259fe70c2d58e13c8ed0c8e036245760923fcf2187b964628cea2f7741b
+  data.tar.gz: f96d84a9c2ae09e474ede155e1187cce8cd9a0dc38f56646531519aae27c07d5883c5373a60fae9fe92eef9fe0da7f23b1af7e3a71ce1a4283fda9ee6533551a

data/lib/vwo/constants.rb

@@ -27,7 +27,7 @@ class VWO
     HTTP_PROTOCOL = 'http://'
     HTTPS_PROTOCOL = 'https://'
     URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
-    SDK_VERSION = '1.23.2'
+    SDK_VERSION = '1.28.0'
     SDK_NAME = 'ruby'
     VWO_DELIMITER = '_vwo_'
     MAX_EVENTS_PER_REQUEST = 5000
@@ -44,6 +44,7 @@ class VWO
       TRACK_GOAL = '/server-side/track-goal'
       PUSH = '/server-side/push'
       BATCH_EVENTS = '/server-side/batch-events'
+      EVENTS = '/events/t'
     end
 
     module EVENTS
@@ -101,6 +102,7 @@ class VWO
       PUSH = 'push'
       GET_AND_UPDATE_SETTINGS_FILE = 'get_and_update_settings_file'
       FLUSH_EVENTS = 'flush_events'
+      OPT_OUT = 'opt_out'
     end
 
     module PushApi
@@ -113,5 +115,10 @@ class VWO
       FEATURE_TEST = 'FEATURE_TEST'
       FEATURE_ROLLOUT = 'FEATURE_ROLLOUT'
     end
+
+    module EventEnum
+      VWO_VARIATION_SHOWN = 'vwo_variationShown'
+      VWO_SYNC_VISITOR_PROP = 'vwo_syncVisitorProp'
+    end
   end
 end

data/lib/vwo/core/variation_decider.rb

@@ -463,10 +463,19 @@ class VWO
       # @return[Hash]
 
       def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
-        if variation_targeting_variables.nil?
-          variation_targeting_variables = { _vwo_user_id: user_id }
+        if campaign.key?('isUserListEnabled') && campaign["isUserListEnabled"]
+          vwo_user_id = generator_for(user_id, @settings_file['accountId'])
+          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
         else
-          variation_targeting_variables[:_vwo_user_id] = user_id
+          if variation_targeting_variables.nil?
+            variation_targeting_variables = { _vwo_user_id: user_id }
+          else
+            variation_targeting_variables[:_vwo_user_id] = user_id
+          end
         end
         targeted_variations = []
 

data/lib/vwo/enums.rb

@@ -114,6 +114,9 @@ class VWO
         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"
+        IMPRESSION_FOR_EVENT_ARCH_TRACK_USER = "(%<file>s): impression built for vwo_variationShown event for account ID:%<a>s, user ID:%<u>s, and campaign ID:%<c>s"
+        IMPRESSION_FOR_EVENT_ARCH_TRACK_GOAL = "(%<file>s): impression built for %<goal_identifier>s event for account ID:%<a>s, user ID:%<u>s, and campaign ID:%<c>s"
+        IMPRESSION_FOR_EVENT_ARCH_PUSH = "(%<file>s): impression built for visitor property:%<property>s for account ID:%<a>s and user ID:%<u>s"
       end
 
       # Info Messages
@@ -128,6 +131,7 @@ class VWO
         AUDIENCE_CONDITION_NOT_MET = '(%<file>s): userId:%<user_id>s does not become part of campaign because of not meeting audience conditions'
         GOT_VARIATION_FOR_USER = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_key>s got variationName:%<variation_name>s'
         USER_GOT_NO_VARIATION = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_key>s did not allot any variation'
+        IMPRESSION_SUCCESS_FOR_EVENT_ARCH = '(%<file>s): Impression for %<event>s - %<url>s was successfully received by VWO for account ID:%<a>s'
         IMPRESSION_SUCCESS = '(%<file>s): Impression event - %<end_point>s was successfully received by VWO having main keys: accountId:%<account_id>s campaignId:%<campaign_id>s and variationId:%<variation_id>s'
         MAIN_KEYS_FOR_IMPRESSION = '(%<file>s): Having main keys: accountId:%<account_id>s campaignId:%<campaign_id>s and variationId:%<variation_id>s}'
         MAIN_KEYS_FOR_PUSH_API = '(%<file>s): Having main keys: accountId:%<account_id>s u:%<u>s and tags:%<tags>s}'
@@ -160,6 +164,8 @@ class VWO
         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"
+        OPT_OUT_API_CALLED = "(%<file>s): You have opted out for not tracking i.e. all API calls will stop functioning and will simply early return"
+        API_NOT_ENABLED = "(%<file>s): %<api>s API is disabled as you opted out for tracking. Reinitialize the SDK to enable the normal functioning of all APIs."
       end
 
       # Warning Messages
@@ -201,7 +207,6 @@ class VWO
         TAG_KEY_LENGTH_EXCEEDED = '(%<file>s): In API: %<api_name>s, the length of tag_key:%<tag_key>s and userID: %<user_id>s can not be greater than 255'
         TRACK_API_MISSING_PARAMS = '(%<file>s): "track" API got bad parameters. It expects campaignKey(null/String/array) as first, userId(String/Number) as second and goalIdentifier (string) as third argument. options is revenueValue(Float/Number/String) and is required for revenue goal only.'
         NO_CAMPAIGN_FOUND = '(%<file>s): No campaign found for goal_identifier:%<goal_identifier>s. Please verify from VWO app.'
-        INVALID_TRACK_RETURNING_USER_VALUE  = '(%<file>s): should_track_returning_user should be boolean'
         INVALID_GOAL_TYPE = '(%<file>s): goal_type_to_track should be certain strings'
         EVENT_BATCHING_NOT_OBJECT = '(%<file>s): Batch events settings are not of type object.'
         EVENTS_PER_REQUEST_INVALID = '(%<file>s): events_per_request should be an integer'

data/lib/vwo/schemas/settings_file.rb

@@ -26,6 +26,9 @@ class VWO
         accountId: {
           type: %w[number string]
         },
+        isEventArchEnabled: {
+          type: ['boolean']
+        },
         campaigns: {
           if: {
             type: 'array'
@@ -95,6 +98,7 @@ class VWO
               }
             },
             isBucketingSeedEnabled: ['boolean'],
+            isUserListEnabled: ['boolean'],
             minItems: 2
           }
         },

data/lib/vwo/services/event_dispatcher.rb

@@ -15,11 +15,13 @@
 require_relative '../logger'
 require_relative '../enums'
 require_relative '../utils/request'
+require_relative '../constants'
 
 class VWO
   module Services
     class EventDispatcher
       include VWO::Enums
+      include VWO::CONSTANTS
 
       EXCLUDE_KEYS = ['url'].freeze
 
@@ -63,6 +65,38 @@ class VWO
         )
         false
       end
+
+      def dispatch_event_arch_post(params, post_data)
+        return true if @is_development_mode
+
+        url = HTTPS_PROTOCOL + ENDPOINTS::BASE_URL + ENDPOINTS::EVENTS
+        resp = VWO::Utils::Request.event_post(url, params, post_data, SDK_NAME)
+        if resp.code == '200'
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::IMPRESSION_SUCCESS_FOR_EVENT_ARCH, 
+              file: FileNameEnum::EventDispatcher, 
+              event: 'visitor property:' + JSON.generate(post_data[:d][:visitor][:props]), 
+              url: url,
+              a: params[:a]
+            )
+          )
+          true
+        else
+          @logger.log(
+            LogLevelEnum::ERROR,
+            format(LogMessageEnum::ErrorMessages::IMPRESSION_FAILED, file: FileNameEnum::EventDispatcher, end_point: url)
+          )
+          false
+        end
+      rescue StandardError
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::IMPRESSION_FAILED, file: FileNameEnum::EventDispatcher, end_point: url)
+        )
+        false
+      end
     end
   end
 end

data/lib/vwo/utils/function.rb

@@ -33,6 +33,11 @@ class VWO
         Time.now.to_i
       end
 
+      # @return[Integer]
+      def get_current_unix_timestamp_in_millis
+        (Time.now.to_f * 1000).to_i
+      end
+
       # @return[any, any]
       def get_key_value(obj)
         [obj.keys[0], obj.values[0]]

data/lib/vwo/utils/impression.rb

@@ -164,6 +164,186 @@ class VWO
         end
         impression
       end
+
+      # Builds generic properties for different tracking calls required by VWO servers.
+      #
+      # @param[Hash]                      :settings_file
+      # @param[String]                    :sdk_key
+      # @param[String]                    :event_name
+      # @param[Hash]                      :usage_stats
+      # @return[Hash]                     :properties
+      # 
+      def get_events_base_properties(settings_file, event_name, usage_stats = {})
+        properties = {
+          en: event_name,
+          a: settings_file['accountId'],
+          env: settings_file['sdkKey'],
+          eTime: get_current_unix_timestamp_in_millis,
+          random: get_random_number,
+          p: "FS"
+        }
+
+        if event_name == EventEnum::VWO_VARIATION_SHOWN
+          properties = properties.merge(usage_stats)
+        end
+        properties
+      end
+
+      # Builds generic payload required by all the different tracking calls.
+      #
+      # @param[Hash]                   :settings_file
+      # @param[String]                 :user_id
+      # @param[String]                 :event_name
+      # @param[Hash]                   :usage_stats
+      # @return[Hash]                  :properties
+      # 
+      def get_event_base_payload(settings_file, user_id, event_name, usage_stats = {})
+        uuid = generator_for(user_id, (settings_file['accountId']))
+        sdk_key = settings_file['sdkKey']
+
+        props = {
+          sdkName: SDK_NAME,
+          sdkVersion: SDK_VERSION,
+          '$visitor': {
+            props: {
+              vwo_fs_environment: sdk_key
+            }
+          }
+        }
+
+        # if usage_stats
+        #   props = props.merge(usage_stats)
+        # end
+
+        properties = {
+          d: {
+            msgId: uuid + '_' + Time.now.to_i.to_s,
+            visId: uuid,
+            sessionId: Time.now.to_i,
+            event: {
+              props: props,
+              name: event_name,
+              time: get_current_unix_timestamp_in_millis
+            },
+            visitor: {
+              props: {
+                vwo_fs_environment: sdk_key
+              }
+            }
+          }
+        }
+
+        properties
+      end
+
+      # Builds payload to track the visitor.
+      #
+      # @param[Hash]                   :settings_file
+      # @param[String]                 :user_id
+      # @param[String]                 :event_name
+      # @param[Integer]                :campaign_id
+      # @param[Integer]                :variation_id
+      # @param[Hash]                   :usage_stats
+      # @return[Hash]                  :properties
+      #
+      def get_track_user_payload_data(settings_file, user_id, event_name, campaign_id, variation_id, usage_stats = {})
+        properties = get_event_base_payload(settings_file, user_id, event_name)
+        properties[:d][:event][:props][:id] = campaign_id
+        properties[:d][:event][:props][:variation] = variation_id
+
+        #this is currently required by data-layer team, we can make changes on DACDN and remove it from here
+        properties[:d][:event][:props][:isFirst] = 1
+
+        logger = VWO::Logger.get_instance
+        logger.log(
+            LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::IMPRESSION_FOR_EVENT_ARCH_TRACK_USER,
+            file: FileNameEnum::ImpressionUtil,
+            a: settings_file['accountId'],
+            u: user_id,
+            c: campaign_id.to_s
+          )
+        )
+        properties
+      end
+
+      # Builds payload to track the Goal.
+      #
+      # @param[Hash]                   :settings_file
+      # @param[String]                 :user_id
+      # @param[String]                 :event_name
+      # @param[Integer]                :revenue_value
+      # @param[Hash]                   :metric_map
+      # @param[Array]                  :revenue_props
+      #
+      # @return[Hash]                  :properties
+      #
+      def get_track_goal_payload_data(settings_file, user_id, event_name, revenue_value, metric_map, revenue_props = [])
+        properties = get_event_base_payload(settings_file, user_id, event_name)
+
+        logger = VWO::Logger.get_instance
+        metric = {}
+        metric_map.each do |campaign_id, goal_id|
+          metric[('id_' + campaign_id.to_s).to_sym] = ['g_' + goal_id.to_s]
+          logger.log(
+            LogLevelEnum::DEBUG,
+            format(
+              LogMessageEnum::DebugMessages::IMPRESSION_FOR_EVENT_ARCH_TRACK_GOAL,
+              file: FileNameEnum::ImpressionUtil,
+              goal_identifier: event_name,
+              a: settings_file['accountId'],
+              u: user_id,
+              c: campaign_id
+            )
+          )
+        end
+
+        properties[:d][:event][:props][:vwoMeta] = {
+          metric: metric
+        }
+
+        if revenue_props.length() != 0 && revenue_value
+          revenue_props.each do |revenue_prop|
+            properties[:d][:event][:props][:vwoMeta][revenue_prop.to_sym] = revenue_value
+          end
+        end
+
+        properties[:d][:event][:props][:isCustomEvent] = true
+        properties
+      end
+
+      # Builds payload to appply post segmentation on VWO campaign reports.
+      #
+      # @param[Hash]                   :settings_file
+      # @param[String]                 :user_id
+      # @param[String]                 :event_name
+      # @param[Hash]                   :custom_dimension_map
+      #
+      # @return[Hash]                  :properties
+      #
+      def get_push_payload_data(settings_file, user_id, event_name, custom_dimension_map = {})
+        properties = get_event_base_payload(settings_file, user_id, event_name)
+        properties[:d][:event][:props][:isCustomEvent] = true
+
+        custom_dimension_map.each do |tag_key, tag_value|
+          properties[:d][:event][:props][('$visitor'.to_sym)][:props][tag_key] = tag_value
+          properties[:d][:visitor][:props][tag_key] = tag_value
+        end
+
+        logger = VWO::Logger.get_instance
+        logger.log(
+          LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::IMPRESSION_FOR_EVENT_ARCH_PUSH,
+            file: FileNameEnum::ImpressionUtil,
+            a: settings_file['accountId'],
+            u: user_id,
+            property: JSON.generate(custom_dimension_map)
+          )
+        )
+        properties
+      end
     end
   end
 end

data/lib/vwo/utils/request.rb

@@ -38,6 +38,20 @@ class VWO
         response = http.post(uri, post_data.to_json, headers)
         response
       end
+
+      def self.event_post(url, params, post_data, user_agent_value)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        uri.query = URI.encode_www_form(params)
+        headers = {
+          'User-Agent' => user_agent_value,
+          'Content-Type' =>'application/json',
+          'Accept'=>'application/json'
+        }
+        response = http.post(uri, post_data.to_json, headers)
+        response
+      end
     end
   end
 end

data/lib/vwo.rb

@@ -65,6 +65,7 @@ class VWO
     options = {}
   )
     options = convert_to_symbol_hash(options)
+    @is_opted_out = false
     @account_id = account_id
     @sdk_key = sdk_key
     @user_storage = user_storage
@@ -89,25 +90,6 @@ class VWO
       return
     end
 
-    if options.key?(:should_track_returning_user)
-      if [true, false].include? options[:should_track_returning_user]
-        @should_track_returning_user = options[:should_track_returning_user]
-        usage_stats[:tr] = 1 if @should_track_returning_user
-      else
-        @logger.log(
-          LogLevelEnum::ERROR,
-          format(
-            LogMessageEnum::ErrorMessages::INVALID_TRACK_RETURNING_USER_VALUE,
-            file: FILE
-          )
-        )
-        @is_instance_valid = false
-        return
-      end
-    else
-      @should_track_returning_user = false
-    end
-
     if options.key?(:goal_type_to_track)
       if GOAL_TYPES.key? options[:goal_type_to_track]
         @goal_type_to_track = options[:goal_type_to_track]
@@ -227,6 +209,10 @@ class VWO
   # VWO get_settings method to get settings for a particular account_id
   def get_and_update_settings_file
 
+    if is_opted_out(ApiMethods::GET_AND_UPDATE_SETTINGS_FILE)
+      return false
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -236,7 +222,7 @@ class VWO
           api_name: ApiMethods.GET_AND_UPDATE_SETTINGS_FILE
         )
       )
-      return
+      return false
     end
 
     latest_settings = @settings_file_manager.get_settings_file(true)
@@ -286,6 +272,10 @@ class VWO
   #                                               otherwise null in case of user not becoming part
 
   def activate(campaign_key, user_id, options = {})
+    if is_opted_out(ApiMethods::ACTIVATE)
+      return nil
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -303,10 +293,9 @@ class VWO
     custom_variables = options[:custom_variables]
     variation_targeting_variables = options[:variation_targeting_variables]
 
-    should_track_returning_user = get_should_track_returning_user(options)
     # Validate input parameters
     unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
-      (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) && [true, false].include?(should_track_returning_user)
+      (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -381,7 +370,7 @@ class VWO
       return
     end
 
-    if is_eligible_to_send_impression(should_track_returning_user)
+    if is_eligible_to_send_impression()
       if defined?(@batch_events)
         impression = create_bulk_event_impression(
           @settings_file,
@@ -390,6 +379,10 @@ class VWO
           user_id
         )
         @batch_events_queue.enqueue(impression)
+      elsif is_event_arch_enabled
+        properties = get_events_base_properties(@settings_file, EventEnum::VWO_VARIATION_SHOWN, @usage_stats.usage_stats)
+        payload = get_track_user_payload_data(@settings_file, user_id, EventEnum::VWO_VARIATION_SHOWN, campaign['id'], variation['id'])
+        @event_dispatcher.dispatch_event_arch_post(properties, payload)
       else
         # Variation found, dispatch it to server
         impression = create_impression(
@@ -460,6 +453,10 @@ class VWO
   #                                                       Otherwise null in case of user not becoming part
   #
   def get_variation_name(campaign_key, user_id, options = {})
+    if is_opted_out(ApiMethods::GET_VARIATION_NAME)
+      return nil
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -571,6 +568,10 @@ class VWO
   #
 
   def track(campaign_key, user_id, goal_identifier, options = {})
+    if is_opted_out(ApiMethods::TRACK)
+      return false
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -587,12 +588,11 @@ class VWO
     revenue_value = options[:revenue_value]
     custom_variables = options[:custom_variables]
     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)) &&
-      (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) && [true, false].include?(should_track_returning_user) && (GOAL_TYPES.key? (goal_type_to_track))
+      (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) && (GOAL_TYPES.key? (goal_type_to_track))
       # log invalid params
       @logger.log(
         LogLevelEnum::ERROR,
@@ -613,6 +613,8 @@ class VWO
       return nil
     end
 
+    metric_map = {}
+    revenue_props = []
     result = {}
     campaigns.each do |campaign|
       begin
@@ -682,7 +684,7 @@ class VWO
             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
+          else
             @logger.log(
               LogLevelEnum::INFO,
               format(
@@ -708,6 +710,11 @@ class VWO
               revenue_value
             )
             @batch_events_queue.enqueue(impression)
+          elsif  is_event_arch_enabled
+            metric_map[campaign['id']] = goal['id']
+            if goal['type'] == GoalTypes::REVENUE && !(revenue_props.include? goal['revenueProp'])
+              revenue_props << goal['revenueProp']
+            end
           else
             impression = create_impression(
               @settings_file,
@@ -758,6 +765,12 @@ class VWO
       end
     end
 
+    if is_event_arch_enabled
+      properties = get_events_base_properties(@settings_file, goal_identifier)
+      payload = get_track_goal_payload_data(@settings_file, user_id, goal_identifier, revenue_value, metric_map, revenue_props)
+      @event_dispatcher.dispatch_event_arch_post(properties, payload)
+    end
+
     if result.length() == 0
       return nil
     end
@@ -790,6 +803,10 @@ class VWO
   # @return[Boolean]  true if user becomes part of feature test/rollout, otherwise false.
 
   def feature_enabled?(campaign_key, user_id, options = {})
+    if is_opted_out(ApiMethods::IS_FEATURE_ENABLED)
+      return false
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -806,7 +823,6 @@ class VWO
     # Retrieve custom variables
     custom_variables = options[:custom_variables]
     variation_targeting_variables = options[:variation_targeting_variables]
-    should_track_returning_user = get_should_track_returning_user(options)
     @logger.log(
       LogLevelEnum::INFO,
       format(
@@ -818,7 +834,7 @@ class VWO
     )
     # Validate input parameters
     unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
-      (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) && [true, false].include?(should_track_returning_user)
+      (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -874,7 +890,7 @@ class VWO
 
     # if campaign type is feature_test Send track call to server
 
-    if is_eligible_to_send_impression(should_track_returning_user)
+    if is_eligible_to_send_impression()
       if defined?(@batch_events)
         impression = create_bulk_event_impression(
           @settings_file,
@@ -883,6 +899,10 @@ class VWO
           user_id
         )
         @batch_events_queue.enqueue(impression)
+      elsif is_event_arch_enabled
+        properties = get_events_base_properties(@settings_file, EventEnum::VWO_VARIATION_SHOWN, @usage_stats.usage_stats)
+        payload = get_track_user_payload_data(@settings_file, user_id, EventEnum::VWO_VARIATION_SHOWN, campaign['id'], variation['id'])
+        @event_dispatcher.dispatch_event_arch_post(properties, payload)
       else
         impression = create_impression(
           @settings_file,
@@ -984,13 +1004,17 @@ class VWO
   #
 
   def get_feature_variable_value(campaign_key, variable_key, user_id, options = {})
+    if is_opted_out(ApiMethods::GET_FEATURE_VARIABLE_VALUE)
+      return nil
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
         format(
           LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
           file: FILE,
-          api_name: ApiMethods.GET_FEATURE_VARIABLE_VALUE
+          api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
         )
       )
       return
@@ -1132,25 +1156,38 @@ class VWO
   # This API method: Makes a call to our server to store the tag_values
   # 1. Validates the arguments being passed
   # 2. Send a call to our server
-  # @param[String]          :tag_key              key name of the tag
-  # @param[String]          :tag_value            Value of the tag
+  # @param[String|Hash]     :tag_key              key name of the tag OR tagKey/tagValue pair(custom dimension map)
+  # @param[String]          :tag_value            Value of the tag OR userId if TagKey is hash
   # @param[String]          :user_id              ID of the user for which value should be stored
   # @return                                       true if call is made successfully, else false
 
-  def push(tag_key, tag_value, user_id)
+  def push(tag_key, tag_value, user_id = nil)
+    if is_opted_out(ApiMethods::PUSH)
+      return false
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
         format(
           LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
           file: FILE,
-          api_name: ApiMethods.PUSH
+          api_name: ApiMethods::PUSH
         )
       )
-      return
+      return false
+    end
+
+    # Argument reshuffling.
+    custom_dimension_map = {}
+    if user_id.nil? || tag_key.is_a?(Hash)
+      custom_dimension_map = convert_to_symbol_hash(tag_key)
+      user_id = tag_value
+    else
+      custom_dimension_map[tag_key.to_sym] = tag_value
     end
 
-    unless valid_string?(tag_key) && valid_string?(tag_value) && valid_string?(user_id)
+    unless (valid_string?(tag_key) || valid_hash?(tag_key)) && valid_string?(tag_value) && valid_string?(user_id)
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -1162,51 +1199,61 @@ class VWO
       return false
     end
 
-    if tag_key.length > PushApi::TAG_KEY_LENGTH
-      @logger.log(
-        LogLevelEnum::ERROR,
-        format(
-          LogMessageEnum::ErrorMessages::TAG_KEY_LENGTH_EXCEEDED,
-          file: FILE,
-          user_id: user_id,
-          tag_key: tag_key,
-          api_name: ApiMethods::PUSH
+    custom_dimension_map.each do |tag_key, tag_value|
+      if tag_key.length > PushApi::TAG_KEY_LENGTH
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(
+            LogMessageEnum::ErrorMessages::TAG_KEY_LENGTH_EXCEEDED,
+            file: FILE,
+            user_id: user_id,
+            tag_key: tag_key,
+            api_name: ApiMethods::PUSH
+          )
         )
-      )
-      return false
-    end
+        return false
+      end
 
-    if tag_value.length > PushApi::TAG_VALUE_LENGTH
-      @logger.log(
-        LogLevelEnum::ERROR,
-        format(
-          LogMessageEnum::ErrorMessages::TAG_VALUE_LENGTH_EXCEEDED,
-          file: FILE,
-          user_id: user_id,
-          tag_value: tag_value,
-          api_name: ApiMethods::PUSH
+      if tag_value.length > PushApi::TAG_VALUE_LENGTH
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(
+            LogMessageEnum::ErrorMessages::TAG_VALUE_LENGTH_EXCEEDED,
+            file: FILE,
+            user_id: user_id,
+            tag_value: tag_value,
+            api_name: ApiMethods::PUSH
+          )
         )
-      )
-      return false
+        return false
+      end
     end
 
     if defined?(@batch_events)
-      impression = get_batch_event_url_params(@settings_file, tag_key, tag_value, user_id)
-      @batch_events_queue.enqueue(impression)
+      custom_dimension_map.each do |tag_key, tag_value|
+        impression = get_batch_event_url_params(@settings_file, tag_key, tag_value, user_id)
+        @batch_events_queue.enqueue(impression)
+      end
+    elsif is_event_arch_enabled
+      properties = get_events_base_properties(@settings_file, EventEnum::VWO_SYNC_VISITOR_PROP)
+      payload = get_push_payload_data(@settings_file, user_id, EventEnum::VWO_SYNC_VISITOR_PROP, custom_dimension_map)
+      @event_dispatcher.dispatch_event_arch_post(properties, payload)
     else
-      impression = get_url_params(@settings_file, tag_key, tag_value, user_id, @sdk_key)
-      @event_dispatcher.dispatch(impression)
+      custom_dimension_map.each do |tag_key, tag_value|
+        impression = get_url_params(@settings_file, tag_key, tag_value, user_id, @sdk_key)
+        @event_dispatcher.dispatch(impression)
 
-      @logger.log(
-        LogLevelEnum::INFO,
-        format(
-          LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_PUSH_API,
-          file: FILE,
-          u: impression['u'],
-          account_id: impression['account_id'],
-          tags: impression['tags']
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_PUSH_API,
+            file: FILE,
+            u: impression['u'],
+            account_id: impression['account_id'],
+            tags: impression['tags']
+          )
         )
-      )
+      end
     end
     true
   rescue StandardError => e
@@ -1222,26 +1269,15 @@ class VWO
     false
   end
 
-  def get_should_track_returning_user(options)
-    if !options.key?(:should_track_returning_user)
-      options[:should_track_returning_user] = @should_track_returning_user
-    elsif ![true, false].include?(options[:should_track_returning_user])
-      @logger.log(
-        LogLevelEnum::ERROR,
-        format(
-          LogMessageEnum::ErrorMessages::INVALID_TRACK_RETURNING_USER_VALUE,
-          file: FILE
-        )
-      )
-    end
-    options[:should_track_returning_user]
-  end
-
-  def is_eligible_to_send_impression(should_track_returning_user = false)
-    !@user_storage || !@variation_decider.has_stored_variation || should_track_returning_user
+  def is_eligible_to_send_impression()
+    !@user_storage || !@variation_decider.has_stored_variation
   end
 
   def flush_events
+    if is_opted_out(ApiMethods::FLUSH_EVENTS)
+      return false
+    end
+
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
@@ -1251,10 +1287,13 @@ class VWO
           api_name: ApiMethods::FLUSH_EVENTS
         )
       )
-      return
+      return false
+    end
+    result = false
+    if defined?(@batch_events) && !@batch_events_queue.nil?
+      result = @batch_events_queue.flush(manual: true)
+      @batch_events_queue.kill_thread
     end
-    result = @batch_events_queue.flush(manual: true)
-    @batch_events_queue.kill_thread
     result
   rescue StandardError => e
     @logger.log(
@@ -1290,4 +1329,57 @@ class VWO
     end
     goal_type_to_track
   end
+
+  # Manually opting out of VWO SDK, No tracking will happen
+  #
+  # return[bool]
+  #
+  def set_opt_out
+    @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::OPT_OUT_API_CALLED,
+          file: FILE
+        )
+      )
+      if defined?(@batch_events) && !@batch_events_queue.nil?
+        @batch_events_queue.flush(manual: true)
+        @batch_events_queue.kill_thread
+      end
+
+      @is_opted_out = true
+      @settings_file = nil
+      @user_storage = nil
+      @event_dispatcher = nil
+      @variation_decider = nil
+      @config = nil
+      @usage_stats = nil
+      @batch_event_dispatcher = nil
+      @batch_events_queue = nil
+      @batch_events = nil
+
+      return @is_opted_out
+  end
+
+
+  # Check if VWO SDK is manually opted out
+  # @param[String]          :api_name              api_name is used in logging
+  # @return[bool]
+  def is_opted_out(api_name)
+    if @is_opted_out
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::API_NOT_ENABLED,
+          file: FILE,
+          api: api_name
+        )
+      )
+    end
+    return @is_opted_out
+  end
+
+  def is_event_arch_enabled
+    return @settings_file.key?('isEventArchEnabled') && @settings_file['isEventArchEnabled']
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vwo-sdk
 version: !ruby/object:Gem::Version
-  version: 1.23.2
+  version: 1.28.0
 platform: ruby
 authors:
 - VWO
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-30 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov