vwo-sdk 1.3.0

data/lib/vwo/core/variation_decider.rb

@@ -0,0 +1,308 @@
+# Copyright 2019 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# frozen_string_literal: true
+
+require_relative '../logger'
+require_relative '../enums'
+require_relative '../utils/campaign'
+require_relative '../utils/validations'
+require_relative 'bucketer'
+
+class VWO
+  module Core
+    class VariationDecider
+      attr_reader :user_storage_service
+
+      include VWO::Enums
+      include VWO::Utils::Campaign
+      include VWO::Utils::Validations
+
+      FILE = FileNameEnum::VariationDecider
+
+      # Initializes various services
+      # @param[Hash] -   Settings file
+      # @param[Class] -  Class instance having the capability of
+      #                  get and save.
+      def initialize(settings_file, user_storage_service = nil)
+        @logger = VWO::Logger.get_instance
+        @user_storage_service = user_storage_service
+        # Check if user_storage_service provided is valid or not
+        @user_storage_service = user_storage_service
+        @bucketer = VWO::Core::Bucketer.new
+        @settings_file = settings_file
+      end
+
+      # Returns variation for the user for the passed campaign-key
+      # Check in User Storage, if user found, validate variation and return
+      # Otherwise, proceed with variation assignment logic
+      #
+      #
+      # @param[String]          :user_id             The unique ID assigned to User
+      # @param[Hash]            :campaign            Campaign hash itslef
+      # @return[String,String]                       ({variation_id, variation_name}|Nil): Tuple of
+      #                                              variation_id and variation_name if variation allotted, else nil
+
+      def get_variation(user_id, campaign)
+        if campaign
+          campaign_key = campaign['key']
+        end
+
+        user_campaign_map = get_user_storage(user_id, campaign_key)
+        variation = get_stored_variation(user_id, campaign_key, user_campaign_map) if valid_hash?(user_campaign_map)
+
+        if variation
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::GOT_STORED_VARIATION,
+              file: FILE,
+              campaign_key: campaign_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_storage(user_id, campaign_key, variation_name) if variation_name
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::VARIATION_ALLOCATED,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              variation_name: variation_name
+            )
+          )
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: user_id)
+          )
+        end
+        [variation_id, variation_name]
+      end
+
+      # Returns the Variation Alloted for required campaign
+      #
+      # @param[String]  :user_id      The unique ID assigned to User
+      # @param[Hash]    :campaign     Campaign hash for Unique campaign key
+      #
+      # @return[Hash]
+
+      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_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_key: nil,
+              method: 'get_variation_allotted'
+            )
+          )
+        end
+        [variation_id, variation_name]
+      end
+
+      # Assigns variation to a particular user depending on the campaign PercentTraffic.
+      #
+      # @param[String]              :user_id      The unique ID assigned to a user
+      # @param[Hash]                :campaign     The Campaign of which user is to be made a part of
+      # @return[Hash]                         Variation allotted to User
+      def get_variation_of_campaign_for_user(user_id, campaign)
+        unless campaign
+          @logger.log(
+            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_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_key: campaign['key']
+          )
+        )
+        [nil, nil]
+      end
+
+      private
+
+      # Get the UserStorageData after looking up into get method
+      # Being provided via UserStorageService
+      #
+      # @param[String]: Unique user identifier
+      # @param[String]: Unique campaign key
+      # @return[Hash|Boolean]: user_storage data
+
+      def get_user_storage(user_id, campaign_key)
+        unless @user_storage_service
+          @logger.log(
+            LogLevelEnum::DEBUG,
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_LOOKUP, file: FILE)
+          )
+          return false
+        end
+
+        data = @user_storage_service.get(user_id, campaign_key)
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::LOOKING_UP_USER_STORAGE_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_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+        )
+        false
+      end
+
+      # If UserStorageService is provided and variation was stored,
+      # Get the stored variation
+      # @param[String]            :user_id
+      # @param[String]            :campaign_key campaign identified
+      # @param[Hash]              :user_campaign_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_key, user_campaign_map)
+        if user_campaign_map[campaign_key] == campaign_key
+          variation_name = user_campaign_map[:variationName]
+          @logger.log(
+            LogLevelEnum::DEBUG,
+            format(
+              LogMessageEnum::DebugMessages::GETTING_STORED_VARIATION,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              variation_name: variation_name
+            )
+          )
+          return get_campaign_variation(
+            @settings_file,
+            campaign_key,
+            variation_name
+          )
+        end
+
+        @logger.log(
+          LogLevelEnum::DEBUG,
+          format(
+            LogMessageEnum::DebugMessages::NO_STORED_VARIATION,
+            file: FILE,
+            campaign_key: campaign_key,
+            user_id: user_id
+          )
+        )
+        nil
+      end
+
+      # If UserStorageService is provided, save the assigned variation
+      #
+      # @param[String]              :user_id            Unique user identifier
+      # @param[String]              :campaign_key       Unique campaign identifier
+      # @param[String]              :variation_name     Variation identifier
+      # @return[Boolean]                                true if found otherwise false
+
+      def save_user_storage(user_id, campaign_key, variation_name)
+        unless @user_storage_service
+          @logger.log(
+            LogLevelEnum::DEBUG,
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
+          )
+          return false
+        end
+        new_campaign_user_mapping = {}
+        new_campaign_user_mapping['campaign_key'] = campaign_key
+        new_campaign_user_mapping['user_id'] = user_id
+        new_campaign_user_mapping['variation_name'] = variation_name
+
+        @user_storage_service.set(new_campaign_user_mapping)
+
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id)
+        )
+        true
+      rescue StandardError
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+        )
+        false
+      end
+    end
+  end
+end

data/lib/vwo/enums.rb

@@ -0,0 +1,115 @@
+# Copyright 2019 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/LineLength
+
+require 'logger'
+
+class VWO
+  module Enums
+    module FileNameEnum
+      VWO_PATH = 'vwo'
+      UTIL_PATH = 'vwo/utils'
+
+      VWO = VWO_PATH + '/vwo'
+      Bucketer = VWO_PATH + '/core/bucketer'
+      VariationDecider = VWO_PATH + '/core/variation_decider'
+      EventDispatcher = VWO_PATH + '/services/event_dispatcher'
+      Logger = VWO_PATH + '/logger'
+      SettingsFileProcessor = VWO_PATH + '/services/settings_file_processor'
+
+      CampaignUtil = UTIL_PATH + '/campaign'
+      FunctionUtil = UTIL_PATH + '/function'
+      ImpressionUtil = UTIL_PATH + '/impression'
+      UuidUtil = UTIL_PATH + '/uuid'
+      ValidateUtil = UTIL_PATH + '/validations'
+    end
+
+    # Logging Enums
+    module LogMessageEnum
+      # Debug Messages
+      module DebugMessages
+        LOG_LEVEL_SET = '(%<file>s): Log level set to %<level>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_key>s found in UserStorageService'
+        NO_USER_STORAGE_SERVICE_LOOKUP = '(%<file>s): No UserStorageService to look for stored data'
+        NO_USER_STORAGE_SERVICE_SAVE = '(%<file>s): No UserStorageService to save data'
+        GETTING_STORED_VARIATION = '(%<file>s): Got stored variation for UserId:%<user_id>s of Campaign:%<campaign_key>s as Variation: %<variation_name>s found in UserStorageService'
+        CHECK_USER_ELIGIBILITY_FOR_CAMPAIGN = '(%<file>s): campaign:%<campaign_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_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_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_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_key>s got variationName:%<variation_name>s'
+      end
+
+      # Info Messages
+      module InfoMessages
+        VARIATION_RANGE_ALLOCATION = '(%<file>s): Campaign:%<campaign_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_key>s got variation: %<variation_name>s'
+        LOOKING_UP_USER_STORAGE_SERVICE = '(%<file>s): Looked into UserStorageService for userId:%<user_id>s %<status>s'
+        SAVING_DATA_USER_STORAGE_SERVICE = '(%<file>s): Saving into UserStorageService for userId:%<user_id>s successful'
+        GOT_STORED_VARIATION = '(%<file>s): Got stored variation:%<variation_name>s of campaign:%<campaign_key>s for userId:%<user_id>s from UserStorageService'
+        NO_VARIATION_ALLOCATED = '(%<file>s): UserId:%<user_id>s of Campaign:%<campaign_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_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 = '(%<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_key>s'
+      end
+
+      # Warning Messages
+      module WarningMessages; end
+
+      # Error Messages
+      module ErrorMessages
+        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_NAME_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_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_key>s and userId:%<user_id>s'
+        TRACK_API_VARIATION_NOT_FOUND = '(%<file>s): Variation not found for campaign:%<campaign_key>s and userId:%<user_id>s'
+        CAMPAIGN_NOT_RUNNING = '(%<file>s): API used:%<api>s - Campaign:%<campaign_key>s is not RUNNING. Please verify from VWO App'
+        LOOK_UP_USER_STORAGE_SERVICE_FAILED = '(%<file>s): Looking data from UserStorageService failed for userId:%<user_id>s'
+        SAVE_USER_STORAGE_SERVICE_FAILED = '(%<file>s): Saving data into UserStorageService 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
+# rubocop:enable Metrics/LineLength

data/lib/vwo/logger.rb

@@ -0,0 +1,37 @@
+# Copyright 2019 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# frozen_string_literal: true
+
+require 'logger'
+
+class VWO
+  class Logger
+    @logger = nil
+    @logger_instance = nil
+
+    def self.get_instance(logger_instance = nil)
+      @@logger ||= VWO::Logger.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