vwo-fme-ruby-sdk 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 070ef4b08bf92bddf7d91a7a520a570651ed5c79c2d792a73021889803589f46
-  data.tar.gz: 5a6bb42880b3d4e73da654d33c78e05566bd487c15205918bef6020447793454
+  metadata.gz: aba596eb41128d18fecdbac11316dfe345d0fdcd2b8c1a0a612b1145bde5b779
+  data.tar.gz: 0ca14ec46f853f5cd86171ee4a0a7c93fb57f009872f847e2777fc3375e01cd6
 SHA512:
-  metadata.gz: 5f48860c62dd6c81743ee2647fe7144ba503bff54fc68f4ddb8619bde4ff698b13ba46db401f1ea40abffd30b4909b8ca0a42af628b9b2b71670eef15f54b215
-  data.tar.gz: dd3eaf38a66d744dd3e9f0b553e707610ae1b130980b1359eca5b9ae9ee70f063cfe4dd3a1c43a397676d52a2289e3770638ab1b076cdfc769b5bc72f5bb3f63
+  metadata.gz: 398d9be0a02c8b364712eb1b1ef38061138ecfcd71a8ec4f8ec5a6ad5d7ef1b0a6ee678f8ed1cb057bc6db337baf885cd3852c0ad935d480d5cd705ab7e2768c
+  data.tar.gz: ae7f284247ccc40c0c881dcd7ab23665989b71f3252931e755417a428cc606cf5e7af091cac9a28f20d274c5a782afab095633635ced57a23879b965579d56a6

data/lib/vwo/constants/constants.rb

@@ -17,7 +17,7 @@
 # Define the Constants module
 module Constants
   SDK_NAME = 'vwo-fme-ruby-sdk'.freeze
-  SDK_VERSION = '1.5.0'.freeze
+  SDK_VERSION = '1.6.0'.freeze
 
   MAX_TRAFFIC_PERCENT = 100
   MAX_TRAFFIC_VALUE = 10_000

data/lib/vwo/models/user/context_model.rb

@@ -15,14 +15,15 @@
 require_relative './context_vwo_model'
 
 class ContextModel
-  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :vwo
+  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :post_segmentation_variables, :vwo
 
-  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, vwo = nil)
+  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, post_segmentation_variables = {}, vwo = nil)
     @id = id
     @user_agent = user_agent
     @ip_address = ip_address
     @custom_variables = custom_variables || {}
     @variation_targeting_variables = variation_targeting_variables || {}
+    @post_segmentation_variables = post_segmentation_variables || {}
     @vwo = vwo
   end
 
@@ -45,6 +46,7 @@ class ContextModel
     @ip_address = context[:ipAddress]
     @custom_variables = context[:customVariables] if context.key?(:customVariables)
     @variation_targeting_variables = context[:variationTargetingVariables] if context.key?(:variationTargetingVariables)
+    @post_segmentation_variables = context[:postSegmentationVariables] if context.key?(:postSegmentationVariables)
     @vwo = ContextVWOModel.new.model_from_dictionary(context[:_vwo]) if context.key?(:_vwo)
 
     self
@@ -90,6 +92,14 @@ class ContextModel
     @variation_targeting_variables = variation_targeting_variables
   end
 
+  def get_post_segmentation_variables
+    @post_segmentation_variables
+  end
+
+  def set_post_segmentation_variables(post_segmentation_variables)
+    @post_segmentation_variables = post_segmentation_variables
+  end
+
   def get_vwo
     @vwo
   end

data/lib/vwo/packages/segmentation_evaluator/enums/segment_operand_regex_enum.rb

@@ -21,9 +21,9 @@ module SegmentOperandRegexEnum
     REGEX_MATCH = '^regex\\((.*)\\)'
     STARTING_STAR = '^\\*'
     ENDING_STAR = '\\*$'
-    GREATER_THAN_MATCH = '^gt\\((\\d+\\.?\\d*|\\.\\d+)\\)'
-    GREATER_THAN_EQUAL_TO_MATCH = '^gte\\((\\d+\\.?\\d*|\\.\\d+)\\)'
-    LESS_THAN_MATCH = '^lt\\((\\d+\\.?\\d*|\\.\\d+)\\)'
-    LESS_THAN_EQUAL_TO_MATCH = '^lte\\((\\d+\\.?\\d*|\\.\\d+)\\)'
+    GREATER_THAN_MATCH = '^gt\\((\\d+(?:\\.\\d+)*|\\.\\d+)\\)'
+    GREATER_THAN_EQUAL_TO_MATCH = '^gte\\((\\d+(?:\\.\\d+)*|\\.\\d+)\\)'
+    LESS_THAN_MATCH = '^lt\\((\\d+(?:\\.\\d+)*|\\.\\d+)\\)'
+    LESS_THAN_EQUAL_TO_MATCH = '^lte\\((\\d+(?:\\.\\d+)*|\\.\\d+)\\)'
   end
   

data/lib/vwo/packages/segmentation_evaluator/enums/segment_operator_value_enum.rb

@@ -27,4 +27,7 @@ module SegmentOperatorValueEnum
     BROWSER_AGENT = 'browser_string'
     UA = 'ua'
     FEATURE_ID = 'featureId'
+    IP = 'ip_address'
+    BROWSER_VERSION = 'browser_version'
+    OS_VERSION = 'os_version'
   end

data/lib/vwo/packages/segmentation_evaluator/evaluators/segment_evaluator.rb

@@ -57,6 +57,12 @@ class SegmentEvaluator
       SegmentOperandEvaluator.new.evaluate_user_dsl(sub_dsl, properties)
     when SegmentOperatorValueEnum::UA
       SegmentOperandEvaluator.new.evaluate_user_agent_dsl(sub_dsl, @context)
+    when SegmentOperatorValueEnum::IP
+      SegmentOperandEvaluator.new.evaluate_string_operand_dsl(sub_dsl, @context, SegmentOperatorValueEnum::IP)
+    when SegmentOperatorValueEnum::BROWSER_VERSION
+      SegmentOperandEvaluator.new.evaluate_string_operand_dsl(sub_dsl, @context, SegmentOperatorValueEnum::BROWSER_VERSION)
+    when SegmentOperatorValueEnum::OS_VERSION
+      SegmentOperandEvaluator.new.evaluate_string_operand_dsl(sub_dsl, @context, SegmentOperatorValueEnum::OS_VERSION)
     else
       false
     end

data/lib/vwo/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.rb

@@ -15,15 +15,22 @@
 require_relative '../utils/segment_util'
 require_relative '../enums/segment_operand_value_enum'
 require_relative '../enums/segment_operand_regex_enum'
+require_relative '../enums/segment_operator_value_enum'
 require_relative '../../../utils/data_type_util'
 require_relative '../../../utils/gateway_service_util'
 require_relative '../../../enums/url_enum'
 require_relative '../../../services/logger_service'
 require_relative '../../../models/user/context_model'
 require_relative '../../../enums/log_level_enum'
+
+# SegmentOperandEvaluator class provides methods to evaluate different types of DSL (Domain Specific Language)
+# expressions based on the segment conditions defined for custom variables, user IDs, and user agents.
 class SegmentOperandEvaluator
+  # Regex pattern to check if a string contains non-numeric characters (except decimal point)
+  NON_NUMERIC_PATTERN = /[^0-9.]/
+
   # Evaluates the custom variable DSL
-  # @param dsl_operand_value [String] The operand value to evaluate
+  # @param dsl_operand_value [Hash] The operand value to evaluate
   # @param properties [Hash] The properties to evaluate the operand against
   # @return [Boolean] True if the operand value matches the tag value, false otherwise
   def evaluate_custom_variable_dsl(dsl_operand_value, properties)
@@ -42,10 +49,11 @@ class SegmentOperandEvaluator
         return false
       end
 
-      tag_value = pre_process_tag_value(properties[operand_key])
+      tag_value = properties[operand_key]
+      attribute_value = pre_process_tag_value(tag_value)
       list_id = match[1]
 
-      query_params_obj = { attribute: tag_value, listId: list_id }
+      query_params_obj = { attribute: attribute_value, listId: list_id }
 
       begin
         res = get_from_gateway_service(query_params_obj, UrlEnum::ATTRIBUTE_CHECK)
@@ -60,9 +68,12 @@ class SegmentOperandEvaluator
 
       false
     else
-      tag_value = pre_process_tag_value(properties[operand_key])
-      processed_values = process_values(*pre_process_operand_value(operand), tag_value)
-      extract_result(processed_values[:operand_type], processed_values[:operand_value], processed_values[:tag_value])
+      tag_value = properties[operand_key]
+      tag_value = pre_process_tag_value(tag_value)
+      processed_operand = pre_process_operand_value(operand)
+      processed_values = process_values(processed_operand[:operand_value], tag_value)
+      tag_value = processed_values[:tag_value]
+      extract_result(processed_operand[:operand_type], processed_values[:operand_value], tag_value)
     end
   end
 
@@ -80,21 +91,144 @@ class SegmentOperandEvaluator
   # @param context [ContextModel] The context to evaluate the operand against
   # @return [Boolean] True if the operand value matches the tag value, false otherwise
   def evaluate_user_agent_dsl(dsl_operand_value, context)
-    return false unless context.get_user_agent
+    operand = dsl_operand_value
+    unless context.get_user_agent
+      LoggerService.log(LogLevelEnum::INFO, 'To Evaluate UserAgent segmentation, please provide userAgent in context', nil)
+      return false
+    end
 
     tag_value = CGI.unescape(context.get_user_agent)
-    processed_values = process_values(*pre_process_operand_value(dsl_operand_value), tag_value)
-    extract_result(processed_values[:operand_type], processed_values[:operand_value], processed_values[:tag_value])
+    processed_operand = pre_process_operand_value(operand)
+    processed_values = process_values(processed_operand[:operand_value], tag_value)
+    tag_value = processed_values[:tag_value]
+    extract_result(processed_operand[:operand_type], processed_values[:operand_value], tag_value)
   end
 
-  # Pre-processes the tag value
-  # @param tag_value [String] The tag value to pre-process
-  # @return [String] The pre-processed tag value
-  def pre_process_tag_value(tag_value)
-    return '' if tag_value.nil?
-    return tag_value if [true, false].include?(tag_value)
+  # Evaluates a given string tag value against a DSL operand value.
+  # @param dsl_operand_value [String] The DSL operand string (e.g., "contains(\"value\")").
+  # @param context [ContextModel] The context object containing the value to evaluate.
+  # @param operand_type [String] The type of operand being evaluated (ip_address, browser_version, os_version).
+  # @return [Boolean] True if tag value matches DSL operand criteria, false otherwise.
+  def evaluate_string_operand_dsl(dsl_operand_value, context, operand_type)
+    operand = dsl_operand_value.to_s
+
+    # Determine the tag value based on operand type
+    tag_value = get_tag_value_for_operand_type(context, operand_type)
+
+    if tag_value.nil?
+      log_missing_context_error(operand_type)
+      return false
+    end
+
+    operand_type_and_value = pre_process_operand_value(operand)
+    processed_values = process_values(operand_type_and_value[:operand_value], tag_value, operand_type)
+    processed_tag_value = processed_values[:tag_value]
+
+    extract_result(
+      operand_type_and_value[:operand_type],
+      processed_values[:operand_value].to_s.strip.gsub(/"/, ''),
+      processed_tag_value
+    )
+  end
+
+  # Evaluates IP address DSL expression.
+  # @param dsl_operand_value [String] The DSL expression for the IP address.
+  # @param context [ContextModel] The context object containing the IP address.
+  # @return [Boolean] True if the IP address matches the DSL condition, otherwise false.
+  def evaluate_ip_dsl(dsl_operand_value, context)
+    evaluate_string_operand_dsl(dsl_operand_value, context, SegmentOperatorValueEnum::IP)
+  end
+
+  # Evaluates browser version DSL expression.
+  # @param dsl_operand_value [String] The DSL expression for the browser version.
+  # @param context [ContextModel] The context object containing the user agent info.
+  # @return [Boolean] True if the browser version matches the DSL condition, otherwise false.
+  def evaluate_browser_version_dsl(dsl_operand_value, context)
+    evaluate_string_operand_dsl(dsl_operand_value, context, SegmentOperatorValueEnum::BROWSER_VERSION)
+  end
+
+  # Evaluates OS version DSL expression.
+  # @param dsl_operand_value [String] The DSL expression for the OS version.
+  # @param context [ContextModel] The context object containing the user agent info.
+  # @return [Boolean] True if the OS version matches the DSL condition, otherwise false.
+  def evaluate_os_version_dsl(dsl_operand_value, context)
+    evaluate_string_operand_dsl(dsl_operand_value, context, SegmentOperatorValueEnum::OS_VERSION)
+  end
+
+  # Gets the appropriate tag value based on the operand type.
+  # @param context [ContextModel] The context object.
+  # @param operand_type [String] The type of operand.
+  # @return [String, nil] The tag value or nil if not available.
+  def get_tag_value_for_operand_type(context, operand_type)
+    case operand_type
+    when SegmentOperatorValueEnum::IP
+      context.get_ip_address
+    when SegmentOperatorValueEnum::BROWSER_VERSION
+      get_browser_version_from_context(context)
+    else
+      # Default works for OS version
+      get_os_version_from_context(context)
+    end
+  end
+
+  # Gets browser version from context.
+  # @param context [ContextModel] The context object.
+  # @return [String, nil] The browser version or nil if not available.
+  def get_browser_version_from_context(context)
+    user_agent = context.get_vwo&.get_ua_info
+    return nil unless user_agent && user_agent.is_a?(Hash) && !user_agent.empty?
+
+    # Assuming UserAgent dictionary contains browser_version
+    if user_agent.key?('browser_version')
+      return user_agent['browser_version']&.to_s
+    end
+    nil
+  end
+
+  # Gets OS version from context.
+  # @param context [ContextModel] The context object.
+  # @return [String, nil] The OS version or nil if not available.
+  def get_os_version_from_context(context)
+    user_agent = context.get_vwo&.get_ua_info
+    return nil unless user_agent && user_agent.is_a?(Hash) && !user_agent.empty?
+
+    # Assuming UserAgent dictionary contains os_version
+    if user_agent.key?('os_version')
+      return user_agent['os_version']&.to_s
+    end
+    nil
+  end
+
+  # Logs appropriate error message for missing context.
+  # @param operand_type [String] The type of operand.
+  def log_missing_context_error(operand_type)
+    case operand_type
+    when SegmentOperatorValueEnum::IP
+      LoggerService.log(LogLevelEnum::INFO, 'To evaluate IP segmentation, please provide ipAddress in context', nil)
+    when SegmentOperatorValueEnum::BROWSER_VERSION
+      LoggerService.log(LogLevelEnum::INFO, 'To evaluate browser version segmentation, please provide userAgent in context', nil)
+    else
+      LoggerService.log(LogLevelEnum::INFO, 'To evaluate OS version segmentation, please provide userAgent in context', nil)
+    end
+  end
 
-    tag_value.to_s
+  # Pre-processes the tag value to ensure it is in the correct format for evaluation.
+  # @param tag_value [Any] The value to be processed.
+  # @return [String, Boolean] The processed tag value, either as a string or a boolean.
+  def pre_process_tag_value(tag_value)
+    # Default to empty string if undefined
+    if tag_value.nil?
+      tag_value = ''
+    end
+    # Convert boolean values to boolean type
+    if DataTypeUtil.is_boolean(tag_value)
+      tag_value = tag_value ? true : false
+    end
+    # Convert all non-null values to string
+    unless tag_value.nil?
+      tag_value = tag_value.to_s
+    end
+    tag_value
   end
 
   # Pre-processes the operand value
@@ -106,16 +240,23 @@ class SegmentOperandEvaluator
       { operand_type: SegmentOperandValueEnum::LOWER_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::LOWER_MATCH) }
     when /#{SegmentOperandRegexEnum::WILDCARD_MATCH}/
       value = extract_operand_value(operand, SegmentOperandRegexEnum::WILDCARD_MATCH)
-      if value.match?(SegmentOperandRegexEnum::STARTING_STAR) && value.match?(SegmentOperandRegexEnum::ENDING_STAR)
+      starting_star = match_with_regex(value, SegmentOperandRegexEnum::STARTING_STAR)
+      ending_star = match_with_regex(value, SegmentOperandRegexEnum::ENDING_STAR)
+      
+      # Determine specific wildcard type
+      if starting_star && ending_star
         type = SegmentOperandValueEnum::STARTING_ENDING_STAR_VALUE
-        value = value.gsub(/^\*|\*$/, '')
-      elsif value.match?(SegmentOperandRegexEnum::STARTING_STAR)
+      elsif starting_star
         type = SegmentOperandValueEnum::STARTING_STAR_VALUE
-        value = value.gsub(/^\*/, '')
-      elsif value.match?(SegmentOperandRegexEnum::ENDING_STAR)
+      elsif ending_star
         type = SegmentOperandValueEnum::ENDING_STAR_VALUE
-        value = value.gsub(/\*$/, '')
       end
+      
+      # Remove wildcard characters from the operand value
+      value = value
+        .gsub(Regexp.new(SegmentOperandRegexEnum::STARTING_STAR), '')
+        .gsub(Regexp.new(SegmentOperandRegexEnum::ENDING_STAR), '')
+      
       { operand_type: type, operand_value: value }
     when /#{SegmentOperandRegexEnum::REGEX_MATCH}/
       { operand_type: SegmentOperandValueEnum::REGEX_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::REGEX_MATCH) }
@@ -137,29 +278,54 @@ class SegmentOperandEvaluator
   # @param regex [String] The regex to match the operand against
   # @return [String] The extracted operand value
   def extract_operand_value(operand, regex)
-    match = operand.match(/#{regex}/)
-    match ? match[1] : ''
+    match_result = match_with_regex(operand, regex)
+    match_result && match_result[1] ? match_result[1] : ''
   end
 
-  # Processes the values from the operand and tag value
-  # @param operand_type [Symbol] The type of operand
-  # @param operand_value [String] The value of the operand
-  # @param tag_value [String] The value of the tag
-  # @return [Hash] The processed operand value and tag value
-  def process_values(operand_type, operand_value, tag_value)
-    # Extract values from arrays if needed
-    operand_type = operand_type[1] if operand_type.is_a?(Array)
-    operand_value = operand_value[1] if operand_value.is_a?(Array)
-    tag_value = tag_value[1] if tag_value.is_a?(Array)
+  # Processes numeric values from operand and tag values, converting them to strings.
+  # @param operand_value [Any] The operand value to process.
+  # @param tag_value [Any] The tag value to process.
+  # @param operand_type [String] The type of operand being evaluated (optional).
+  # @return [Hash] An object containing the processed operand and tag values as strings.
+  def process_values(operand_value, tag_value, operand_type = nil)
+    if [SegmentOperatorValueEnum::IP, SegmentOperatorValueEnum::BROWSER_VERSION, SegmentOperatorValueEnum::OS_VERSION].include?(operand_type)
+      return {
+        operand_value: operand_value,
+        tag_value: tag_value
+      }
+    end
+
+    # Convert operand and tag values to floats
+    if NON_NUMERIC_PATTERN.match?(tag_value.to_s)
+      return {
+        operand_value: operand_value,
+        tag_value: tag_value
+      }
+    end
 
     processed_operand_value = operand_value.to_f
     processed_tag_value = tag_value.to_f
 
-    if processed_operand_value == 0 || processed_tag_value == 0
-      return { operand_type: operand_type, operand_value: operand_value, tag_value: tag_value }
+    # Return original values if conversion fails
+    if processed_operand_value == 0 && operand_value.to_s != '0' && operand_value.to_s != '0.0'
+      return {
+        operand_value: operand_value,
+        tag_value: tag_value
+      }
+    end
+
+    if processed_tag_value == 0 && tag_value.to_s != '0' && tag_value.to_s != '0.0'
+      return {
+        operand_value: operand_value,
+        tag_value: tag_value
+      }
     end
 
-    { operand_type: operand_type, operand_value: processed_operand_value.to_s, tag_value: processed_tag_value.to_s }
+    # Convert numeric values back to strings
+    {
+      operand_value: processed_operand_value.to_s,
+      tag_value: processed_tag_value.to_s
+    }
   end
 
   # Extracts the result from the operand value and tag value
@@ -168,31 +334,81 @@ class SegmentOperandEvaluator
   # @param tag_value [String] The value of the tag
   # @return [Boolean] True if the operand value matches the tag value, false otherwise
   def extract_result(operand_type, operand_value, tag_value)
+    result = false
+
+    return false if tag_value.nil?
+
+    # Ensure operand_value and tag_value are strings
+    operand_value_str = operand_value.to_s
+    tag_value_str = tag_value.to_s
+
     case operand_type
     when SegmentOperandValueEnum::LOWER_VALUE
-      operand_value.downcase == tag_value.downcase
+      result = operand_value_str.downcase == tag_value_str.downcase
     when SegmentOperandValueEnum::STARTING_ENDING_STAR_VALUE
-      tag_value.include?(operand_value)
+      result = tag_value_str.include?(operand_value_str)
     when SegmentOperandValueEnum::STARTING_STAR_VALUE
-      tag_value.end_with?(operand_value)
+      result = tag_value_str.end_with?(operand_value_str)
     when SegmentOperandValueEnum::ENDING_STAR_VALUE
-      tag_value.start_with?(operand_value)
+      result = tag_value_str.start_with?(operand_value_str)
     when SegmentOperandValueEnum::REGEX_VALUE
       begin
-        !!Regexp.new(operand_value).match?(tag_value)
+        pattern = Regexp.new(operand_value_str)
+        result = pattern.match?(tag_value_str)
       rescue StandardError
-        false
+        result = false
       end
     when SegmentOperandValueEnum::GREATER_THAN_VALUE
-      operand_value.to_f < tag_value.to_f
-    when SegmentOperandValueEnum::LESS_THAN_VALUE
-      operand_value.to_f > tag_value.to_f
+      result = compare_versions(tag_value_str, operand_value_str) > 0
     when SegmentOperandValueEnum::GREATER_THAN_EQUAL_TO_VALUE
-      operand_value.to_f <= tag_value.to_f
+      result = compare_versions(tag_value_str, operand_value_str) >= 0
+    when SegmentOperandValueEnum::LESS_THAN_VALUE
+      result = compare_versions(tag_value_str, operand_value_str) < 0
     when SegmentOperandValueEnum::LESS_THAN_EQUAL_TO_VALUE
-      operand_value.to_f >= tag_value.to_f
+      result = compare_versions(tag_value_str, operand_value_str) <= 0
     else
-      tag_value == operand_value
+      # For version-like strings, use version comparison; otherwise use string comparison
+      if version_string?(tag_value_str) && version_string?(operand_value_str)
+        result = compare_versions(tag_value_str, operand_value_str) == 0
+      else
+        result = tag_value_str == operand_value_str
+      end
+    end
+
+    result
+  end
+
+  # Checks if a string appears to be a version string (contains only digits and dots).
+  # @param str [String] The string to check.
+  # @return [Boolean] True if the string appears to be a version string.
+  def version_string?(str)
+    /^(\d+\.)*\d+$/.match?(str)
+  end
+
+  # Compares two version strings using semantic versioning rules.
+  # Supports formats like "1.2.3", "1.0", "2.1.4.5", etc.
+  # @param version1 [String] First version string.
+  # @param version2 [String] Second version string.
+  # @return [Integer] -1 if version1 < version2, 0 if equal, 1 if version1 > version2.
+  def compare_versions(version1, version2)
+    # Split versions by dots and convert to integers
+    parts1 = version1.split('.').map { |part| part.match?(/^\d+$/) ? part.to_i : 0 }
+    parts2 = version2.split('.').map { |part| part.match?(/^\d+$/) ? part.to_i : 0 }
+
+    # Find the maximum length to handle different version formats
+    max_length = [parts1.length, parts2.length].max
+
+    (0...max_length).each do |i|
+      part1 = i < parts1.length ? parts1[i] : 0
+      part2 = i < parts2.length ? parts2[i] : 0
+
+      if part1 < part2
+        return -1
+      elsif part1 > part2
+        return 1
+      end
     end
+
+    0 # Versions are equal
   end
 end

data/lib/vwo/utils/gateway_service_util.rb

@@ -72,7 +72,7 @@ end
 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
+    \b(country|region|city|os|device|device_type|browser_string|ua|browser_version|os_version)\b
     |
     "custom_variable"\s*:\s*{\s*"name"\s*:\s*"inlist\([^)]*\)"
   /x

data/lib/vwo/utils/impression_util.rb

@@ -35,12 +35,10 @@ def create_and_send_impression_for_variation_shown(settings, campaign_id, variat
 
   # Construct payload data for tracking the user
   payload = NetworkUtil.get_track_user_payload_data(
-    context.get_id,
     EventEnum::VWO_VARIATION_SHOWN,
     campaign_id,
     variation_id,
-    context.get_user_agent,
-    context.get_ip_address
+    context
   )
 
   # check if batching is enabled

data/lib/vwo/utils/network_util.rb

@@ -24,6 +24,7 @@ require_relative '../packages/network_layer/models/response_model'
 require_relative '../utils/url_util'
 require_relative '../utils/uuid_util'
 require_relative '../utils/usage_stats_util'
+require_relative '../models/user/context_model'
 
 class NetworkUtil
   class << self
@@ -146,8 +147,15 @@ class NetworkUtil
     end
 
     # Builds track-user payload data
-    def get_track_user_payload_data(user_id, event_name, campaign_id, variation_id, visitor_user_agent = '', ip_address = '')
+    def get_track_user_payload_data(event_name, campaign_id, variation_id, context)
+        user_id = context.get_id
+        visitor_user_agent = context.get_user_agent
+        ip_address = context.get_ip_address
+        custom_variables = context.get_custom_variables
+        post_segmentation_variables = context.get_post_segmentation_variables
+
         properties = _get_event_base_payload(user_id, event_name, visitor_user_agent, ip_address)
+
         properties[:d][:event][:props][:id] = campaign_id
         properties[:d][:event][:props][:variation] = variation_id
         properties[:d][:event][:props][:isFirst] = 1
@@ -156,6 +164,22 @@ class NetworkUtil
         properties[:d][:visitor_ua] = visitor_user_agent if visitor_user_agent && !visitor_user_agent.empty?
         properties[:d][:visitor_ip] = ip_address if ip_address && !ip_address.empty?
 
+        # Add post-segmentation variables if they exist in custom variables
+        if post_segmentation_variables&.any? && custom_variables&.any?
+            post_segmentation_variables.each do |key|
+                # Try to get value using string key first, then symbol key
+                value = custom_variables[key] || custom_variables[key.to_sym]
+                if value
+                    properties[:d][:visitor][:props][key] = value
+                end
+            end
+        end
+
+        # Add IP address as a standard attribute if available
+        if ip_address && !ip_address.empty?
+          properties[:d][:visitor][:props][:ip] = ip_address
+        end
+
         LoggerService.log(LogLevelEnum::DEBUG, "IMPRESSION_FOR_TRACK_USER", {
             accountId: SettingsService.instance.account_id,
             userId: user_id,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vwo-fme-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - VWO
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-29 00:00:00.000000000 Z
+date: 2025-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools