vwo-ruby-sdk 1.0.0

data/lib/vwo/common/uuid_utils.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative '../custom_logger'
+require_relative 'enums'
+require_relative 'constants'
+
+# Utility module for manipulating VWO campaigns
+class VWO
+  module Common
+    module UUIDUtils
+      include VWO::Common::Enums
+      include VWO::Common::CONSTANTS
+
+      def self.parse(obj)
+        str = obj.to_s.sub(/\Aurn:uuid:/, '')
+        str.gsub!(/[^0-9A-Fa-f]/, '')
+        [str[0..31]].pack 'H*'
+      end
+
+      def self.uuid_v5(uuid_namespace, name)
+        uuid_namespace = parse(uuid_namespace)
+        hash_class = ::Digest::SHA1
+        version = 5
+
+        hash = hash_class.new
+        hash.update(uuid_namespace)
+        hash.update(name)
+
+        ary = hash.digest.unpack('NnnnnN')
+        ary[2] = (ary[2] & 0x0FFF) | (version << 12)
+        ary[3] = (ary[3] & 0x3FFF) | 0x8000
+        # rubocop:disable Lint/FormatString
+        '%08x-%04x-%04x-%04x-%04x%08x' % ary
+        # rubocop:enable Lint/FormatString
+      end
+
+      VWO_NAMESPACE = uuid_v5(URL_NAMESPACE, 'https://vwo.com')
+
+      # Generates desired UUID
+      #
+      # @param[Integer|String]      :user_id        User identifier
+      # @param[Integer|String]      :account_id     Account identifier
+      #
+      # @return[Integer]                            Desired UUID
+      #
+      def generator_for(user_id, account_id)
+        user_id = user_id.to_s
+        account_id = account_id.to_s
+        user_id_namespace = generate(VWO_NAMESPACE, account_id)
+        uuid_for_account_user_id = generate(user_id_namespace, user_id)
+
+        desired_uuid = uuid_for_account_user_id.delete('-').upcase
+
+        VWO::CustomLogger.get_instance.log(
+          LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::UUID_FOR_USER,
+            file: FileNameEnum::UuidUtil,
+            user_id: user_id,
+            account_id: account_id,
+            desired_uuid: desired_uuid
+          )
+        )
+        desired_uuid
+      end
+
+      # Generated uuid from namespace and name, uses uuid5
+      #
+      # @param[String]        :namespace    Namespace
+      # @param[String)        :name         Name
+      #
+      # @return[String|Nil]                Uuid, nil if any of the arguments is empty
+      def generate(namespace, name)
+        VWO::Common::UUIDUtils.uuid_v5(namespace, name) if name && namespace
+      end
+    end
+  end
+end

data/lib/vwo/common/validations.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'json-schema'
+require_relative 'schemas/settings_file'
+
+class VWO
+  module Common
+    module Validations
+      UTILITIES = {
+        'logger' => ['log'],
+        'event_dispatcher' => ['dispatch'],
+        'user_profile_service' => %w[lookup save]
+      }.freeze
+      # Validates the project settings_file
+      # @param [Hash]:  JSON object received from DACDN server or somewhere else,
+      #                 must be json string representation.
+      # @return [Boolean]
+      def valid_settings_file?(settings_file)
+        settings_file = JSON.parse(settings_file)
+        JSON::Validator.validate!(VWO::Common::Schema::SETTINGS_FILE_SCHEMA, settings_file)
+      rescue StandardError
+        false
+      end
+
+      # @return [Boolean]
+      def valid_value?(val)
+        !val.nil?
+      end
+
+      # @return [Boolean]
+      def valid_number?(val)
+        val.is_a?(Numeric)
+      end
+
+      # @return [Boolean]
+      def valid_string?(val)
+        val.is_a?(String)
+      end
+
+      # @return [Boolean]
+      def valid_hash?(val)
+        val.is_a?(Hash)
+      end
+
+      # @param [Class] - User defined class instance
+      # @param [utility_name] - Name of the utility
+      # @return [Boolean]
+      def valid_utility?(utility, utility_name)
+        utility_attributes = UTILITIES[utility_name]
+        return false if utility_attributes.nil?
+
+        utility_attributes.each do |attr|
+          return false unless method?(utility, attr)
+        end
+        true
+      end
+
+      private
+
+      # @return [Boolean]
+      def method?(object, method)
+        object.methods.include?(method.to_sym)
+      end
+    end
+  end
+end

data/lib/vwo/custom_logger.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+class VWO
+  class CustomLogger
+    @logger = nil
+    @logger_instance = nil
+
+    def self.get_instance(logger_instance = nil)
+      @@logger ||= VWO::CustomLogger.new(logger_instance)
+    end
+
+    def initialize(logger_instance)
+      @@logger_instance = logger_instance || Logger.new(STDOUT)
+    end
+
+    # Override this method to handle logs in a custom manner
+    def log(level, message)
+      @@logger_instance.log(level, message)
+    end
+  end
+end

data/lib/vwo/decision_service.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative 'custom_logger'
+require_relative 'common/enums'
+require_relative 'common/campaign_utils'
+require_relative 'common/validations'
+require_relative 'bucketing_service'
+
+# Class encapsulating all decision related capabilities.
+class VWO
+  class DecisionService
+    include VWO::Common::Enums
+    include VWO::Common::CampaignUtils
+    include Common::Validations
+
+    # Initializes DecisionService with settings_file, UserProfileService and logger.
+    # @param[Hash] -   Settings file of the project.
+    # @param[Class] -  Class instance having the capability of
+    #                   lookup and save.
+    def initialize(settings_file, user_profile_service = nil)
+      @logger = CustomLogger.get_instance
+      @user_profile_service = user_profile_service
+      # Check if user_profile_service provided is valid or not
+      @user_profile_service = user_profile_service if valid_utility?(user_profile_service, 'user_profile_service')
+      @bucketer = VWO::BucketingService.new
+      @settings_file = settings_file
+    end
+
+    # Returns variation for the user for required campaign
+    # First lookup in the UPS, if user_profile is found,
+    # return from there
+    # Else, calculates the variation with helper method
+    #
+    #
+    # @param[String]          :user_id             The unique ID assigned to User
+    # @param[Hash]            :campaign            Campaign in which user is participating
+    # @param[String]          :campaign_test_key   The unique ID of the campaign passed
+    # @return[String,String]                       ({variation_id, variation_name}|Nil): Tuple of
+    #                                              variation_id and variation_name if variation allotted, else nil
+
+    def get(user_id, campaign, campaign_test_key)
+      campaign_bucket_map = resolve_campaign_bucket_map(user_id)
+      variation = get_stored_variation(user_id, campaign_test_key, campaign_bucket_map) if valid_hash?(campaign_bucket_map)
+
+      if variation
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::GOT_STORED_VARIATION,
+            file: FILE,
+            campaign_test_key: campaign_test_key,
+            user_id: user_id,
+            variation_name: variation['name']
+          )
+        )
+        return variation['id'], variation['name']
+      end
+
+      variation_id, variation_name = get_variation_allotted(user_id, campaign)
+
+      if variation_name
+        save_user_profile(user_id, campaign_test_key, variation_name) if variation_name
+
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::VARIATION_ALLOCATED,
+            file: FILE,
+            campaign_test_key: campaign_test_key,
+            user_id: user_id,
+            variation_name: variation_name
+          )
+        )
+      else
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_test_key: campaign_test_key, user_id: user_id)
+        )
+      end
+      [variation_id, variation_name]
+    end
+
+    # Returns the Variation Allotted to User
+    #
+    # @param[String]  :user_id      The unique ID assigned to User
+    # @param[Hash]    :campaign     Campaign Object
+    #
+    # @return[Hash]   Variation     Object allotted to User
+
+    def get_variation_allotted(user_id, campaign)
+      variation_id, variation_name = nil
+      unless valid_value?(user_id)
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::INVALID_USER_ID, file: FILE, user_id: user_id, method: 'get_variation_alloted')
+        )
+        return variation_id, variation_name
+      end
+
+      if @bucketer.user_part_of_campaign?(user_id, campaign)
+        variation_id, variation_name = get_variation_of_campaign_for_user(user_id, campaign)
+        @logger.log(
+          LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::GOT_VARIATION_FOR_USER,
+            file: FILE,
+            variation_name: variation_name,
+            user_id: user_id,
+            campaign_test_key: campaign['key'],
+            method: 'get_variation_allotted'
+          )
+        )
+      else
+        # not part of campaign
+        @logger.log(
+          LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::USER_NOT_PART_OF_CAMPAIGN,
+            file: FILE,
+            user_id: user_id,
+            campaign_test_key: nil,
+            method: 'get_variation_allotted'
+          )
+        )
+      end
+      [variation_id, variation_name]
+    end
+
+    # Assigns random variation ID to a particular user
+    # Depending on the PercentTraffic.
+    # Makes user a part of campaign if user's included in Traffic.
+    #
+    # @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|nil]                         Variation allotted to User
+    def get_variation_of_campaign_for_user(user_id, campaign)
+      unless campaign
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(
+            LogMessageEnum::ErrorMessages::INVALID_CAMPAIGN,
+            file: FILE,
+            method: 'get_variation_of_campaign_for_user'
+          )
+        )
+        return nil, nil
+      end
+
+      variation = @bucketer.bucket_user_to_variation(user_id, campaign)
+
+      if variation && variation['name']
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::GOT_VARIATION_FOR_USER,
+            file: FILE,
+            variation_name: variation['name'],
+            user_id: user_id,
+            campaign_test_key: campaign['key']
+          )
+        )
+        return variation['id'], variation['name']
+      end
+
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::USER_GOT_NO_VARIATION,
+          file: FILE,
+          user_id: user_id,
+          campaign_test_key: campaign['key']
+        )
+      )
+      [nil, nil]
+    end
+
+    private
+
+    # Returns the campaign bucket map corresponding to the user_id
+    #
+    # @param[String] :user_id Unique user identifier
+    # @return[Hash]
+
+    def resolve_campaign_bucket_map(user_id)
+      user_data = get_user_profile(user_id)
+      campaign_bucket_map = {}
+      campaign_bucket_map = user_data['campaignBucketMap'] if user_data
+      campaign_bucket_map.dup
+    end
+
+    # Get the UserProfileData after looking up into lookup method
+    # Being provided via UserProfileService
+    #
+    # @param[String]: Unique user identifier
+    # @return[Hash|Boolean]: user_profile data
+
+    def get_user_profile(user_id)
+      unless @user_profile_service
+        @logger.log(
+          LogLevelEnum::DEBUG,
+          format(LogMessageEnum::DebugMessages::NO_USER_PROFILE_SERVICE_LOOKUP, file: FILE)
+        )
+        return false
+      end
+
+      data = @user_profile_service.lookup(user_id)
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(
+          LogMessageEnum::InfoMessages::LOOKING_UP_USER_PROFILE_SERVICE,
+          file: FILE,
+          user_id: user_id,
+          status: data.nil? ? 'Not Found' : 'Found'
+        )
+      )
+      data
+    rescue StandardError
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(LogMessageEnum::ErrorMessages::LOOK_UP_USER_PROFILE_SERVICE_FAILED, file: FILE, user_id: user_id)
+      )
+      false
+    end
+
+    # If userProfileService is provided and variation was stored,
+    # Get the stored variation
+    # @param[String]            :user_id
+    # @param[String]            :campaign_test_key campaign identified
+    # @param[Hash]              :campaign_bucket_map BucketMap consisting of stored user variation
+    #
+    # @return[Object, nil]      if found then variation settings object otherwise None
+
+    def get_stored_variation(user_id, campaign_test_key, campaign_bucket_map)
+      if campaign_bucket_map[campaign_test_key]
+        decision = campaign_bucket_map[campaign_test_key]
+        variation_name = decision['variationName']
+        @logger.log(
+          LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::GETTING_STORED_VARIATION,
+            file: FILE,
+            campaign_test_key: campaign_test_key,
+            user_id: user_id,
+            variation_name: variation_name
+          )
+        )
+        return get_campaign_variation(
+          @settings_file,
+          campaign_test_key,
+          variation_name
+        )
+      end
+
+      @logger.log(
+        LogLevelEnum::DEBUG,
+        format(
+          LogMessageEnum::DebugMessages::NO_STORED_VARIATION,
+          file: FILE,
+          campaign_test_key: campaign_test_key,
+          user_id: user_id
+        )
+      )
+      nil
+    end
+
+    # If userProfileService is provided and variation was stored
+    # Save the assigned variation
+    # It creates bucket and then stores.
+    #
+    # @param[String]              :user_id            Unique user identifier
+    # @param[String]              :campaign_test_key  Unique campaign identifier
+    # @param[String]              :variation_name     Variation identifier
+    # @return[Boolean]                                true if found otherwise false
+
+    def save_user_profile(user_id, _campaign_test_key, variation_name)
+      unless @user_profile_service
+        @logger.log(
+          LogLevelEnum::DEBUG,
+          format(LogMessageEnum::DebugMessages::NO_USER_PROFILE_SERVICE_SAVE, file: FILE)
+        )
+        return false
+      end
+      new_campaign_bucket_map = {
+        campaign_test_key: {
+          variationName: variation_name
+        }
+      }
+      @user_profile_service.save(
+        userId: user_id,
+        campaignBucketMap: new_campaign_bucket_map
+      )
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_PROFILE_SERVICE, file: FILE, user_id: user_id)
+      )
+      true
+    rescue StandardError
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(LogMessageEnum::ErrorMessages::SAVE_USER_PROFILE_SERVICE_FAILED, file: FILE, user_id: user_id)
+      )
+      false
+    end
+  end
+end

data/lib/vwo/event_dispatcher.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'custom_logger'
+require_relative 'common/enums'
+require_relative 'common/requests'
+
+# Module for dispatching events to the server.
+class VWO
+  class EventDispatcher
+    include VWO::Common::Enums
+
+    EXCLUDE_KEYS = ['url'].freeze
+
+    # Initialize the dispatcher with logger
+    #
+    # @param [Boolean] :  To specify whether the request
+    #                     to our server should be made or not.
+    #
+    def initialize(is_development_mode = false)
+      @logger = CustomLogger.get_instance
+      @is_development_mode = is_development_mode
+    end
+
+    # Dispatch the event being represented in the properties object.
+    #
+    # @param[Hash]        :properties       Object holding information about
+    #                                       the request to be dispatched to the VWO backend.
+    # @return[Boolean]
+    #
+    def dispatch(properties)
+      return true if @is_development_mode
+
+      modified_properties = properties.reject do |key, _value|
+        EXCLUDE_KEYS.include?(key)
+      end
+
+      resp = VWO::Common::Requests.get(properties['url'], modified_properties)
+      if resp.code == '200'
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::IMPRESSION_SUCCESS,
+            file: FileNameEnum::EventDispatcher,
+            end_point: properties[:url],
+            campaign_id: properties[:experiment_id],
+            user_id: properties[:uId],
+            account_id: properties[:account_id],
+            variation_id: properties[:combination]
+          )
+        )
+        return true
+      else
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::IMPRESSION_FAILED, file: FileNameEnum.EventDispatcher, end_point: properties['url'])
+        )
+        return false
+      end
+    rescue StandardError
+      @logger.log(
+        LogLevelEnum::ERROR,
+        format(LogMessageEnum::ErrorMessages::IMPRESSION_FAILED, file: FileNameEnum::EventDispatcher, end_point: properties['url'])
+      )
+      false
+    end
+  end
+end

data/lib/vwo/get_settings.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'common/utils'
+require_relative 'common/constants'
+require_relative 'common/requests'
+require_relative 'common/validations'
+
+class VWO
+  class GetSettings
+    include VWO::Common::Validations
+
+    PROTOCOL = 'https'
+    HOSTNAME = VWO::Common::CONSTANTS::ENDPOINTS::BASE_URL
+    PATH = VWO::Common::CONSTANTS::ENDPOINTS::ACCOUNT_SETTINGS
+
+    def initialize(account_id, sdk_key)
+      @account_id = account_id
+      @sdk_key = sdk_key
+    end
+
+    # Get method to retrieve settings_file for customer from dacdn server
+    # @param [string]:      Account ID of user
+    # @param [string]:      Unique sdk key for user,
+    #                       can be retrieved from our website
+    # @return[string]:      Json String representation of settings_file,
+    #                       as received from the website,
+    #                       nil if no settings_file is found or sdk_key is incorrect
+
+    def get
+      is_valid_key = valid_number?(@account_id) || valid_string?(@account_id)
+
+      unless is_valid_key && valid_string?(@sdk_key)
+        STDERR.warn 'account_id and sdk_key are required for fetching account settings. Aborting!'
+        return '{}'
+      end
+
+      dacdn_url = "#{PROTOCOL}://#{HOSTNAME}#{PATH}"
+
+      settings_file_response = VWO::Common::Requests.get(dacdn_url, params)
+
+      if settings_file_response.code != '200'
+        STDERR.warn <<-DOC
+          Request failed for fetching account settings.
+          Got Status Code: #{settings_file_response.code}
+          and message: #{settings_file_response.body}.
+        DOC
+      end
+      settings_file_response.body
+    rescue StandardError => e
+      STDERR.warn "Error fetching Settings File #{e}"
+    end
+
+    private
+
+    def params
+      {
+        a: @account_id,
+        i: @sdk_key,
+        r: VWO::Common::Utils.get_random_number,
+        platform: 'server',
+        'api-version' => 2
+      }
+    end
+  end
+end

data/lib/vwo/project_config_manager.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'custom_logger'
+require_relative 'common/enums'
+require_relative 'common/campaign_utils'
+
+# Representation of the VWO settings file.
+
+class VWO
+  class ProjectConfigManager
+    include VWO::Common::Enums
+    include VWO::Common::CampaignUtils
+
+    # ProjectConfigManager init method to load and set project config data.
+    #
+    # @params
+    #  settings_file (Hash): Hash object of setting
+    #  representing the project settings_file.
+
+    def initialize(settings_file)
+      @settings_file = JSON.parse(settings_file)
+      @logger = VWO::CustomLogger.get_instance
+    end
+
+    # Processes the settings_file, assigns variation allocation range
+    def process_settings_file
+      (@settings_file['campaigns'] || []).each do |campaign|
+        set_variation_allocation(campaign)
+      end
+      @logger.log(
+        LogLevelEnum::DEBUG,
+        format(LogMessageEnum::DebugMessages::SETTINGS_FILE_PROCESSED, file: FileNameEnum::ProjectConfigManager)
+      )
+    end
+
+    def get_settings_file
+      @settings_file
+    end
+  end
+end

data/lib/vwo/user_profile.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class VWO
+  # Abstract class encapsulating user profile service functionality.
+  # Override with your own implementation for storing
+  # And retrieving the user profile.
+
+  class UserProfile
+    # Abstract method, must be defined to fetch the
+    # User profile dict corresponding to the user_id.
+    #
+    # @param[String]        :user_id            ID for user whose profile needs to be retrieved.
+    # @return[Hash]         :user_profile_obj   Object representing the user's profile.
+    #
+    def lookup(_user_id); end
+
+    # Abstract method, must be to defined to save
+    # The user profile dict sent to this method.
+    # @param[Hash]    :user_profile_obj     Object representing the user's profile.
+    #
+    def save(_user_profile_obj); end
+  end
+end