vwo-fme-ruby-sdk 1.6.1 → 1.8.0

data/lib/vwo/services/settings_service.rb

@@ -21,9 +21,11 @@ require_relative '../utils/network_util'
 require_relative '../services/logger_service'
 require_relative '../enums/log_level_enum'
 require_relative '../models/schemas/settings_schema_validation'
+require_relative '../enums/api_enum'
+require_relative '../utils/debugger_service_util'
 
 class SettingsService
-  attr_accessor :sdk_key, :account_id, :expiry, :network_timeout, :hostname, :port, :protocol, :is_gateway_service_provided, :is_settings_valid, :settings_fetch_time
+  attr_accessor :sdk_key, :account_id, :expiry, :network_timeout, :hostname, :port, :protocol, :is_gateway_service_provided, :is_settings_valid, :settings_fetch_time, :proxy_url, :is_proxy_url_provided, :collection_prefix
 
   class << self
     attr_accessor :instance
@@ -53,6 +55,15 @@ class SettingsService
       @protocol = parsed_url.scheme
       @port = parsed_url.port || options.dig(:gateway_service, :port)
       @is_gateway_service_provided = true
+      if options[:proxy_url] && !options[:proxy_url].nil? && !options[:proxy_url].empty?
+        LoggerService.log(LogLevelEnum::INFO, "PROXY_AND_GATEWAY_SERVICE_PROVIDED")
+      end
+    elsif options[:proxy_url] && !options[:proxy_url].nil? && !options[:proxy_url].empty?
+      parsed_url = URI.parse(options[:proxy_url])
+      @hostname = parsed_url.hostname
+      @protocol = parsed_url.scheme
+      @port = parsed_url.port
+      @is_proxy_url_provided = true
     else
       @hostname = Constants::HOST_NAME
       @protocol = Constants::HTTPS_PROTOCOL
@@ -62,6 +73,13 @@ class SettingsService
     SettingsService.instance = self
   end
 
+  def get_updated_endpoint_with_collection_prefix(endpoint)
+    if @collection_prefix && !@collection_prefix.empty?
+      return "/#{@collection_prefix}#{endpoint}"
+    end
+    return endpoint
+  end
+
   # Fetch settings and cache them in storage.
   # @return [SettingsModel] The fetched settings
   def fetch_settings_and_cache_in_storage
@@ -69,8 +87,8 @@ class SettingsService
       response = fetch_settings
       response
     rescue => e
-      LoggerService.log(LogLevelEnum::ERROR, "SETTINGS_FETCH_ERROR", { err: e.message })
-      nil
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::INIT}, false)
+      {}
     end
   end
 
@@ -79,7 +97,7 @@ class SettingsService
   # @return [SettingsModel] The fetched settings
   def fetch_settings(is_via_webhook = false)
     if @sdk_key.nil? || @account_id.nil?
-      LoggerService.log(LogLevelEnum::ERROR, "sdkKey is required for fetching account settings. Aborting!", nil)
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_SDK_KEY_OR_ACCOUNT_ID", { an: ApiEnum::INIT})
     end
 
     network_instance = NetworkManager.instance
@@ -108,15 +126,25 @@ class SettingsService
       # calculate the time taken to fetch the settings
       settings_fetch_end_time = (Time.now.to_f * 1000).to_i
       time_taken = settings_fetch_end_time - settings_fetch_start_time
-      @settings_fetch_time = time_taken.to_s 
+      @settings_fetch_time = time_taken.to_s
+
+      if response.get_total_attempts > 0
+        api_enum = is_via_webhook ? ApiEnum::UPDATE_SETTINGS : ApiEnum::INIT
+        debug_event_props = NetworkUtil.create_network_and_retry_debug_event(response, nil, api_enum, path)
+        # send debug event
+        DebuggerServiceUtil.send_debugger_event(debug_event_props)
+      end
       settings = response.get_data
+      if settings.nil? || settings.empty?
+        settings = {}
+      end
       # Deep duplicate the settings to avoid modifying the original object
       normalized_settings = SettingsService.normalize_settings(settings)
-
+      @collection_prefix = normalized_settings['collectionPrefix'] if normalized_settings['collectionPrefix'] && !normalized_settings['collectionPrefix'].empty?
       normalized_settings
     rescue => e
-      LoggerService.log(LogLevelEnum::ERROR, "Error fetching settings: #{e.message}", nil)
-      raise e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::INIT})
+      {}
     end
   end
 
@@ -134,7 +162,7 @@ class SettingsService
         LoggerService.log(LogLevelEnum::INFO, "SETTINGS_FETCH_SUCCESS")
         settings
       else
-        LoggerService.log(LogLevelEnum::ERROR, "SETTINGS_SCHEMA_INVALID")
+        LoggerService.log(LogLevelEnum::ERROR, "INVALID_SETTINGS_SCHEMA", { accountId: @account_id, sdkKey: @sdk_key, settings: settings, an: ApiEnum::INIT}, false)
         {}
       end
     end

data/lib/vwo/services/storage_service.rb

@@ -18,6 +18,7 @@ require_relative '../packages/storage/storage'
 require_relative '../services/logger_service'
 require_relative '../enums/log_level_enum'
 require_relative '../utils/data_type_util'
+require_relative '../enums/api_enum'
 
 class StorageService
   attr_accessor :storage_data
@@ -40,7 +41,7 @@ class StorageService
       data = storage_instance.get(feature_key, context.get_id)
       return data.nil? ? StorageEnum::NO_DATA_FOUND : data
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "STORED_DATA_ERROR", { err: e.message })
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_READING_DATA_FROM_STORAGE", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
       return StorageEnum::NO_DATA_FOUND
     end
   end
@@ -48,7 +49,7 @@ class StorageService
   # Stores data in the storage.
   # @param data [Hash] The data to be stored.
   # @return [Boolean] True if data is successfully stored, otherwise false.
-  def set_data_in_storage(data)
+  def set_data_in_storage(data, context)
     storage_instance = Storage.instance.get_connector
 
     # Check if the storage instance is available
@@ -57,8 +58,8 @@ class StorageService
     begin
       storage_instance.set(data)
       return true
-    rescue StandardError
-      LoggerService.log(LogLevelEnum::ERROR, "STORED_DATA_ERROR", { err: e.message })
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_STORING_DATA_IN_STORAGE", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
       return false
     end
   end

data/lib/vwo/utils/{batch_event_dispatcher.rb → batch_event_dispatcher_util.rb}

@@ -12,15 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'set'
 require_relative './network_util'
 require_relative '../enums/http_method_enum'
 require_relative '../enums/url_enum'
 require_relative '../enums/log_level_enum'
+require_relative '../enums/event_enum'
 require_relative '../services/logger_service'
 require_relative '../packages/network_layer/manager/network_manager'
 require_relative '../packages/network_layer/models/request_model'
+require_relative '../packages/network_layer/models/response_model'
+require_relative '../utils/function_util'
 
-class BatchEventDispatcher
+class BatchEventDispatcherUtil
 
   class << self
 
@@ -40,26 +44,45 @@ class BatchEventDispatcher
       headers['Authorization'] = "#{SettingsService.instance.sdk_key}"
 
       request = RequestModel.new(
-        UrlUtil.get_base_url,
+        SettingsService.instance.hostname,
         HttpMethodEnum::POST,
-        UrlEnum::BATCH_EVENTS,
+        SettingsService.instance.get_updated_endpoint_with_collection_prefix(UrlEnum::BATCH_EVENTS),
         properties,
         payload,
         headers,
         SettingsService.instance.protocol,
         SettingsService.instance.port
       )
+      
+      event_counts = extract_event_counts(payload)
+      extra_data = "#{Constants::BATCH_EVENTS} having"
+      if event_counts[:variation_shown_count] > 0
+        extra_data += "getFlag events: #{event_counts[:variation_shown_count]}, "
+      end
+      if event_counts[:custom_event_count] > 0
+        extra_data += "conversion events: #{event_counts[:custom_event_count]}, "
+      end
+      if event_counts[:set_attribute_count] > 0
+        extra_data += "setAttribute events: #{event_counts[:set_attribute_count]}, "
+      end
 
       begin
         response = network_instance.post(request)
+        # Only send debug event if response is valid and has retry attempts
+        if response.is_a?(ResponseModel) && response.get_total_attempts && response.get_total_attempts > 0
+          debug_event_props = NetworkUtil.create_network_and_retry_debug_event(response, nil, Constants::BATCH_EVENTS, extra_data)
+          # send debug event
+          DebuggerServiceUtil.send_debugger_event(debug_event_props) if debug_event_props
+        end
         handle_batch_response(UrlEnum::BATCH_EVENTS, payload, properties, response, response.get_data, callback)
       rescue StandardError => err
+        # TODO: remove this log after testing
         LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
-              method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
-              err: err.is_a?(Hash) ? err.to_json : err
+              method: extra_data,
+              err: get_formatted_error_message(err)
           })
       end
-  end
+    end
 
     # Handles the response from a batch event API call
     # @param end_point [String] The API endpoint that was called
@@ -69,6 +92,7 @@ class BatchEventDispatcher
     # @param raw_data [String] The raw response data from the API
     # @param callback [Proc] Optional callback to be executed after handling the response
     def handle_batch_response(end_point, payload, query_params, res, raw_data, callback)
+      # TODO: update this method with debug event logs
       events_per_request = payload[:ev].length
       account_id = query_params[:a]
 
@@ -78,7 +102,7 @@ class BatchEventDispatcher
         LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
           method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
           err: error
-        })
+        }, false)
         callback.call(error, payload.to_json) if callback.respond_to?(:call)
         return {status: "error", events: payload}
       else
@@ -99,7 +123,7 @@ class BatchEventDispatcher
           LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
               method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
               err: error
-          })
+          }, false)
           callback.call(error, payload.to_json) if callback.respond_to?(:call)
           return {status: "error", events: payload}
         else
@@ -107,11 +131,48 @@ class BatchEventDispatcher
           LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
               method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
               err: error
-          })
+          }, false)
           callback.call(error, payload.to_json) if callback.respond_to?(:call)
           return {status: "error", events: payload}
         end
       end
     end
+
+    # Extracts event counts from a batch payload
+    # @param payload [Hash] The payload containing events
+    # @return [Hash] Hash with variationShownCount, setAttributeCount, and customEventCount
+    def extract_event_counts(payload)
+      counts = {
+        variation_shown_count: 0,
+        set_attribute_count: 0,
+        custom_event_count: 0
+      }
+
+      # Get all standard event names from EventEnum
+      standard_event_names = EventEnum.constants.map { |const| EventEnum.const_get(const) }.to_set
+      events = payload&.dig(:ev) || []
+
+      events.each do |entry|
+        name = entry&.dig(:d, :event, :name)
+
+        next unless name
+
+        if name == EventEnum::VWO_VARIATION_SHOWN
+          counts[:variation_shown_count] += 1
+          next
+        end
+
+        if name == EventEnum::VWO_SYNC_VISITOR_PROP
+          counts[:set_attribute_count] += 1
+          next
+        end
+
+        unless standard_event_names.include?(name)
+          counts[:custom_event_count] += 1
+        end
+      end
+
+      counts
+    end
   end
 end

data/lib/vwo/utils/campaign_util.rb

@@ -246,4 +246,39 @@ module CampaignUtil
       })
     end
   end
+
+  # Retrieves the campaign key from the campaign ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @return [String] The campaign key
+  def self.get_campaign_key_from_campaign_id(settings, campaign_id)
+    settings.get_campaigns.each do |campaign|
+      return campaign.get_key if campaign.get_id == campaign_id
+    end
+    nil
+  end
+
+  # Retrieves the variation name from the campaign ID and variation ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @param variation_id [Integer] The ID of the variation
+  # @return [String] The variation name
+  def self.get_variation_name_from_campaign_id_and_variation_id(settings, campaign_id, variation_id)
+    campaign = settings.get_campaigns.find { |c| c.get_id == campaign_id }
+    return nil unless campaign
+
+    variation = campaign.get_variations.find { |v| v.get_id == variation_id }
+    variation ? variation.get_key : nil
+  end
+
+  # Retrieves the campaign type from the campaign ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @return [String] The campaign type
+  def self.get_campaign_type_from_campaign_id(settings, campaign_id)
+    campaign = settings.get_campaigns.find { |c| c.get_id == campaign_id }
+    return nil unless campaign
+
+    campaign.get_type
+  end
 end

data/lib/vwo/utils/debugger_service_util.rb

@@ -0,0 +1,40 @@
+# Copyright 2024-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 '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../utils/network_util'
+require_relative '../services/batch_event_queue'
+require_relative '../enums/event_enum'
+
+class DebuggerServiceUtil
+  class << self
+    def send_debugger_event(event_props)
+      # get base properties for the event
+      properties = NetworkUtil.get_events_base_properties(EventEnum::VWO_DEBUGGER_EVENT)
+
+      # get debugger event payload
+      payload = NetworkUtil.get_debugger_event_payload(event_props)
+
+      # send event
+      if BatchEventsQueue.instance
+        # add the payload to the batch events queue
+        BatchEventsQueue.instance.enqueue(payload)
+      else
+        # Send the prepared payload via POST API request
+        NetworkUtil.send_event(properties, payload)
+      end
+    end
+  end
+end

data/lib/vwo/utils/event_util.rb

@@ -44,6 +44,12 @@ def send_sdk_usage_stats_event(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)
+  # check if batching is enabled
+  if BatchEventsQueue.instance
+    # add the payload to the batch events queue
+    BatchEventsQueue.instance.enqueue(payload)
+  else
+    # send event
+    NetworkUtil.send_event(properties, payload)
+  end
 end

data/lib/vwo/utils/function_util.rb

@@ -125,3 +125,17 @@ def add_linked_campaigns_to_settings(settings)
     feature.set_rules_linked_campaign(rules_linked_campaign)
   end
 end
+
+# Formats error messages for logging
+# @param error [Object] The error object (can be Error, String, Hash, etc.)
+# @return [String] The formatted error message
+def get_formatted_error_message(error)
+  if error.is_a?(StandardError)
+    error.message
+  elsif error.is_a?(String)
+    error
+  elsif error.is_a?(Hash) || error.is_a?(Array)
+    error.to_json
+  end
+  error
+end

data/lib/vwo/utils/gateway_service_util.rb

@@ -17,10 +17,10 @@ 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'
+require_relative '../enums/api_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.
@@ -30,15 +30,15 @@ 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")
+    LoggerService.log(LogLevelEnum::ERROR, "INVALID_GATEWAY_URL", { an: ApiEnum::GET_FLAG})
     return false
   end
 
   begin
     request = RequestModel.new(
-      UrlUtil.get_base_url,
+      SettingsService.instance.hostname,
       HttpMethodEnum::GET,
-      endpoint,
+      SettingsService.instance.get_updated_endpoint_with_collection_prefix(endpoint),
       query_params,
       nil,
       nil,
@@ -49,7 +49,7 @@ def get_from_gateway_service(query_params, endpoint)
     response = network_instance.get(request)
     return response.get_data
   rescue StandardError => e
-    LoggerService.log(LogLevelEnum::ERROR, "Error fetching from Gateway Service: #{e.message}", nil)
+    LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::GET_FLAG})
     return false
   end
 end

data/lib/vwo/utils/impression_util.rb

@@ -17,6 +17,7 @@ require_relative './network_util'
 require_relative '../models/user/context_model'
 require_relative '../enums/event_enum'
 require_relative '../services/batch_event_queue'
+require_relative '../utils/campaign_util'
 # 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.
@@ -25,7 +26,7 @@ require_relative '../services/batch_event_queue'
 # @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)
+def create_and_send_impression_for_variation_shown(settings, campaign_id, variation_id, context, feature_key)
   # Get base properties for the event
   properties = NetworkUtil.get_events_base_properties(
     EventEnum::VWO_VARIATION_SHOWN,
@@ -41,12 +42,25 @@ def create_and_send_impression_for_variation_shown(settings, campaign_id, variat
     context
   )
 
+  campaign_key_with_feature_name = CampaignUtil.get_campaign_key_from_campaign_id(settings, campaign_id)
+  variation_name = CampaignUtil.get_variation_name_from_campaign_id_and_variation_id(settings, campaign_id, variation_id)
+
+  campaign_key = ''
+
+  if feature_key == campaign_key_with_feature_name
+    campaign_key = Constants::IMPACT_ANALYSIS
+  else
+    campaign_key = campaign_key_with_feature_name.split("#{feature_key}_")[1]
+  end
+
+  campaign_type = CampaignUtil.get_campaign_type_from_campaign_id(settings, campaign_id)
+
   # 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)
+    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

data/lib/vwo/utils/meg_util.rb

@@ -30,6 +30,7 @@ require_relative './decision_util'
 require_relative './function_util'
 require_relative '../services/logger_service'
 require_relative '../enums/log_level_enum'
+require_relative '../enums/api_enum'
 
 # Evaluates groups for a given feature and group ID.
 # @param settings [SettingsModel] The settings for the VWO instance
@@ -249,16 +250,20 @@ def normalize_weights_and_find_winning_campaign(shortlisted_campaigns, context,
       }
     )
 
-    StorageDecorator.new.set_data_in_storage(
-      {
-        feature_key: "#{Constants::VWO_META_MEG_KEY}#{group_id}",
-        context: context,
-        experiment_id: winner_campaign.id,
-        experiment_key: winner_campaign.key,
-        experiment_variation_id: winner_campaign.type == CampaignTypeEnum::PERSONALIZE ? winner_campaign.variations[0].id : -1
-      },
-      storage_service
-    )
+    begin
+      StorageDecorator.new.set_data_in_storage(
+        {
+          feature_key: "#{Constants::VWO_META_MEG_KEY}#{group_id}",
+          context: context,
+          experiment_id: winner_campaign.id,
+          experiment_key: winner_campaign.key,
+          experiment_variation_id: winner_campaign.type == CampaignTypeEnum::PERSONALIZE ? winner_campaign.variations[0].id : -1
+        },
+        storage_service
+      )
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_STORING_DATA_IN_STORAGE", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
+    end
 
     return winner_campaign if called_campaign_ids.include?(winner_campaign.id)
   else
@@ -329,18 +334,20 @@ def get_campaign_using_advanced_algo(settings, shortlisted_campaigns, context, c
         algo: 'using advanced algorithm'
       }
     )
-
-    StorageDecorator.new.set_data_in_storage(
-      {
-        feature_key: "#{Constants::VWO_META_MEG_KEY}#{group_id}",
-        context: context,
-        experiment_id: winner_campaign.id,
-        experiment_key: winner_campaign.key,
-        experiment_variation_id: winner_campaign.type == CampaignTypeEnum::PERSONALIZE ? winner_campaign.variations[0].id : -1
-      },
-      storage_service
-    )
-    
+    begin
+      StorageDecorator.new.set_data_in_storage(
+        {
+          feature_key: "#{Constants::VWO_META_MEG_KEY}#{group_id}",
+          context: context,
+          experiment_id: winner_campaign.id,
+          experiment_key: winner_campaign.key,
+          experiment_variation_id: winner_campaign.type == CampaignTypeEnum::PERSONALIZE ? winner_campaign.variations[0].id : -1
+        },
+        storage_service
+      )
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_STORING_DATA_IN_STORAGE", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
+    end
     return winner_campaign if called_campaign_ids.include?(winner_campaign.id)
   else
     LoggerService.log(LogLevelEnum::INFO, "No winner campaign found for MEG group: #{group_id}, using advanced algorithm", nil)