vwo-ruby-sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb6f642d7cd1669a15bc5a0d2f269a83e92c9d31
+  data.tar.gz: 299909d28f2c4ea3b6e2bac8eb27670dfba39ec9
+SHA512:
+  metadata.gz: b16d5035c15fb7e292e6c4ab116180e652a9a852d10d9e435facf9b85f290e2063a6d05114cb0e215149c0cd98f68281e7dea1ba8394508cf4380d31fbfd86ba
+  data.tar.gz: 23c28fac8fdee1ab542eb8d7930a222889f4e6542bdc3071f0baf1531febb77c39f2c2598de9a68a152f1fcfcbce2bb4050b088c46a19624928ed6dedc5745f4

data/lib/vwo/bucketing_service.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'murmurhash3'
+require_relative 'custom_logger'
+require_relative 'common/enums'
+require_relative 'common/validations'
+require_relative 'common/constants'
+
+# Class encapsulating all decision related capabilities.
+class VWO
+  class BucketingService
+    include VWO::Common::Enums
+    include VWO::Common::CONSTANTS
+    include VWO::Common::Validations
+
+    U_MAX_32_BIT = 0xFFFFFFFF
+    MAX_HASH_VALUE = 2**32
+    FILE = FileNameEnum::BucketingService
+
+    def initialize
+      @logger = CustomLogger.get_instance
+    end
+
+    # Calculate if this user should become part of the campaign or not
+    # @param[String]         :user_id     The unique ID assigned to a user
+    # @param[Dict]           :campaign    For getting traffic allotted to the campaign
+    # @return[Boolean]                    If User is a part of Campaign or not
+    #
+    def user_part_of_campaign?(user_id, campaign)
+      unless valid_value?(user_id)
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::INVALID_USER_ID, file: FILE, user_id: user_id, method: 'is_user_part_of_campaign')
+        )
+        return false
+      end
+
+      if campaign.nil?
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::INVALID_CAMPAIGN, file: FILE, method: 'is_user_part_of_campaign')
+        )
+        return false
+      end
+
+      traffic_allocation = campaign['percentTraffic']
+
+      value_assigned_to_user = get_bucket_value_for_user(user_id)
+      is_user_part = (value_assigned_to_user != 0) && value_assigned_to_user <= traffic_allocation
+      @logger.log(
+        LogLevelEnum::INFO,
+        format(LogMessageEnum::InfoMessages::USER_ELIGIBILITY_FOR_CAMPAIGN, file: FILE, user_id: user_id, is_user_part: is_user_part)
+      )
+      is_user_part
+    end
+
+    # Validates the User ID and
+    # Generates Variation into which the User is bucketed in.
+    #
+    # @param[String]            :user_id          The unique ID assigned to User
+    # @param[Hash]              :campaign         The Campaign of which User is a part of
+    #
+    # @return[Hash|nil}                           Variation data into which user is bucketed in
+    #                                             or nil if not
+    def bucket_user_to_variation(user_id, campaign)
+      unless valid_value?(user_id)
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::INVALID_USER_ID, file: FILE, user_id: user_id, method: 'bucket_user_to_variation')
+        )
+        return
+      end
+
+      unless campaign
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::INVALID_CAMPAIGN, file: FILE, method: 'is_user_part_of_campaign')
+        )
+        return
+      end
+
+      hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
+      normalize = MAX_TRAFFIC_VALUE / campaign['percentTraffic']
+      multiplier = normalize / 100
+      bucket_value = generate_bucket_value(
+        hash_value,
+        MAX_TRAFFIC_VALUE,
+        multiplier
+      )
+
+      @logger.log(
+        LogLevelEnum::DEBUG,
+        format(
+          LogMessageEnum::DebugMessages::VARIATION_HASH_BUCKET_VALUE,
+          file: FILE,
+          user_id: user_id,
+          campaign_test_key: campaign['key'],
+          percent_traffic: campaign['percentTraffic'],
+          bucket_value: bucket_value,
+          hash_value: hash_value
+        )
+      )
+      get_variation(campaign, bucket_value)
+    end
+
+    private
+
+    # Returns the Variation by checking the Start and End
+    # Bucket Allocations of each Variation
+    #
+    # @param[Hash]        :campaign       Which contains the variations
+    # @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|
+        (variation['start_variation_allocation']..variation['end_variation_allocation']).cover?(bucket_value)
+      end
+    end
+
+    # Validates the User ID and generates Bucket Value of the
+    # User by hashing the userId by murmurHash and scaling it down.
+    #
+    # @param[String]    :user_id    The unique ID assigned to User
+    # @return[Integer]              The bucket Value allotted to User
+    #                               (between 1 to $this->$MAX_TRAFFIC_PERCENT)
+    def get_bucket_value_for_user(user_id)
+      hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
+      bucket_value = generate_bucket_value(hash_value, MAX_TRAFFIC_PERCENT)
+
+      @logger.log(
+        LogLevelEnum::DEBUG,
+        format(
+          LogMessageEnum::DebugMessages::USER_HASH_BUCKET_VALUE,
+          file: FILE,
+          hash_value: hash_value,
+          bucket_value: bucket_value,
+          user_id: user_id
+        )
+      )
+      bucket_value
+    end
+
+    # Generates Bucket Value of the User by hashing the User ID by murmurHash
+    # And scaling it down.
+    #
+    # @param[Integer]             :hash_value   HashValue generated after hashing
+    # @param[Integer]             :max_value    The value up-to which hashValue needs to be scaled
+    # @param[Integer]             :multiplier
+    # @return[Integer]                          Bucket Value of the User
+    #
+    def generate_bucket_value(hash_value, max_value, multiplier = 1)
+      ratio = hash_value.to_f / MAX_HASH_VALUE
+      multiplied_value = (max_value * ratio + 1) * multiplier
+      multiplied_value.to_i
+    end
+  end
+end

data/lib/vwo/common/campaign_utils.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative '../custom_logger'
+require_relative 'enums'
+require_relative 'constants'
+
+# Utility module for manipulating VWO campaigns
+class VWO
+  module Common
+    module CampaignUtils
+      include VWO::Common::Enums
+      include VWO::Common::CONSTANTS
+
+      # Finds and Returns campaign from given campaign_test_key.
+      #
+      # @param[Hash]      :settings_file      Settings file for the project
+      # @param[String]    :campaign_test_key  Campaign identifier key
+      # @return[Hash]     :campaign object
+
+      def get_campaign(settings_file, campaign_test_key)
+        (settings_file['campaigns'] || []).find do |campaign|
+          campaign['key'] == campaign_test_key
+        end
+      end
+
+      # Sets variation allocation range in the provided campaign
+      #
+      # @param [Hash]: Campaign object
+
+      def set_variation_allocation(campaign)
+        current_allocation = 0
+        campaign['variations'].each do |variation|
+          step_factor = get_variation_bucketing_range(variation['weight'])
+          if step_factor
+            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
+
+          CustomLogger.get_instance.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::VARIATION_RANGE_ALLOCATION,
+              file: FileNameEnum::CampaignUtil,
+              campaign_test_key: campaign['key'],
+              variation_name: variation['name'],
+              variation_weight: variation['weight'],
+              start: variation['start_variation_allocation'],
+              end: variation['end_variation_allocation']
+            )
+          )
+        end
+      end
+
+      # Returns goal from given campaign_test_key and gaol_identifier.
+      # @param[Hash]              :settings_file        Settings file of the project
+      # @param[String]            :campaign_test_key    Campaign identifier key
+      # @param[String]            :goal_identifier      Goal identifier
+      #
+      # @return[Hash]                                   Goal corresponding to Goal_identifier in respective campaign
+
+      def get_campaign_goal(settings_file, campaign_test_key, goal_identifier)
+        return unless settings_file && campaign_test_key && goal_identifier
+
+        campaign = get_campaign(settings_file, campaign_test_key)
+        return unless campaign
+
+        campaign['goals'].find do |goal|
+          goal['identifier'] == goal_identifier
+        end
+      end
+
+      private
+
+      # Returns the bucket size of variation.
+      # @param (Number): weight of variation
+      # @return (Integer): Bucket start range of Variation
+
+      def get_variation_bucketing_range(weight)
+        return 0 if weight.nil? || weight == 0
+
+        start_range = (weight * 100).ceil.to_i
+        [start_range, MAX_TRAFFIC_VALUE].min
+      end
+
+      # Returns variation from given campaign_test_key and variation_name.
+      #
+      # @param[Hash]            :settings_file  Settings file of the project
+      # @param[Hash]            :campaign_test_key Campaign identifier key
+      # @param[String]          :variation_name Variation identifier
+      #
+      # @return[Hash]           Variation corresponding to variation_name in respective campaign
+
+      def get_campaign_variation(settings_file, campaign_test_key, variation_name)
+        return if settings_file && campaign_test_key && variation_name
+
+        campaign = get_campaign(settings_file, campaign_test_key)
+        return unless campaign
+
+        campaign['variations'].find do |variation|
+          variation['name'] == variation_name
+        end
+      end
+    end
+  end
+end

data/lib/vwo/common/constants.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class VWO
+  module Common
+    module CONSTANTS
+      API_VERSION = 2
+      PLATFORM = 'server'
+      SEED_VALUE = 1
+      MAX_TRAFFIC_PERCENT = 100
+      MAX_TRAFFIC_VALUE = 10_000
+      STATUS_RUNNING = 'RUNNING'
+      LIBRARY_PATH =  File.expand_path('../..', __FILE__)
+      HTTP_PROTOCOL = 'http://'
+      HTTPS_PROTOCOL = 'https://'
+      URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
+      SDK_VERSION = '1.0.0'
+
+      module ENDPOINTS
+        BASE_URL = 'dev.visualwebsiteoptimizer.com'
+        ACCOUNT_SETTINGS = '/server-side/settings'
+        TRACK_USER = '/server-side/track-user'
+        TRACK_GOAL = '/server-side/track-goal'
+      end
+
+      module EVENTS
+        TRACK_USER = 'track-user'
+        TRACK_GOAL = 'track-goal'
+      end
+
+      module DATATYPE
+        NUMBER = 'number'
+        STRING = 'string'
+        FUNCTION = 'function'
+        BOOLEAN = 'boolean'
+      end
+
+      module APIMETHODS
+        CREATE_INSTANCE = 'CREATE_INSTANCE'
+        ACTIVATE = 'ACTIVATE'
+        GET_VARIATION = 'GET_VARIATION'
+        TRACK = 'TRACK'
+      end
+
+      module GOALTYPES
+        REVENUE = 'REVENUE_TRACKING'
+        CUSTOM = 'CUSTOM_GOAL'
+      end
+    end
+  end
+end

data/lib/vwo/common/enums.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/LineLength
+
+require 'logger'
+
+class VWO
+  module Common
+    module Enums
+      module FileNameEnum
+        VWO_PATH = 'vwo'
+        COMMON_PATH = 'vwo/common'
+
+        VWO = VWO_PATH + '/vwo'
+        BucketingService = VWO_PATH + '/bucketing_service'
+        DecisionService = VWO_PATH + '/decision_service'
+        EventDispatcher = VWO_PATH + '/event_dispatcher'
+        Logger = VWO_PATH + '/logger'
+        ProjectConfigManager = VWO_PATH + '/project_config_manager'
+
+        CampaignUtil = COMMON_PATH + '/campaign_util'
+        FunctionUtil = COMMON_PATH + '/function_util'
+        ImpressionUtil = COMMON_PATH + '/impression_util'
+        UuidUtil = COMMON_PATH + '/uuid_util'
+        ValidateUtil = COMMON_PATH + '/validate_util'
+      end
+
+      # Classobj encapsulating various logging messages
+      module LogMessageEnum
+        # Classobj encapsulating various DEBUG messages
+        module DebugMessages
+          LOG_LEVEL_SET = '(%<file>s): Log level set to %<level>s'
+          SET_COLORED_LOG = '(%<file>s): Colored log set to %<value>s'
+          SET_DEVELOPMENT_MODE = '(%<file>s): DEVELOPMENT mode is ON'
+          VALID_CONFIGURATION = '(%<file>s): SDK configuration and account settings are valid.'
+          CUSTOM_LOGGER_USED = '(%<file>s): Custom logger used'
+          SDK_INITIALIZED = '(%<file>s): SDK properly initialized'
+          SETTINGS_FILE_PROCESSED = '(%<file>s): Settings file processed'
+          NO_STORED_VARIATION = '(%<file>s): No stored variation for UserId:%<user_id>s for Campaign:%<campaign_test_key>s found in UserProfileService'
+          NO_USER_PROFILE_SERVICE_LOOKUP = '(%<file>s): No UserProfileService to look for stored data'
+          NO_USER_PROFILE_SERVICE_SAVE = '(%<file>s): No UserProfileService to save data'
+          GETTING_STORED_VARIATION = '(%<file>s): Got stored variation for UserId:%<user_id>s of Campaign:%<campaign_test_key>s as Variation: %<variation_name>s found in UserProfileService'
+          CHECK_USER_ELIGIBILITY_FOR_CAMPAIGN = '(%<file>s): campaign:%<campaign_test_key>s having traffic allocation:%<traffic_allocation>s assigned value:%<traffic_allocation>s to userId:%<user_id>s'
+          USER_HASH_BUCKET_VALUE = '(%<file>s): userId:%<user_id>s having hash:%<hash_value>s got bucketValue:%<bucket_value>s'
+          VARIATION_HASH_BUCKET_VALUE = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_test_key>s having percent traffic:%<percent_traffic>s got hash-value:%<hash_value>s and bucket value:%<bucket_value>s'
+          IMPRESSION_FAILED = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_test_key>s got variationName:%<variation_name>s inside method:%<method>s'
+          USER_NOT_PART_OF_CAMPAIGN = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_test_key>s did not become part of campaign method:%<method>s'
+          UUID_FOR_USER = '(%<file>s): Uuid generated for userId:%<user_id>s and accountId:%<account_id>s is %<desired_uuid>s'
+          IMPRESSION_FOR_TRACK_USER = '(%<file>s): Impression built for track-user - %<properties>s'
+          IMPRESSION_FOR_TRACK_GOAL = '(%<file>s): Impression built for track-goal - %<properties>s'
+          GOT_VARIATION_FOR_USER = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_test_key>s got variationName:%<variation_name>s'
+        end
+
+        # Classobj encapsulating various INFO messages
+        module InfoMessages
+          VARIATION_RANGE_ALLOCATION = '(%<file>s): Campaign:%<campaign_test_key>s having variations:%<variation_name>s with weight:%<variation_weight>s got range as: ( %<start>s - %<end>s ))'
+          VARIATION_ALLOCATED = '(%<file>s): UserId:%<user_id>s of Campaign:%<campaign_test_key>s got variation: %<variation_name>s'
+          LOOKING_UP_USER_PROFILE_SERVICE = '(%<file>s): Looked into UserProfileService for userId:%<user_id>s %<status>s'
+          SAVING_DATA_USER_PROFILE_SERVICE = '(%<file>s): Saving into UserProfileService for userId:%<user_id>s successful'
+          GOT_STORED_VARIATION = '(%<file>s): Got stored variation:%<variation_name>s of campaign:%<campaign_test_key>s for userId:%<user_id>s from UserProfileService'
+          NO_VARIATION_ALLOCATED = '(%<file>s): UserId:%<user_id>s of Campaign:%<campaign_test_key>s did not get any variation'
+          USER_ELIGIBILITY_FOR_CAMPAIGN = '(%<file>s): Is userId:%<user_id>s part of campaign? %<is_user_part>s'
+          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_test_key>s got variationName:%<variation_name>s'
+          USER_GOT_NO_VARIATION = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_test_key>s did not allot any variation'
+          IMPRESSION_SUCCESS = '(%<file>s): Impression event - %<end_point>s was successfully received by VWO having main keys: accountId:%<account_id>s userId:%<user_id>s campaignId:%<campaign_id>s and variationId:%<variation_id>s'
+          INVALID_VARIATION_KEY = '(%<file>s): Variation was not assigned to userId:%<user_id>s for campaign:%<campaign_test_key>s'
+          RETRY_FAILED_IMPRESSION_AFTER_DELAY = '(%<file>s): Failed impression event for %<end_point>s will be retried after %<retry_timeout>s milliseconds delay'
+        end
+
+        # Classobj encapsulating various WARNING messages
+        module WarningMessages; end
+
+        # Classobj encapsulating various ERROR messages
+        module ErrorMessages
+          PROJECT_CONFIG_CORRUPTED = '(%<file>s): config passed to createInstance is not a valid JSON object.'
+          INVALID_CONFIGURATION = '(%<file>s): SDK configuration or account settings or both is/are not valid.'
+          SETTINGS_FILE_CORRUPTED = '(%<file>s): Settings file is corrupted. Please contact VWO Support for help.'
+          ACTIVATE_API_MISSING_PARAMS = '(%<file>s): "activate" API got bad parameters. It expects campaignTestKey(String) as first and userId(String) as second argument'
+          ACTIVATE_API_CONFIG_CORRUPTED = '(%<file>s): "activate" API has corrupted configuration'
+          GET_VARIATION_API_MISSING_PARAMS = '(%<file>s): "getVariation" API got bad parameters. It expects campaignTestKey(String) as first and userId(String) as second argument'
+          GET_VARIATION_API_CONFIG_CORRUPTED = '(%<file>s): "getVariation" API has corrupted configuration'
+          TRACK_API_MISSING_PARAMS = '(%<file>s): "track" API got bad parameters. It expects campaignTestKey(String) as first userId(String) as second and goalIdentifier(String/Number) as third argument. Fourth is revenueValue(Float/Number/String) and is required for revenue goal only.'
+          TRACK_API_CONFIG_CORRUPTED = '(%<file>s): "track" API has corrupted configuration'
+          TRACK_API_GOAL_NOT_FOUND = '(%<file>s): Goal:%<goal_identifier>s not found for campaign:%<campaign_test_key>s and userId:%<user_id>s'
+          TRACK_API_REVENUE_NOT_PASSED_FOR_REVENUE_GOAL = '(%<file>s): Revenue value should be passed for revenue goal:%<goal_identifier>s for campaign:%<campaign_test_key>s and userId:%<user_id>s'
+          TRACK_API_VARIATION_NOT_FOUND = '(%<file>s): Variation not found for campaign:%<campaign_test_key>s and userId:%<user_id>s'
+          CAMPAIGN_NOT_RUNNING = '(%<file>s): API used:%<api>s - Campaign:%<campaign_test_key>s is not RUNNING. Please verify from VWO App'
+          LOOK_UP_USER_PROFILE_SERVICE_FAILED = '(%<file>s): Looking data from UserProfileService failed for userId:%<user_id>s'
+          SAVE_USER_PROFILE_SERVICE_FAILED = '(%<file>s): Saving data into UserProfileService failed for userId:%<user_id>s'
+          INVALID_CAMPAIGN = '(%<file>s): Invalid campaign passed to %<method>s of this file'
+          INVALID_USER_ID = '(%<file>s): Invalid userId:%<user_id>s passed to %<method>s of this file'
+          IMPRESSION_FAILED = '(%<file>s): Impression event could not be sent to VWO - %<end_point>s'
+          CUSTOM_LOGGER_MISCONFIGURED = '(%<file>s): Custom logger is provided but seems to have mis-configured. %<extra_info>s Please check the API Docs. Using default logger.'
+        end
+      end
+
+      module LogLevelEnum
+        INFO = Logger::INFO
+        DEBUG = Logger::DEBUG
+        WARNING = Logger::WARN
+        ERROR = Logger::ERROR
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/LineLength

data/lib/vwo/common/function_utils.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../custom_logger'
+require_relative 'enums'
+require_relative 'constants'
+
+# Utility module for manipulating VWO campaigns
+class VWO
+  module Common
+    module FunctionUtils
+      include VWO::Common::Enums
+      include VWO::Common::CONSTANTS
+
+      # @return[Float]
+      def get_random_number
+        rand
+      end
+
+      # @return[Integer]
+      def get_current_unix_timestamp
+        Time.now.to_i
+      end
+    end
+  end
+end

data/lib/vwo/common/impression_utils.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'cgi'
+require_relative '../custom_logger'
+require_relative 'enums'
+require_relative 'constants'
+require_relative 'function_utils'
+require_relative 'uuid_utils'
+
+# Utility module for manipulating VWO campaigns
+class VWO
+  module Common
+    module ImpressionUtils
+      include VWO::Common::Enums
+      include VWO::Common::CONSTANTS
+      include FunctionUtils
+      include UUIDUtils
+
+      # Trigger the goal by sending it to server
+      #
+      # @param[Hash]                        :settings_file          Settings file object
+      # @param[String]                      :campaign_id            Campaign identifier
+      # @param[String]                      :variation_id           Variation identifier
+      # @param[String]                      :user_id                User identifier
+      # @param[String]                      :goal_id                Goal identifier, if building track impression
+      # @param[String|Float|Integer|nil)    :revenue                Number value, in any representation, if building track impression
+      #
+      # @return[nil|Hash]                                           None if campaign ID or variation ID is invalid,
+      #                                                             Else Properties(dict)
+      def build_event(settings_file, campaign_id, variation_id, user_id, goal_id = nil, revenue = nil)
+        return unless valid_number?(campaign_id) && valid_string?(user_id)
+
+        is_track_user_api = true
+        is_track_user_api = false unless goal_id.nil?
+        account_id = settings_file['accountId']
+
+        properties = {
+          account_id: account_id,
+          experiment_id: campaign_id,
+          ap: PLATFORM,
+          uId: CGI.escape(user_id.encode('utf-8')),
+          combination: variation_id,
+          random: get_random_number,
+          sId: get_current_unix_timestamp,
+          u: generator_for(user_id, account_id)
+        }
+        # Version and SDK constants
+        sdk_version = Gem.loaded_specs['vwo_sdk'] ? Gem.loaded_specs['vwo_sdk'].version : VWO::SDK_VERSION
+        properties['sdk'] = 'ruby'
+        properties['sdk-v'] = sdk_version
+
+        url = HTTPS_PROTOCOL + ENDPOINTS::BASE_URL
+        logger = VWO::CustomLogger.get_instance
+
+        if is_track_user_api
+          properties['ed'] = JSON.generate(p: 'server')
+          properties['url'] = "#{url}#{ENDPOINTS::TRACK_USER}"
+          logger.log(
+            LogLevelEnum::DEBUG,
+            format(
+              LogMessageEnum::DebugMessages::IMPRESSION_FOR_TRACK_USER,
+              file: FileNameEnum::ImpressionUtil,
+              properties: JSON.generate(properties)
+            )
+          )
+        else
+          properties['url'] = url + ENDPOINTS::TRACK_GOAL
+          properties['goal_id'] = goal_id
+          properties['r'] = revenue if revenue
+          logger.log(
+            LogLevelEnum::DEBUG,
+            format(
+              LogMessageEnum::DebugMessages::IMPRESSION_FOR_TRACK_GOAL,
+              file: FileNameEnum::ImpressionUtil,
+              properties: JSON.generate(properties)
+            )
+          )
+        end
+        properties
+      end
+    end
+  end
+end

data/lib/vwo/common/requests.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+class VWO
+  module Common
+    class Requests
+      def self.get(url, params)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        uri.query = URI.encode_www_form(params)
+        Net::HTTP.get_response(uri)
+      end
+    end
+  end
+end

data/lib/vwo/common/schemas/settings_file.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class VWO
+  module Common
+    # Schema for verifying the settings_file provided by the customer
+    module Schema
+      SETTINGS_FILE_SCHEMA = {
+        type: 'object',
+        properties: {
+          version: {
+            type: %w[number string]
+          },
+          accountId: {
+            type: %w[number string]
+          },
+          campaigns: {
+            if: {
+              type: 'array'
+            },
+            then: {
+              minItems: 1,
+              items: {
+                '$ref' => '#/definitions/campaign_object_schema'
+              }
+            },
+            else: {
+              type: 'object',
+              maxProperties: 0
+            }
+          }
+        },
+        definitions: {
+          campaign_variation_schema: {
+            type: 'object',
+            properties: {
+              id: {
+                type: %w[number string]
+              },
+              name: {
+                type: ['string']
+              },
+              weight: {
+                type: %w[number string]
+              }
+            },
+            required: %w[id name weight]
+          },
+          campaign_object_schema: {
+            type: 'object',
+            properties: {
+              id: {
+                type: %w[number string]
+              },
+              key: {
+                type: ['string']
+              },
+              status: {
+                type: ['string']
+              },
+              percentTraffic: {
+                type: ['number']
+              },
+              variations: {
+                type: 'array',
+                items: {
+                  '$ref' => '#/definitions/campaign_variation_schema'
+                }
+              },
+              minItems: 2
+            }
+          },
+          required: %w[
+            id
+            key
+            status
+            percentTraffic
+            variations
+          ]
+        },
+        required: %w[
+          version
+          accountId
+          campaigns
+        ]
+      }.freeze
+    end
+  end
+end

data/lib/vwo/common/utils.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class VWO
+  module Common
+    class Utils
+      def self.get_random_number
+        rand
+      end
+    end
+  end
+end