feat: batching write - exponential random backoff (code style fix)

Author: rhajek

lib/influxdb2/client/worker.rb

@@ -102,12 +102,12 @@ def _write(data)
 
     def _write_raw(key, points)
       write_retry = InfluxDB2::WriteRetry.new(
-        :api_client => @api_client,
-        :max_retries => @write_options.max_retries,
-        :exponential_base => @write_options.exponential_base,
-        :retry_interval => @write_options.retry_interval,
-        :max_retry_delay => @write_options.max_retry_delay,
-        :max_retry_time => @write_options.max_retry_time,
+        api_client: @api_client,
+        max_retries: @write_options.max_retries,
+        exponential_base: @write_options.exponential_base,
+        retry_interval: @write_options.retry_interval,
+        max_retry_delay: @write_options.max_retry_delay,
+        max_retry_time: @write_options.max_retry_time
       )
 
       if @write_options.jitter_interval > 0
@@ -119,6 +119,5 @@ def _write_raw(key, points)
         @api_client.write_raw(points.join("\n"), precision: key.precision, bucket: key.bucket, org: key.org)
       end
     end
-
   end
 end

lib/influxdb2/client/write_retry.rb

@@ -19,8 +19,9 @@
 # THE SOFTWARE.
 
 module InfluxDB2
+  # Exponential random write retry.
   class WriteRetry
-    @error_msg_prefix = "Error with options to with_retries:"
+    @error_msg_prefix = 'Error with options to with_retries:'
 
     # @param [Hash] options the retry options.
     # @option options [Integer] :max_retries (5) The maximum number of times to run the block.
@@ -33,14 +34,14 @@ def initialize(options = {})
       @api_client = options[:api_client]
       @max_retries = options[:max_retries] || 5
       raise "#{@error_msg_prefix} :max_retries must be greater than 0." unless @max_retries > 0
+
       @retry_interval = options[:retry_interval] || 5_000
       @max_retry_delay = options[:max_retry_delay] || 125_000
       @max_retry_time = options[:max_retry_time] || 180_000
       @exponential_base = options[:exponential_base] || 2
       @jitter_interval = options[:jitter_interval] || 0
-      if @retry_interval > @max_retry_delay
-        raise "#{@error_msg_prefix} :retry_interval cannot be greater than :max_retry_delay."
-      end
+      raise "#{@error_msg_prefix} :retry_interval cannot be greater than :max_retry_delay." if
+        @retry_interval > @max_retry_delay
     end
 
     def get_backoff_time(attempts)
@@ -51,7 +52,7 @@ def get_backoff_time(attempts)
       while i < attempts
         i += 1
         range_start = range_stop
-        range_stop = range_stop * @exponential_base
+        range_stop *= @exponential_base
         break if range_stop > @max_retry_delay
       end
 
@@ -60,17 +61,17 @@ def get_backoff_time(attempts)
     end
 
     # Runs the supplied code block with a exponential backoff retry strategy.
-    def retry(&block)
+    def retry
       raise "#{@error_msg_prefix} must be passed a block" unless block_given?
+
       attempts = 0
       start_time = Time.now
       begin
         attempts += 1
-        return block.call(attempts)
+        yield attempts
       rescue InfluxError => e
-
         if attempts > @max_retries
-          @api_client.log(:error, "Maximum retry attempts reached.")
+          @api_client.log(:error, 'Maximum retry attempts reached.')
           raise e
         end
 
@@ -81,11 +82,11 @@ def retry(&block)
 
         raise e if (e.code.nil? || e.code.to_i < 429) && !_connection_error(e.original)
 
-        if e.retry_after.nil? || e.retry_after.empty?
-          timeout = get_backoff_time(attempts)
-        else
-          timeout = (e.retry_after.to_f * 1000) + @jitter_interval * rand
-        end
+        timeout = if e.retry_after.nil? || e.retry_after.empty?
+                    get_backoff_time(attempts)
+                  else
+                    (e.retry_after.to_f * 1000) + @jitter_interval * rand
+                  end
 
         message = 'The retriable error occurred during writing of data. '\
     "Reason: '#{e.message}'. Retry in: #{timeout.to_f / 1000}s."
@@ -100,4 +101,4 @@ def _connection_error(error)
       InfluxError::HTTP_ERRORS.any? { |c| error.instance_of? c }
     end
   end
-end
+end

test/influxdb/write_api_batching_test.rb

@@ -450,7 +450,6 @@ def test_connection_error
     sleep(11)
     assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 4, body: request)
-
   end
 
   def test_write_connection_error
@@ -475,7 +474,6 @@ def test_write_connection_error
 
     assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 3, body: request)
-
   end
 
   def test_abort_on_exception
@@ -564,42 +562,39 @@ def test_retry_contains_message
   end
 
   def test_backoff_time_default
-
     retries = InfluxDB2::WriteRetry.new
 
     backoff = retries.get_backoff_time(1)
-    assert_gte backoff, 5000
-    assert_lte backoff, 10000
+    assert_gte backoff, 5_000
+    assert_lte backoff, 10_000
 
     backoff = retries.get_backoff_time(2)
-    assert_gte backoff, 10000
-    assert_lte backoff, 20000
+    assert_gte backoff, 10_000
+    assert_lte backoff, 20_000
 
     backoff = retries.get_backoff_time(3)
-    assert_gte backoff, 20000
-    assert_lte backoff, 40000
+    assert_gte backoff, 20_000
+    assert_lte backoff, 40_000
 
     backoff = retries.get_backoff_time(4)
-    assert_gte backoff, 40000
-    assert_lte backoff, 80000
+    assert_gte backoff, 40_000
+    assert_lte backoff, 80_000
 
     backoff = retries.get_backoff_time(5)
-    assert_gte backoff, 80000
-    assert_lte backoff, 125000
+    assert_gte backoff, 80_000
+    assert_lte backoff, 125_000
 
     backoff = retries.get_backoff_time(6)
-    assert_gte backoff, 80000
-    assert_lte backoff, 125000
-
+    assert_gte backoff, 80_000
+    assert_lte backoff, 125_000
   end
 
   def test_backoff_time_custom
-
     retries = InfluxDB2::WriteRetry.new(
-      :max_retry_delay => 2000,
-      :retry_interval => 100,
-      :exponential_base => 2,
-      :max_retries => 5,
+      max_retry_delay: 2_000,
+      retry_interval: 100,
+      exponential_base: 2,
+      max_retries: 5
     )
 
     backoff = retries.get_backoff_time(1)
@@ -616,12 +611,10 @@ def test_backoff_time_custom
 
     backoff = retries.get_backoff_time(4)
     assert_gte backoff, 800
-    assert_lte backoff, 1600
+    assert_lte backoff, 1_600
 
     backoff = retries.get_backoff_time(5)
-    assert_gte backoff, 1600
-    assert_lte backoff, 2000
-
+    assert_gte backoff, 1_600
+    assert_lte backoff, 2_000
   end
-
 end

test/test_helper.rb

@@ -52,18 +52,18 @@ def add(level, &block)
   end
 end
 
-def assert_gt(a, b)
-  assert_operator a, :>, b
+def assert_gt(val1, val2)
+  assert_operator val1, :>, val2
 end
 
-def assert_gte(a, b)
-  assert_operator a, :>=, b
+def assert_gte(val1, val2)
+  assert_operator val1, :>=, val2
 end
 
-def assert_lt(a, b)
-  assert_operator a, :<, b
+def assert_lt(val1, val2)
+  assert_operator val1, :<, val2
 end
 
-def assert_lte(a, b)
-  assert_operator a, :<=, b
-end
+def assert_lte(val1, val2)
+  assert_operator val1, :<=, val2
+end