graph_weaver 0.6.1 → 0.7.1

data/lib/graph_weaver/retry.rb

@@ -38,7 +38,8 @@ require_relative "transport"
 #     default — pass the codes your API uses for transient failures)
 #
 # A server that answers with Retry-After sets the delay itself (clamped
-# to max_delay:); otherwise the configured backoff decides.
+# to max_delay:) — whether that answer raised or came back as a response
+# carrying GraphQL errors; otherwise the configured backoff decides.
 #
 # Exhausting the retries re-raises the last error (or returns the last
 # code-matched response).
@@ -52,22 +53,31 @@ class GraphWeaver::Retry
   # server asking you to come back later rather than to fix anything
   RETRIABLE_CLIENT_STATUSES = [408, 429].freeze
 
+  # The status half of the policy, asked of a raised ServerError's status
+  # and of the status a response arrived on — one answer, so the two can't
+  # drift apart.
+  RETRIABLE_STATUS = ->(status) { status >= 500 || RETRIABLE_CLIENT_STATUSES.include?(status) }
+
   # retry 5xx (and 408/429), not the rest of 4xx; everything else listed
   # in retry_on: retries
   DEFAULT_RETRY_IF = lambda do |error|
-    !error.is_a?(GraphWeaver::ServerError) ||
-      error.status >= 500 || RETRIABLE_CLIENT_STATUSES.include?(error.status)
+    !error.is_a?(GraphWeaver::ServerError) || RETRIABLE_STATUS.call(error.status)
   end
 
   # said once, where the decision is made and where it is explained
   MUTATION_HINT = "not retrying a mutation — a request that failed without an answer " \
     "may still have been applied; pass retry_mutations: true if yours are idempotent"
-  private_constant :DEFAULT_RETRY_IF, :MUTATION_HINT
+  private_constant :RETRIABLE_STATUS, :DEFAULT_RETRY_IF, :MUTATION_HINT
 
   def initialize(client, retries: 2, retry_on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
     backoff: :exponential, base_delay: 0.5, max_delay: 30, jitter: true, retry_if: DEFAULT_RETRY_IF,
     retry_codes: [], retry_mutations: false, sleeper: nil)
     raise ArgumentError, "retries: must be >= 0" unless retries.is_a?(Integer) && retries >= 0
+    # a negative would reach Kernel#sleep, which raises — and the failure being
+    # retried would be lost behind an ArgumentError from somewhere else
+    { base_delay:, max_delay: }.each do |name, value|
+      raise ArgumentError, "#{name}: must be >= 0, got #{value}" unless value >= 0
+    end
 
     @client = client
     @retries = retries
@@ -96,13 +106,19 @@ class GraphWeaver::Retry
   def execute(query, variables: {}, operation_name: nil)
     attempts = mutation?(query) ? 1 : @retries + 1
     attempt = 0
-    failure = T.let(nil, T.nilable(Exception))
 
     loop do
       attempt += 1
+      failure = nil
       begin
-        response = @client.execute(query, variables:, operation_name:)
+        # each attempt is its own EXECUTE_EVENT; :retries says which one,
+        # so "slow" and "slow after two 502s" don't read the same in an APM
+        response = GraphWeaver::Internal::Log.with_retries(attempt - 1) do
+          @client.execute(query, variables:, operation_name:)
+        end
         return response unless attempt < attempts && retryable_response?(response)
+
+        failure = response
       rescue *@retry_on => e
         if attempt >= attempts || !@retry_if.call(e)
           GraphWeaver::Internal::Log.log(:warn) { MUTATION_HINT } if attempts == 1 && @retries.positive?
@@ -119,7 +135,6 @@ class GraphWeaver::Retry
         "retrying #{operation_name || "query"} in #{seconds.round(2)}s (attempt #{attempt + 1} of #{attempts})"
       end
       @sleeper.call(seconds)
-      failure = nil
     end
   end
 
@@ -130,6 +145,19 @@ class GraphWeaver::Retry
   end
 
   def retryable_response?(response)
+    retryable_status?(response) || retryable_code?(response)
+  end
+
+  # The status a response arrived on, where it came back with one — the
+  # bundled transports say; a schema class, a fake and a hand-rolled client
+  # answer a plain Hash, and a response with no status is never retried on
+  # one.
+  def retryable_status?(response)
+    status = response.http_status if response.respond_to?(:http_status)
+    !status.nil? && RETRIABLE_STATUS.call(status)
+  end
+
+  def retryable_code?(response)
     return false if @retry_codes.empty?
 
     codes = (response.to_h["errors"] || []).filter_map { |error| error.dig("extensions", "code") }
@@ -137,14 +165,18 @@ class GraphWeaver::Retry
   end
 
   def delay(attempt, failure)
-    # A Retry-After wins over our backoff: the server is the only party
-    # that knows when its window reopens, and it isn't guessing. Still
-    # clamped to max_delay:, so "come back in an hour" can't park a thread for
-    # an hour — and not jittered, since it's an instruction, not a guess.
-    after = failure.retry_after if failure.is_a?(GraphWeaver::ServerError)
+    # A Retry-After wins over our backoff, however the failure arrived — a
+    # raised ServerError, or the envelope a rate limit that came back with an
+    # errors body makes. The server is the only party that knows when its
+    # window reopens, and it isn't guessing. Still clamped to max_delay:, so
+    # "come back in an hour" can't park a thread for an hour — and not
+    # jittered, since it's an instruction, not a guess.
+    after = failure.retry_after if failure.respond_to?(:retry_after)
     return [after, @max_delay].min.to_f if after
 
-    seconds = [@backoff.call(@base_delay, attempt), @max_delay].min.to_f
+    # floored at 0: a custom backoff: is the caller's arithmetic, and a
+    # negative from it would raise out of Kernel#sleep rather than retry
+    seconds = [[@backoff.call(@base_delay, attempt), @max_delay].min.to_f, 0.0].max
     @jitter ? seconds * (0.5 + rand * 0.5) : seconds
   end
 end