vwo-fme-ruby-sdk 1.0.0 → 1.1.0

data/lib/vwo/utils/decision_util.rb

@@ -0,0 +1,253 @@
+# 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/campaign_type_enum'
+require_relative '../enums/status_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 '../models/user/context_model'
+require_relative '../packages/decision_maker/decision_maker'
+require_relative '../packages/segmentation_evaluator/core/segmentation_manager'
+require_relative '../services/campaign_decision_service'
+require_relative '../services/storage_service'
+require_relative '../utils/data_type_util'
+require_relative '../constants/constants'
+require_relative '../utils/campaign_util'
+require_relative '../utils/function_util'
+require_relative '../utils/meg_util'
+require_relative '../utils/uuid_util'
+require_relative '../decorators/storage_decorator'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+
+class DecisionUtil
+  # Check if the campaign satisfies whitelisting and pre-segmentation
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature [FeatureModel] The feature to evaluate
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @param evaluated_feature_map [Hash] The map of evaluated features
+  # @param meg_group_winner_campaigns [Hash] The map of MEG group winner campaigns
+  def self.check_whitelisting_and_pre_seg(settings, feature, campaign, context, evaluated_feature_map, meg_group_winner_campaigns, storage_service, decision)
+    vwo_user_id = UUIDUtil.get_uuid(context.get_id, settings.get_account_id)
+    campaign_id = campaign.get_id
+
+    if campaign.get_type == CampaignTypeEnum::AB
+      # Set _vwoUserId for variation targeting variables
+      variation_targeting_vars = context.get_variation_targeting_variables || {}
+      variation_targeting_vars["_vwoUserId"] = campaign.get_is_user_list_enabled ? vwo_user_id : context.get_id
+      context.set_variation_targeting_variables(variation_targeting_vars)
+      decision[:variation_targeting_variables] = variation_targeting_vars
+
+      # Check for whitelisting
+      if campaign.get_is_forced_variation_enabled
+        whitelisted_variation = check_campaign_whitelisting(campaign, context)
+        return [true, whitelisted_variation] if whitelisted_variation && !whitelisted_variation.empty?
+      else
+        LoggerService.log(LogLevelEnum::INFO, "WHITELISTING_SKIP", {
+          campaignKey: campaign.get_rule_key,
+          userId: context.get_id
+        })
+      end
+    end
+
+    # User list segment check for campaign pre-segmentation
+    custom_vars = context.get_custom_variables || {}
+    custom_vars["_vwoUserId"] = campaign.get_is_user_list_enabled ? vwo_user_id : context.get_id
+    context.set_custom_variables(custom_vars)
+    decision[:custom_variables] = custom_vars
+
+    # Check if rule belongs to Mutually Exclusive Group (MEG)
+    group_details = CampaignUtil.get_group_details_if_campaign_part_of_it(settings, campaign_id, campaign.get_type == CampaignTypeEnum::PERSONALIZE ? campaign.get_variations[0].get_id : nil)
+    group_id = group_details[:group_id]
+
+    # Check if the group has already been evaluated
+    group_winner_campaign_id = meg_group_winner_campaigns[group_id] if meg_group_winner_campaigns && meg_group_winner_campaigns.key?(group_id)
+    return evaluate_meg_campaign(group_winner_campaign_id, campaign, context, meg_group_winner_campaigns, group_id) if group_winner_campaign_id
+
+    # Check in storage if the group was already evaluated
+    stored_data = StorageDecorator.new.get_feature_from_storage("#{Constants::VWO_META_MEG_KEY}#{group_id}", context, storage_service)
+    if stored_data && stored_data[:experiment_key] && stored_data[:experiment_id]
+      LoggerService.log(LogLevelEnum::INFO, "MEG_CAMPAIGN_FOUND_IN_STORAGE", {
+        campaignKey: stored_data[:experiment_key],
+        userId: context.get_id
+      })
+
+      if stored_data[:experiment_id] == campaign_id
+        return evaluate_meg_personalization(campaign, stored_data, meg_group_winner_campaigns, group_id)
+      end
+      meg_group_winner_campaigns[group_id] = stored_data[:experiment_variation_id] != -1 ? "#{stored_data[:experiment_id]}_#{stored_data[:experiment_variation_id]}" : stored_data[:experiment_id]
+      return [false, nil]
+    end
+
+    # Pre-segmentation check
+    pre_segmentation_passed = CampaignDecisionService.new.get_pre_segmentation_decision(campaign, context)
+
+    if pre_segmentation_passed && group_id
+      winner_campaign = evaluate_groups(settings, feature, group_id, evaluated_feature_map, context, storage_service)
+      return evaluate_meg_campaign_winner(winner_campaign, campaign, context, meg_group_winner_campaigns, group_id)
+    end
+
+    [pre_segmentation_passed, nil]
+  end
+
+  # Evaluate the MEG campaign
+  # @param group_winner_campaign_id [String] The ID of the MEG group winner campaign
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @param meg_group_winner_campaigns [Hash] The map of MEG group winner campaigns
+  # @param group_id [String] The ID of the MEG group
+  def self.evaluate_meg_campaign(group_winner_campaign_id, campaign, context, meg_group_winner_campaigns, group_id)
+    if campaign.get_type == CampaignTypeEnum::AB && group_winner_campaign_id == campaign.get_id
+      return [true, nil]
+    elsif campaign.get_type == CampaignTypeEnum::PERSONALIZE && group_winner_campaign_id == "#{campaign.get_id}_#{campaign.get_variations[0].get_id}"
+      return [true, nil]
+    end
+    [false, nil]
+  end
+
+  def self.evaluate_meg_personalization(campaign, stored_data, meg_group_winner_campaigns, group_id)
+    if campaign.get_type == CampaignTypeEnum::PERSONALIZE
+      if stored_data[:experiment_variation_id] == campaign.get_variations[0].get_id
+        return [true, nil]
+      else
+        meg_group_winner_campaigns[group_id] = "#{stored_data[:experiment_id]}_#{stored_data[:experiment_variation_id]}"
+        return [false, nil]
+      end
+    else
+      return [true, nil]
+    end
+  end
+
+  # Evaluate the MEG campaign winner
+  # @param winner_campaign [CampaignModel] The winner campaign
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @param meg_group_winner_campaigns [Hash] The map of MEG group winner campaigns
+  # @param group_id [String] The ID of the MEG group
+  def self.evaluate_meg_campaign_winner(winner_campaign, campaign, context, meg_group_winner_campaigns, group_id)
+    if winner_campaign && winner_campaign.get_id == campaign.get_id
+      if winner_campaign.get_type == CampaignTypeEnum::AB
+        return [true, nil]
+      else
+        # if personalise then check if the requested variation is the winner
+        if winner_campaign.get_variations[0].get_id == campaign.get_variations[0].get_id
+          return [true, nil]
+        else
+          meg_group_winner_campaigns[group_id] = "#{winner_campaign.get_id}_#{winner_campaign.get_variations[0].get_id}"
+          return [false, nil]
+        end
+      end
+    elsif winner_campaign
+      if winner_campaign.get_type == CampaignTypeEnum::AB
+        meg_group_winner_campaigns[group_id] = winner_campaign.get_id
+      else
+        meg_group_winner_campaigns[group_id] = "#{winner_campaign.get_id}_#{winner_campaign.get_variations[0].get_id}"
+      end
+      return [false, nil]
+    end
+    
+    meg_group_winner_campaigns[group_id] = -1
+    [false, nil]
+  end
+
+  # Evaluate the traffic and get the variation
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param user_id [String] The ID of the user
+  def self.evaluate_traffic_and_get_variation(settings, campaign, user_id)
+    variation = CampaignDecisionService.new.get_variation_alloted(user_id, settings.get_account_id, campaign)
+    if variation.nil?
+      LoggerService.log(LogLevelEnum::INFO, "USER_CAMPAIGN_BUCKET_INFO", {
+        campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+        userId: user_id,
+        status: 'did not get any variation'
+      })
+      return nil
+    end
+    LoggerService.log(LogLevelEnum::INFO, "USER_CAMPAIGN_BUCKET_INFO", {
+      campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+      userId: user_id,
+      status: "got variation: #{variation.get_key}"
+    })
+    variation
+  end
+
+  # Check if the campaign satisfies whitelisting
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  def self.check_campaign_whitelisting(campaign, context)
+    # Check if the campaign satisfies whitelisting
+    whitelisting_result = evaluate_whitelisting(campaign, context)
+    status = whitelisting_result ? StatusEnum::PASSED : StatusEnum::FAILED
+    variation_string = whitelisting_result ? whitelisting_result[:variation].get_key : ''
+
+    LoggerService.log(LogLevelEnum::INFO, "WHITELISTING_STATUS", {
+      userId: context.get_id,
+      campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+      status: status,
+      variationString: variation_string
+    })
+
+    whitelisting_result
+  end
+
+  # Evaluate the whitelisting
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  def self.evaluate_whitelisting(campaign, context)
+    targeted_variations = []
+    
+    campaign.get_variations.each do |variation|
+      next if DataTypeUtil.is_object(variation.get_segments) && variation.get_segments.empty?
+      if DataTypeUtil.is_object(variation.get_segments)
+        segmentation_result = SegmentationManager.instance.validate_segmentation(
+          variation.get_segments,
+          context.get_variation_targeting_variables
+        )
+
+        targeted_variations.push(clone_object(variation)) if segmentation_result
+      end
+    end
+
+    # Determine the whitelisted variation
+    whitelisted_variation = nil
+    if targeted_variations.length > 1
+      scale_variation_weights(targeted_variations)
+      current_allocation = 0
+
+      targeted_variations.each do |variation|
+        step_factor = assign_range_values(variation, current_allocation)
+        current_allocation += step_factor
+      end
+
+      whitelisted_variation = CampaignDecisionService.new.get_variation(
+        targeted_variations,
+        DecisionMaker.new.calculate_bucket_value(CampaignUtil.get_bucketing_seed(context.get_id, campaign, nil))
+      )
+    else
+      whitelisted_variation = targeted_variations.first
+    end
+
+    return nil unless whitelisted_variation
+
+    {
+      variation: whitelisted_variation,
+      variation_name: whitelisted_variation.get_key,
+      variation_id: whitelisted_variation.get_id
+    }
+  end
+end

data/lib/vwo/utils/function_util.rb

@@ -0,0 +1,123 @@
+# 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/campaign_type_enum'
+require_relative '../models/campaign/campaign_model'
+require_relative '../models/campaign/feature_model'
+require_relative '../models/settings/settings_model'
+require_relative '../utils/data_type_util'
+
+# Clones an object deeply.
+# @param obj [Object] The object to clone.
+# @return [Object] The cloned object.
+def clone_object(obj)
+  return obj unless obj
+  Marshal.load(Marshal.dump(obj))
+end
+
+# Gets the current time in ISO string format.
+# @return [String] The current time in ISO string format.
+def get_current_time
+  Time.now.utc.iso8601
+end
+
+# Gets the current Unix timestamp in seconds.
+# @return [Integer] The current Unix timestamp.
+def get_current_unix_timestamp
+  Time.now.to_i
+end
+
+# Gets the current Unix timestamp in milliseconds.
+# @return [Integer] The current Unix timestamp in milliseconds.
+def get_current_unix_timestamp_in_millis
+  (Time.now.to_f * 1000).to_i
+end
+
+# Generates a random number between 0 and 1.
+# @return [Float] A random number.
+def get_random_number
+  rand
+end
+
+# Retrieves specific rules based on the type from a feature.
+# @param feature [FeatureModel] The feature object.
+# @param type [CampaignTypeEnum, nil] The type of the rules to retrieve.
+# @return [Array] An array of rules that match the type.
+def get_specific_rules_based_on_type(feature, type = nil)
+  return [] unless feature&.get_rules_linked_campaign
+
+  return feature.get_rules_linked_campaign if type.nil? || !DataTypeUtil.is_string(type)
+
+  feature.get_rules_linked_campaign.select do |rule|
+    rule_model = CampaignModel.new.model_from_dictionary(rule)
+    rule_model.get_type == type
+  end
+end
+
+# Retrieves all AB and Personalize rules from a feature.
+# @param feature [FeatureModel] The feature object.
+# @return [Array] An array of AB and Personalize rules.
+def get_all_experiment_rules(feature)
+  return [] unless feature
+
+  feature.get_rules_linked_campaign.select do |rule|
+    [CampaignTypeEnum::AB, CampaignTypeEnum::PERSONALIZE].include?(rule.get_type)
+  end
+end
+
+# Retrieves a feature by its key from the settings.
+# @param settings [SettingsModel] The settings containing features.
+# @param feature_key [String] The key of the feature to find.
+# @return [FeatureModel, nil] The feature if found, otherwise nil.
+def get_feature_from_key(settings, feature_key)
+  return nil unless settings&.get_features
+
+  settings.get_features.find { |feature| feature.get_key == feature_key }
+end
+
+# Checks if an event exists within any feature's metrics.
+# @param event_name [String] The name of the event to check.
+# @param settings [SettingsModel] The settings containing features.
+# @return [Boolean] True if the event exists, otherwise false.
+def does_event_belong_to_any_feature(event_name, settings)
+  settings.get_features.any? do |feature|
+    feature.get_metrics.any? { |metric| metric.get_identifier == event_name }
+  end
+end
+
+# Adds linked campaigns to each feature in the settings based on rules.
+# @param settings [SettingsModel] The settings file to modify.
+def add_linked_campaigns_to_settings(settings)
+  campaign_map = settings.get_campaigns.each_with_object({}) do |campaign, map|
+    map[campaign.get_id] = campaign
+  end
+
+  settings.get_features.each do |feature|
+    rules_linked_campaign = feature.get_rules.map do |rule|
+      campaign = campaign_map[rule.get_campaign_id]
+      next unless campaign
+
+      linked_campaign = campaign.clone
+      linked_campaign.set_rule_key(rule.get_rule_key)
+      if rule.get_variation_id
+        variation = campaign.get_variations.find { |v| v.get_id == rule.get_variation_id }
+        linked_campaign.set_variations([variation]) if variation
+      end
+
+      linked_campaign
+    end.compact
+
+    feature.set_rules_linked_campaign(rules_linked_campaign)
+  end
+end

data/lib/vwo/utils/gateway_service_util.rb

@@ -0,0 +1,101 @@
+# 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 '../models/settings/settings_model'
+require_relative '../packages/network_layer/manager/network_manager'
+require_relative '../packages/network_layer/models/request_model'
+require_relative '../enums/http_method_enum'
+require_relative '../services/settings_service'
+require_relative 'url_util'
+require_relative '../enums/campaign_type_enum'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+
+# Retrieves data from a web service using the specified query parameters and endpoint.
+# @param query_params [Hash] The parameters to be used in the query string of the request.
+# @param endpoint [String] The endpoint URL to which the request is sent.
+# @return [Hash, Boolean] The response data or false if an error occurs.
+def get_from_gateway_service(query_params, endpoint)
+  network_instance = NetworkManager.instance
+
+  unless SettingsService.instance.is_gateway_service_provided
+    LoggerService.log(LogLevelEnum::ERROR, "GATEWAY_URL_ERROR")
+    return false
+  end
+
+  begin
+    request = RequestModel.new(
+      UrlUtil.get_base_url,
+      HttpMethodEnum::GET,
+      endpoint,
+      query_params,
+      nil,
+      nil,
+      SettingsService.instance.protocol,
+      SettingsService.instance.port
+    )
+
+    response = network_instance.get(request)
+    return response.get_data
+  rescue StandardError => e
+    LoggerService.log(LogLevelEnum::ERROR, "Error fetching from Gateway Service: #{e.message}", nil)
+    return false
+  end
+end
+
+# Encodes the query parameters to ensure they are URL-safe.
+# @param query_params [Hash] The query parameters to be encoded.
+# @return [Hash] An object containing the encoded query parameters.
+def get_query_params(query_params)
+  encoded_params = {}
+
+  query_params.each do |key, value|
+    encoded_params[key] = URI.encode_www_form_component(value.to_s)
+  end
+
+  encoded_params
+end
+
+# Adds isGatewayServiceRequired flag to each feature in the settings based on pre-segmentation.
+# @param settings [SettingsModel] The settings file to modify.
+def add_is_gateway_service_required_flag(settings)
+  pattern = /
+    (?!custom_variable\s*:\s*{\s*"name"\s*:\s*")   # Prevent matching inside custom_variable
+    \b(country|region|city|os|device|device_type|browser_string|ua)\b
+    |
+    "custom_variable"\s*:\s*{\s*"name"\s*:\s*"inlist\([^)]*\)"
+  /x
+
+  settings.get_features.each do |feature|
+    feature.get_rules_linked_campaign.each do |rule|
+      segments = {}
+
+      if [CampaignTypeEnum::PERSONALIZE, CampaignTypeEnum::ROLLOUT].include?(rule.get_type)
+        segments = rule.get_variations[0].get_segments
+      else
+        segments = rule.get_segments
+      end
+
+      next unless segments
+
+      json_segments = segments.to_json
+      matches = json_segments.scan(pattern)
+
+      if matches.any?
+        feature.set_is_gateway_service_required(true)
+        break
+      end
+    end
+  end
+end

data/lib/vwo/utils/impression_util.rb

@@ -0,0 +1,49 @@
+# 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 '../models/settings/settings_model'
+require_relative './network_util'
+require_relative '../models/user/context_model'
+require_relative '../enums/event_enum'
+
+# Creates and sends an impression for a variation shown event.
+# This function constructs the necessary properties and payload for the event
+# and uses the NetworkUtil to send a POST API request.
+#
+# @param settings [SettingsModel] The settings model containing configuration.
+# @param campaign_id [Integer] The ID of the campaign.
+# @param variation_id [Integer] The ID of the variation shown to the user.
+# @param context [ContextModel] The user context model containing user-specific data.
+def create_and_send_impression_for_variation_shown(settings, campaign_id, variation_id, context)
+  # Get base properties for the event
+  properties = NetworkUtil.get_events_base_properties(
+    settings,
+    EventEnum::VWO_VARIATION_SHOWN,
+    URI.encode_www_form_component(context.get_user_agent), # Encode user agent for URL safety
+    context.get_ip_address
+  )
+
+  # Construct payload data for tracking the user
+  payload = NetworkUtil.get_track_user_payload_data(
+    settings,
+    context.get_id,
+    EventEnum::VWO_VARIATION_SHOWN,
+    campaign_id,
+    variation_id,
+    context.get_user_agent,
+    context.get_ip_address
+  )
+
+  NetworkUtil.send_post_api_request(properties, payload)
+end

data/lib/vwo/utils/log_message_util.rb

@@ -0,0 +1,42 @@
+# 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.
+
+# Constructs a message by replacing placeholders in a template with corresponding values from a data hash.
+#
+# @param template [String] The message template containing placeholders in the format `{key}`.
+# @param data [Hash] An object containing keys and values used to replace the placeholders in the template.
+# @return [String] The constructed message with all placeholders replaced by their corresponding values from the data hash.
+def build_message(template, data = {})
+    begin
+      template.gsub(/\{([0-9a-zA-Z_]+)\}/) do |match|
+        key = match.tr('{}', '') # Extract the key from `{key}`
+        
+        # Check for escaped placeholders like `{{key}}`
+        if template[template.index(match) - 1] == '{' && template[template.index(match) + match.length] == '}'
+          key
+        else
+          value = data[key.to_sym] || data[key] # Support both string and symbol keys
+  
+          # Return empty string if key is missing
+          next '' if value.nil?
+  
+          # If value is a callable (Proc/Lambda), execute it
+          value.respond_to?(:call) ? value.call : value
+        end
+      end
+    rescue StandardError
+      template # Return the original template in case of an error
+    end
+  end
+