influxdb-client 1.16.0.pre.2686 → 1.16.0.pre.2765

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1980343bc130f3760b59ec721021be779263747c0cd441e30212ceacc821d65b
-  data.tar.gz: f8c77313016a4b78eeebb82ad30c4b5a3a1275ce36d7e0b381f442f2c7bc7567
+  metadata.gz: 877a4c787f2606b1500f37957bdab29e4c58a9a8c810ac1d324aefb207dd476b
+  data.tar.gz: 61920b4d1ecfd0b52b74177f723fc85aac6d06185d2ccd529179b7b9531fac47
 SHA512:
-  metadata.gz: 48b584e2e946aa3cc5a5db8135a38c155d88e75403bb771a156f4b3537f0c3d4266aa744f2d9d697a07ee9f075485af06efb738ae2190e7d57566282cd00f072
-  data.tar.gz: dc19ef50dbeb2dbb5e0bb1822ab83ae359418409dd008c41d97be0c0059ebbf58981efeb134485bc0fdfb7d03778443c6f158254915c50e81b6ad285a3d8dd1f
+  metadata.gz: 4e19378ef8f37121af2e834142cc5877f045a09ce1ecd903dc39cd7078bc61fbc2fd3dbb9f6b59ed2fe1217eb551b2ccc1eac81c5224a9ea1678f470ec209fc9
+  data.tar.gz: c6f38e24dae4bd27523b3727484f71973526ee7624c6b0678ccb88eb3d9a8b2a71eb34b698002359f99fe09841af883bace23c6b619cf5d88c6663e458288cf7

data/README.md

@@ -159,13 +159,14 @@ The writes are processed in batches which are configurable by `WriteOptions`:
 
 | Property | Description | Default Value |
 | --- | --- | --- |
-| batchSize | the number of data point to collect in batch | 1000 |
-| flush_interval | the number of milliseconds before the batch is written | 1000 |
-| retry_interval | the number of milliseconds to retry unsuccessful write. The retry interval is used when the InfluxDB server does not specify "Retry-After" header. | 5000 |
+| batchSize | the number of data point to collect in batch | 1_000 |
+| flush_interval | the number of milliseconds before the batch is written | 1_000 |
+| retry_interval | the number of milliseconds to retry unsuccessful write. The retry interval is used when the InfluxDB server does not specify "Retry-After" header. | 5_000 |
 | jitter_interval | the number of milliseconds to increase the batch flush interval by a random amount | 0 |
 | max_retries | the number of max retries when write fails | 5 |
-| max_retry_delay | maximum delay when retrying write in milliseconds | 180000 |
-| exponential_base | the base for the exponential retry delay, the next delay is computed as `retry_interval * exponential_base^(attempts - 1) + random(jitter_interval)` | 5 |
+| max_retry_delay | maximum delay when retrying write in milliseconds | 125_000 |
+| max_retry_time | maximum total retry timeout in milliseconds | 180_000 |
+| exponential_base | the base for the exponential retry delay, the next delay is computed using random exponential backoff as a random value within the interval  ``retry_interval * exponential_base^(attempts-1)`` and ``retry_interval * exponential_base^(attempts)``. Example for ``retry_interval=5000, exponential_base=2, max_retry_delay=125000, total=5`` Retry delays are random distributed values within the ranges of ``[5000-10000, 10000-20000, 20000-40000, 40000-80000, 80000-125000]`` | 2 |
 | batch_abort_on_exception | the batching worker will be aborted after failed retry strategy | false |
 ```ruby
 write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,

data/lib/influxdb-client.rb

@@ -28,3 +28,4 @@ require 'influxdb2/client/delete_api'
 require 'influxdb2/client/health_api'
 require 'influxdb2/client/point'
 require 'influxdb2/client/flux_table'
+require 'influxdb2/client/write_retry'

data/lib/influxdb2/client/worker.rb

@@ -96,36 +96,28 @@ module InfluxDB2
 
     def _write(data)
       data.each do |key, points|
-        _write_raw(key, points, 1, @write_options.retry_interval)
+        _write_raw(key, points)
       end
     end
 
-    def _write_raw(key, points, attempts, retry_interval)
+    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
+      )
+
       if @write_options.jitter_interval > 0
         jitter_delay = (@write_options.jitter_interval.to_f / 1_000) * rand
         sleep jitter_delay
       end
-      @api_client.write_raw(points.join("\n"), precision: key.precision, bucket: key.bucket, org: key.org)
-    rescue InfluxError => e
-      raise e if attempts > @write_options.max_retries
-      raise e if (e.code.nil? || e.code.to_i < 429) && !_connection_error(e.original)
-
-      timeout = if e.retry_after.empty?
-                  [retry_interval.to_f, @write_options.max_retry_delay.to_f].min / 1_000
-                else
-                  e.retry_after.to_f
-                end
-
-      message = 'The retriable error occurred during writing of data. '\
-"Reason: '#{e.message}'. Retry in: #{timeout}s."
-
-      @api_client.log(:warn, message)
-      sleep timeout
-      _write_raw(key, points, attempts + 1, retry_interval * @write_options.exponential_base)
-    end
 
-    def _connection_error(error)
-      InfluxError::HTTP_ERRORS.any? { |c| error.instance_of? c }
+      write_retry.retry do
+        @api_client.write_raw(points.join("\n"), precision: key.precision, bucket: key.bucket, org: key.org)
+      end
     end
   end
 end

data/lib/influxdb2/client/write_api.rb

@@ -36,19 +36,23 @@ module InfluxDB2
     # @param [Integer] jitter_interval: the number of milliseconds to increase the batch flush interval
     # @param [Integer] max_retries: max number of retries when write fails
     # @param [Integer] max_retry_delay: maximum delay when retrying write in milliseconds
-    #   by a random amount
-    # @param [Integer] exponential_base: base for the exponential retry delay, the next delay is computed as
-    #   "exponential_base^(attempts-1) + random(jitter_interval)"
+    # @param [Integer] max_retry_time: maximum total retry timeout in milliseconds
+    # @param [Integer] exponential_base: the next delay is computed using random exponential backoff as a random value
+    #   within the interval retry_interval*exponential_base^(attempts-1) and retry_interval*exponential_base^(attempts).
+    #   Example for retry_interval=5000, exponential_base=2, max_retry_delay=125000, total=5
+    #   Retry delays are random distributed values within the ranges of
+    #   [5000-10000, 10000-20000, 20000-40000, 40000-80000, 80000-125000]
     # @param [Boolean] batch_abort_on_exception: batching worker will be aborted after failed retry strategy
     def initialize(write_type: WriteType::SYNCHRONOUS, batch_size: 1_000, flush_interval: 1_000, retry_interval: 5_000,
-                   jitter_interval: 0, max_retries: 5, max_retry_delay: 180_000, exponential_base: 5,
-                   batch_abort_on_exception: false)
+                   jitter_interval: 0, max_retries: 5, max_retry_delay: 125_000, max_retry_time: 180_000,
+                   exponential_base: 2, batch_abort_on_exception: false)
       _check_not_negative('batch_size', batch_size)
       _check_not_negative('flush_interval', flush_interval)
       _check_not_negative('retry_interval', retry_interval)
       _check_positive('jitter_interval', jitter_interval)
-      _check_positive('max_retries', jitter_interval)
-      _check_positive('max_retry_delay', jitter_interval)
+      _check_positive('max_retries', max_retries)
+      _check_positive('max_retry_delay', max_retry_delay)
+      _check_positive('max_retry_time', max_retry_time)
       _check_positive('exponential_base', exponential_base)
       @write_type = write_type
       @batch_size = batch_size
@@ -57,12 +61,13 @@ module InfluxDB2
       @jitter_interval = jitter_interval
       @max_retries = max_retries
       @max_retry_delay = max_retry_delay
+      @max_retry_time = max_retry_time
       @exponential_base = exponential_base
       @batch_abort_on_exception = batch_abort_on_exception
     end
 
     attr_reader :write_type, :batch_size, :flush_interval, :retry_interval, :jitter_interval,
-                :max_retries, :max_retry_delay, :exponential_base, :batch_abort_on_exception
+                :max_retries, :max_retry_delay, :max_retry_time, :exponential_base, :batch_abort_on_exception
 
     def _check_not_negative(key, value)
       raise ArgumentError, "The '#{key}' should be positive or zero, but is: #{value}" if value <= 0

data/lib/influxdb2/client/write_retry.rb

@@ -0,0 +1,104 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module InfluxDB2
+  # Exponential random write retry.
+  class WriteRetry
+    @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.
+    # @option options [Integer] :retry_interval (5000) number of milliseconds to retry unsuccessful write.
+    # @option options [Integer] :max_retry_delay (125_000) maximum delay when retrying write in milliseconds.
+    # @option options [Integer] :max_retry_time (180_000) maximum total retry timeout in milliseconds.
+    # @option options [Integer] :exponential_base base for the exponential retry delay
+    # @option options [Integer] :jitter_delay random milliseconds added to write interval
+    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
+      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)
+      range_start = @retry_interval
+      range_stop = @retry_interval * @exponential_base
+
+      i = 1
+      while i < attempts
+        i += 1
+        range_start = range_stop
+        range_stop *= @exponential_base
+        break if range_stop > @max_retry_delay
+      end
+
+      range_stop = @max_retry_delay if range_stop > @max_retry_delay
+      range_start + (range_stop - range_start) * rand
+    end
+
+    # Runs the supplied code block with a exponential backoff retry strategy.
+    def retry
+      raise "#{@error_msg_prefix} must be passed a block" unless block_given?
+
+      attempts = 0
+      start_time = Time.now
+      begin
+        attempts += 1
+        yield attempts
+      rescue InfluxError => e
+        if attempts > @max_retries
+          @api_client.log(:error, 'Maximum retry attempts reached.')
+          raise e
+        end
+
+        if (Time.now - start_time) * 1000 > @max_retry_time
+          @api_client.log(:error, "Maximum retry time #{@max_retry_time} ms exceeded")
+          raise e
+        end
+
+        raise e if (e.code.nil? || e.code.to_i < 429) && !_connection_error(e.original)
+
+        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."
+
+        @api_client.log(:warn, message)
+        sleep timeout / 1000
+        retry
+      end
+    end
+
+    def _connection_error(error)
+      InfluxError::HTTP_ERRORS.any? { |c| error.instance_of? c }
+    end
+  end
+end

data/test/influxdb/write_api_batching_test.rb

@@ -292,9 +292,9 @@ class WriteApiRetryStrategyTest < MiniTest::Test
 
     @write_client.write(data: ['h2o_feet,location=coyote_creek water_level=1.0 1',
                                InfluxDB2::Point.new(name: 'h2o_feet')
-                                   .add_tag('location', 'coyote_creek')
-                                   .add_field('water_level', 2.0)
-                                   .time(2, InfluxDB2::WritePrecision::NANOSECOND)])
+                                               .add_tag('location', 'coyote_creek')
+                                               .add_field('water_level', 2.0)
+                                               .time(2, InfluxDB2::WritePrecision::NANOSECOND)])
 
     sleep(0.5)
 
@@ -342,32 +342,7 @@ class WriteApiRetryStrategyTest < MiniTest::Test
 
     @client.create_write_api(write_options: write_options).write(data: point)
 
-    sleep(0.5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 1, body: request)
-
-    sleep(2)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 2, body: request)
-
-    sleep(4)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 3, body: request)
-
-    sleep(5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 4, body: request)
-
-    sleep(5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 4, body: request)
-
-    sleep(5)
+    sleep(15)
 
     assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 4, body: request)
@@ -465,38 +440,14 @@ class WriteApiRetryStrategyTest < MiniTest::Test
     request = 'h2o,location=europe level=2.0'
 
     write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
-                                                batch_size: 1, retry_interval: 2_000, max_retries: 3,
+                                                batch_size: 1, retry_interval: 1000, max_retries: 3,
                                                 max_retry_delay: 5_000, exponential_base: 2)
 
     @client.create_write_api(write_options: write_options).write(data: point)
 
-    sleep(0.5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 1, body: request)
-
-    sleep(2)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 2, body: request)
-
-    sleep(4)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 3, body: request)
-
-    sleep(5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 4, body: request)
-
-    sleep(5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 4, body: request)
-
-    sleep(5)
-
+    # random sleep intervals
+    # [1000, 2000], [2000, 4000], [4000, 5000]
+    sleep(11)
     assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 4, body: request)
   end
@@ -519,22 +470,7 @@ class WriteApiRetryStrategyTest < MiniTest::Test
 
     @client.create_write_api(write_options: write_options).write(data: point)
 
-    sleep(0.5)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 1, body: request)
-
-    sleep(2)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 2, body: request)
-
-    sleep(4)
-
-    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 3, body: request)
-
-    sleep(5)
+    sleep(10)
 
     assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 3, body: request)
@@ -624,4 +560,61 @@ class WriteApiRetryStrategyTest < MiniTest::Test
 
     assert_equal(message, @logger.messages[0][1])
   end
+
+  def test_backoff_time_default
+    retries = InfluxDB2::WriteRetry.new
+
+    backoff = retries.get_backoff_time(1)
+    assert_gte backoff, 5_000
+    assert_lte backoff, 10_000
+
+    backoff = retries.get_backoff_time(2)
+    assert_gte backoff, 10_000
+    assert_lte backoff, 20_000
+
+    backoff = retries.get_backoff_time(3)
+    assert_gte backoff, 20_000
+    assert_lte backoff, 40_000
+
+    backoff = retries.get_backoff_time(4)
+    assert_gte backoff, 40_000
+    assert_lte backoff, 80_000
+
+    backoff = retries.get_backoff_time(5)
+    assert_gte backoff, 80_000
+    assert_lte backoff, 125_000
+
+    backoff = retries.get_backoff_time(6)
+    assert_gte backoff, 80_000
+    assert_lte backoff, 125_000
+  end
+
+  def test_backoff_time_custom
+    retries = InfluxDB2::WriteRetry.new(
+      max_retry_delay: 2_000,
+      retry_interval: 100,
+      exponential_base: 2,
+      max_retries: 5
+    )
+
+    backoff = retries.get_backoff_time(1)
+    assert_gte backoff, 100
+    assert_lte backoff, 200
+
+    backoff = retries.get_backoff_time(2)
+    assert_gte backoff, 200
+    assert_lte backoff, 400
+
+    backoff = retries.get_backoff_time(3)
+    assert_gte backoff, 400
+    assert_lte backoff, 800
+
+    backoff = retries.get_backoff_time(4)
+    assert_gte backoff, 800
+    assert_lte backoff, 1_600
+
+    backoff = retries.get_backoff_time(5)
+    assert_gte backoff, 1_600
+    assert_lte backoff, 2_000
+  end
 end

data/test/test_helper.rb

@@ -34,7 +34,7 @@ require 'influxdb-client'
 
 require 'minitest/autorun'
 require 'minitest/reporters'
-Minitest::Reporters.use!
+Minitest::Reporters.use! unless ENV['RM_INFO']
 
 require 'webmock/minitest'
 
@@ -46,6 +46,24 @@ class MockLogger
   end
 
   def add(level, &block)
-    @messages << [level, yield(block)]
+    line = yield(block)
+    print("#{line}\n")
+    @messages << [level, line]
   end
 end
+
+def assert_gt(val1, val2)
+  assert_operator val1, :>, val2
+end
+
+def assert_gte(val1, val2)
+  assert_operator val1, :>=, val2
+end
+
+def assert_lt(val1, val2)
+  assert_operator val1, :<, val2
+end
+
+def assert_lte(val1, val2)
+  assert_operator val1, :<=, val2
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: influxdb-client
 version: !ruby/object:Gem::Version
-  version: 1.16.0.pre.2686
+  version: 1.16.0.pre.2765
 platform: ruby
 authors:
 - Jakub Bednar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-04 00:00:00.000000000 Z
+date: 2021-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -151,6 +151,7 @@ files:
 - lib/influxdb2/client/version.rb
 - lib/influxdb2/client/worker.rb
 - lib/influxdb2/client/write_api.rb
+- lib/influxdb2/client/write_retry.rb
 - test/influxdb/client_test.rb
 - test/influxdb/default_api_test.rb
 - test/influxdb/delete_api_integration_test.rb