rudder-sdk-ruby 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52b1b8f35eb08a1605158c6b2e4c5b2a2ee2a1be857feec7bb6dec09b5588a3f
-  data.tar.gz: 1fc177549a89b5815d3f1b9040305b9b97b4be2dbe6b752e611a433ac45a4c45
+  metadata.gz: 0c9b8eb6cc946f9d16599987f88eba38e8144ceb857dc546d100c71a060c4d96
+  data.tar.gz: a06fe89b9b8a79b6d3a0699efe079056c71f0c2a7220b2c38941685e6856f464
 SHA512:
-  metadata.gz: 7bfb7b5aa455e71191996319567c7e06a4e2b15133439b187fa1028991a15620697b3baa17523bffe0be5aa372263423a6048b70fac11c85592be272eedb48d7
-  data.tar.gz: 3baffcfa0311bdcdd9cd120426f7a3f04f0c2b482bc9b57f382dad1301486d8b3c41b6ac467143a384352a88c3b005fc145ad5746e0c7da9a7a7a028e4cc0ca9
+  metadata.gz: 61c607dc7ca890d18b76f15caed8f7fb5ca11f6af1e3d11084eec7867c2df4ca2aa9247a64ff429899ac34b0d33d8a5e0be78cfb865a242821efb7a6456f6d66
+  data.tar.gz: 8bcde926a31525d8d60e6a3e534fc0806cfcb5db15dfb1da7402ffe4b44ef4bc77ac66ce19500f2200f96387382ca0da59625a38553f58617cc4a61bf4888bd2

data/lib/rudder/analytics/backoff_policy.rb

@@ -15,36 +15,30 @@ module Rudder
       # @option opts [Numeric] :randomization_factor The randomization factor
       #   to use to create a range around the retry interval
       def initialize(opts = {})
-        @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
-        @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
-        @multiplier = opts[:multiplier] || MULTIPLIER
-        @randomization_factor = opts[:randomization_factor] || RANDOMIZATION_FACTOR
+        @min_timeout_ms = [opts[:min_timeout_ms] || MIN_TIMEOUT_MS, 0].max
+        @max_timeout_ms = [opts[:max_timeout_ms] || MAX_TIMEOUT_MS, 0].max
+        @multiplier = [opts[:multiplier] || MULTIPLIER, 0].max
+        @randomization_factor = [[opts[:randomization_factor] || RANDOMIZATION_FACTOR, 0].max, 1].min
 
         @attempts = 0
       end
 
       # @return [Numeric] the next backoff interval, in milliseconds.
-      def next_interval
-        interval = @min_timeout_ms * (@multiplier**@attempts)
+      def next_interval(floor_ms = 0)
+        interval = [@min_timeout_ms * (@multiplier**@attempts), @max_timeout_ms].min
+        interval = [interval, floor_ms].max
         interval = add_jitter(interval, @randomization_factor)
 
         @attempts += 1
-
-        [interval, @max_timeout_ms].min
+        interval
       end
 
       private
 
       def add_jitter(base, randomization_factor)
-        random_number = rand
-        max_deviation = base * randomization_factor
-        deviation = random_number * max_deviation
-
-        if random_number < 0.5
-          base - deviation
-        else
-          base + deviation
-        end
+        return base if base <= 0 || randomization_factor <= 0
+
+        base + (rand * base * randomization_factor)
       end
     end
   end

data/lib/rudder/analytics/configuration.rb

@@ -7,7 +7,9 @@ module Rudder
     class Configuration
       include Rudder::Analytics::Utils
 
-      attr_reader :write_key, :data_plane_url, :on_error, :on_error_with_messages, :stub, :gzip, :ssl, :batch_size, :test, :max_queue_size, :backoff_policy, :retries
+      attr_reader :write_key, :data_plane_url, :on_error, :on_error_with_messages, :stub, :gzip, :ssl, :batch_size,
+                  :test, :max_queue_size, :backoff_policy, :retries, :retry_base_delay, :max_retry_delay,
+                  :retry_jitter_ratio, :respect_retry_after
 
       def initialize(settings = {})
         symbolized_settings = symbolize_keys(settings)
@@ -23,12 +25,42 @@ module Rudder
         @batch_size = symbolized_settings[:batch_size] || Defaults::MessageBatch::MAX_SIZE
         @gzip = symbolized_settings[:gzip]
         @backoff_policy = symbolized_settings[:backoff_policy]
-        @retries = symbolized_settings[:retries]
+        configure_retry(symbolized_settings)
         raise ArgumentError, 'Missing required option :write_key' \
           unless @write_key
         raise ArgumentError, 'Data plane url must be initialized' \
           unless @data_plane_url
       end
+
+      private
+
+      def configure_retry(settings)
+        @retries = settings[:retries]
+        @retry_base_delay = normalize_non_negative_integer(settings[:retry_base_delay])
+        @max_retry_delay = normalize_non_negative_integer(
+          settings[:max_retry_delay] || settings[:maximum_backoff_duration]
+        )
+        @retry_jitter_ratio = normalize_jitter_ratio(settings[:retry_jitter_ratio])
+        @respect_retry_after = normalize_respect_retry_after(settings)
+      end
+
+      def normalize_non_negative_integer(value)
+        return nil if value.nil?
+
+        [value.to_i, 0].max
+      end
+
+      def normalize_jitter_ratio(value)
+        return nil if value.nil?
+
+        [[value.to_f, 0.0].max, 1.0].min
+      end
+
+      def normalize_respect_retry_after(settings)
+        return nil unless settings.has_key?(:respect_retry_after)
+
+        settings[:respect_retry_after] ? true : false
+      end
     end
   end
 end

data/lib/rudder/analytics/defaults.rb

@@ -11,6 +11,7 @@ module Rudder
                     'Content-Type' => 'application/json',
                     'Content-Encoding' => 'gzip' }
         RETRIES = 10
+        MAX_RETRIES = RETRIES - 1
       end
 
       module Queue
@@ -28,9 +29,9 @@ module Rudder
 
       module BackoffPolicy
         MIN_TIMEOUT_MS = 100
-        MAX_TIMEOUT_MS = 10000
-        MULTIPLIER = 1.5
-        RANDOMIZATION_FACTOR = 0.5
+        MAX_TIMEOUT_MS = 30000
+        MULTIPLIER = 2
+        RANDOMIZATION_FACTOR = 0.2
       end
     end
   end

data/lib/rudder/analytics/field_parser.rb

@@ -74,14 +74,12 @@ module Rudder
           check_string(group_id, 'group_id')
 
           group_data = {
-            type: 'group',
-            groupId: group_id
+            :type => 'group',
+            :groupId => group_id
           }
 
           # Add traits if present
-          if fields[:traits]
-            group_data[:traits] = fields[:traits]
-          end          
+          group_data[:traits] = fields[:traits] if fields[:traits]
 
           common.merge(group_data)
         end

data/lib/rudder/analytics/retry_policy.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'rudder/analytics/backoff_policy'
+require 'rudder/analytics/defaults'
+require 'net/http'
+require 'net/https'
+require 'time'
+
+module Rudder
+  class Analytics
+    class RetryPolicy
+      include Rudder::Analytics::Defaults::Request
+
+      RETRYABLE_ERRORS = [
+        Timeout::Error,
+        EOFError,
+        IOError,
+        SocketError,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH,
+        Errno::ETIMEDOUT,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        Net::ProtocolError,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      attr_reader :backoff_policy, :max_retries
+
+      def self.from_config(config)
+        backoff_policy = config.backoff_policy || Rudder::Analytics::BackoffPolicy.new(backoff_options(config))
+        new(
+          :retries => config.retries.nil? ? RETRIES : config.retries,
+          :respect_retry_after => config.respect_retry_after.nil? ? true : config.respect_retry_after,
+          :backoff_policy => backoff_policy
+        )
+      end
+
+      def self.backoff_options(config)
+        {
+          :min_timeout_ms => config.retry_base_delay || BackoffPolicy::MIN_TIMEOUT_MS,
+          :max_timeout_ms => config.max_retry_delay || BackoffPolicy::MAX_TIMEOUT_MS,
+          :multiplier => BackoffPolicy::MULTIPLIER,
+          :randomization_factor => config.retry_jitter_ratio || BackoffPolicy::RANDOMIZATION_FACTOR
+        }
+      end
+
+      def initialize(options = {})
+        @max_retries = normalize_max_retries(options)
+        @respect_retry_after = options.has_key?(:respect_retry_after) ? options[:respect_retry_after] : true
+        @backoff_policy = options[:backoff_policy] || Rudder::Analytics::BackoffPolicy.new
+      end
+
+      def max_attempts
+        @max_retries + 1
+      end
+
+      def retryable_status_code?(status_code)
+        status_code.zero? || status_code == 429 || (status_code >= 500 && status_code <= 599)
+      end
+
+      def retryable_exception?(exception)
+        RETRYABLE_ERRORS.any? { |error_class| exception.is_a?(error_class) }
+      end
+
+      def retry_delay_in_seconds(headers = {})
+        interval = next_backoff_interval(retry_after_delay_in_milliseconds(headers))
+        interval.to_f / 1000
+      end
+
+      private
+
+      def normalize_max_retries(options)
+        if options.has_key?(:max_retries)
+          [options[:max_retries].to_i, 0].max
+        elsif options.has_key?(:retries)
+          [options[:retries].to_i - 1, 0].max
+        else
+          MAX_RETRIES
+        end
+      end
+
+      def next_backoff_interval(retry_after_delay)
+        if @backoff_policy.method(:next_interval).arity.zero?
+          [@backoff_policy.next_interval, retry_after_delay].max
+        else
+          @backoff_policy.next_interval(retry_after_delay)
+        end
+      end
+
+      def retry_after_delay_in_milliseconds(headers)
+        return 0 unless @respect_retry_after
+
+        value = header_value(headers, 'Retry-After')
+        return 0 if value.nil?
+
+        parse_retry_after_delay(value)
+      end
+
+      def header_value(headers, name)
+        headers.find { |header_name, _| header_name.to_s.casecmp(name).zero? }&.last
+      end
+
+      def parse_retry_after_delay(value)
+        value = value.to_s.strip
+        return value.to_i * 1000 if value.match?(/\A\d+\z/)
+
+        retry_at = Time.httpdate(value)
+        [((retry_at - Time.now) * 1000).ceil, 0].max
+      rescue ArgumentError
+        0
+      end
+    end
+  end
+end

data/lib/rudder/analytics/transport.rb

@@ -5,6 +5,7 @@ require 'rudder/analytics/utils'
 require 'rudder/analytics/response'
 require 'rudder/analytics/logging'
 require 'rudder/analytics/backoff_policy'
+require 'rudder/analytics/retry_policy'
 require 'net/http'
 require 'net/https'
 require 'json'
@@ -23,8 +24,9 @@ module Rudder
       def initialize(config)
         @stub = config.stub || false
         @path = PATH
-        @retries = config.retries || RETRIES
-        @backoff_policy = config.backoff_policy || Rudder::Analytics::BackoffPolicy.new
+        @retry_policy = Rudder::Analytics::RetryPolicy.from_config(config)
+        @retries = @retry_policy.max_attempts
+        @backoff_policy = @retry_policy.backoff_policy
 
         uri = URI(config.data_plane_url)
 
@@ -37,88 +39,93 @@ module Rudder
         @gzip = config.gzip.nil? ? true : config.gzip
       end
 
-      # Sends a batch of messages to the API
-      #
-      # @return [Response] API response
       def send(write_key, batch)
         logger.debug("Sending request for #{batch.length} items")
 
-        last_response, exception = retry_with_backoff(@retries) do
-          status_code, body = send_request(write_key, batch)
-          error = body
-          # rudder server now return 'OK'
-          # begin
-          #     error = JSON.parse(body)['error']
-          # rescue StandardError
-          #   error = JSON.parse(body.to_json)
-          #       end
-
-          # puts error
-          should_retry = should_retry_request?(status_code, body)
-          logger.debug("Response status code: #{status_code}")
-          logger.debug("Response error: #{error}") if error
-
-          [Response.new(status_code, error), should_retry]
-        end
+        retries = 0
 
-        if exception
-          logger.error(exception.message)
-          exception.backtrace.each { |line| logger.error(line) }
-          Response.new(-1, exception.to_s)
-        else
-          last_response
+        loop do
+          begin
+            response, headers = build_response(write_key, batch)
+            return response unless should_retry_request?(response.status, response.error)
+            return response unless retries_remaining?(retries)
+
+            retries = retry_request(retries, headers, "status #{response.status}")
+          rescue StandardError => e
+            return error_response(e) unless retryable_exception?(e)
+            return error_response(e) unless retries_remaining?(retries)
+
+            retries = retry_exception(retries, e)
+          end
         end
       end
 
-      # Closes a persistent connection if it exists
       def shutdown
         @http.finish if @http.started?
       end
 
       private
 
+      def build_response(write_key, batch)
+        status_code, body, headers = send_request(write_key, batch)
+        error = body
+        logger.debug("Response status code: #{status_code}")
+        logger.debug("Response error: #{error}") if error
+
+        [Response.new(status_code, error), headers]
+      end
+
+      def retries_remaining?(retries)
+        retries < @retry_policy.max_retries
+      end
+
+      def retry_request(retries, headers, reason)
+        retries += 1
+        sleep_before_retry(retries, headers, reason)
+        retries
+      end
+
+      def retry_exception(retries, exception)
+        retries += 1
+        reset_connection
+        sleep_before_retry(retries, {}, "transport error #{exception.class.name}")
+        retries
+      end
+
       def should_retry_request?(status_code, body)
-        if status_code >= 500
-          true # Server error
-        elsif status_code == 429
-          true # Rate limited
-        elsif status_code >= 400
-          logger.error(body)
-          false # Client error. Do not retry, but log
-        else
-          false
-        end
+        logger.error(body) if status_code >= 400 && !retryable_status_code?(status_code)
+
+        retryable_status_code?(status_code)
       end
 
-      # Takes a block that returns [result, should_retry].
-      #
-      # Retries upto `retries_remaining` times, if `should_retry` is false or
-      # an exception is raised. `@backoff_policy` is used to determine the
-      # duration to sleep between attempts
-      #
-      # Returns [last_result, raised_exception]
-      def retry_with_backoff(retries_remaining, &block)
-        result, caught_exception = nil
-        should_retry = false
-
-        begin
-          result, should_retry = yield
-          return [result, nil] unless should_retry
-        rescue StandardError => e
-          should_retry = true
-          caught_exception = e
-        end
+      def retryable_status_code?(status_code)
+        @retry_policy.retryable_status_code?(status_code)
+      end
 
-        if should_retry && (retries_remaining > 1)
-          logger.debug("Retrying request, #{retries_remaining} retries left")
-          sleep(@backoff_policy.next_interval.to_f / 1000)
-          retry_with_backoff(retries_remaining - 1, &block)
-        else
-          [result, caught_exception]
-        end
+      def retryable_exception?(exception)
+        @retry_policy.retryable_exception?(exception)
+      end
+
+      def sleep_before_retry(retry_number, headers, reason)
+        delay = @retry_policy.retry_delay_in_seconds(headers)
+        remaining = @retry_policy.max_retries - retry_number
+        logger.debug("Retrying request after #{reason} in #{delay}s " \
+                     "(attempt #{retry_number} of #{@retry_policy.max_attempts}, #{remaining} retries left)")
+        sleep(delay) if delay.positive?
+      end
+
+      def error_response(exception)
+        logger.error(exception.message)
+        exception.backtrace&.each { |line| logger.error(line) }
+        Response.new(-1, exception.to_s)
+      end
+
+      def reset_connection
+        @http.finish if @http.started?
+      rescue StandardError
+        nil
       end
 
-      # Sends a request for the batch, returns [status_code, body]
       def send_request(write_key, batch)
         payload = {
           :batch => batch.messages
@@ -127,27 +134,39 @@ module Rudder
           logger.debug "stubbed request to #{@path}: " \
             "write key = #{write_key}, batch = #{JSON.generate(payload)}"
 
-          [200, '{}']
+          [200, '{}', {}]
         else
 
-          headers = HEADERS
-
-          if @gzip
-            gzip = Zlib::GzipWriter.new(StringIO.new)
-            gzip << payload.to_json
-            payload = gzip.close.string
-          else
-            headers.delete('Content-Encoding')
-            payload = JSON.generate(payload)
-          end
+          payload, headers = encoded_payload(payload)
 
           request = Net::HTTP::Post.new(@path, headers)
           request.basic_auth(write_key, nil)
           @http.start unless @http.started? # Maintain a persistent connection
           response = @http.request(request, payload)
-          [response.code.to_i, response.body]
+          [response.code.to_i, response.body, response_headers(response)]
         end
       end
+
+      def encoded_payload(payload)
+        headers = HEADERS.dup
+
+        if @gzip
+          gzip = Zlib::GzipWriter.new(StringIO.new)
+          gzip << payload.to_json
+          payload = gzip.close.string
+        else
+          headers.delete('Content-Encoding')
+          payload = JSON.generate(payload)
+        end
+
+        [payload, headers]
+      end
+
+      def response_headers(response)
+        headers = {}
+        response.each_header { |name, value| headers[name] = value }
+        headers
+      end
     end
   end
 end

data/lib/rudder/analytics/version.rb

@@ -2,6 +2,6 @@
 
 module Rudder
   class Analytics
-    VERSION = '3.1.1'
+    VERSION = '3.2.0'
   end
 end

data/lib/rudder/analytics/worker.rb

@@ -47,8 +47,8 @@ module Rudder
 
           # res = Request.new(:data_plane_url => @data_plane_url, :ssl => @ssl).post @write_key, @batch
           res = @transport.send @write_key, @batch
-          unless res.status == 200
-            @on_error.call(res.status, res.error) 
+          unless success_status?(res.status)
+            @on_error.call(res.status, res.error)
             @on_error_with_messages.call(res.status, res.error, @batch.messages)
           end
 
@@ -66,6 +66,10 @@ module Rudder
 
       private
 
+      def success_status?(status)
+        status >= 200 && status < 300
+      end
+
       def consume_message_from_queue!
         @batch << @queue.pop
       rescue MessageBatch::JSONGenerationError => e

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rudder-sdk-ruby
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Rudder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-26 00:00:00.000000000 Z
+date: 2026-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -141,6 +141,7 @@ files:
 - lib/rudder/analytics/logging.rb
 - lib/rudder/analytics/message_batch.rb
 - lib/rudder/analytics/response.rb
+- lib/rudder/analytics/retry_policy.rb
 - lib/rudder/analytics/test_queue.rb
 - lib/rudder/analytics/transport.rb
 - lib/rudder/analytics/utils.rb