vwo-fme-ruby-sdk 1.6.1 → 1.8.0

data/lib/vwo/packages/network_layer/client/network_client.rb

@@ -20,6 +20,10 @@ require_relative '../../../utils/network_util'
 require 'net/http'
 require 'concurrent-ruby'
 require_relative '../../../constants/constants'
+require_relative '../../../services/logger_service'
+require_relative '../../../enums/log_level_enum'
+require_relative '../../../enums/event_enum'
+require_relative '../../../utils/function_util'
 
 class NetworkClient
   HTTPS_SCHEME = 'https'
@@ -48,61 +52,181 @@ class NetworkClient
   end
 
   def get(request_model)
-    # Build the URL and headers
+    execute_with_retry(request_model, :get_request)
+  end
+
+  def post(request_model)
+    execute_with_retry(request_model, :post_request)
+  end
+
+  private
+
+  def execute_with_retry(request_model, request_type)
     url = request_model.get_url + request_model.get_path
     uri = URI(url)
+    attempt = 0
+
+    # Get retry config from request model or use defaults
+    retry_config = request_model.get_retry_config || Constants::DEFAULT_RETRY_CONFIG.dup
+    extra_data = request_model.get_extra_info
+    endpoint = request_model.get_path.split('?')[0]
     
-    # Create the HTTP GET request
-    request = Net::HTTP::Get.new(uri)
-    # Add headers to the request
-    request_model.get_headers.each { |k, v| request[k] = v }
-  
-    # Send the GET request and get the response
-    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-      http.request(request)
+    # If retry is disabled, execute without retry logic
+    unless retry_config[:should_retry]
+      response_model, _should_retry, _last_error_message =
+        perform_single_attempt(uri, request_model, request_type, attempt, retry_config)
+      return response_model
     end
-  
-    # Process the response
-    response_model = ResponseModel.new
-    response_model.set_status_code(response.code.to_i)  # Convert status code to integer
-    
+
+    # Attempt loop: initial attempt (0) + configured retries
+    last_error_message = nil
+    last_response_model = nil
+
+    (0..retry_config[:max_retries] - 1).each do |attempt_index|
+      attempt = attempt_index
+
+      # Perform a single attempt
+      response_model, should_retry, last_error_message =
+        perform_single_attempt(uri, request_model, request_type, attempt, retry_config, last_error_message)
+
+      last_response_model = response_model
+
+      # If there is no retry needed, return immediately
+      return response_model unless should_retry
+
+      # Calculate delay before next retry (in seconds)
+      delay_seconds = calculate_retry_delay(attempt_index, retry_config)
+
+      # Log retry attempt
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        "ATTEMPTING_RETRY_FOR_FAILED_NETWORK_CALL",
+        {
+          endPoint: endpoint,
+          err: last_error_message,
+          delay: delay_seconds,
+          attempt: attempt_index + 1,
+          maxRetries: retry_config[:max_retries]
+        }.merge(extra_data), false
+      )
+
+      # Store last error on request for diagnostics
+      request_model.set_last_error(last_error_message)
+
+      sleep(delay_seconds)
+    end
+
+    # All attempts exhausted
+    total_attempts = retry_config[:max_retries]
+    final_error_message = last_error_message || 'Unknown error'
+
+    # Log failure after max retries (skip for debugger events)
+    unless endpoint.include?(EventEnum::VWO_DEBUGGER_EVENT)
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        "NETWORK_CALL_FAILURE_AFTER_MAX_RETRIES",
+        {
+          extraData: endpoint,
+          attempts: total_attempts,
+          err: final_error_message
+        }.merge(extra_data), 
+        false
+      )
+    end
+
+    if last_response_model
+      last_response_model.set_total_attempts(total_attempts)
+      last_response_model.set_error(final_error_message)
+      last_response_model
+    else
+      response_model = ResponseModel.new
+      response_model.set_error(final_error_message)
+      response_model.set_total_attempts(total_attempts)
+      response_model
+    end
+  end
+
+  # Performs a single HTTP attempt (GET/POST) and returns:
+  # [ResponseModel, should_retry (Boolean), last_error_message (String or nil)]
+  def perform_single_attempt(uri, request_model, request_type, attempt, retry_config, prev_error_message = nil)
     begin
-      # Parse the response body as JSON
-      parsed_data = JSON.parse(response.body)
-      response_model.set_data(parsed_data)
+      # Low-level HTTP call
+      response = if request_type == :get_request
+                   perform_get_request(uri, request_model)
+                 else
+                   perform_post_request(uri, request_model)
+                 end
+
+      response_model = build_response_model(response)
+
+      # Success (2xx)
+      if response.is_a?(Net::HTTPSuccess)
+        # On retries, echo back last error and attempts (for diagnostics)
+        if attempt.positive?
+          response_model.set_total_attempts(attempt)
+          response_model.set_error(request_model.get_last_error)
+        end
+        return [response_model, false, nil]
+      end
+
+      # Client error 400 → do not retry
+      if response.code.to_i == 400
+        error_message = "#{response.body}, Status Code: #{response.code.to_i}"
+        response_model.set_error(error_message)
+        response_model.set_total_attempts(attempt)
+        return [response_model, false, error_message]
+      end
+
+      # Non-2xx/400 status → decide if we should retry based on status code
+      should_retry = should_retry(response, attempt, retry_config)
+      error_message = "#{response.body}, Status Code: #{response.code.to_i}"
+      response_model.set_error(error_message)
+      response_model.set_total_attempts(attempt)
+      [response_model, should_retry, error_message]
     rescue StandardError => e
-      # Handle any JSON parsing errors
-      response_model.set_error(e.message)
+      # Network / timeout / other exceptions
+      error_message = get_formatted_error_message(e)
+      response_model = ResponseModel.new
+      response_model.set_error(error_message)
+      response_model.set_total_attempts(attempt)
+
+      should_retry = should_retry_on_error(e, attempt, retry_config)
+      [response_model, should_retry, error_message]
     end
-  
-    # Return the response model
-    response_model
   end
 
-  def post(request_model)
-    url = request_model.get_url + request_model.get_path
-    uri = URI(url)
+  def perform_get_request(uri, request_model)
+    request = Net::HTTP::Get.new(uri)
+    request_model.get_headers.each { |k, v| request[k] = v }
+
+    Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', open_timeout: Constants::REQUEST_TIMEOUT, read_timeout: Constants::REQUEST_TIMEOUT) do |http|
+      http.request(request)
+    end
+  end
+
+  def perform_post_request(uri, request_model)
     headers = request_model.get_headers
     body = JSON.dump(request_model.get_body)
 
     request = Net::HTTP::Post.new(uri, headers)
     request.body = body
 
-    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(request) }
+    Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', open_timeout: Constants::REQUEST_TIMEOUT, read_timeout: Constants::REQUEST_TIMEOUT) do |http|
+      http.request(request)
+    end
+  end
 
+  def build_response_model(response)
     response_model = ResponseModel.new
     response_model.set_status_code(response.code.to_i)
 
-    # Check if the response body is empty or invalid before parsing
     if response.is_a?(Net::HTTPSuccess) && !response.body.strip.empty?
-      # Check if the response body is JSON
       content_type = response['Content-Type']&.downcase
       if content_type&.include?('application/json')
         begin
           parsed_data = JSON.parse(response.body)
           response_model.set_data(parsed_data)
         rescue JSON::ParserError => e
-          # Handle invalid JSON response
           response_model.set_error("Invalid JSON response: #{e.message}")
         end
       else
@@ -111,11 +235,42 @@ class NetworkClient
     end
 
     response_model
-  rescue StandardError => e
-    LoggerService.log(LogLevelEnum::ERROR, "POST request failed: #{e.message}", nil)
-    response_model = ResponseModel.new
-    response_model.set_error(e.message)
-    response_model
   end
+
+  def should_retry(response, attempt, retry_config)
+    # Retry on server errors (5xx) or network timeouts
+    status_code = response.code.to_i
+    status_code < 200 || status_code > 300
+  end
+
+  def should_retry_on_error(error, attempt, retry_config)
+    return false if attempt >= retry_config[:max_retries]
+
+    # Retry on network errors, timeouts, and connection errors
+    # Check for specific error types that indicate transient network issues
+    retryable = error.is_a?(Net::OpenTimeout) ||
+                error.is_a?(Net::ReadTimeout) ||
+                error.is_a?(Errno::ECONNREFUSED) ||
+                error.is_a?(Errno::ETIMEDOUT) ||
+                error.is_a?(Errno::EHOSTUNREACH) ||
+                error.is_a?(Errno::ENETUNREACH) ||
+                error.is_a?(Errno::ECONNRESET) ||
+                error.is_a?(Errno::EPIPE) ||
+                error.is_a?(SocketError) ||
+                (error.respond_to?(:message) && error.message && 
+                 (error.message.downcase.include?('timeout') || 
+                  error.message.downcase.include?('connection') ||
+                  error.message.downcase.include?('connection refused') ||
+                  error.message.downcase.include?('getaddrinfo') ||
+                  error.message.downcase.include?('connection reset') ||
+                  error.message.downcase.include?('broken pipe')))
+
+    retryable
+  end
+
+  def calculate_retry_delay(attempt, retry_config)
+    retry_config[:initial_delay] * (retry_config[:backoff_multiplier] ** attempt)
+  end
+
   
 end

data/lib/vwo/packages/network_layer/manager/network_manager.rb

@@ -18,6 +18,9 @@ require_relative '../models/global_request_model'
 require_relative '../../../services/logger_service'
 require_relative '../../../enums/log_level_enum'
 require_relative '../../../constants/constants'
+require_relative '../../../enums/api_enum'
+require_relative '../../../utils/data_type_util'
+
 class NetworkManager
   @instance = nil
 
@@ -25,14 +28,73 @@ class NetworkManager
     @client = NetworkClient.new(options)
     @config = GlobalRequestModel.new(nil, {}, {}, {})
     @should_use_threading = options.key?(:enabled) ? options[:enabled] : Constants::SHOULD_USE_THREADING
+    @retry_config = nil
   end
 
   def self.instance(options = {})
     @instance ||= new(options)
   end
 
-  def attach_client(client = nil)
-    @client = client || NetworkClient.new(@should_use_threading)
+  def attach_client(client = nil, retry_config = nil)
+    # Only set retry configuration if it's not already initialized or if a new config is provided
+    if !@retry_config || retry_config
+      # Define default retry configuration
+      default_retry_config = Constants::DEFAULT_RETRY_CONFIG.dup
+
+      # Merge provided retry_config with defaults, giving priority to provided values
+      merged_config = default_retry_config.merge(retry_config || {})
+
+      # Validate the merged configuration
+      @retry_config = validate_retry_config(merged_config)
+    end
+  end
+
+  def get_retry_config
+    @retry_config ? @retry_config.dup : nil
+  end
+
+  def validate_retry_config(retry_config)
+    validated_config = retry_config.dup
+    is_invalid_config = false
+
+    # Validate should_retry: should be a boolean value
+    if !DataTypeUtil.is_boolean(validated_config[:should_retry])
+      validated_config[:should_retry] = Constants::DEFAULT_RETRY_CONFIG[:should_retry]
+      is_invalid_config = true
+    end
+
+    # Validate max_retries: should be a non-negative integer and should not be less than 1
+    if !DataTypeUtil.is_number(validated_config[:max_retries]) ||
+       !validated_config[:max_retries].is_a?(Integer) ||
+       validated_config[:max_retries] < 1
+      validated_config[:max_retries] = Constants::DEFAULT_RETRY_CONFIG[:max_retries]
+      is_invalid_config = true
+    end
+
+    # Validate initial_delay: should be a non-negative integer and should not be less than 1
+    if !DataTypeUtil.is_number(validated_config[:initial_delay]) ||
+       !validated_config[:initial_delay].is_a?(Integer) ||
+       validated_config[:initial_delay] < 1
+      validated_config[:initial_delay] = Constants::DEFAULT_RETRY_CONFIG[:initial_delay]
+      is_invalid_config = true
+    end
+
+    # Validate backoff_multiplier: should be a non-negative integer and should not be less than 2
+    if !DataTypeUtil.is_number(validated_config[:backoff_multiplier]) ||
+       !validated_config[:backoff_multiplier].is_a?(Integer) ||
+       validated_config[:backoff_multiplier] < 2
+      validated_config[:backoff_multiplier] = Constants::DEFAULT_RETRY_CONFIG[:backoff_multiplier]
+      is_invalid_config = true
+    end
+
+    if is_invalid_config
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_RETRY_CONFIG", {
+        retryConfig: validated_config.to_json,
+        an: ApiEnum::INIT
+      })
+    end
+
+    is_invalid_config ? Constants::DEFAULT_RETRY_CONFIG.dup : validated_config
   end
 
   def get_client
@@ -48,7 +110,12 @@ class NetworkManager
   end
 
   def create_request(request)
-    RequestHandler.new.create_request(request, @config)
+    network_request = RequestHandler.new.create_request(request, @config)
+    # Set retry config from network manager if not already set in request
+    if @retry_config && (!network_request.get_retry_config || network_request.get_retry_config.nil?)
+      network_request.set_retry_config(@retry_config.dup)
+    end
+    network_request
   end
 
   def get(request)
@@ -59,8 +126,7 @@ class NetworkManager
       response = @client.get(network_options)
       response
     rescue => e
-      LoggerService.log(LogLevelEnum::ERROR, "Error getting: #{e.message}", nil)
-      raise e
+      return ResponseModel.new.set_error(e.message)
     end
   end
   
@@ -73,7 +139,6 @@ class NetworkManager
       response = @client.post(network_options) # Return the response
       response
     rescue => e
-      LoggerService.log(LogLevelEnum::ERROR, "Error posting: #{e.message}", nil)
       return ResponseModel.new.set_error(e.message) # Return error response
     end
   end

data/lib/vwo/packages/network_layer/models/request_model.rb

@@ -13,9 +13,9 @@
 # limitations under the License.
 
 class RequestModel
-    attr_accessor :url, :method, :path, :query, :timeout, :body, :headers, :scheme, :port
+    attr_accessor :url, :method, :path, :query, :timeout, :body, :headers, :scheme, :port, :last_error, :retry_config, :event_name, :uuid, :campaign_id, :event_properties
   
-    def initialize(url, method = 'GET', path = '', query = {}, body = {}, headers = {}, scheme = 'https', port = nil)
+    def initialize(url, method = 'GET', path = '', query = {}, body = {}, headers = {}, scheme = 'https', port = nil, retry_config = nil)
       @url = scheme + '://' + url
       @method = method
       @path = path
@@ -25,6 +25,12 @@ class RequestModel
       @headers = headers
       @scheme = scheme
       @port = port
+      @last_error = nil
+      @retry_config = retry_config
+      @event_name = nil
+      @uuid = nil
+      @campaign_id = nil
+      @event_properties = nil
       if !@port.nil?
         @url = @url + ':' + @port.to_s
       end
@@ -33,7 +39,7 @@ class RequestModel
     end
   
     def parse_options
-      hostname, collection_prefix = @url.split('/')
+      _hostname, collection_prefix = @url.split('/')
       
       # Process body if present
       if !@body.nil?
@@ -141,5 +147,33 @@ class RequestModel
     def get_url
       @url
     end 
-  end
+
+    def set_last_error(last_error)
+      @last_error = last_error
+    end
+
+    def get_last_error
+      @last_error
+    end
+
+    def get_retry_config
+      @retry_config
+    end
+
+    def set_retry_config(retry_config)
+      @retry_config = retry_config
+    end
+
+    def get_extra_info
+      extra_info = {}
+      white_listed_keys = [:event_name, :uuid, :campaign_id, :event_properties]
+      
+      white_listed_keys.each do |key|
+        value = instance_variable_get("@#{key}")
+        extra_info[key] = value if !value.nil?
+      end
+      
+      extra_info
+    end
+end
   

data/lib/vwo/packages/network_layer/models/response_model.rb

@@ -13,13 +13,14 @@
 # limitations under the License.
 
 class ResponseModel
-    attr_accessor :status_code, :error, :headers, :data
+    attr_accessor :status_code, :error, :headers, :data, :total_attempts
   
     def initialize
       @status_code = nil
       @error = nil
       @headers = {}
       @data = nil
+      @total_attempts = 0
     end
   
     def set_status_code(code)
@@ -49,5 +50,13 @@ class ResponseModel
     def get_status_code
       @status_code
     end
+
+    def set_total_attempts(total_attempts)
+      @total_attempts = total_attempts
+    end
+
+    def get_total_attempts
+      @total_attempts
+    end
   end
   

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

@@ -23,6 +23,7 @@ require_relative '../../../models/user/context_vwo_model'
 require_relative '../../../services/settings_service'
 require_relative '../../../utils/data_type_util'
 require_relative '../../../enums/log_level_enum'
+require_relative '../../../enums/api_enum'
 class SegmentationManager
   @@instance = nil # Singleton instance
 
@@ -64,7 +65,7 @@ class SegmentationManager
           vwo_data = get_from_gateway_service(params, UrlEnum::GET_USER_DATA)
           context.set_vwo(ContextVWOModel.new.model_from_dictionary(vwo_data))
         rescue StandardError => e
-          LoggerService.log(LogLevelEnum::ERROR, "Error in setting contextual data for segmentation. Got error: #{e.message}", nil)
+          LoggerService.log(LogLevelEnum::ERROR, "ERROR_SETTING_SEGMENTATION_CONTEXT", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
         end
       end
     end

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

@@ -24,6 +24,8 @@ require_relative '../core/segmentation_manager'
 require_relative '../utils/segment_util'
 require_relative './segment_operand_evaluator'
 require_relative '../../../enums/log_level_enum'
+require_relative '../../../enums/api_enum'
+
 class SegmentEvaluator
   attr_accessor :context, :settings, :feature
 
@@ -100,7 +102,7 @@ class SegmentEvaluator
               return !result if feature_id_value == 'off'
               return result
             else
-              LoggerService.log(LogLevelEnum::ERROR, "Feature not found with featureIdKey: #{feature_id_key}", nil)
+              LoggerService.log(LogLevelEnum::INFO, "Feature not found with featureIdKey: #{feature_id_key}", nil)
               return nil
             end
           end
@@ -146,7 +148,7 @@ class SegmentEvaluator
   # @return [Boolean] True if the location pre-segmentation is valid, false otherwise
   def check_location_pre_segmentation(location_map)
     unless @context&.get_ip_address
-      LoggerService.log(LogLevelEnum::ERROR, 'To evaluate location pre Segment, please pass ipAddress in context object', nil)
+      LoggerService.log(LogLevelEnum::ERROR, 'INVALID_IP_ADDRESS_IN_CONTEXT_FOR_PRE_SEGMENTATION', { an: ApiEnum::GET_FLAG, sId: @context.get_session_id, uuid: @context.get_uuid})
       return false
     end
     
@@ -162,7 +164,7 @@ class SegmentEvaluator
   # @return [Boolean] True if the user agent parser is valid, false otherwise
   def check_user_agent_parser(ua_parser_map)
     unless @context&.get_user_agent
-      LoggerService.log(LogLevelEnum::ERROR, 'To evaluate user agent related segments, please pass userAgent in context object', nil)
+      LoggerService.log(LogLevelEnum::ERROR, 'INVALID_USER_AGENT_IN_CONTEXT_FOR_PRE_SEGMENTATION', { an: ApiEnum::GET_FLAG, sId: @context.get_session_id, uuid: @context.get_uuid})
       return false
     end
 

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

@@ -22,6 +22,7 @@ require_relative '../../../enums/url_enum'
 require_relative '../../../services/logger_service'
 require_relative '../../../models/user/context_model'
 require_relative '../../../enums/log_level_enum'
+require_relative '../../../enums/api_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.
@@ -45,7 +46,7 @@ class SegmentOperandEvaluator
     if operand.include?('inlist')
       match = operand.match(/inlist\(([^)]+)\)/)
       unless match
-        LoggerService.log(LogLevelEnum::ERROR, "Invalid 'inList' operand format", nil)
+        LoggerService.log(LogLevelEnum::ERROR, "INVALID_ATTRIBUTE_LIST_FORMAT", { an: ApiEnum::GET_FLAG, sId: @context.get_session_id, uuid: @context.get_uuid})
         return false
       end
 
@@ -62,7 +63,7 @@ class SegmentOperandEvaluator
         end
         return res
       rescue StandardError => e
-        LoggerService.log(LogLevelEnum::ERROR, "Error while fetching data: #{e}", nil)
+        LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_DATA_FROM_GATEWAY", { err: e.message, an: ApiEnum::GET_FLAG, sId: @context.get_session_id, uuid: @context.get_uuid})
         return false
       end
 

data/lib/vwo/services/logger_service.rb

@@ -17,13 +17,15 @@ require_relative '../vwo_client'
 require_relative '../packages/logger/core/log_manager'
 require_relative '../enums/log_level_enum'
 require_relative '../utils/log_message_util'
+require_relative '../enums/debug_category_enum'
+require_relative '../utils/debugger_service_util'
 
 class LoggerService
   class << self
     attr_accessor :debug_messages, :info_messages, :error_messages, :warning_messages
   end
 
-  def self.log(level, key = nil, map = {})
+  def self.log(level, key = nil, map = {}, should_send_to_vwo = true)
     log_manager = LogManager.instance
 
     if key && map
@@ -41,6 +43,10 @@ class LoggerService
       log_manager.warn(message)
     else
       log_manager.error(message)
+      if should_send_to_vwo
+        # print log
+        self.send_log_to_vwo(key, message, map)
+      end
     end
   end
 
@@ -80,4 +86,18 @@ class LoggerService
       @error_messages
     end
   end
+
+  def self.send_log_to_vwo(template, message, debug_props = {})
+    # send debugger event to VWO
+    begin
+      debug_props[:msg_t] = template
+      debug_props[:msg] = message
+      debug_props[:lt] = LogLevelEnum::ERROR
+      debug_props[:cg] = DebugCategoryEnum::ERROR
+
+      DebuggerServiceUtil.send_debugger_event(debug_props)
+    rescue StandardError => e
+      puts "[VWO-SDK] ERROR: Error sending log to VWO: #{e.message}"
+    end
+  end
 end