faraday_loop 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d56c0d8c38f2280182be9196717e0c5d7d34d4fb379f0d8131980cf823001b7
+  data.tar.gz: 9ac03fb0cf3df5c99af7d8408c2108e6da5d23d637f062fa245fda830f03795e
+SHA512:
+  metadata.gz: 9d88120599802fd04ff91582d2428dd7ff419111308b68712d431242474ec892e714b3c4c7013135a054beba8171ba6486adee7bc8e2c97192e9bfea5f1ffea6
+  data.tar.gz: 0e89c8fc6a71b85f721b23090b9e53cca189b89230313a6d29badd13b8ac3bbd6344af24dc8dfa5bc0bb083b4689640c9f7d74162a721142fd0c0e0176bc797c

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-04-24
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in faraday_loop.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    faraday_loop (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.18.0)
+    rake (13.0.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  faraday_loop!
+  minitest (~> 5.0)
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.3.22

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Sutro Labs Inc.
+
+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.

data/README.md

@@ -0,0 +1,83 @@
+# Faraday Loop
+
+Ever need a nice way to retry a block of code? Maybe you need a maximum number of retries? Exponential backoff? Different handling for different exceptions?
+
+[Faraday](https://github.com/lostisland/faraday) has one!
+
+But, while Faraday is one nice piece of kit, you might not be in the market for an http client like Faraday and all of its Middelware.
+
+So we took the [Farday Retry Middleware](https://github.com/lostisland/faraday-retry), and just simply cloned it into its own utility.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add faraday_loop
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install faraday_loop
+
+## Usage
+
+You'll first need to require it:
+
+```ruby
+require 'faraday_loop'
+```
+
+Then, create a new instance of the retry utility, passing any options as needed:
+
+```ruby
+retry_utility = FaradayLoop::Retry.new(
+  max: 3,
+  interval: 1,
+  max_interval: 10,
+  interval_randomness: 0.5,
+  backoff_factor: 2,
+  exceptions: [MyCustomException],
+  retry_if: ->(e) { e.is_a?(MyCustomException) },
+  retry_block: ->(retries, e) { puts "Retry #{retries}: #{e.message}" }
+)
+```
+
+- max: The maximum number of retries (default: 2)
+- interval: The initial interval between retries in seconds (default: 0)
+- max_interval: The maximum interval between retries in seconds (default: Float::MAX)
+- interval_randomness: A factor to add randomness to the retry intervals (default: 0)
+- backoff_factor: The factor to multiply the interval by for each retry (default: 1)
+- exceptions: An array of exception classes to retry (default: Faraday::RetriableExceptions)
+- retry_if: A lambda that returns true if the exception should be retried (default: checks if the exception is in the exceptions array)
+- retry_block: An optional lambda that is called before each retry, passing in the current retry count and the exception raised
+
+Finally, wrap the operation you want to retry in a block:
+
+```ruby
+retry_utility.call do
+  # Your operation that might fail and require retries
+end
+```
+
+You can also shortcut this with:
+
+```ruby
+retry_utility = FaradayLoop::Retry(
+  options
+).retry do
+    # Your operation that might fail and require retries
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+Feedback
+--------
+[Source code available on Github](https://github.com/sutrolabs/faraday_loop). Feedback and pull requests are greatly appreciated. Let us know if we can improve this.
+
+From
+-----------
+:wave: The folks at lotisland really made this: https://github.com/lostisland/faraday-retry. We at [Census](http://getcensus.com) just hoisted it up.
+
+Interested in other things we do? **[Come work with us](https://www.getcensus.com/careers)**.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/lib/faraday_loop/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FaradayLoop
+  VERSION = "0.1.0"
+end

data/lib/faraday_loop.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "faraday_loop/version"
+
+module FaradayLoop
+  class Error < StandardError; end
+
+  # Clones the Faraday request retry middleware behavior.
+  # (https://github.com/lostisland/faraday/blob/v1.3.1/lib/faraday/request/retry.rb)
+  #
+  # Allows us to apply this familiar retry/backoff machinery outside of Faraday.
+  class Retry
+    def self.retry(
+      max: nil,
+      interval: nil,
+      max_interval: nil,
+      interval_randomness: nil,
+      backoff_factor: nil,
+      exceptions: nil,
+      retry_if: nil,
+      retry_block: nil,
+      &block
+    )
+      retry_handler =
+        Retry.new(
+          max: max,
+          interval: interval,
+          max_interval: max_interval,
+          interval_randomness: interval_randomness,
+          backoff_factor: backoff_factor,
+          exceptions: exceptions,
+          retry_if: retry_if,
+          retry_block: retry_block
+        )
+      retry_handler.call(&block)
+    end
+
+    DEFAULT_EXCEPTIONS = [StandardError].freeze
+    DEFAULT_CHECK = ->(_exception) { true }
+
+    def initialize(
+      max: nil,
+      interval: nil,
+      max_interval: nil,
+      interval_randomness: nil,
+      backoff_factor: nil,
+      exceptions: nil,
+      retry_if: nil,
+      retry_block: nil
+    )
+      @max = max || 2
+      @interval = interval || 0
+      @max_interval = max_interval || Float::MAX
+      @interval_randomness = interval_randomness || 0
+      @backoff_factor = backoff_factor || 1
+      @exceptions = Array(exceptions || DEFAULT_EXCEPTIONS)
+      @retry_if = retry_if || DEFAULT_CHECK
+      @retry_block = retry_block || proc { |_, _| }
+    end
+
+    def call(&block)
+      retries = @max
+      begin
+        block.call
+      rescue => e
+        # Yes, we really want to catch all error types here; the caller is in
+        # full control of which errors to retry.
+        raise unless matched_error?(e)
+
+        if retries.positive? && retry_request?(e)
+          retries -= 1
+          @retry_block.call(retries, e)
+          if (sleep_amount = calculate_retry_interval(retries + 1))
+            Kernel.sleep sleep_amount
+            retry
+          end
+        end
+
+        raise
+      end
+    end
+
+    private
+
+    def matched_error?(error)
+      @exceptions.any? do |ex|
+        if ex.is_a? Module
+          error.is_a? ex
+        else
+          error.class.to_s == ex.to_s
+        end
+      end
+    end
+
+    def retry_request?(exception)
+      @retry_if.call(exception)
+    end
+
+    def calculate_retry_interval(retries)
+      retry_index = @max - retries
+      current_interval = @interval * (@backoff_factor**retry_index)
+      current_interval = [current_interval, @max_interval].min
+      random_interval = rand * @interval_randomness.to_f * @interval
+      current_interval + random_interval
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: faraday_loop
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- n8
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-04-27 00:00:00.000000000 Z
+dependencies: []
+description: Faraday Loop provides an easy-to-use mechanism for retrying failed operations
+  in any Ruby application, independent of the full Faraday library.
+email:
+- nate@getcensus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/faraday_loop.rb
+- lib/faraday_loop/version.rb
+homepage: https://github.com/sutrolabs/faraday_loop
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sutrolabs/faraday_loop
+  source_code_uri: https://github.com/sutrolabs/faraday_loop
+  changelog_uri: https://github.com/sutrolabs/faraday_loop/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: A lightweight, generic retry utility extracted from the Faraday Ruby project
+test_files: []