vwo-fme-ruby-sdk 1.4.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314b352ba0d4578530e72be01599eee2846ed17f080adf40ddaadfe404d1a849
-  data.tar.gz: 54f0126d7666337219026a5c47c046a9516c60ffa658ae8e3d45f379258dc946
+  metadata.gz: aba596eb41128d18fecdbac11316dfe345d0fdcd2b8c1a0a612b1145bde5b779
+  data.tar.gz: 0ca14ec46f853f5cd86171ee4a0a7c93fb57f009872f847e2777fc3375e01cd6
 SHA512:
-  metadata.gz: 7dcceb86720c7f1d8c763d0974beb710cca033724bf76f35a884b80f3c7bb12b3adea108b04fdccdc85f297e585ee9813bf64ce9a854313e15ee775f34d20780
-  data.tar.gz: 21c80bd1c369b7344c93d3e72858fa4a47d4ad2199b9df63bf8c95371e92f39adcbd82012903ab26c7e09e1873e285d201229d040c0781fb1071f213ff4c2f9d
+  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.4.1'.freeze
+  SDK_VERSION = '1.6.0'.freeze
 
   MAX_TRAFFIC_PERCENT = 100
   MAX_TRAFFIC_VALUE = 10_000

data/lib/vwo/enums/event_enum.rb

@@ -15,6 +15,7 @@
 # Event types
 module EventEnum
     VWO_VARIATION_SHOWN = 'vwo_variationShown'
-    VWO_SYNC_VISITOR_PROP = 'vwo_syncVisitorProp',
+    VWO_SYNC_VISITOR_PROP = 'vwo_syncVisitorProp'
     VWO_INIT_CALLED = 'vwo_fmeSdkInit'
-  end
+    VWO_USAGE_STATS = 'vwo_sdkUsageStats'
+end

data/lib/vwo/models/schemas/settings_schema_validation.rb

@@ -84,6 +84,7 @@ class SettingsSchema
       optional(:sdkKey).maybe(:string)
       required(:version).filled(:integer)
       required(:accountId).filled(:integer)
+      optional(:usageStatsAccountId).maybe(:integer)
       optional(:features).array(:hash)
       required(:campaigns).array(:hash)
       optional(:groups).maybe(:hash)

data/lib/vwo/models/settings/settings_model.rb

@@ -17,12 +17,13 @@ require_relative '../campaign/feature_model'
 require_relative '../../constants/constants'
 
 class SettingsModel
-  attr_reader :sdk_key, :account_id, :version, :collection_prefix,
+  attr_reader :sdk_key, :account_id, :usage_stats_account_id, :version, :collection_prefix,
               :features, :campaigns, :campaign_groups, :groups, :poll_interval
 
   def initialize(settings)
     @sdk_key = settings["sdkKey"]
     @account_id = settings["accountId"]
+    @usage_stats_account_id = settings["usageStatsAccountId"]
     @version = settings["version"]
     @collection_prefix = settings["collectionPrefix"]
     @poll_interval = settings["pollInterval"] || Constants::POLLING_INTERVAL
@@ -59,6 +60,10 @@ class SettingsModel
     @account_id
   end
 
+  def get_usage_stats_account_id
+    @usage_stats_account_id
+  end
+
   def get_version
     @version
   end

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/event_util.rb

@@ -33,4 +33,17 @@ def send_sdk_init_event(settings_fetch_time, sdk_init_time)
     # Send the constructed payload via POST request
     NetworkUtil.send_event(properties, payload)
   end
+end
+
+# Sends a usage stats event to VWO.
+# @param usage_stats_account_id - The account id for usage stats.
+def send_sdk_usage_stats_event(usage_stats_account_id)
+  # create query parameters
+  properties = NetworkUtil.get_events_base_properties(EventEnum::VWO_USAGE_STATS, nil, nil, true, usage_stats_account_id)
+
+  # create payload
+  payload = NetworkUtil.get_sdk_usage_stats_payload_data(EventEnum::VWO_USAGE_STATS, usage_stats_account_id)
+
+  # send event
+  NetworkUtil.send_event(properties, payload)
 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
@@ -80,52 +81,81 @@ class NetworkUtil
     end
 
     # Builds generic properties for different tracking calls
-    def get_events_base_properties(event_name, visitor_user_agent = '', ip_address = '')
-        sdk_key = SettingsService.instance.sdk_key || ''
-        {
-        en: event_name,
-        a: SettingsService.instance.account_id,
-        env: sdk_key,
-        eTime: get_current_unix_timestamp_in_millis,
-        random: get_random_number,
-        p: 'FS',
-        visitor_ua: visitor_user_agent || '',
-        visitor_ip: ip_address || '',
-        url: "#{UrlUtil.get_base_url}#{UrlEnum::EVENTS}"
+    def get_events_base_properties(event_name, visitor_user_agent = '', ip_address = '', is_usage_stats_event = false, usage_stat_account_id = '')
+        properties = {
+            en: event_name,
+            a: SettingsService.instance.account_id,
+            eTime: get_current_unix_timestamp_in_millis,
+            random: get_random_number,
+            p: 'FS',
+            visitor_ua: visitor_user_agent || '',
+            visitor_ip: ip_address || '',
+            url: "#{UrlUtil.get_base_url}#{UrlEnum::EVENTS}"
         }
+
+        if !is_usage_stats_event
+            # set env key for standard sdk events
+            properties[:env] = SettingsService.instance.sdk_key
+        else
+            # set env key for usage stats events
+            properties[:a] = usage_stat_account_id
+        end
+
+        properties
     end
 
     # Builds base payload for tracking events
-    def _get_event_base_payload(user_id, event_name, visitor_user_agent = '', ip_address = '')
-        uuid = UUIDUtil.get_uuid(user_id.to_s, SettingsService.instance.account_id)
+    def _get_event_base_payload(user_id, event_name, visitor_user_agent = '', ip_address = '', is_usage_stats_event = false, usage_stat_account_id = '')
+        account_id = SettingsService.instance.account_id
+
+        if is_usage_stats_event
+            account_id = usage_stat_account_id
+        end
+
+        uuid = UUIDUtil.get_uuid(user_id.to_s, account_id.to_s)
         sdk_key = SettingsService.instance.sdk_key
 
-        {
-        d: {
-            msgId: "#{uuid}-#{get_current_unix_timestamp_in_millis}",
-            visId: uuid,
-            sessionId: get_current_unix_timestamp,
-            event: {
-            props: {
-                vwo_sdkName: Constants::SDK_NAME,
-                vwo_sdkVersion: Constants::SDK_VERSION,
-                vwo_envKey: sdk_key
-            },
-            name: event_name,
-            time: get_current_unix_timestamp_in_millis
-            },
-            visitor: {
-            props: {
-                vwo_fs_environment: sdk_key
-            }
+        payload = {
+            d: {
+                msgId: "#{uuid}-#{get_current_unix_timestamp_in_millis}",
+                visId: uuid,
+                sessionId: get_current_unix_timestamp,
+                event: {
+                    props: {
+                        vwo_sdkName: Constants::SDK_NAME,
+                        vwo_sdkVersion: Constants::SDK_VERSION,
+                    },
+                    name: event_name,
+                    time: get_current_unix_timestamp_in_millis
+                }
             }
         }
-        }
+
+        if !is_usage_stats_event
+            # set env key for standard sdk events
+            payload[:d][:event][:props][:vwo_envKey] = sdk_key
+
+            # set visitor props for standard sdk events
+            payload[:d][:visitor] = {
+                props: {
+                    vwo_fs_environment: sdk_key
+                }
+            }
+        end
+
+        payload
     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
@@ -134,10 +164,20 @@ 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?
 
-        # check if usage stats size is greater than 0
-        usage_stats = UsageStatsUtil.get_usage_stats
-        if usage_stats.size > 0
-            properties[:d][:event][:props][:vwoMeta] = usage_stats
+        # 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", {
@@ -207,6 +247,18 @@ class NetworkUtil
         properties
     end
 
+    # Constructs the payload for usage stats called event.
+    # @param event_name - The name of the event.
+    # @param usage_stats_account_id - The account id for usage stats.
+    # @returns The constructed payload with required fields.
+    def get_sdk_usage_stats_payload_data(event_name, usage_stats_account_id)
+        user_id = SettingsService.instance.account_id.to_s + "_" + SettingsService.instance.sdk_key
+        properties = _get_event_base_payload(user_id, event_name, nil, nil, true, usage_stats_account_id)
+        properties[:d][:event][:props][:product] = Constants::PRODUCT_NAME
+        properties[:d][:event][:props][:vwoMeta] = UsageStatsUtil.get_usage_stats
+        properties
+    end
+
     # Sends a POST API request with given properties and payload
     def send_post_api_request(properties, payload)
         network_instance = NetworkManager.instance
@@ -229,16 +281,10 @@ class NetworkUtil
             if network_instance.get_client.get_should_use_threading
                 network_instance.get_client.get_thread_pool.post {
                     response = network_instance.post(request)
-                    if response.get_status_code == 200
-                        UsageStatsUtil.clear_usage_stats
-                    end
                     response
                 }
             else
                 response = network_instance.post(request)
-                if response.get_status_code == 200
-                    UsageStatsUtil.clear_usage_stats
-                end
                 response
             end
         rescue ResponseModel => err
@@ -259,15 +305,20 @@ class NetworkUtil
         headers[HeadersEnum::USER_AGENT] = payload[:d][:visitor_ua] if payload[:d][:visitor_ua]
         headers[HeadersEnum::IP] = payload[:d][:visitor_ip] if payload[:d][:visitor_ip]
 
+        url = Constants::HOST_NAME
+        if UrlUtil.get_collection_prefix && !UrlUtil.get_collection_prefix.empty?
+            url = "#{url}/#{UrlUtil.get_collection_prefix}"
+        end
+
         request = RequestModel.new(
-            UrlUtil.get_base_url,
+            url,
             HttpMethodEnum::POST,
             UrlEnum::EVENTS,
             properties,
             payload,
             headers,
-            SettingsService.instance.protocol,
-            SettingsService.instance.port
+            Constants::HTTPS_PROTOCOL,
+            nil
         )
 
         begin

data/lib/vwo/utils/url_util.rb

@@ -42,5 +42,12 @@ class UrlUtil
 
       base_url
     end
+
+    # Retrieves the collection prefix.
+    #
+    # @return [String] The collection prefix.
+    def get_collection_prefix
+      @collection_prefix
+    end
   end
 end

data/lib/vwo/utils/usage_stats_util.rb

@@ -69,6 +69,8 @@ class UsageStatsUtil
 
     data = {}
 
+    data[:a] = SettingsService.instance.account_id
+    data[:env] = SettingsService.instance.sdk_key
     data[:ig] = 1 if integrations
     data[:eb] = 1 if event_batching
     data[:gs] = 1 if gateway_service
@@ -84,7 +86,7 @@ class UsageStatsUtil
       data[:ll] = LogLevelToNumber.to_number(logger[:level]) || -1
     end
 
-    data[:pi] = 1 if poll_interval
+    data[:pi] = poll_interval if poll_interval
 
     if vwo_meta && vwo_meta.key?(:ea)
       data[:_ea] = 1

data/lib/vwo.rb

@@ -93,6 +93,14 @@ class VWO
         # send the sdk init info to vwo server
         send_sdk_init_event(SettingsService.instance.settings_fetch_time, time_taken_for_init.to_s)
       end
+
+      # send the usage stats event to vwo server
+      # get usage stats account id from settings
+      usage_stats_account_id = @@instance.original_settings["usageStatsAccountId"]
+      if usage_stats_account_id
+        send_sdk_usage_stats_event(usage_stats_account_id)
+      end
+
       @@instance
     rescue StandardError => e
       puts "[ERROR]: VWO-SDK: Got error while initializing VWO: #{e.message}"

metadata

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