stripe 5.1.1 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3317e27f361af5e5506ab608ccdc9c18b3746c76e6244a5db15b149135b7deee
-  data.tar.gz: 65f8bd1faf0c64125bfd0badeb835e555cf3a23437bf8d62c3101058b153de76
+  metadata.gz: 04bf14074bb94dbb41edf733c9240f770026a9e51647359d4d1d55820c1f3c46
+  data.tar.gz: e5a8433b4284faf095da5ad4ebd102127b005a52b56b7651dadfa579a06188f1
 SHA512:
-  metadata.gz: b5123ec85b0009c8ae4b3ae7c3532fc59f6501abaaf350f106cd0e64f9d2fec221bd54ca9384636edec370922391d48ceafdb044394a1367a45fdef4e372888e
-  data.tar.gz: 5fa03e4c45c1b1e82b617fb50f79339740e3c431a0fefbda0c6af78ce4bb0e1e2539ae67b9494fc5fa694ccec1c8444772f179c6f283f6cc6ea20abe71eb850f
+  metadata.gz: e905a1f7fa40887d5c8bd78c428f1d377b42ead6586cf147f6334fafc6264d81ccbdb504e6ef2c8da3e473f40ad18b275f372cc70eea147435252d813ac948b8
+  data.tar.gz: 3d03fb7104356a787b85287455e74157761e92b159db33414685af565fd99e7ff596e9cd1f4ce7dd0e00f44e2c342618fc65f52ad91ed7ccedabd42db6d990c4

data/.rubocop.yml

@@ -19,8 +19,17 @@ Layout/IndentFirstHashElement:
 Layout/IndentHeredoc:
   Enabled: false
 
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    # `context` in tests are blocks and get quite large, so exclude the test
+    # directory from having to adhere to this rule.
+    - "test/**/*.rb"
+
 Metrics/ClassLength:
   Exclude:
+    # Test classes get quite large, so exclude the test directory from having
+    # to adhere to this rule.
     - "test/**/*.rb"
 
 Metrics/LineLength:

data/.rubocop_todo.yml

@@ -10,12 +10,6 @@
 Metrics/AbcSize:
   Max: 51
 
-# Offense count: 33
-# Configuration parameters: CountComments, ExcludedMethods.
-# ExcludedMethods: refine
-Metrics/BlockLength:
-  Max: 509
-
 # Offense count: 12
 # Configuration parameters: CountComments.
 Metrics/ClassLength:

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 5.5.0 - 2019-10-03
+* [#859](https://github.com/stripe/stripe-ruby/pull/859) User-friendly messages and retries for `EOFError`, `Errno::ECONNRESET`, `Errno::ETIMEDOUT`, and `Errno::EHOSTUNREACH` network errors
+
+## 5.4.1 - 2019-10-01
+* [#858](https://github.com/stripe/stripe-ruby/pull/858) Drop Timecop dependency
+
+## 5.4.0 - 2019-10-01
+* [#857](https://github.com/stripe/stripe-ruby/pull/857) Move to monotonic time for duration calculations
+
+## 5.3.0 - 2019-10-01
+* [#853](https://github.com/stripe/stripe-ruby/pull/853) Support `Stripe-Should-Retry` header
+
+## 5.2.0 - 2019-09-19
+* [#851](https://github.com/stripe/stripe-ruby/pull/851) Introduce system for garbage collecting connection managers
+
 ## 5.1.1 - 2019-09-04
 * [#845](https://github.com/stripe/stripe-ruby/pull/845) Transfer the request_id from the http_headers to error.
 

data/Gemfile

@@ -11,7 +11,6 @@ group :development do
   gem "rake"
   gem "shoulda-context"
   gem "test-unit"
-  gem "timecop"
   gem "webmock"
 
   # Rubocop changes pretty quickly: new cops get added and old cops change

data/VERSION

@@ -1 +1 @@
-5.1.1
+5.5.0

data/lib/stripe/api_operations/nested_resource.rb

@@ -6,7 +6,7 @@ module Stripe
     # that it's possible to do so from a static context (i.e. without a
     # pre-existing collection of subresources on the parent).
     #
-    # For examle, a transfer gains the static methods for reversals so that the
+    # For example, a transfer gains the static methods for reversals so that the
     # methods `.create_reversal`, `.retrieve_reversal`, `.update_reversal`,
     # etc. all become available.
     module NestedResource
@@ -14,9 +14,11 @@ module Stripe
                                         resource_plural: nil)
         resource_plural ||= "#{resource}s"
         path ||= resource_plural
+
         raise ArgumentError, "operations array required" if operations.nil?
 
         resource_url_method = :"#{resource}s_url"
+
         define_singleton_method(resource_url_method) do |id, nested_id = nil|
           url = "#{resource_url}/#{CGI.escape(id)}/#{CGI.escape(path)}"
           url += "/#{CGI.escape(nested_id)}" unless nested_id.nil?
@@ -27,39 +29,39 @@ module Stripe
           case operation
           when :create
             define_singleton_method(:"create_#{resource}") \
-                do |id, params = {}, opts = {}|
-              url = send(resource_url_method, id)
-              resp, opts = request(:post, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, params = {}, opts = {}|
+                url = send(resource_url_method, id)
+                resp, opts = request(:post, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :retrieve
             define_singleton_method(:"retrieve_#{resource}") \
-                do |id, nested_id, opts = {}|
-              url = send(resource_url_method, id, nested_id)
-              resp, opts = request(:get, url, {}, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, nested_id, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = request(:get, url, {}, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :update
             define_singleton_method(:"update_#{resource}") \
-                do |id, nested_id, params = {}, opts = {}|
-              url = send(resource_url_method, id, nested_id)
-              resp, opts = request(:post, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, nested_id, params = {}, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = request(:post, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :delete
             define_singleton_method(:"delete_#{resource}") \
-                do |id, nested_id, params = {}, opts = {}|
-              url = send(resource_url_method, id, nested_id)
-              resp, opts = request(:delete, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, nested_id, params = {}, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = request(:delete, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :list
             define_singleton_method(:"list_#{resource_plural}") \
-                do |id, params = {}, opts = {}|
-              url = send(resource_url_method, id)
-              resp, opts = request(:get, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, params = {}, opts = {}|
+                url = send(resource_url_method, id)
+                resp, opts = request(:get, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           else
             raise ArgumentError, "Unknown operation: #{operation.inspect}"
           end

data/lib/stripe/connection_manager.rb

@@ -9,24 +9,36 @@ module Stripe
   #
   # Note that this class in itself is *not* thread safe. We expect it to be
   # instantiated once per thread.
-  #
-  # Note also that this class doesn't currently clean up after itself because
-  # it expects to only ever have a few connections (unless `.clear` is called
-  # manually). It'd be possible to tank memory by constantly changing the value
-  # of `Stripe.api_base` or the like. A possible improvement might be to detect
-  # and prune old connections whenever a request is executed.
   class ConnectionManager
+    # Timestamp (in seconds procured from the system's monotonic clock)
+    # indicating when the connection manager last made a request. This is used
+    # by `StripeClient` to determine whether a connection manager should be
+    # garbage collected or not.
+    attr_reader :last_used
+
     def initialize
       @active_connections = {}
+      @last_used = Util.monotonic_time
+
+      # A connection manager may be accessed across threads as one thread makes
+      # requests on it while another is trying to clear it (either because it's
+      # trying to garbage collect the manager or trying to clear it because a
+      # configuration setting has changed). That's probably thread-safe already
+      # because of Ruby's GIL, but just in case the library's running on JRuby
+      # or the like, use a mutex to synchronize access in this connection
+      # manager.
+      @mutex = Mutex.new
     end
 
     # Finishes any active connections by closing their TCP connection and
     # clears them from internal tracking.
     def clear
-      @active_connections.each do |_, connection|
-        connection.finish
+      @mutex.synchronize do
+        @active_connections.each do |_, connection|
+          connection.finish
+        end
+        @active_connections = {}
       end
-      @active_connections = {}
     end
 
     # Gets a connection for a given URI. This is for internal use only as it's
@@ -35,17 +47,19 @@ module Stripe
     #
     # `uri` is expected to be a string.
     def connection_for(uri)
-      u = URI.parse(uri)
-      connection = @active_connections[[u.host, u.port]]
+      @mutex.synchronize do
+        u = URI.parse(uri)
+        connection = @active_connections[[u.host, u.port]]
 
-      if connection.nil?
-        connection = create_connection(u)
-        connection.start
+        if connection.nil?
+          connection = create_connection(u)
+          connection.start
 
-        @active_connections[[u.host, u.port]] = connection
-      end
+          @active_connections[[u.host, u.port]] = connection
+        end
 
-      connection
+        connection
+      end
     end
 
     # Executes an HTTP request to the given URI with the given method. Also
@@ -65,6 +79,8 @@ module Stripe
       raise ArgumentError, "query should be a string" \
         if query && !query.is_a?(String)
 
+      @last_used = Util.monotonic_time
+
       connection = connection_for(uri)
 
       u = URI.parse(uri)
@@ -74,7 +90,9 @@ module Stripe
                u.path
              end
 
-      connection.send_request(method.to_s.upcase, path, body, headers)
+      @mutex.synchronize do
+        connection.send_request(method.to_s.upcase, path, body, headers)
+      end
     end
 
     #

data/lib/stripe/stripe_client.rb

@@ -5,18 +5,17 @@ module Stripe
   # recover both a resource a call returns as well as a response object that
   # contains information on the HTTP call.
   class StripeClient
-    # A set of all known connection managers across all threads and a mutex to
+    # A set of all known thread contexts across all threads and a mutex to
     # synchronize global access to them.
-    @all_connection_managers = []
-    @all_connection_managers_mutex = Mutex.new
+    @thread_contexts_with_connection_managers = []
+    @thread_contexts_with_connection_managers_mutex = Mutex.new
+    @last_connection_manager_gc = Util.monotonic_time
 
-    attr_accessor :connection_manager
-
-    # Initializes a new `StripeClient`. Expects a `ConnectionManager` object,
-    # and uses a default connection manager unless one is passed.
-    def initialize(connection_manager = nil)
-      self.connection_manager = connection_manager ||
-                                self.class.default_connection_manager
+    # Initializes a new `StripeClient`.
+    #
+    # Takes a connection manager object for backwards compatibility only, and
+    # that use is DEPRECATED.
+    def initialize(_connection_manager = nil)
       @system_profiler = SystemProfiler.new
       @last_request_metrics = nil
     end
@@ -42,17 +41,24 @@ module Stripe
       # Just a quick path for when configuration is being set for the first
       # time before any connections have been opened. There is technically some
       # potential for thread raciness here, but not in a practical sense.
-      return if @all_connection_managers.empty?
-
-      @all_connection_managers_mutex.synchronize do
-        @all_connection_managers.each(&:clear)
+      return if @thread_contexts_with_connection_managers.empty?
+
+      @thread_contexts_with_connection_managers_mutex.synchronize do
+        @thread_contexts_with_connection_managers.each do |thread_context|
+          # Note that the thread context itself is not destroyed, but we clear
+          # its connection manager and remove our reference to it. If it ever
+          # makes a new request we'll give it a new connection manager and
+          # it'll go back into `@thread_contexts_with_connection_managers`.
+          thread_context.default_connection_manager.clear
+          thread_context.default_connection_manager = nil
+        end
+        @thread_contexts_with_connection_managers.clear
       end
     end
 
     # A default client for the current thread.
     def self.default_client
-      current_thread_context.default_client ||=
-        StripeClient.new(default_connection_manager)
+      current_thread_context.default_client ||= StripeClient.new
     end
 
     # A default connection manager for the current thread.
@@ -60,8 +66,9 @@ module Stripe
       current_thread_context.default_connection_manager ||= begin
         connection_manager = ConnectionManager.new
 
-        @all_connection_managers_mutex.synchronize do
-          @all_connection_managers << connection_manager
+        @thread_contexts_with_connection_managers_mutex.synchronize do
+          maybe_gc_connection_managers
+          @thread_contexts_with_connection_managers << current_thread_context
         end
 
         connection_manager
@@ -74,17 +81,23 @@ module Stripe
     def self.should_retry?(error, method:, num_retries:)
       return false if num_retries >= Stripe.max_network_retries
 
-      # Retry on timeout-related problems (either on open or read).
-      return true if error.is_a?(Net::OpenTimeout)
-      return true if error.is_a?(Net::ReadTimeout)
+      case error
+      when Net::OpenTimeout, Net::ReadTimeout
+        # Retry on timeout-related problems (either on open or read).
+        true
+      when EOFError, Errno::ECONNREFUSED, Errno::ECONNRESET,
+            Errno::EHOSTUNREACH, Errno::ETIMEDOUT, SocketError
+        # Destination refused the connection, the connection was reset, or a
+        # variety of other connection failures. This could occur from a single
+        # saturated server, so retry in case it's intermittent.
+        true
+      when Stripe::StripeError
+        # The API may ask us not to retry (e.g. if doing so would be a no-op),
+        # or advise us to retry (e.g. in cases of lock timeouts). Defer to
+        # those instructions if given.
+        return false if error.http_headers["stripe-should-retry"] == "false"
+        return true if error.http_headers["stripe-should-retry"] == "true"
 
-      # Destination refused the connection, the connection was reset, or a
-      # variety of other connection failures. This could occur from a single
-      # saturated server, so retry in case it's intermittent.
-      return true if error.is_a?(Errno::ECONNREFUSED)
-      return true if error.is_a?(SocketError)
-
-      if error.is_a?(Stripe::StripeError)
         # 409 Conflict
         return true if error.http_status == 409
 
@@ -106,10 +119,10 @@ module Stripe
         return true if error.http_status == 500 && method != :post
 
         # 503 Service Unavailable
-        return true if error.http_status == 503
+        error.http_status == 503
+      else
+        false
       end
-
-      false
     end
 
     def self.sleep_time(num_retries)
@@ -131,6 +144,15 @@ module Stripe
       sleep_seconds
     end
 
+    # Gets the connection manager in use for the current `StripeClient`.
+    #
+    # This method is DEPRECATED and for backwards compatibility only.
+    def connection_manager
+      self.class.default_connection_manager
+    end
+    extend Gem::Deprecate
+    deprecate :connection_manager, :none, 2020, 9
+
     # Executes the API call within the given block. Usage looks like:
     #
     #     client = StripeClient.new
@@ -207,10 +229,10 @@ module Stripe
       context.query           = query
 
       http_resp = execute_request_with_rescues(method, api_base, context) do
-        connection_manager.execute_request(method, url,
-                                           body: body,
-                                           headers: headers,
-                                           query: query)
+        self.class.default_connection_manager.execute_request(method, url,
+                                                              body: body,
+                                                              headers: headers,
+                                                              query: query)
       end
 
       begin
@@ -233,6 +255,14 @@ module Stripe
     # private
     #
 
+    # Time (in seconds) that a connection manager has not been used before it's
+    # eligible for garbage collection.
+    CONNECTION_MANAGER_GC_LAST_USED_EXPIRY = 120
+
+    # How often to check (in seconds) for connection managers that haven't been
+    # used in a long time and which should be garbage collected.
+    CONNECTION_MANAGER_GC_PERIOD = 60
+
     ERROR_MESSAGE_CONNECTION =
       "Unexpected error communicating when trying to connect to " \
         "Stripe (%s). You may be seeing this message because your DNS is not " \
@@ -266,7 +296,11 @@ module Stripe
     # The original error message is also appended onto the final exception for
     # full transparency.
     NETWORK_ERROR_MESSAGES_MAP = {
+      EOFError => ERROR_MESSAGE_CONNECTION,
       Errno::ECONNREFUSED => ERROR_MESSAGE_CONNECTION,
+      Errno::ECONNRESET => ERROR_MESSAGE_CONNECTION,
+      Errno::EHOSTUNREACH => ERROR_MESSAGE_CONNECTION,
+      Errno::ETIMEDOUT => ERROR_MESSAGE_TIMEOUT_CONNECT,
       SocketError => ERROR_MESSAGE_CONNECTION,
 
       Net::OpenTimeout => ERROR_MESSAGE_TIMEOUT_CONNECT,
@@ -320,6 +354,46 @@ module Stripe
       Thread.current[:stripe_client__internal_use_only] ||= ThreadContext.new
     end
 
+    # Garbage collects connection managers that haven't been used in some time,
+    # with the idea being that we want to remove old connection managers that
+    # belong to dead threads and the like.
+    #
+    # Prefixed with `maybe_` because garbage collection will only run
+    # periodically so that we're not constantly engaged in busy work. If
+    # connection managers live a little passed their useful age it's not
+    # harmful, so it's not necessary to get them right away.
+    #
+    # For testability, returns `nil` if it didn't run and the number of
+    # connection managers that were garbage collected otherwise.
+    #
+    # IMPORTANT: This method is not thread-safe and expects to be called inside
+    # a lock on `@thread_contexts_with_connection_managers_mutex`.
+    #
+    # For internal use only. Does not provide a stable API and may be broken
+    # with future non-major changes.
+    def self.maybe_gc_connection_managers
+      next_gc_time = @last_connection_manager_gc + CONNECTION_MANAGER_GC_PERIOD
+      return nil if next_gc_time > Util.monotonic_time
+
+      last_used_threshold =
+        Util.monotonic_time - CONNECTION_MANAGER_GC_LAST_USED_EXPIRY
+
+      pruned_thread_contexts = []
+      @thread_contexts_with_connection_managers.each do |thread_context|
+        connection_manager = thread_context.default_connection_manager
+        next if connection_manager.last_used > last_used_threshold
+
+        connection_manager.clear
+        thread_context.default_connection_manager = nil
+        pruned_thread_contexts << thread_context
+      end
+
+      @thread_contexts_with_connection_managers -= pruned_thread_contexts
+      @last_connection_manager_gc = Util.monotonic_time
+
+      pruned_thread_contexts.count
+    end
+
     private def api_url(url = "", api_base = nil)
       (api_base || Stripe.api_base) + url
     end
@@ -375,7 +449,7 @@ module Stripe
     private def execute_request_with_rescues(method, api_base, context)
       num_retries = 0
       begin
-        request_start = Time.now
+        request_start = Util.monotonic_time
         log_request(context, num_retries)
         resp = yield
         context = context.dup_from_response_headers(resp)
@@ -385,7 +459,8 @@ module Stripe
         log_response(context, request_start, resp.code.to_i, resp.body)
 
         if Stripe.enable_telemetry? && context.request_id
-          request_duration_ms = ((Time.now - request_start) * 1000).to_int
+          request_duration_ms =
+            ((Util.monotonic_time - request_start) * 1000).to_int
           @last_request_metrics =
             StripeRequestMetrics.new(context.request_id, request_duration_ms)
         end
@@ -656,7 +731,7 @@ module Stripe
       Util.log_info("Response from Stripe API",
                     account: context.account,
                     api_version: context.api_version,
-                    elapsed: Time.now - request_start,
+                    elapsed: Util.monotonic_time - request_start,
                     idempotency_key: context.idempotency_key,
                     method: context.method,
                     path: context.path,
@@ -678,7 +753,7 @@ module Stripe
 
     private def log_response_error(context, request_start, error)
       Util.log_error("Request error",
-                     elapsed: Time.now - request_start,
+                     elapsed: Util.monotonic_time - request_start,
                      error_message: error.message,
                      idempotency_key: context.idempotency_key,
                      method: context.method,

data/lib/stripe/util.rb

@@ -172,6 +172,18 @@ module Stripe
       result
     end
 
+    # `Time.now` can be unstable in cases like an administrator manually
+    # updating its value or a reconcilation via NTP. For this reason, prefer
+    # the use of the system's monotonic clock especially where comparing times
+    # to calculate an elapsed duration.
+    #
+    # Shortcut for getting monotonic time, mostly for purposes of line length
+    # and test stubbing. Returns time in seconds since the event used for
+    # monotonic reference purposes by the platform (e.g. system boot time).
+    def self.monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     def self.normalize_id(id)
       if id.is_a?(Hash) # overloaded id
         params_hash = id.dup

data/lib/stripe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stripe
-  VERSION = "5.1.1"
+  VERSION = "5.5.0"
 end

data/test/stripe/connection_manager_test.rb

@@ -8,6 +8,14 @@ module Stripe
       @manager = Stripe::ConnectionManager.new
     end
 
+    context "#initialize" do
+      should "set #last_used to current time" do
+        t = 123.0
+        Util.stubs(:monotonic_time).returns(t)
+        assert_equal t, Stripe::ConnectionManager.new.last_used
+      end
+    end
+
     context "#clear" do
       should "clear any active connections" do
         stub_request(:post, "#{Stripe.api_base}/path")
@@ -133,6 +141,23 @@ module Stripe
         end
         assert_equal e.message, "query should be a string"
       end
+
+      should "set #last_used to current time" do
+        stub_request(:post, "#{Stripe.api_base}/path")
+          .to_return(body: JSON.generate(object: "account"))
+
+        t = 123.0
+        Util.stubs(:monotonic_time).returns(t)
+
+        manager = Stripe::ConnectionManager.new
+
+        # `#last_used` is also set by the constructor, so make sure we get a
+        # new value for it.
+        Util.stubs(:monotonic_time).returns(t + 1.0)
+
+        manager.execute_request(:post, "#{Stripe.api_base}/path")
+        assert_equal t + 1.0, manager.last_used
+      end
     end
   end
 end

data/test/stripe/stripe_client_test.rb

@@ -17,6 +17,76 @@ module Stripe
       end
     end
 
+    context ".maybe_gc_connection_managers" do
+      should "garbage collect old connection managers when appropriate" do
+        stub_request(:post, "#{Stripe.api_base}/v1/path")
+          .to_return(body: JSON.generate(object: "account"))
+
+        # Make sure we start with a blank slate (state may have been left in
+        # place by other tests).
+        StripeClient.clear_all_connection_managers
+
+        # Establish a base time.
+        t = 0.0
+
+        # And pretend that `StripeClient` was just initialized for the first
+        # time. (Don't access instance variables like this, but it's tricky to
+        # test properly otherwise.)
+        StripeClient.instance_variable_set(:@last_connection_manager_gc, t)
+
+        #
+        # t
+        #
+        Util.stubs(:monotonic_time).returns(t)
+
+        # Execute an initial request to ensure that a connection manager was
+        # created.
+        client = StripeClient.new
+        client.execute_request(:post, "/v1/path")
+
+        # The GC shouldn't run yet  (a `nil` return indicates that GC didn't run).
+        assert_equal nil, StripeClient.maybe_gc_connection_managers
+
+        #
+        # t + StripeClient::CONNECTION_MANAGER_GC_PERIOD - 1
+        #
+        # Move time to just *before* garbage collection is eligible to run.
+        # Nothing should happen.
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_PERIOD - 1)
+
+        assert_equal nil, StripeClient.maybe_gc_connection_managers
+
+        #
+        # t + StripeClient::CONNECTION_MANAGER_GC_PERIOD + 1
+        #
+        # Move time to just *after* garbage collection is eligible to run.
+        # Garbage collection will run, but because the connection manager is
+        # not passed its expiry age, it will not be collected. Zero is returned
+        # to indicate so.
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_PERIOD + 1)
+
+        assert_equal 0, StripeClient.maybe_gc_connection_managers
+
+        #
+        # t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1
+        #
+        # Move us far enough into the future that we're passed the horizons for
+        # both a GC run as well as well as the expiry age of a connection
+        # manager. That means the GC will run and collect the connection
+        # manager that we created above.
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1)
+
+        assert_equal 1, StripeClient.maybe_gc_connection_managers
+
+        # And as an additional check, the connection manager of the current
+        # thread context should have been set to `nil` as it was GCed.
+        assert_nil StripeClient.current_thread_context.default_connection_manager
+      end
+    end
+
     context ".clear_all_connection_managers" do
       should "clear connection managers across all threads" do
         stub_request(:post, "#{Stripe.api_base}/path")
@@ -102,6 +172,26 @@ module Stripe
                                           method: :post, num_retries: 0)
       end
 
+      should "retry on EOFError" do
+        assert StripeClient.should_retry?(EOFError.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Errno::ECONNRESET" do
+        assert StripeClient.should_retry?(Errno::ECONNRESET.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Errno::ETIMEDOUT" do
+        assert StripeClient.should_retry?(Errno::ETIMEDOUT.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Errno::EHOSTUNREACH" do
+        assert StripeClient.should_retry?(Errno::EHOSTUNREACH.new,
+                                          method: :post, num_retries: 0)
+      end
+
       should "retry on Net::OpenTimeout" do
         assert StripeClient.should_retry?(Net::OpenTimeout.new,
                                           method: :post, num_retries: 0)
@@ -117,6 +207,28 @@ module Stripe
                                           method: :post, num_retries: 0)
       end
 
+      should "retry when the `Stripe-Should-Retry` header is `true`" do
+        headers = StripeResponse::Headers.new(
+          "Stripe-Should-Retry" => ["true"]
+        )
+
+        # Note we send status 400 here, which would normally not be retried.
+        assert StripeClient.should_retry?(Stripe::StripeError.new(http_headers: headers,
+                                                                  http_status: 400),
+                                          method: :post, num_retries: 0)
+      end
+
+      should "not retry when the `Stripe-Should-Retry` header is `false`" do
+        headers = StripeResponse::Headers.new(
+          "Stripe-Should-Retry" => ["false"]
+        )
+
+        # Note we send status 409 here, which would normally be retried.
+        refute StripeClient.should_retry?(Stripe::StripeError.new(http_headers: headers,
+                                                                  http_status: 409),
+                                          method: :post, num_retries: 0)
+      end
+
       should "retry on a 409 Conflict" do
         assert StripeClient.should_retry?(Stripe::StripeError.new(http_status: 409),
                                           method: :post, num_retries: 0)
@@ -199,20 +311,6 @@ module Stripe
       end
     end
 
-    context "#initialize" do
-      should "set Stripe.default_connection_manager" do
-        client = StripeClient.new
-        assert_equal StripeClient.default_connection_manager,
-                     client.connection_manager
-      end
-
-      should "set a different connection if one was specified" do
-        connection_manager = ConnectionManager.new
-        client = StripeClient.new(connection_manager)
-        assert_equal connection_manager, client.connection_manager
-      end
-    end
-
     context "#execute_request" do
       context "headers" do
         should "support literal headers" do
@@ -239,16 +337,11 @@ module Stripe
       context "logging" do
         setup do
           # Freeze time for the purposes of the `elapsed` parameter that we
-          # emit for responses. I didn't want to bring in a new dependency for
-          # this, but Mocha's `anything` parameter can't match inside of a hash
-          # and is therefore not useful for this purpose. If we switch over to
-          # rspec-mocks at some point, we can probably remove Timecop from the
-          # project.
-          Timecop.freeze(Time.local(1990))
-        end
-
-        teardown do
-          Timecop.return
+          # emit for responses. Mocha's `anything` parameter can't match inside
+          # of a hash and is therefore not useful for this purpose. If we
+          # switch over to rspec-mocks at some point, we can probably remove
+          # this.
+          Util.stubs(:monotonic_time).returns(0.0)
         end
 
         should "produce appropriate logging" do
@@ -470,10 +563,10 @@ module Stripe
             .to_return(body: "", status: 500)
 
           client = StripeClient.new
+
           e = assert_raises Stripe::APIError do
             client.execute_request(:post, "/v1/charges")
           end
-
           assert_equal 'Invalid response object from API: "" (HTTP response code was 500)', e.message
         end
 
@@ -482,22 +575,36 @@ module Stripe
             .to_return(body: "", status: 200)
 
           client = StripeClient.new
+
           e = assert_raises Stripe::APIError do
             client.execute_request(:post, "/v1/charges")
           end
-
           assert_equal 'Invalid response object from API: "" (HTTP response code was 200)', e.message
         end
 
+        should "feed a request ID through to the error object" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_missing_id_error),
+                       headers: { "Request-ID": "req_123" },
+                       status: 400)
+
+          client = StripeClient.new
+
+          e = assert_raises Stripe::InvalidRequestError do
+            client.execute_request(:post, "/v1/charges")
+          end
+          assert_equal("req_123", e.request_id)
+        end
+
         should "handle low level error" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_raise(Errno::ECONNREFUSED.new)
 
           client = StripeClient.new
+
           e = assert_raises Stripe::APIConnectionError do
             client.execute_request(:post, "/v1/charges")
           end
-
           assert_equal StripeClient::ERROR_MESSAGE_CONNECTION % Stripe.api_base +
                        "\n\n(Network error: Connection refused)",
                        e.message
@@ -508,10 +615,10 @@ module Stripe
             .to_return(body: JSON.generate(bar: "foo"), status: 500)
 
           client = StripeClient.new
+
           e = assert_raises Stripe::APIError do
             client.execute_request(:post, "/v1/charges")
           end
-
           assert_equal 'Invalid response object from API: "{\"bar\":\"foo\"}" (HTTP response code was 500)', e.message
         end
 
@@ -521,6 +628,7 @@ module Stripe
 
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(data), status: 400)
+
           client = StripeClient.new
 
           e = assert_raises Stripe::IdempotencyError do
@@ -533,75 +641,81 @@ module Stripe
         should "raise InvalidRequestError on other 400s" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(make_missing_id_error), status: 400)
+
           client = StripeClient.new
-          begin
+
+          e = assert_raises Stripe::InvalidRequestError do
             client.execute_request(:post, "/v1/charges")
-          rescue Stripe::InvalidRequestError => e
-            assert_equal(400, e.http_status)
-            assert_equal(true, e.json_body.is_a?(Hash))
           end
+          assert_equal(400, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
 
         should "raise AuthenticationError on 401" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(make_missing_id_error), status: 401)
+
           client = StripeClient.new
-          begin
+
+          e = assert_raises Stripe::AuthenticationError do
             client.execute_request(:post, "/v1/charges")
-          rescue Stripe::AuthenticationError => e
-            assert_equal(401, e.http_status)
-            assert_equal(true, e.json_body.is_a?(Hash))
           end
+          assert_equal(401, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
 
         should "raise CardError on 402" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(make_invalid_exp_year_error), status: 402)
+
           client = StripeClient.new
-          begin
+
+          e = assert_raises Stripe::CardError do
             client.execute_request(:post, "/v1/charges")
-          rescue Stripe::CardError => e
-            assert_equal(402, e.http_status)
-            assert_equal(true, e.json_body.is_a?(Hash))
-            assert_equal("invalid_expiry_year", e.code)
-            assert_equal("exp_year", e.param)
           end
+          assert_equal(402, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
+          assert_equal("invalid_expiry_year", e.code)
+          assert_equal("exp_year", e.param)
         end
 
         should "raise PermissionError on 403" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(make_missing_id_error), status: 403)
+
           client = StripeClient.new
-          begin
+
+          e = assert_raises Stripe::PermissionError do
             client.execute_request(:post, "/v1/charges")
-          rescue Stripe::PermissionError => e
-            assert_equal(403, e.http_status)
-            assert_equal(true, e.json_body.is_a?(Hash))
           end
+          assert_equal(403, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
 
         should "raise InvalidRequestError on 404" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(make_missing_id_error), status: 404)
+
           client = StripeClient.new
-          begin
+
+          e = assert_raises Stripe::InvalidRequestError do
             client.execute_request(:post, "/v1/charges")
-          rescue Stripe::InvalidRequestError => e
-            assert_equal(404, e.http_status)
-            assert_equal(true, e.json_body.is_a?(Hash))
           end
+          assert_equal(404, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
 
         should "raise RateLimitError on 429" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(make_rate_limit_error), status: 429)
+
           client = StripeClient.new
-          begin
+
+          e = assert_raises Stripe::RateLimitError do
             client.execute_request(:post, "/v1/charges")
-          rescue Stripe::RateLimitError => e
-            assert_equal(429, e.http_status)
-            assert_equal(true, e.json_body.is_a?(Hash))
           end
+          assert_equal(429, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
 
         should "raise OAuth::InvalidRequestError when error is a string with value 'invalid_request'" do
@@ -610,6 +724,7 @@ module Stripe
                                            error_description: "No grant type specified"), status: 400)
 
           client = StripeClient.new
+
           opts = { api_base: Stripe.connect_base }
           e = assert_raises Stripe::OAuth::InvalidRequestError do
             client.execute_request(:post, "/oauth/token", opts)
@@ -625,6 +740,7 @@ module Stripe
                                            error_description: "This authorization code has already been used. All tokens issued with this code have been revoked."), status: 400)
 
           client = StripeClient.new
+
           opts = { api_base: Stripe.connect_base }
           e = assert_raises Stripe::OAuth::InvalidGrantError do
             client.execute_request(:post, "/oauth/token", opts)
@@ -641,6 +757,7 @@ module Stripe
                                            error_description: "This application is not connected to stripe account acct_19tLK7DSlTMT26Mk, or that account does not exist."), status: 401)
 
           client = StripeClient.new
+
           opts = { api_base: Stripe.connect_base }
           e = assert_raises Stripe::OAuth::InvalidClientError do
             client.execute_request(:post, "/oauth/deauthorize", opts)
@@ -657,6 +774,7 @@ module Stripe
                                            error_description: "Something."), status: 401)
 
           client = StripeClient.new
+
           opts = { api_base: Stripe.connect_base }
           e = assert_raises Stripe::OAuth::OAuthError do
             client.execute_request(:post, "/oauth/deauthorize", opts)
@@ -817,6 +935,22 @@ module Stripe
       end
     end
 
+    context "#connection_manager" do
+      should "warn that #connection_manager is deprecated" do
+        old_stderr = $stderr
+        $stderr = StringIO.new
+        begin
+          client = StripeClient.new
+          client.connection_manager
+          message = "NOTE: Stripe::StripeClient#connection_manager is " \
+                    "deprecated"
+          assert_match Regexp.new(message), $stderr.string
+        ensure
+          $stderr = old_stderr
+        end
+      end
+    end
+
     context "#request" do
       should "return a result and response object" do
         stub_request(:post, "#{Stripe.api_base}/v1/charges")

data/test/test_helper.rb

@@ -8,7 +8,6 @@ require "test/unit"
 require "mocha/setup"
 require "stringio"
 require "shoulda/context"
-require "timecop"
 require "webmock/test_unit"
 
 PROJECT_ROOT = ::File.expand_path("../", __dir__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stripe
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 5.5.0
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-04 00:00:00.000000000 Z
+date: 2019-10-03 00:00:00.000000000 Z
 dependencies: []
 description: Stripe is the easiest way to accept payments online.  See https://stripe.com
   for details.