vwo-fme-ruby-sdk 1.0.0 → 1.1.0

data/lib/vwo/services/settings_service.rb

@@ -0,0 +1,120 @@
+# Copyright 2025 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.
+
+require 'json'
+require_relative '../packages/network_layer/manager/network_manager'
+require_relative '../packages/network_layer/models/request_model'
+require_relative '../packages/network_layer/models/response_model'
+require_relative '../constants/constants'
+require_relative '../utils/network_util'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../models/schemas/settings_schema_validation'
+
+class SettingsService
+  attr_accessor :sdk_key, :account_id, :expiry, :network_timeout, :hostname, :port, :protocol, :is_gateway_service_provided
+
+  class << self
+    attr_accessor :instance
+    
+    def get_instance
+      @instance ||= SettingsService.new
+    end
+  end
+
+  def initialize(options)
+    @sdk_key = options[:sdk_key]
+    @account_id = options[:account_id]
+    @expiry = options.dig(:settings, :expiry) || Constants::SETTINGS_EXPIRY
+    @network_timeout = options.dig(:settings, :timeout) || Constants::SETTINGS_TIMEOUT
+
+    if options[:gateway_service] && options[:gateway_service][:url]
+      parsed_url = URI.parse(options[:gateway_service][:url].start_with?(Constants::HTTP_PROTOCOL) || options[:gateway_service][:url].start_with?(Constants::HTTPS_PROTOCOL) ? options[:gateway_service][:url] : "#{Constants::HTTPS_PROTOCOL}#{options[:gateway_service][:url]}")
+      @hostname = parsed_url.hostname
+      @protocol = parsed_url.scheme
+      @port = parsed_url.port || options.dig(:gateway_service, :port)
+      @is_gateway_service_provided = true
+    else
+      @hostname = Constants::HOST_NAME
+      @protocol = Constants::HTTPS_PROTOCOL
+    end
+
+    LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", { service: 'Settings Manager' })
+    SettingsService.instance = self
+  end
+
+  # Fetch settings and cache them in storage.
+  # @return [SettingsModel] The fetched settings
+  def fetch_settings_and_cache_in_storage
+    begin
+      response = fetch_settings
+      response
+    rescue => e
+      LoggerService.log(LogLevelEnum::ERROR, "SETTINGS_FETCH_ERROR", { err: e.message })
+      nil
+    end
+  end
+
+  # Fetch settings from the server.
+  # @param is_via_webhook [Boolean] Whether to fetch settings via webhook
+  # @return [SettingsModel] The fetched settings
+  def fetch_settings(is_via_webhook = false)
+    if @sdk_key.nil? || @account_id.nil?
+      LoggerService.log(LogLevelEnum::ERROR, "sdkKey is required for fetching account settings. Aborting!", nil)
+    end
+
+    network_instance = NetworkManager.instance
+    options = NetworkUtil.get_settings_path(@sdk_key, @account_id)
+
+    options['api-version'] = Constants::API_VERSION
+    options[:source] = 'prod'
+
+    # When using gateway service, always fetch from SETTINGS_ENDPOINT since the gateway maintains the latest settings
+    if @is_gateway_service_provided
+      path = Constants::SETTINGS_ENDPOINT
+    else
+      path = is_via_webhook ? Constants::WEBHOOK_SETTINGS_ENDPOINT : Constants::SETTINGS_ENDPOINT
+    end
+
+    request = RequestModel.new(@hostname, "GET", path, options, nil, nil, @protocol, @port)
+    request.set_timeout(@network_timeout)
+
+    begin
+      response = network_instance.get(request)
+      response.get_data
+    rescue => e
+      LoggerService.log(LogLevelEnum::ERROR, "Error fetching settings: #{e.message}", nil)
+      raise e
+    end
+  end
+
+  # Get settings (either from storage or by forcing fetch).
+  # @param force_fetch [Boolean] Whether to force fetch the settings
+  # @return [SettingsModel] The fetched settings
+  def get_settings(force_fetch = false)
+    if force_fetch
+      fetch_settings_and_cache_in_storage
+    else
+      settings = fetch_settings_and_cache_in_storage
+      is_valid = SettingsSchema.new.is_settings_valid(settings)
+      if is_valid
+        LoggerService.log(LogLevelEnum::INFO, "SETTINGS_FETCH_SUCCESS")
+        settings
+      else
+        LoggerService.log(LogLevelEnum::ERROR, "SETTINGS_SCHEMA_INVALID")
+        {}
+      end
+    end
+  end
+end

data/lib/vwo/services/storage_service.rb

@@ -0,0 +1,65 @@
+# Copyright 2025 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.
+
+require_relative '../enums/storage_enum'
+require_relative '../models/user/context_model'
+require_relative '../packages/storage/storage'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../utils/data_type_util'
+
+class StorageService
+  attr_accessor :storage_data
+
+  def initialize
+    @storage_data = {}
+  end
+
+  # Retrieves data from storage based on the feature key and user ID.
+  # @param feature_key [String] The key to identify the feature data.
+  # @param context [ContextModel] The user context containing an ID.
+  # @return [Hash] The data retrieved or a storage status enum.
+  def get_data_from_storage(feature_key, context)
+    storage_instance = Storage.instance.get_connector
+
+    # Check if the storage instance is available
+    return StorageEnum::STORAGE_UNDEFINED if DataTypeUtil.is_null(storage_instance) || DataTypeUtil.is_undefined(storage_instance)
+
+    begin
+      data = storage_instance.get(feature_key, context.get_id)
+      return data.nil? ? StorageEnum::NO_DATA_FOUND : data
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "STORED_DATA_ERROR", { err: e.message })
+      return StorageEnum::NO_DATA_FOUND
+    end
+  end
+
+  # Stores data in the storage.
+  # @param data [Hash] The data to be stored.
+  # @return [Boolean] True if data is successfully stored, otherwise false.
+  def set_data_in_storage(data)
+    storage_instance = Storage.instance.get_connector
+
+    # Check if the storage instance is available
+    return false if storage_instance.nil?
+
+    begin
+      storage_instance.set(data)
+      return true
+    rescue StandardError
+      LoggerService.log(LogLevelEnum::ERROR, "STORED_DATA_ERROR", { err: e.message })
+      return false
+    end
+  end
+end

data/lib/vwo/utils/campaign_util.rb

@@ -0,0 +1,249 @@
+# Copyright 2025 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.
+
+require_relative '../constants/constants'
+require_relative '../enums/campaign_type_enum'
+require_relative '../models/campaign/campaign_model'
+require_relative '../models/campaign/feature_model'
+require_relative '../models/campaign/variation_model'
+require_relative '../models/settings/settings_model'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../models/campaign/rule_model'
+
+module CampaignUtil
+  # Sets the variation allocation for a campaign
+  # @param campaign [CampaignModel] The campaign to set the variation allocation for
+  def self.set_variation_allocation(campaign)
+    if [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+      handle_rollout_campaign(campaign)
+    else
+      current_allocation = 0
+      campaign.get_variations.each do |variation|
+        step_factor = assign_range_values(variation, current_allocation)
+        current_allocation += step_factor
+
+        LoggerService.log(LogLevelEnum::INFO, "VARIATION_RANGE_ALLOCATION", {
+          variationKey: variation.get_key,
+          campaignKey: campaign.get_key,
+          variationWeight: variation.get_weight,
+          startRange: variation.get_start_range_variation,
+          endRange: variation.get_end_range_variation
+        })
+      end
+    end
+  end
+
+  # Assigns start and end range values to a variation
+  # @param variation [VariationModel] The variation to assign the start and end range values to
+  # @param current_allocation [Integer] The current allocation
+  # @return [Integer] The step factor
+  def self.assign_range_values(variation, current_allocation)
+    step_factor = get_variation_bucket_range(variation.get_weight)
+
+    if step_factor > 0
+      variation.set_start_range(current_allocation + 1)
+      variation.set_end_range(current_allocation + step_factor)
+    else
+      variation.set_start_range(-1)
+      variation.set_end_range(-1)
+    end
+
+    step_factor
+  end
+
+  # Scales variation weights to sum up to 100%
+  # @param variations [Array<VariationModel>] The variations to scale the weights of
+  # @return [Array<VariationModel>] The scaled variations
+  def self.scale_variation_weights(variations)
+    total_weight = variations.sum(&:weight)
+
+    if total_weight.zero?
+      equal_weight = 100.0 / variations.length
+      variations.each { |variation| variation.weight = equal_weight }
+    else
+      variations.each { |variation| variation.weight = (variation.weight / total_weight) * 100 }
+    end
+  end
+
+  # Generates a bucketing seed based on user ID and campaign
+  # @param user_id [String] The ID of the user
+  # @param campaign [CampaignModel] The campaign to generate the bucketing seed for
+  # @param group_id [String] The ID of the group
+  # @return [String] The bucketing seed
+  def self.get_bucketing_seed(user_id, campaign, group_id = nil)
+    return "#{group_id}_#{user_id}" if group_id
+
+    is_rollout_or_personalize = [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+    salt = is_rollout_or_personalize ? campaign.get_variations.first.get_salt : campaign.get_salt
+
+    salt ? "#{salt}_#{user_id}" : "#{campaign.get_id}_#{user_id}"
+  end
+
+  # Retrieves variation from campaign key
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_key [String] The key of the campaign
+  # @param variation_id [Integer] The ID of the variation
+  # @return [VariationModel] The variation
+  def self.get_variation_from_campaign_key(settings, campaign_key, variation_id)
+    campaign = settings.get_campaigns.find { |c| c.get_key == campaign_key }
+    return nil unless campaign
+
+    variation = campaign.get_variations.find { |v| v.get_id == variation_id }
+    variation ? VariationModel.new.model_from_dictionary(variation) : nil
+  end
+
+  # Sets campaign allocation ranges
+  # @param campaigns [Array<CampaignModel>] The campaigns to set the allocation ranges for
+  def self.set_campaign_allocation(campaigns)
+    current_allocation = 0
+
+    campaigns.each do |campaign|
+      step_factor = assign_range_values_meg(campaign, current_allocation)
+      current_allocation += step_factor
+    end
+  end
+
+  # Retrieves campaign group details if part of a group
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @param variation_id [Integer] The ID of the variation
+  # @return [Hash] The group details
+  def self.get_group_details_if_campaign_part_of_it(settings, campaign_id, variation_id = nil)
+    campaign_to_check = variation_id ? "#{campaign_id}_#{variation_id}" : campaign_id.to_s
+
+    if settings.get_campaign_groups.key?(campaign_to_check)
+      group_id = settings.get_campaign_groups[campaign_to_check]
+      { group_id: group_id, group_name: settings.get_groups[group_id.to_s][:name.to_s]}
+    else
+      {}
+    end
+  end
+
+  # Finds groups associated with a feature
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature_key [String] The key of the feature
+  # @return [Array] The groups associated with the feature
+  def self.find_groups_feature_part_of(settings, feature_key)
+    rule_array = []
+    settings.get_features.each do |feature|
+      if feature.get_key == feature_key
+        rule_array.concat(feature.get_rules)
+      end
+    end
+
+    groups = []
+    rule_array.each do |rule|
+      group = get_group_details_if_campaign_part_of_it(settings, rule.get_campaign_id, rule.get_type == CampaignTypeEnum::PERSONALIZE ? rule.get_variation_id : nil)
+      groups << group unless group.empty? || groups.any? { |g| g[:group_id] == group[:group_id] }
+    end
+
+    groups
+  end
+
+  # Retrieves campaigns by group ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param group_id [String] The ID of the group
+  # @return [Array] The campaigns associated with the group
+  def self.get_campaigns_by_group_id(settings, group_id)
+    settings.get_groups[group_id.to_s]&.fetch(:campaigns.to_s, []) || []
+  end
+
+  # Retrieves feature keys from campaign IDs
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_ids [Array] The IDs of the campaigns
+  # @return [Array] The feature keys associated with the campaigns
+  def self.get_feature_keys_from_campaign_ids(settings, campaign_ids)
+    feature_keys = []
+
+    campaign_ids.each do |campaign|
+      campaign_id, variation_id = campaign.split('_').map(&:to_i)
+
+      settings.get_features.each do |feature|
+        next if feature_keys.include?(feature.get_key)
+
+        feature.get_rules.each do |rule|
+          if rule.get_campaign_id == campaign_id
+            feature_keys << feature.get_key if variation_id.nil? || rule.get_variation_id == variation_id
+          end
+        end
+      end
+    end
+
+    feature_keys
+  end
+
+  # Retrieves campaign IDs from a feature key
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature_key [String] The key of the feature
+  # @return [Array] The campaign IDs associated with the feature
+  def self.get_campaign_ids_from_feature_key(settings, feature_key)
+    settings.get_features.each do |feature|
+      return feature.get_rules.map(&:get_campaign_id) if feature.get_key == feature_key
+    end
+    []
+  end
+
+  # Assigns range values to a MEG campaign
+  # @param data [VariationModel] The variation to assign the start and end range values to
+  # @param current_allocation [Integer] The current allocation
+  # @return [Integer] The step factor
+  def self.assign_range_values_meg(data, current_allocation)
+    step_factor = get_variation_bucket_range(data.weight)
+
+    if step_factor > 0
+      data.start_range_variation = current_allocation + 1
+      data.end_range_variation = current_allocation + step_factor
+    else
+      data.start_range_variation = -1
+      data.end_range_variation = -1
+    end
+
+    step_factor
+  end
+
+  # Retrieves the rule type for a given campaign ID from a feature
+  def self.get_rule_type_using_campaign_id_from_feature(feature, campaign_id)
+    rule = feature.get_rules.find { |r| r.get_campaign_id == campaign_id }
+    rule ? rule.get_type : ''
+  end
+
+  # Calculates bucket range for a variation
+  # @param variation_weight [Float] The weight of the variation
+  # @return [Integer] The bucket range
+  def self.get_variation_bucket_range(variation_weight)
+    return 0 unless variation_weight && variation_weight.positive?
+
+    start_range = (variation_weight * 100).ceil
+    [start_range, Constants::MAX_TRAFFIC_VALUE].min
+  end
+
+  # Handles rollout campaign logic
+  # @param campaign [CampaignModel] The campaign to handle the rollout logic for
+  def self.handle_rollout_campaign(campaign)
+    campaign.get_variations.each do |variation|
+      end_range = variation.get_weight * 100
+      variation.set_start_range(1)
+      variation.set_end_range(end_range)
+
+      LoggerService.log(LogLevelEnum::INFO, "VARIATION_RANGE_ALLOCATION", {
+        variationKey: variation.get_key,
+        campaignKey: campaign.get_key,
+        variationWeight: variation.get_weight,
+        startRange: 1,
+        endRange: end_range
+      })
+    end
+  end
+end

data/lib/vwo/utils/data_type_util.rb

@@ -0,0 +1,105 @@
+# Copyright 2025 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.
+
+module DataTypeUtil
+    # Checks if the value is a Hash (object in JS)
+    def self.is_object(val)
+      val.is_a?(Hash)
+    end
+  
+    # Checks if the value is an Array
+    def self.is_array(val)
+      val.is_a?(Array)
+    end
+  
+    # Checks if the value is nil
+    def self.is_null(val)
+      val.nil?
+    end
+  
+    # Checks if the value is undefined (not applicable in Ruby, so return false)
+    def self.is_undefined(val)
+      false
+    end
+  
+    # Checks if the value is defined (not nil)
+    def self.is_defined(val)
+      !val.nil?
+    end
+  
+    # Checks if the value is a Number (including NaN)
+    def self.is_number(val)
+      val.is_a?(Numeric)
+    end
+  
+    # Checks if the value is a String
+    def self.is_string(val)
+      val.is_a?(String)
+    end
+  
+    # Checks if the value is a Boolean
+    def self.is_boolean(val)
+      val.is_a?(TrueClass) || val.is_a?(FalseClass)
+    end
+  
+    # Checks if the value is NaN (only applicable for Float in Ruby)
+    def self.is_nan(val)
+      val.is_a?(Float) && val.nan?
+    end
+  
+    # Checks if the value is a Date
+    def self.is_date(val)
+      val.is_a?(Date) || val.is_a?(Time) || val.is_a?(DateTime)
+    end
+  
+    # Checks if the value is a Function (Proc or Lambda in Ruby)
+    def self.is_function(val)
+      val.is_a?(Proc) || val.is_a?(Method)
+    end
+  
+    # Checks if the value is a Regular Expression
+    def self.is_regex(val)
+      val.is_a?(Regexp)
+    end
+  
+    # Determines the type of the given value
+    def self.get_type(val)
+      case
+      when is_object(val)
+        "Object"
+      when is_array(val)
+        "Array"
+      when is_null(val)
+        "Null"
+      when is_undefined(val)
+        "Undefined"
+      when is_nan(val)
+        "NaN"
+      when is_number(val)
+        "Number"
+      when is_string(val)
+        "String"
+      when is_boolean(val)
+        "Boolean"
+      when is_date(val)
+        "Date"
+      when is_regex(val)
+        "Regex"
+      when is_function(val)
+        "Function"
+      else
+        "Unknown Type"
+      end
+    end
+  end