vwo-fme-ruby-sdk 1.50.0 → 1.60.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d76a694880edd0c5a2fa5b892193eef8f601c95d3d0a140c28681450196e2ee
-  data.tar.gz: 95ff81d4b0e38159a57e7d22a603d7f81df3319ad2fb43bb7395691c46b24a79
+  metadata.gz: 734b280edc8de1dad1ea2256570267ecdbf0b87a840820f5d8d1c09e7627af33
+  data.tar.gz: e5b779d4263129a46e2c862e6317b555482fc1695f6d721e6682ba310ad4881e
 SHA512:
-  metadata.gz: '051825ffb285e02b0db70c7b869dedc2508946e199cec12bcdb402d4ff9f499028df3d8f4da46e24eeb28e45dfc42f2af937130c4118a43b5fd2ccca2abf57f9'
-  data.tar.gz: 42ce7d1946c602b1c73e182677feaee8a78c3a6ccbc9ed5ba5063788e4af45d827cbdba78586a5f37e9f193ce4eb226b0769aa02784ca165b3e684a71e1df5de
+  metadata.gz: cf8f0bb234458b3055b957522a66b17688a6c8eabc323b41492a52973c48659496dbdb0ecebda043318188880c323c4676e1b103726d4229ff25ddda63a92237
+  data.tar.gz: 0f6a49ca2d7f3cdd98586a920ab37f4287b95976ac7d8b292f2070f2768b9338c54855c5eff158c0a24fbe0537b08a82323c3e2d0edc17b76b5f576f8a113df1

data/lib/resources/debug_messages.json

@@ -11,6 +11,7 @@
     "IMPRESSION_FOR_TRACK_USER": "Impression built for vwo_variationShown({brand} standard event for tracking user) event haivng Account ID:{accountId}, User ID:{userId}, and experiment ID:{campaignId}",
     "IMPRESSION_FOR_TRACK_GOAL": "Impression built for event:{eventName} event having Account ID:{accountId}, and user ID:{userId}",
     "IMPRESSION_FOR_SYNC_VISITOR_PROP": "Impression built for {eventName}({brand} internal event) event for Account ID:{accountId}, and user ID:{userId}",
+    "IMPRESSION_FOR_USAGE_TRACKING": "Impression built for vwo_feTrackUsage({brand} standard event for usage tracking call) event having Account ID:{accountId}, and user ID:{userId}",
 
     "CONFIG_BATCH_EVENT_LIMIT_EXCEEDED": "Impression event - {endPoint} failed due to exceeding payload size. Parameter eventsPerRequest in batchEvents config in init API has value:{eventsPerRequest} for account ID:{accountId}. Please read the official documentation for knowing the size limits",
 

data/lib/resources/error_messages.json

@@ -59,5 +59,9 @@
 
     "ERROR_EVALUATING_RULE": "Error occurred while evaluating rule. Error: {err}",
     "BATCH_FLUSH_FAILED": "Failed to send batch events. Re-enqueuing events for retry.",
-    "ERROR_PARSING_GATEWAY_URL": "Error occurred while parsing gateway service URL: {err}"
+    "ERROR_PARSING_GATEWAY_URL": "Error occurred while parsing gateway service URL: {err}",
+    
+    "INVALID_WEB_TESTING_CAMPAIGNS_DUPLICATE_KEY": "Duplicate campaignId found in webTestingCampaigns",
+    "INVALID_WEB_TESTING_CAMPAIGNS_JSON": "webTestingCampaigns provided in context is not a valid JSON string",
+    "INVALID_WEB_TESTING_CAMPAIGNS_TYPE": "webTestingCampaigns provided in context is of type {kind}, but must be of type string or object"
   }

data/lib/resources/info_messages.json

@@ -30,6 +30,7 @@
     "MEG_WINNER_CAMPAIGN": "MEG: Campaign {campaignKey} is the winner for group {groupId} for user ID:{userId} {algo}",
     "SETTINGS_UPDATED": "Settings fetched and updated successfully on the current {brand} client instance when API: {apiName} got called having isViaWebhook param as {isViaWebhook}",
     "NETWORK_CALL_SUCCESS": "Impression for {event} - {endPoint} was successfully received by {brand} having Account ID:{accountId}, UUID: {uuid}",
+    "USAGE_TRACKING_DISPATCHED": "FE track usage call dispatched for Account ID:{accountId}, User ID:{userId}, and feature key:{featureKey}",
 
     "EVENT_BATCH_DEFAULTS": "{parameter} in SDK configuration is missing or invalid (should be greater than {minLimit}). Using default value: {defaultValue}",
     "EVENT_QUEUE": "Event with payload:{event} pushed to the {queueType} queue",

data/lib/wingify/api/get_flag.rb

@@ -40,6 +40,10 @@ class FlagApi
       rollout_variation_to_return = nil
       experiment_variation_to_return = nil
       should_check_for_experiments_rules = false
+      # Flag to check if variation shown event has been fired
+      is_variation_shown_fired = false
+      # Flag to check if tracking usage is enabled
+      is_tracking_usage_enabled = settings.get_is_tracking_usage_enabled
   
       passed_rules_information = {} # for storing integration callback
       evaluated_feature_map = {}
@@ -65,6 +69,8 @@ class FlagApi
     
             if variation
               LoggerService.log(LogLevelEnum::INFO, "STORED_VARIATION_FOUND", {variationKey: variation.get_key, userId: context.get_id, experimentKey: stored_data[:experiment_key], experimentType: "experiment"})
+              # Send usage tracking call when user is served from storage
+              send_tracking_usage(settings, context, is_tracking_usage_enabled, feature_key)
               return GetFlagResponse.new(true, variation.get_variables, context.get_uuid, context.get_session_id)
             end
           end
@@ -91,6 +97,8 @@ class FlagApi
   
       if feature.nil?
         LoggerService.log(LogLevelEnum::ERROR, "FEATURE_NOT_FOUND", {featureKey: feature_key, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
+        # Send usage tracking call when feature is not found
+        send_tracking_usage(settings, context, is_tracking_usage_enabled, feature_key)
         return GetFlagResponse.new(false, [], context.get_uuid, context.get_session_id)
       end
   
@@ -106,6 +114,12 @@ class FlagApi
         rollout_rules.each do |rule|
           result = evaluate_rule(settings, feature, rule, context, evaluated_feature_map, nil, storage_service, decision)
           pre_segmentation_result = result[:pre_segmentation_result]
+          whitelisted_object = result[:whitelisted_object]
+          
+          if whitelisted_object.is_a?(Hash) && !whitelisted_object.empty?
+            is_variation_shown_fired = true
+          end
+
           updated_decision = result[:updated_decision]
           decision.merge!(updated_decision) if updated_decision
   
@@ -131,6 +145,8 @@ class FlagApi
             update_integrations_decision_object(passed_rollout_campaign, variation, passed_rules_information, decision)
   
             create_and_send_impression_for_variation_shown(settings, passed_rollout_campaign.get_id, variation.get_id, context, feature_key)
+            # set is_variation_shown_fired to true since we already sent variation shown call for rollout
+            is_variation_shown_fired = true
           end
         end
       elsif rollout_rules.empty?
@@ -147,11 +163,16 @@ class FlagApi
           result = evaluate_rule(settings, feature, rule, context, evaluated_feature_map, meg_group_winner_campaigns, storage_service, decision)
           pre_segmentation_result = result[:pre_segmentation_result]
           whitelisted_object = result[:whitelisted_object]
+          
+          if whitelisted_object.is_a?(Hash) && !whitelisted_object.empty?
+            is_variation_shown_fired = true
+          end
+
           updated_decision = result[:updated_decision]
           decision.merge!(updated_decision) if updated_decision
 
           if pre_segmentation_result
-            if whitelisted_object.nil?
+            if whitelisted_object.nil? || whitelisted_object.empty?
               experiment_rules_to_evaluate << rule
             else
               is_enabled = true
@@ -176,6 +197,8 @@ class FlagApi
             update_integrations_decision_object(campaign, variation, passed_rules_information, decision)
   
             create_and_send_impression_for_variation_shown(settings, campaign.get_id, variation.get_id, context, feature_key)
+            # set is_variation_shown_fired to true since we already sent variation shown call for experiment
+            is_variation_shown_fired = true
           end
         end
       end
@@ -216,8 +239,15 @@ class FlagApi
           context,
           feature_key
         )
+        # set is_variation_shown_fired to true since we already sent variation shown call for impact analysis
+        is_variation_shown_fired = true
+      end
+
+      # Send usage tracking call when no primary variation_shown event was dispatched.
+      # If a primary variation_shown event was fired, the server already has the usage tracking signal.
+      if !is_variation_shown_fired
+        send_tracking_usage(settings, context, is_tracking_usage_enabled, feature_key)
       end
-  
       # Return final evaluated feature flag
       return GetFlagResponse.new(is_enabled, experiment_variation_to_return&.get_variables || rollout_variation_to_return&.get_variables || [], context.get_uuid, context.get_session_id)
     end

data/lib/wingify/constants/constants.rb

@@ -17,7 +17,7 @@
 # Define the Constants module
 module Constants
   SDK_NAME = 'vwo-fme-ruby-sdk'.freeze
-  SDK_VERSION = '1.50.0'.freeze
+  SDK_VERSION = '1.60.0'.freeze
 
   # --- Brand-specific constants ---
 

data/lib/wingify/enums/event_enum.rb

@@ -19,4 +19,5 @@ module EventEnum
     DEBUGGER_EVENT = 'vwo_sdkDebug'
     INIT_CALLED = 'vwo_fmeSdkInit'
     USAGE_STATS = 'vwo_sdkUsageStats'
+    USER_EVALUATED = 'vwo_feTrackUsage'
 end

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

@@ -18,7 +18,7 @@ require_relative '../../constants/constants'
 
 class SettingsModel
   attr_reader :sdk_key, :account_id, :usage_stats_account_id, :version, :collection_prefix,
-              :features, :campaigns, :campaign_groups, :groups, :poll_interval, :is_web_connectivity_enabled
+              :features, :campaigns, :campaign_groups, :groups, :poll_interval, :is_web_connectivity_enabled, :is_tracking_usage_enabled
 
   def initialize(settings)
     @sdk_key = settings["sdkKey"]
@@ -32,6 +32,7 @@ class SettingsModel
     @campaign_groups = settings["campaignGroups"] || {}
     @groups = settings["groups"] || {}
     @is_web_connectivity_enabled = settings.fetch("isWebConnectivityEnabled", true)
+    @is_tracking_usage_enabled = settings.fetch("isMAU", false)
 
     process_features(settings)
     process_campaigns(settings)
@@ -98,4 +99,8 @@ class SettingsModel
   def get_is_web_connectivity_enabled
     @is_web_connectivity_enabled
   end
+
+  def get_is_tracking_usage_enabled
+    @is_tracking_usage_enabled
+  end
 end

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

@@ -17,15 +17,16 @@ require_relative '../../utils/uuid_util'
 require_relative '../../services/settings_service'
 
 class ContextModel
-  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :post_segmentation_variables, :vwo, :session_id, :uuid, :bucketing_seed
+  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :post_segmentation_variables, :platform_variables, :vwo, :session_id, :uuid, :bucketing_seed
 
-  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, post_segmentation_variables = {}, vwo = nil, session_id = nil, uuid = nil, bucketing_seed = nil)
+  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, post_segmentation_variables = {}, platform_variables = {}, vwo = nil, session_id = nil, uuid = nil, bucketing_seed = 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 || {}
+    @platform_variables = platform_variables || {}
     @vwo = vwo
     @session_id = session_id
     @uuid = uuid
@@ -52,6 +53,7 @@ class ContextModel
     @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)
+    @platform_variables = context[:platformVariables] if context.key?(:platformVariables)
     @vwo = ContextVWOModel.new.model_from_dictionary(context[:_vwo]) if context.key?(:_vwo)
     @bucketing_seed = context[:bucketingSeed].to_s if context.key?(:bucketingSeed)
 
@@ -120,6 +122,14 @@ class ContextModel
     @post_segmentation_variables = post_segmentation_variables
   end
 
+  def get_platform_variables
+    @platform_variables
+  end
+
+  def set_platform_variables(platform_variables)
+    @platform_variables = platform_variables
+  end
+
   def get_vwo
     @vwo
   end

data/lib/wingify/packages/segmentation_evaluator/core/segmentation_manager.rb

@@ -24,6 +24,8 @@ require_relative '../../../services/settings_service'
 require_relative '../../../utils/data_type_util'
 require_relative '../../../enums/log_level_enum'
 require_relative '../../../enums/api_enum'
+require_relative '../enums/segment_operator_value_enum'
+
 class SegmentationManager
   @@instance = nil # Singleton instance
 
@@ -72,6 +74,43 @@ class SegmentationManager
   end
 
   def validate_segmentation(dsl, properties)
+    if has_campaign_variation_node?(dsl)
+      platform_vars = @evaluator.context&.get_platform_variables
+      web_testing_campaigns = platform_vars && (platform_vars[:webTestingCampaigns] || platform_vars['webTestingCampaigns'])
+      return false unless web_testing_campaigns
+    end
+
     @evaluator.is_segmentation_valid(dsl, properties)
   end
+
+  private
+
+  # Checks if the provided DSL contains a campaign variation node.
+  # This is used to determine if web testing pre-segmentation should be evaluated.
+  #
+  # @param dsl [Hash] The DSL (Domain Specific Language) representing the segmentation rules.
+  # @return [Boolean] Returns true if a web campaign variation node is found, false otherwise.
+  def has_campaign_variation_node?(dsl)
+    # Return false immediately if the DSL is not a hash
+    return false unless dsl.is_a?(Hash)
+
+    # Iterate through each operator and operand in the DSL
+    dsl.each do |operator, operand|
+      # Check if the current operator matches the web campaign variation operator
+      return true if operator.to_s == SegmentOperatorValueEnum::WEB_CAMPAIGN_VARIATION
+
+      # If the operand is an array, recursively check each sub-DSL within it
+      if operand.is_a?(Array)
+        operand.each do |sub_dsl|
+          return true if has_campaign_variation_node?(sub_dsl)
+        end
+      # If the operand is a hash, recursively check the hash itself
+      elsif operand.is_a?(Hash)
+        return true if has_campaign_variation_node?(operand)
+      end
+    end
+    
+    # Return false if no campaign variation node is found in the entire DSL structure
+    false
+  end
 end

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

@@ -30,4 +30,5 @@ module SegmentOperatorValueEnum
     IP = 'ip_address'
     BROWSER_VERSION = 'browser_version'
     OS_VERSION = 'os_version'
+    WEB_CAMPAIGN_VARIATION = 'campaignVariation'
   end

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

@@ -57,6 +57,8 @@ class SegmentEvaluator
       SegmentOperandEvaluator.new.evaluate_custom_variable_dsl(sub_dsl, properties)
     when SegmentOperatorValueEnum::USER
       SegmentOperandEvaluator.new.evaluate_user_dsl(sub_dsl, properties)
+    when SegmentOperatorValueEnum::WEB_CAMPAIGN_VARIATION
+      SegmentOperandEvaluator.new.evaluate_web_testing_campaign_variation_dsl(sub_dsl, @context)
     when SegmentOperatorValueEnum::UA
       SegmentOperandEvaluator.new.evaluate_user_agent_dsl(sub_dsl, @context)
     when SegmentOperatorValueEnum::IP

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

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 require_relative '../utils/segment_util'
+require_relative '../utils/web_testing_segment_util'
 require_relative '../enums/segment_operand_value_enum'
 require_relative '../enums/segment_operand_regex_enum'
 require_relative '../enums/segment_operator_value_enum'
@@ -105,6 +106,22 @@ class SegmentOperandEvaluator
     extract_result(processed_operand[:operand_type], processed_values[:operand_value], tag_value)
   end
 
+  # Evaluates Web Testing pre-segmentation against `context.platform_variables[:webTestingCampaigns]`.
+  # @param dsl_operand_value [String] The operand value to evaluate
+  # @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_web_testing_campaign_variation_dsl(dsl_operand_value, context)
+    operand = dsl_operand_value.to_s.strip
+    assigned_variations_by_campaign_id = WebTestingSegmentUtil.parse_web_testing_campaigns_from_context(context)
+    result_obj = WebTestingSegmentUtil.evaluate_web_testing_campaign_variation(operand, assigned_variations_by_campaign_id)
+    
+    if result_obj[:invalid_format]
+      return false
+    end
+    
+    result_obj[:result]
+  end
+
   # 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.

data/lib/wingify/packages/segmentation_evaluator/utils/web_testing_segment_util.rb

@@ -0,0 +1,146 @@
+# Copyright 2024-2026 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 '../../../enums/api_enum'
+require_relative '../../../services/logger_service'
+require_relative '../../../enums/log_level_enum'
+require_relative '../../../utils/data_type_util'
+
+module WebTestingSegmentUtil
+  class << self
+    # Normalizes Web Testing campaign map keys and variation values to strings.
+    # @param raw_assignments [Hash] The raw assignments map from the context.
+    # @return [Hash] The normalized assignments map with campaign_id as key and variation_id as value.
+    def normalize_web_testing_campaigns_map(raw_assignments)
+      campaign_id_to_variation_id = {}
+      raw_assignments.each do |campaign_id, assigned_variation_id|
+        unless assigned_variation_id.nil? || campaign_id.to_s.empty?
+          campaign_id_to_variation_id[campaign_id.to_s] = assigned_variation_id.to_s
+        end
+      end
+      campaign_id_to_variation_id
+    end
+
+    # Parses `context.platform_variables[:webTestingCampaigns]` (JSON string or plain object).
+    # @param context [ContextModel]
+    # @return [Hash, nil]
+    def parse_web_testing_campaigns_from_context(context)
+      platform_variables = context.get_platform_variables || {}
+      # support both string and symbol keys
+      web_testing_campaigns_input = platform_variables[:webTestingCampaigns] || platform_variables['webTestingCampaigns']
+
+      if web_testing_campaigns_input.nil?
+        return nil
+      end
+
+      if web_testing_campaigns_input.is_a?(Hash)
+        return normalize_web_testing_campaigns_map(web_testing_campaigns_input)
+      end
+
+      if web_testing_campaigns_input.is_a?(String)
+        trimmed_json = web_testing_campaigns_input.strip
+        if trimmed_json.empty?
+          return nil
+        end
+
+        begin
+          # Check for duplicate keys using regex
+          all_campaign_id_tokens = trimmed_json.scan(/"([^"\\]*)"\s*:/).flatten
+          if all_campaign_id_tokens.any?
+            campaign_ids = all_campaign_id_tokens
+            has_duplicate_campaign_id = campaign_ids.length != campaign_ids.uniq.length
+            if has_duplicate_campaign_id
+              LoggerService.log(
+                LogLevelEnum::ERROR,
+                'INVALID_WEB_TESTING_CAMPAIGNS_DUPLICATE_KEY',
+                { an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+              )
+            end
+          end
+
+          parsed_assignments = JSON.parse(trimmed_json)
+          if parsed_assignments.is_a?(Hash)
+            return normalize_web_testing_campaigns_map(parsed_assignments)
+          end
+
+          LoggerService.log(
+            LogLevelEnum::ERROR,
+            'INVALID_WEB_TESTING_CAMPAIGNS_JSON',
+            { an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+          )
+        rescue JSON::ParserError
+          LoggerService.log(
+            LogLevelEnum::ERROR,
+            'INVALID_WEB_TESTING_CAMPAIGNS_JSON',
+            { an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+          )
+        end
+        return nil
+      end
+
+      # For array, numeric, boolean etc.
+      kind = web_testing_campaigns_input.is_a?(Array) ? 'array' : DataTypeUtil.get_type(web_testing_campaigns_input).downcase
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        'INVALID_WEB_TESTING_CAMPAIGNS_TYPE',
+        { kind: kind, an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+      )
+      nil
+    end
+
+    # Evaluates campaignVariation operand encoding:
+    # - "!C" — user is not in campaign C (no entry in map)
+    # - "C_!V" — user is in campaign C and assigned variation is not V
+    # - "C_V" — user is in campaign C with variation V
+    # - "C" (digits only) — user is in campaign C (any variation)
+    def evaluate_web_testing_campaign_variation(campaign_variation_operand, assigned_variations_by_campaign_id)
+      assignments = assigned_variations_by_campaign_id || {}
+
+      # match type !C
+      if match = /^!(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        return { result: !assignments.key?(campaign_id), invalid_format: false }
+      end
+
+      # match type C_!V
+      if match = /^(\d+)_!(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        variation_id = match[2]
+        if !assignments.key?(campaign_id)
+          return { result: false, invalid_format: false }
+        end
+        return { result: assignments[campaign_id] != variation_id, invalid_format: false }
+      end
+      
+      # match type C_V
+      if match = /^(\d+)_(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        variation_id = match[2]
+        if !assignments.key?(campaign_id)
+          return { result: false, invalid_format: false }
+        end
+        return { result: assignments[campaign_id] == variation_id, invalid_format: false }
+      end
+      
+      # match type C
+      if match = /^(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        return { result: assignments.key?(campaign_id), invalid_format: false }
+      end
+
+      { result: false, invalid_format: true }
+    end
+  end
+end

data/lib/wingify/utils/impression_util.rb

@@ -64,3 +64,38 @@ def create_and_send_impression_for_variation_shown(settings, campaign_id, variat
     NetworkUtil.send_post_api_request(properties, payload, { campaign_type: campaign_type, feature_key: feature_key, campaign_key: campaign_key, variation_name: variation_name })
   end
 end
+
+# Sends the usage tracking payload to the server.
+# Called whenever a user is evaluated via get_flag() but no variation_shown event is dispatched.
+#
+# @param settings [SettingsModel] The settings model containing configuration.
+# @param context [ContextModel] The user context model.
+# @param is_tracking_usage_enabled [Boolean] Whether usage tracking is active.
+# @param feature_key [String] The key of the evaluated feature.
+def send_tracking_usage(settings, context, is_tracking_usage_enabled, feature_key)
+  return unless is_tracking_usage_enabled
+
+  # Construct payload data for tracking usage
+  payload = NetworkUtil.get_tracking_usage_payload_data(context)
+
+  # Get base properties for the event
+  properties = NetworkUtil.get_events_base_properties(
+    EventEnum::USER_EVALUATED,
+    URI.encode_www_form_component(context.get_user_agent), # Encode user agent for URL safety
+    context.get_ip_address
+  )
+  LoggerService.log(LogLevelEnum::INFO, "USAGE_TRACKING_DISPATCHED", {
+    accountId: settings.account_id,
+    userId: context.get_id,
+    featureKey: feature_key
+  })
+
+  # check if batching is enabled
+  if BatchEventsQueue.instance
+    # add the payload to the batch events queue
+    BatchEventsQueue.instance.enqueue(payload)
+  else
+    # Send the constructed payload via POST request
+    NetworkUtil.send_post_api_request(properties, payload)
+  end
+end

data/lib/wingify/utils/network_util.rb

@@ -293,6 +293,33 @@ class NetworkUtil
         properties
     end
 
+    # Constructs the payload data for usage tracking call.
+    # Sent to server when a user is evaluated via get_flag() but no variation_shown
+    # event is dispatched by the SDK.
+    # @param context [ContextModel] The context model instance.
+    # @returns [Hash] The constructed payload.
+    def get_tracking_usage_payload_data(context)
+        properties = _get_event_base_payload(context.get_id, EventEnum::USER_EVALUATED, context.get_user_agent, context.get_ip_address)
+
+        # use sessionId from context if present
+        if context.get_session_id
+            properties[:d][:sessionId] = context.get_session_id
+        end
+
+        # use uuid from context if present
+        if context.get_uuid && !context.get_uuid.empty?
+            properties[:d][:visId] = context.get_uuid
+            properties[:d][:msgId] = "#{context.get_uuid}-#{get_current_unix_timestamp_in_millis}"
+        end
+
+        LoggerService.log(LogLevelEnum::DEBUG, "IMPRESSION_FOR_USAGE_TRACKING", {
+            accountId: SettingsService.instance.account_id,
+            userId: context.get_id
+        })
+
+        properties
+    end
+
     # Sends a POST API request with given properties and payload
     def send_post_api_request(properties, payload, campaign_info = {})
         network_instance = NetworkManager.instance

data/lib/wingify.rb

@@ -43,6 +43,11 @@ module Wingify
                    .init_batch
 
     if options[:settings]
+      if SettingsSchema.new.is_settings_valid(options[:settings])
+        SettingsService.instance.is_settings_valid = true
+      else
+        LoggerService.log(LogLevelEnum::ERROR, "INVALID_SETTINGS_SCHEMA", { accountId: options[:account_id], sdkKey: options[:sdk_key], settings: options[:settings], an: ApiEnum::INIT}, false)
+      end
       return @@wingify_builder.build(options[:settings])
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vwo-fme-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 1.50.0
+  version: 1.60.0
 platform: ruby
 authors:
 - VWO
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools
@@ -269,6 +269,7 @@ files:
 - lib/wingify/packages/segmentation_evaluator/evaluators/segment_evaluator.rb
 - lib/wingify/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.rb
 - lib/wingify/packages/segmentation_evaluator/utils/segment_util.rb
+- lib/wingify/packages/segmentation_evaluator/utils/web_testing_segment_util.rb
 - lib/wingify/packages/storage/connector.rb
 - lib/wingify/packages/storage/storage.rb
 - lib/wingify/services/batch_event_queue.rb