vwo-sdk 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2555f32eb2068e63dea737bdf3937708a5ef3e1e
-  data.tar.gz: dd662a2ac80ba5dc6892375c15b3d13e2e0ed3a4
+SHA256:
+  metadata.gz: 4e24789df43b6c0c71d71f8211c44ffe12c113e91943b91f8de581214353ccce
+  data.tar.gz: 95ec02ba3df3e88f91bf3f49eb5ab3ab64302b2c664d4d3caa6f569f2e618952
 SHA512:
-  metadata.gz: 2dae59f19f9342856a343e5be3359b487069db19f4503398b577eed09c9e1e6ff98c37923c53b1fca91b5da5d66ad2d7a2414c582e0b02b3cb78f529a80a1568
-  data.tar.gz: 1d1778ccde23e98efed73462dca543c84c12ccb2a7cf4cb18e129f63514268742afc4a0d7a394b16476dadef08eb2d0bbd47b312a13afce23f1c66c23f5a3a99
+  metadata.gz: 1dcc6b57a5fd35867d58d71f3f4b73b0da3ca73f01d009493f76b8981562e6d315f004a9095bcd20f230de1bf19559ac0a2ffefaa5befb72abae0e61de8fce6d
+  data.tar.gz: a7b154c4d9ae6c5b681c6cb27b231f3183a21c496e3eb5d33eecf81df0ca1d55922db127db37debe175aa060575f56dfe42ddbff29c0843e69839bcb57e4fc8c

data/lib/vwo.rb

@@ -1,4 +1,4 @@
-# Copyright 2019 Wingify Software Pvt. Ltd.
+# Copyright 2019-2020 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.
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# frozen_string_literal: true
+require 'logger'
 
 require_relative 'vwo/services/settings_file_manager'
 require_relative 'vwo/services/event_dispatcher'
@@ -21,16 +21,19 @@ require_relative 'vwo/logger'
 require_relative 'vwo/enums'
 require_relative 'vwo/utils/campaign'
 require_relative 'vwo/utils/impression'
+require_relative 'vwo/utils/feature'
+require_relative 'vwo/utils/custom_dimensions'
 require_relative 'vwo/constants'
 require_relative 'vwo/core/variation_decider'
 
-
 # VWO main file
 class VWO
-  attr_accessor :is_instance_valid
+  attr_accessor :is_instance_valid, :logger
 
   include Enums
   include Utils::Validations
+  include Utils::Feature
+  include Utils::CustomDimensions
   include Utils::Campaign
   include Utils::Impression
   include CONSTANTS
@@ -53,13 +56,15 @@ class VWO
     logger = nil,
     user_storage = nil,
     is_development_mode = false,
-    settings_file = nil
+    settings_file = nil,
+    options = {}
   )
     @account_id = account_id
     @sdk_key = sdk_key
     @user_storage = user_storage
     @is_development_mode = is_development_mode
     @logger = VWO::Logger.get_instance(logger)
+    @logger.instance.level = options[:log_level] if (0..5).include?(options[:log_level])
 
     unless valid_settings_file?(get_settings(settings_file))
       @logger.log(
@@ -74,7 +79,10 @@ class VWO
 
     @logger.log(
       LogLevelEnum::DEBUG,
-      format(LogMessageEnum::DebugMessages::VALID_CONFIGURATION, file: FILE)
+      format(
+        LogMessageEnum::DebugMessages::VALID_CONFIGURATION,
+        file: FILE
+      )
     )
 
     # Process the settings file
@@ -87,7 +95,10 @@ class VWO
     if is_development_mode
       @logger.log(
         LogLevelEnum::DEBUG,
-        format(LogMessageEnum::DebugMessages::SET_DEVELOPMENT_MODE, file: FILE)
+        format(
+          LogMessageEnum::DebugMessages::SET_DEVELOPMENT_MODE,
+          file: FILE
+        )
       )
     end
     # Assign event dispatcher
@@ -96,7 +107,10 @@ class VWO
     # Successfully initialized VWO SDK
     @logger.log(
       LogLevelEnum::DEBUG,
-      format(LogMessageEnum::DebugMessages::SDK_INITIALIZED, file: FILE)
+      format(
+        LogMessageEnum::DebugMessages::SDK_INITIALIZED,
+        file: FILE
+      )
     )
   end
 
@@ -122,15 +136,23 @@ class VWO
   #
   # @param[String]            :campaign_key  Unique campaign key
   # @param[String]            :user_id            ID assigned to a user
+  # @param[Hash]                :options                  Options for custom variables required for segmentation
   # @return[String|None]                          If variation is assigned then variation-name
   #                                               otherwise null in case of user not becoming part
 
-  def activate(campaign_key, user_id)
+  def activate(campaign_key, user_id, options = {})
+    # Retrieve custom variables
+    custom_variables = options['custom_variables'] || options[:custom_variables]
+
     # Validate input parameters
-    unless valid_string?(campaign_key) && valid_string?(user_id)
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables))
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::ACTIVATE_API_MISSING_PARAMS, file: FILE)
+        format(
+          LogMessageEnum::ErrorMessages::ACTIVATE_API_MISSING_PARAMS,
+          api_name: ApiMethods::ACTIVATE,
+          file: FILE
+        )
       )
       return
     end
@@ -138,7 +160,11 @@ class VWO
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::ACTIVATE_API_CONFIG_CORRUPTED, file: FILE)
+        format(
+          LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
+          file: FILE,
+          api_name: ApiMethods::ACTIVATE
+        )
       )
       return
     end
@@ -151,23 +177,54 @@ class VWO
       # Log Campaign as invalid
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING, file: FILE, campaign_key: campaign_key, api: 'activate')
+        format(
+          LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING,
+          file: FILE,
+          campaign_key: campaign_key,
+          api_name: ApiMethods::ACTIVATE
+        )
+      )
+      return
+    end
+
+    # Get campaign type
+    campaign_type = campaign['type']
+
+    # Validate valid api call
+    if campaign_type != CampaignTypes::VISUAL_AB
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::INVALID_API,
+          file: FILE,
+          api_name: ApiMethods::ACTIVATE,
+          user_id: user_id,
+          campaign_key: campaign_key,
+          campaign_type: campaign_type
+        )
       )
       return
     end
 
     # Once the matching RUNNING campaign is found, assign the
     # deterministic variation to the user_id provided
-    variation_id, variation_name = @variation_decider.get_variation(
+    variation = @variation_decider.get_variation(
       user_id,
-      campaign
+      campaign,
+      campaign_key,
+      custom_variables
     )
 
     # Check if variation_name has been assigned
-    unless valid_value?(variation_name)
+    if variation.nil?
       @logger.log(
         LogLevelEnum::INFO,
-        format(LogMessageEnum::InfoMessages::INVALID_VARIATION_KEY, file: FILE, user_id: user_id, campaign_key: campaign_key)
+        format(
+          LogMessageEnum::InfoMessages::INVALID_VARIATION_KEY,
+          file: FILE,
+          user_id: user_id,
+          campaign_key: campaign_key
+        )
       )
       return
     end
@@ -176,11 +233,22 @@ class VWO
     impression = create_impression(
       @settings_file,
       campaign['id'],
-      variation_id,
+      variation['id'],
       user_id
     )
     @event_dispatcher.dispatch(impression)
-    variation_name
+    variation['name']
+  rescue StandardError => e
+    @logger.log(
+      LogLevelEnum::ERROR,
+      format(
+        LogMessageEnum::ErrorMessages::API_NOT_WORKING,
+        file: FILE,
+        api_name: ApiMethods::ACTIVATE,
+        exception: e
+      )
+    )
+    nil
   end
 
   # This API method: Gets the variation name assigned for the
@@ -195,25 +263,35 @@ class VWO
   #
   # @param[String]              :campaign_key             Unique campaign key
   # @param[String]              :user_id                  ID assigned to a user
+  # @param[Hash]                :options                  Options for custom variables required for segmentation
   #
   # @@return[String|Nil]                                  If variation is assigned then variation-name
   #                                                       Otherwise null in case of user not becoming part
   #
-  def get_variation_name(campaign_key, user_id)
-    # Check for valid arguments
-    unless valid_string?(campaign_key) && valid_string?(user_id)
-      # log invalid params
+  def get_variation_name(campaign_key, user_id, options = {})
+    # Retrieve custom variables
+    custom_variables = options['custom_variables'] || options[:custom_variables]
+
+    # Validate input parameters
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables))
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::GET_VARIATION_NAME_API_MISSING_PARAMS, file: FILE)
+        format(
+          LogMessageEnum::ErrorMessages::GET_VARIATION_NAME_API_INVALID_PARAMS,
+          api_name: ApiMethods::GET_VARIATION_NAME,
+          file: FILE
+        )
       )
       return
     end
-
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::ACTIVATE_API_CONFIG_CORRUPTED, file: FILE)
+        format(
+          LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
+          file: FILE,
+          api_name: ApiMethods::GET_VARIATION_NAME
+        )
       )
       return
     end
@@ -225,27 +303,62 @@ class VWO
     if campaign.nil? || campaign['status'] != STATUS_RUNNING
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING, file: FILE, campaign_key: campaign_key, api: 'get_variation')
+        format(
+          LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING,
+          file: FILE,
+          campaign_key: campaign_key,
+          api_name: ApiMethods::GET_VARIATION_NAME
+        )
       )
       return
     end
 
-    _variation_id, variation_name = @variation_decider.get_variation(
-      user_id,
-      campaign
-    )
+    campaign_type = campaign['type']
+
+    if campaign_type == CampaignTypes::FEATURE_ROLLOUT
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages.INVALID_API,
+          file: FILE,
+          api_name: ApiMethods::GET_VARIATION_NAME,
+          user_id: user_id,
+          campaign_key: campaign_key,
+          campaign_type: campaign_type
+        )
+      )
+      return
+    end
+
+    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
 
     # Check if variation_name has been assigned
-    unless valid_value?(variation_name)
+    unless valid_value?(variation)
       # log invalid variation key
       @logger.log(
         LogLevelEnum::INFO,
-        format(LogMessageEnum::InfoMessages::INVALID_VARIATION_KEY, file: FILE, user_id: user_id, campaign_key: campaign_key)
+        format(
+          LogMessageEnum::InfoMessages::INVALID_VARIATION_KEY,
+          file: FILE,
+          user_id: user_id,
+          campaign_key: campaign_key
+        )
       )
       return
     end
 
-    variation_name
+    variation['name']
+  rescue StandardError => e
+    @logger.log(
+      LogLevelEnum::ERROR,
+      format(
+        LogMessageEnum::ErrorMessages::API_NOT_WORKING,
+        file: FILE,
+        api_name: ApiMethods::GET_VARIATION_NAME,
+        exception: e
+      )
+    )
+    nil
   end
 
   # This API method: Marks the conversion of the campaign
@@ -258,22 +371,30 @@ 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[Numeric|String]              :revenue_value    Revenue value for revenue-type goal
+  # @param[String]                      :goal_identifier  Unique campaign's goal identifier
+  # @param[Array|Hash]                  :args             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)
     if args[0].is_a?(Hash)
-      revenue_value = args[0]['revenue_value']
+      revenue_value = args[0]['revenue_value'] || args[0][:revenue_value]
+      custom_variables = args[0]['custom_variables'] || args[0][:custom_variables]
     elsif args.is_a?(Array)
       revenue_value = args[0]
+      custom_variables = nil
     end
 
     # Check for valid args
-    unless valid_string?(campaign_key) && valid_string?(user_id) && valid_string?(goal_identifier)
+    unless valid_string?(campaign_key) && valid_string?(user_id) && valid_string?(goal_identifier) &&
+           (custom_variables.nil? || valid_hash?(custom_variables)) || (revenue_value.nil? || valid_basic_data_type?(revenue_value))
       # log invalid params
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::TRACK_API_MISSING_PARAMS, file: FILE)
+        format(
+          LogMessageEnum::ErrorMessages::TRACK_API_INVALID_PARAMS,
+          file: FILE,
+          api_name: ApiMethods.TRACK
+        )
       )
       return false
     end
@@ -281,7 +402,11 @@ class VWO
     unless @is_instance_valid
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::ACTIVATE_API_CONFIG_CORRUPTED, file: FILE)
+        format(
+          LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
+          file: FILE,
+          api_name: ApiMethods::TRACK
+        )
       )
       return false
     end
@@ -290,33 +415,55 @@ class VWO
     campaign = get_campaign(@settings_file, campaign_key)
 
     # Validate campaign
-    if campaign.nil? || campaign['status'] != STATUS_RUNNING
+    if campaign.nil? || (campaign['status'] != STATUS_RUNNING)
       # log error
       @logger.log(
         LogLevelEnum::ERROR,
-        format(LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING, file: FILE, campaign_key: campaign_key, api: 'track')
+        format(
+          LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING,
+          file: FILE,
+          campaign_key: campaign_key,
+          api_name: ApiMethods::TRACK
+        )
       )
       return false
     end
 
-    campaign_id = campaign['id']
-    variation_id, variation_name = @variation_decider.get_variation_allotted(user_id, campaign)
+    campaign_type = campaign['type']
 
-    if variation_name
-      goal = get_campaign_goal(@settings_file, campaign['key'], goal_identifier)
+    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
+        )
+      )
+      return false
+    end
 
+    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+
+    if variation
+      goal = get_campaign_goal(campaign, goal_identifier)
       if goal.nil?
         @logger.log(
           LogLevelEnum::ERROR,
           format(
             LogMessageEnum::ErrorMessages::TRACK_API_GOAL_NOT_FOUND,
-            file: FILE, goal_identifier: goal_identifier,
+            file: FILE,
+            goal_identifier: goal_identifier,
             user_id: user_id,
-            campaign_key: campaign_key
+            campaign_key: campaign_key,
+            api_name: ApiMethods::TRACK
           )
         )
         return false
-      elsif goal['type'] == GOALTYPES::REVENUE && !valid_value?(revenue_value)
+      elsif goal['type'] == GoalTypes::REVENUE && !valid_value?(revenue_value)
         @logger.log(
           LogLevelEnum::ERROR,
           format(
@@ -324,25 +471,433 @@ class VWO
             file: FILE,
             user_id: user_id,
             goal_identifier: goal_identifier,
-            campaign_key: campaign_key
+            campaign_key: campaign_key,
+            api_name: ApiMethods::TRACK
           )
         )
         return false
+      elsif goal['type'] == GoalTypes::CUSTOM
+        revenue_value = nil
       end
-
-      revenue_value = nil if goal['type'] == GOALTYPES::CUSTOM
-
       impression = create_impression(
         @settings_file,
-        campaign_id,
-        variation_id,
+        campaign['id'],
+        variation['id'],
         user_id,
         goal['id'],
         revenue_value
       )
       @event_dispatcher.dispatch(impression)
+
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_IMPRESSION,
+          file: FILE,
+          campaign_id: impression[:experiment_id],
+          user_id: impression[:uId],
+          account_id: impression[:account_id],
+          variation_id: impression[:combination]
+        )
+      )
       return true
     end
     false
+  rescue StandardError => e
+    @logger.log(
+      LogLevelEnum::ERROR,
+      format(
+        LogMessageEnum::ErrorMessages::API_NOT_WORKING,
+        file: FILE,
+        api_name: ApiMethods::TRACK,
+        exception: e
+      )
+    )
+    false
+  end
+
+  # This API method: Identifies whether the user becomes a part of feature rollout/test or not.
+  # 1. Validates the arguments being passed
+  # 2. Checks if user is eligible to get bucketed into the feature test/rollout,
+  # 3. Assigns the deterministic variation to the user(based on userId),
+  #    If user becomes part of feature test/rollout
+  #    If UserStorage is used, it will look into it for the variation and if found, no further processing is done
+  #
+  # @param[String]                :campaign_key                       Unique campaign key
+  # @param[String]                :user_id                            ID assigned to a user
+  # @param[Hash]                  :custom_variables                   Pass it through options as custom_variables={}
+  #
+  # @return[Boolean]  true if user becomes part of feature test/rollout, otherwise false.
+
+  def feature_enabled?(campaign_key, user_id, options = {})
+    # Retrieve custom variables
+    custom_variables = options['custom_variables'] || options[:custom_variables]
+
+    # Validate input parameters
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables))
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::IS_FEATURE_ENABLED_API_INVALID_PARAMS,
+          api_name: ApiMethods::IS_FEATURE_ENABLED,
+          file: FILE
+        )
+      )
+      return false
+    end
+    unless @is_instance_valid
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
+          file: FILE,
+          api_name: ApiMethods::IS_FEATURE_ENABLED
+        )
+      )
+      return false
+    end
+
+    # Get the campaign settings
+    campaign = get_campaign(@settings_file, campaign_key)
+
+    # Validate campaign
+    unless campaign && campaign['status'] == STATUS_RUNNING
+      # log error
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING,
+          file: FILE,
+          campaign_key: campaign_key,
+          api_name: ApiMethods::IS_FEATURE_ENABLED
+        )
+      )
+      return false
+    end
+
+    # Validate campaign_type
+    campaign_type = campaign['type']
+
+    if campaign_type == CampaignTypes::VISUAL_AB
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::INVALID_API,
+          file: FILE,
+          api_name: ApiMethods::IS_FEATURE_ENABLED,
+          user_id: user_id,
+          campaign_key: campaign_key,
+          campaign_type: campaign_type
+        )
+      )
+      return false
+    end
+
+    # Get variation
+    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+
+    # If no variation, did not become part of feature_test/rollout
+    return false unless variation
+
+    # if campaign type is feature_test Send track call to server
+    if campaign_type == CampaignTypes::FEATURE_TEST
+      impression = create_impression(
+        @settings_file,
+        campaign['id'],
+        variation['id'],
+        user_id
+      )
+
+      @event_dispatcher.dispatch(impression)
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_IMPRESSION,
+          file: FILE,
+          campaign_id: impression[:experiment_id],
+          user_id: impression[:uId],
+          account_id: impression[:account_id],
+          variation_id: impression[:combination]
+        )
+      )
+      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
+    end
+    true
+  rescue StandardError => e
+    @logger.log(
+      LogLevelEnum::ERROR,
+      format(
+        LogMessageEnum::ErrorMessages::API_NOT_WORKING,
+        file: FILE,
+        api_name: ApiMethods::IS_FEATURE_ENABLED,
+        exception: e
+      )
+    )
+    false
+  end
+
+  # Returns the feature variable corresponding to the variable_key
+  # passed. It typecasts the value to the corresponding value type
+  # found in settings_file
+  #
+  # 1. Validates the arguments being passed
+  # 2. Checks if user is eligible to get bucketed into the feature test/rollout,
+  # 3. Assigns the deterministic variation to the user(based on userId),
+  #     If user becomes part of campaign
+  #     If UserStorage is used, it will look into it for the variation and if found, no further processing is done
+  # 4. Retrieves the corresponding variable from variation assigned.
+  #
+  # @param[String]              :campaign_key           Unique campaign key
+  # @param[String]              :variable_key           Variable key
+  # @param[String]              :user_id                ID assigned to a user
+  # @param[Hash]                :custom_variables       Pass it through options as custom_variables={}
+  #
+  # @return[Boolean, String, Integer, Float, nil)      If variation is assigned then variable corresponding to variation assigned else nil
+  #
+
+  def get_feature_variable_value(campaign_key, variable_key, user_id, options = {})
+    # Retrieve custom variables
+    custom_variables = options['custom_variables'] || options[:custom_variables]
+
+    unless valid_string?(campaign_key) && valid_string?(variable_key) && valid_string?(user_id) &&
+           (custom_variables.nil? || valid_hash?(custom_variables))
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::GET_FEATURE_VARIABLE_VALUE_API_INVALID_PARAMS,
+          file: FILE,
+          api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+        )
+      )
+      return
+    end
+
+    unless @is_instance_valid
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::API_CONFIG_CORRUPTED,
+          file: FILE,
+          api_name: ApiMethods.GET_FEATURE_VARIABLE_VALUE
+        )
+      )
+      return
+    end
+
+    # Get the campaign settings
+    campaign = get_campaign(@settings_file, campaign_key)
+
+    # Validate campaign
+    unless campaign && campaign['status'] == STATUS_RUNNING
+      # log error
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::CAMPAIGN_NOT_RUNNING,
+          file: FILE,
+          campaign_key: campaign_key,
+          api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+        )
+      )
+      return
+    end
+
+    campaign_type = campaign['type']
+
+    if campaign_type == CampaignTypes::VISUAL_AB
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::INVALID_API,
+          file: FILE,
+          api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE,
+          campaign_key: campaign_key,
+          campaign_type: campaign_type,
+          user_id: user_id
+        )
+      )
+      return
+    end
+
+    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+
+    # Check if variation has been assigned to user
+    return unless variation
+
+    if campaign_type == CampaignTypes::FEATURE_ROLLOUT
+      variables = campaign['variables']
+    elsif campaign_type == CampaignTypes::FEATURE_TEST
+      if !variation['isFeatureEnabled']
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::FEATURE_NOT_ENABLED_FOR_USER,
+            file: FILE,
+            feature_key: campaign_key,
+            user_id: user_id,
+            api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+          )
+        )
+        variation = get_control_variation(campaign)
+      else
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::FEATURE_ENABLED_FOR_USER,
+            file: FILE,
+            feature_key: campaign_key,
+            user_id: user_id,
+            api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+          )
+        )
+      end
+      variables = variation['variables']
+    end
+    variable = get_variable(variables, variable_key)
+
+    unless variable
+      # Log variable not found
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::VARIABLE_NOT_FOUND,
+          file: FILE,
+          variable_key: variable_key,
+          campaign_key: campaign_key,
+          campaign_type: campaign_type,
+          user_id: user_id,
+          api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+        )
+      )
+      return
+    end
+
+    @logger.log(
+      LogLevelEnum::INFO,
+      format(
+        LogMessageEnum::InfoMessages::VARIABLE_FOUND,
+        file: FILE,
+        variable_key: variable_key,
+        variable_value: variable['value'],
+        campaign_key: campaign_key,
+        campaign_type: campaign_type,
+        user_id: user_id,
+        api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+      )
+    )
+    get_type_casted_feature_value(variable['value'], variable['type'])
+  rescue StandardError => e
+    @logger.log(
+      LogLevelEnum::ERROR,
+      format(
+        LogMessageEnum::ErrorMessages::API_NOT_WORKING,
+        file: FILE,
+        api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE,
+        exception: e
+      )
+    )
+    nil
+  end
+
+  # 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]          :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)
+    unless valid_string?(tag_key) && valid_string?(tag_value) && valid_string?(user_id)
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(
+          LogMessageEnum::ErrorMessages::PUSH_API_INVALID_PARAMS,
+          file: FILE,
+          api_name: ApiMethods::PUSH
+        )
+      )
+      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
+        )
+      )
+      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
+        )
+      )
+      return false
+    end
+
+    impression = get_url_params(@settings_file, tag_key, tag_value, user_id)
+
+    @event_dispatcher.dispatch(impression)
+
+    @logger.log(
+      LogLevelEnum::INFO,
+      format(
+        LogMessageEnum::InfoMessages::MAIN_KEYS_FOR_PUSH_API,
+        file: FILE,
+        u: impression['u'],
+        user_id: impression['uId'],
+        account_id: impression['account_id'],
+        tags: impression['tags']
+      )
+    )
+    true
+  rescue StandardError => e
+    @logger.log(
+      LogLevelEnum::ERROR,
+      format(
+        LogMessageEnum::ErrorMessages::API_NOT_WORKING,
+        file: FILE,
+        api_name: ApiMethods::PUSH,
+        exception: e
+      )
+    )
+    false
   end
 end