faraday 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff30e260051828899307875d73f5ccb1fdcdb4bb40fba3df707e2d6966675cb1
-  data.tar.gz: 4bc5b5df30090ae639a937d180f0cc2d7b66a163dca438be8049eef0a5b2a483
+  metadata.gz: 3737507d92b48e4b98e891c5026210048ab70b2b1ee17ea20993b8ffc65eafb5
+  data.tar.gz: caaaa7f7ad1bdda848ac7bc70d4d1b9ba9d06bc85912a61b1ee4082086629a26
 SHA512:
-  metadata.gz: 6edafc07bcf5c647f82ab5e50aa8cd7c319e5198559bd7350394fd3fb918e96f1a450fa4eb175ee3b7db9e03880cc2534c3b52b3a213cdc852fe094953603e13
-  data.tar.gz: 9d2951f42b5e8ae17505bc92493ee8ef2814412de9ade880adf20c081a02e6437da7174a064ca68f37483793e48efdf67aeb145e07ca3a90c71ac80014926070
+  metadata.gz: 231b96efdd5b0399f204edaeba22d01661b9d301aff6cad7d097c27c1e95f0a0a8adc9184e88f089862fa9db9a833e50a3eb7bfb96034a2df7f1bdd93661f3fb
+  data.tar.gz: f19fca5f59454b7b620160c3e58339e0dff8049be29bda8e8f1a494455dac6c62a1c6cbe4b4e141e999ea3df25cbcdf3ef09d65e93d71a882c318c75c3070dec

data/README.md

@@ -69,7 +69,7 @@ conn = Faraday.new(:url => 'http://sushi.com/api_key=s3cr3t') do |faraday|
 end
 ```
 
-Once you have the connection object, use it to make HTTP requests. You can pass paramters to it in a few different ways:
+Once you have the connection object, use it to make HTTP requests. You can pass parameters to it in a few different ways:
 
 ```ruby
 ## GET ##

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.14.0"
+  VERSION = "0.15.0"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.

data/lib/faraday/adapter.rb

@@ -40,6 +40,8 @@ module Faraday
       env.clear_body if env.needs_body?
     end
 
+    private
+
     def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body

data/lib/faraday/adapter/net_http.rb

@@ -56,6 +56,8 @@ module Faraday
         raise Faraday::Error::TimeoutError, err
       end
 
+      private
+
       def create_request(env)
         request = Net::HTTPGenericRequest.new \
           env[:method].to_s.upcase,    # request method

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,13 +1,23 @@
-# Rely on autoloading instead of explicit require; helps avoid the "already
-# initialized constant" warning on Ruby 1.8.7 when NetHttp is refereced below.
-# require 'faraday/adapter/net_http'
-
 module Faraday
   class Adapter
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
+      private
+
       def net_http_connection(env)
+        proxy_uri = proxy_uri(env)
+
+        cached_connection env[:url], proxy_uri do
+          if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
+            Net::HTTP::Persistent.new(name: 'Faraday', proxy: proxy_uri)
+          else
+            Net::HTTP::Persistent.new('Faraday', proxy_uri)
+          end
+        end
+      end
+
+      def proxy_uri(env)
         proxy_uri = nil
         if (proxy = env[:request][:proxy])
           proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
@@ -18,12 +28,7 @@ module Faraday
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
         end
-
-        if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
-          Net::HTTP::Persistent.new(name: 'Faraday', proxy: proxy_uri)
-        else
-          Net::HTTP::Persistent.new('Faraday', proxy_uri)
-        end
+        proxy_uri
       end
 
       def perform_request(http, env)
@@ -49,6 +54,10 @@ module Faraday
         http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
         http.ssl_version  = ssl[:version]      if ssl[:version]
       end
+
+      def cached_connection(url, proxy_uri)
+        (@cached_connection ||= {})[[url.scheme, url.host, url.port, proxy_uri]] ||= yield
+      end
     end
   end
 end

data/lib/faraday/error.rb

@@ -1,6 +1,5 @@
 module Faraday
   class Error < StandardError; end
-  class MissingDependency < Error; end
 
   class ClientError < Error
     attr_reader :response, :wrapped_exception
@@ -56,8 +55,12 @@ module Faraday
   class SSLError < ClientError
   end
 
-  [:MissingDependency, :ClientError, :ConnectionFailed, :ResourceNotFound,
-   :ParsingError, :TimeoutError, :SSLError].each do |const|
+  class RetriableResponse < ClientError; end
+
+  [:ClientError, :ConnectionFailed, :ResourceNotFound,
+   :ParsingError, :TimeoutError, :SSLError, :RetriableResponse].each do |const|
     Error.const_set(const, Faraday.const_get(const))
   end
+
+
 end

data/lib/faraday/request/retry.rb

@@ -23,7 +23,9 @@ module Faraday
     IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
 
     class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
-                                         :backoff_factor, :exceptions, :methods, :retry_if)
+                                         :backoff_factor, :exceptions, :methods, :retry_if, :retry_block,
+                                         :retry_statuses)
+
       DEFAULT_CHECK = lambda { |env,exception| false }
 
       def self.from(value)
@@ -56,7 +58,8 @@ module Faraday
 
       def exceptions
         Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error',
-                                     Error::TimeoutError])
+                                     Error::TimeoutError,
+                                     Faraday::Error::RetriableResponse])
       end
 
       def methods
@@ -67,6 +70,13 @@ module Faraday
         self[:retry_if] ||= DEFAULT_CHECK
       end
 
+      def retry_block
+        self[:retry_block] ||= Proc.new {}
+      end
+
+      def retry_statuses
+        Array(self[:retry_statuses] ||= [])
+      end
     end
 
     # Public: Initialize middleware
@@ -83,8 +93,8 @@ module Faraday
     #                       (default: 1)
     # exceptions          - The list of exceptions to handle. Exceptions can be
     #                       given as Class, Module, or String. (default:
-    #                       [Errno::ETIMEDOUT, Timeout::Error,
-    #                       Error::TimeoutError])
+    #                       [Errno::ETIMEDOUT, 'Timeout::Error',
+    #                       Error::TimeoutError, Faraday::Error::RetriableResponse])
     # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
     #                       an empty Array to call retry_if for all exceptions.
     #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
@@ -94,18 +104,21 @@ module Faraday
     #                       if the exception produced is non-recoverable or if the
     #                       the HTTP method called is not idempotent.
     #                       (defaults to return false)
+    # retry_block         - block that is executed after every retry. Request environment, middleware options,
+    #                       current number of retries and the exception is passed to the block as parameters.
     def initialize(app, options = nil)
       super(app)
       @options = Options.from(options)
       @errmatch = build_exception_matcher(@options.exceptions)
     end
 
-    def sleep_amount(retries)
-      retry_index = @options.max - retries
-      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
-      current_interval = [current_interval, @options.max_interval].min
-      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
-      current_interval + random_interval
+    def calculate_sleep_amount(retries, env)
+      retry_after     = calculate_retry_after(env)
+      retry_interval  = calculate_retry_interval(retries)
+
+      return if retry_after && retry_after > @options.max_interval
+
+      retry_after && retry_after >= retry_interval ? retry_after : retry_interval
     end
 
     def call(env)
@@ -113,15 +126,25 @@ module Faraday
       request_body = env[:body]
       begin
         env[:body] = request_body # after failure env[:body] is set to the response body
-        @app.call(env)
+        @app.call(env).tap do |resp|
+          raise Faraday::Error::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
+        end
       rescue @errmatch => exception
         if retries > 0 && retry_request?(env, exception)
           retries -= 1
           rewind_files(request_body)
-          sleep sleep_amount(retries + 1)
-          retry
+          @options.retry_block.call(env, @options, retries, exception)
+          if (sleep_amount = calculate_sleep_amount(retries + 1, env))
+            sleep sleep_amount
+            retry
+          end
+        end
+
+        if exception.is_a?(Faraday::Error::RetriableResponse)
+          exception.response
+        else
+          raise
         end
-        raise
       end
     end
 
@@ -160,5 +183,29 @@ module Faraday
       end
     end
 
+    # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+    def calculate_retry_after(env)
+      response_headers = env[:response_headers]
+      return unless response_headers
+
+      retry_after_value = env[:response_headers]["Retry-After"]
+
+      # Try to parse date from the header value
+      begin
+        datetime = DateTime.rfc2822(retry_after_value)
+        datetime.to_time - Time.now.utc
+      rescue ArgumentError
+        retry_after_value.to_f
+      end
+    end
+
+    def calculate_retry_interval(retries)
+      retry_index = @options.max - retries
+      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
+      current_interval = [current_interval, @options.max_interval].min
+      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
+
+      current_interval + random_interval
+    end
   end
 end

data/lib/faraday/response/logger.rb

@@ -20,14 +20,14 @@ module Faraday
     def_delegators :@logger, :debug, :info, :warn, :error, :fatal
 
     def call(env)
-      info "#{env.method} #{apply_filters(env.url.to_s)}"
+      info('request')  { "#{env.method.upcase} #{apply_filters(env.url.to_s)}" }
       debug('request') { apply_filters( dump_headers env.request_headers ) } if log_headers?(:request)
       debug('request') { apply_filters( dump_body(env[:body]) ) } if env[:body] && log_body?(:request)
       super
     end
 
     def on_complete(env)
-      info('Status') { env.status.to_s }
+      info('response')  { "Status #{env.status.to_s}" }
       debug('response') { apply_filters( dump_headers env.response_headers ) } if log_headers?(:response)
       debug('response') { apply_filters( dump_body env[:body] ) } if env[:body] && log_body?(:response)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Rick Olson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-19 00:00:00.000000000 Z
+date: 2018-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: HTTP/REST API client library.