parse-stack-next 5.7.3 → 5.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4017efda309de14faf52b86e26274cc097ee029d282a975f0144e324ac68250
-  data.tar.gz: e46cbf422955acc46ef7ceff8348a564712a9109051511dfec1bd2dce96356f0
+  metadata.gz: ef10cccc964e68942152a64d489ea8044a99eb0b76a3fea00d75c311ddf94d23
+  data.tar.gz: 357793ece65c1bb58147e160fb8c95782e3496deac3a1b843a82faf9dcd06737
 SHA512:
-  metadata.gz: 1cee46e278c9ad77fab0d4f2869636c623b43e9e1b7d2ea0ea77f92be9ad8f6631bb6e5f92421997f92d42ba73470db659486595fe0993a50de93140eb6051fb
-  data.tar.gz: 36322b4f93132dd277476d999fc71511324d5a726979896ae08e4f6aea31d3aa4454fd41910a1c7758d229c9ff1000cb43de12ffaf8f795403e1ab7cf96f71ef
+  metadata.gz: 44ed4c55b5388cd068c723f01bfa02c3efa4fafe61adfa328197a76d0bcf4006eeab313d7d3a42a8b2088b43a4a6a25bd9b89868fe183daa744c3f324c0ef0f2
+  data.tar.gz: 721eebb0297114c0e439babab1c0c39bb1bb9697788ff4197b6d9cf072d80b1fb7d3783f1c629ea0062314321b0695565bd7e252c4e7c39e1940bcf93adabcb7

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## parse-stack-next Changelog
 
+### 5.7.4
+
+#### Reset connections are retried instead of surfacing a raw Faraday error
+
+A focused fix release for the request retry mechanism. A stale keep-alive
+connection (a pooled persistent connection closed by the server or a load
+balancer after idling) failed the next request with a raw
+`Faraday::ConnectionFailed` / `Errno::ECONNRESET` instead of retrying, even
+though an immediate re-send on a fresh connection succeeds. Reset connections
+now retry under the same idempotency rules as read timeouts.
+
+- **FIXED**: `Parse::Client#request` now rescues `Faraday::ConnectionFailed`
+  and inspects the wrapped cause. Reset-class causes (`Errno::ECONNRESET`,
+  `Errno::EPIPE`, `Errno::ECONNABORTED`, and the `EOFError` raised when the
+  remote end closes a keep-alive socket cleanly) are transient, so idempotent
+  requests (GET, DELETE, op-free PUT, and any write covered by asserted
+  server-side request-id dedup) retry with the standard backoff. Connection
+  refused and DNS failures keep the previous fail-fast behavior and propagate
+  the raw `Faraday::ConnectionFailed` with no retry latency.
+- **CHANGED**: A reset connection that persists through the whole retry budget
+  now raises `Parse::Error::ConnectionError` (consistent with the read-timeout
+  path) instead of the raw `Faraday::ConnectionFailed`. Code that rescued
+  `Faraday::ConnectionFailed` to catch resets should rescue
+  `Parse::Error::ConnectionError` instead; refused and DNS failures still
+  raise `Faraday::ConnectionFailed`.
+
 ### 5.7.3
 
 #### Stored values can no longer drive the operator's terminal

data/lib/parse/client.rb

@@ -1424,6 +1424,30 @@ module Parse
           retry
         end
         raise
+      rescue Faraday::ConnectionFailed => e
+        # `Faraday::ConnectionFailed` covers two very different failures under
+        # one class, so it is split on the wrapped cause (see
+        # #connection_reset_error?):
+        #
+        #   - RESET mid-flight (`Errno::ECONNRESET` / `Errno::EPIPE` /
+        #     `Errno::ECONNABORTED` / `EOFError`): the classic stale
+        #     keep-alive failure. A pooled persistent connection idled past
+        #     the server's (or an LB's) keep-alive window and was closed
+        #     remotely, and the next request on it dies at the socket.
+        #     Transient by nature (a fresh connection succeeds immediately),
+        #     so it retries under the same idempotency rules as a read
+        #     timeout: the outcome is unknown, so only idempotent requests
+        #     are re-sent.
+        #
+        #   - REFUSED (and DNS failure): the server is down or misconfigured.
+        #     Retrying only adds backoff latency and `[Parse:Retry]` noise
+        #     before the inevitable error, so it propagates raw and fast.
+        raise unless connection_reset_error?(e)
+        if _retry_count > 0 && idempotent_retry?(method, body, headers)
+          _retry_count = consume_retry_with_backoff(_retry_count, _retry_max, _request)
+          retry
+        end
+        raise Parse::Error::ConnectionError, "#{_request} : #{e.class} - #{e.message}"
       rescue Faraday::ClientError, Faraday::TimeoutError, Net::OpenTimeout => e
         # Request timed out mid-flight: the outcome is unknown (the server may
         # have received and applied the write but never answered), so only
@@ -1431,25 +1455,74 @@ module Parse
         #
         # Faraday 2.x raises `Faraday::TimeoutError` for a read timeout
         # (`Timeout::Error` / `Errno::ETIMEDOUT`); it subclasses `Faraday::Error`,
-        # not `ClientError`, so it must be listed explicitly to be caught. We
-        # deliberately do NOT catch `Faraday::ConnectionFailed` (connection
-        # refused/reset, plus the wrapped connect-timeout): refused is a
-        # non-transient "server down / misconfigured" failure, and auto-retrying
-        # it only adds backoff latency before the inevitable error. Broadening to
-        # reset connections safely (retry reset, fail fast on refused) is tracked
-        # as a follow-up.
+        # not `ClientError`, so it must be listed explicitly to be caught.
+        # `Faraday::ConnectionFailed` is handled in its own rescue above,
+        # split into retry-reset / fail-fast-refused.
         if _retry_count > 0 && idempotent_retry?(method, body, headers)
-          warn "[Parse:Retry] Retries remaining #{_retry_count} : #{_request}"
-          _retry_count -= 1
-          backoff_delay = RETRY_DELAY * (_retry_max - _retry_count)
-          _retry_delay = backoff_delay * (0.75 + rand * 0.5)
-          sleep _retry_delay if _retry_delay > 0
+          _retry_count = consume_retry_with_backoff(_retry_count, _retry_max, _request)
           retry
         end
         raise Parse::Error::ConnectionError, "#{_request} : #{e.class} - #{e.message}"
       end
     end
 
+    # Consumes one attempt from the retry budget: logs the remaining count,
+    # sleeps the linear backoff (RETRY_DELAY x attempt number, +/-25% jitter,
+    # never zero), and returns the decremented budget. Shared by the
+    # connection-reset and timeout rescue branches in {#request} so their
+    # backoff behavior cannot drift apart; the `retry` keyword itself must
+    # stay lexically inside each rescue clause, so it remains at the call
+    # sites. The 429/503 branch keeps its own inline version because it also
+    # honors a server-supplied Retry-After header.
+    # @param retry_count [Integer] the remaining retry budget (must be > 0).
+    # @param retry_max [Integer] the effective starting budget.
+    # @param request [Parse::Request] the request being retried (for logging).
+    # @return [Integer] the decremented retry budget.
+    def consume_retry_with_backoff(retry_count, retry_max, request)
+      warn "[Parse:Retry] Retries remaining #{retry_count} : #{request}"
+      retry_count -= 1
+      backoff_delay = RETRY_DELAY * (retry_max - retry_count)
+      retry_delay = backoff_delay * (0.75 + rand * 0.5)
+      sleep retry_delay if retry_delay > 0
+      retry_count
+    end
+
+    # The wrapped causes that mark a `Faraday::ConnectionFailed` as a RESET
+    # connection (transient, retry-safe for idempotent requests) rather than a
+    # REFUSED one (server down, fail fast). `EOFError` is what net/http raises
+    # when the remote end closes a keep-alive socket cleanly between requests;
+    # ECONNRESET/EPIPE/ECONNABORTED are the unclean variants.
+    # @!visibility private
+    CONNECTION_RESET_CAUSES = [
+      Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, EOFError,
+    ].freeze
+
+    # Message fallback for adapters that raise `Faraday::ConnectionFailed`
+    # with the cause flattened into the message instead of wrapped.
+    # @!visibility private
+    CONNECTION_RESET_MESSAGE = /connection reset|broken pipe|end of file reached/i
+
+    # Whether a `Faraday::ConnectionFailed` was caused by a reset/dropped
+    # connection (retryable) as opposed to connection-refused or a DNS
+    # failure (fail fast). Walks the wrapped exception and the `#cause`
+    # chain looking for a reset-class error.
+    # @param error [Exception] the rescued `Faraday::ConnectionFailed`.
+    # @return [Boolean]
+    def connection_reset_error?(error)
+      inner = error.respond_to?(:wrapped_exception) ? error.wrapped_exception : nil
+      inner ||= error.cause
+      seen = 0
+      while inner && seen < 8
+        return true if CONNECTION_RESET_CAUSES.any? { |klass| inner.is_a?(klass) }
+        inner = inner.cause
+        seen += 1
+      end
+      CONNECTION_RESET_MESSAGE.match?(error.message.to_s)
+    end
+
+    private :consume_retry_with_backoff, :connection_reset_error?
+    private_constant :CONNECTION_RESET_CAUSES, :CONNECTION_RESET_MESSAGE
+
     # Whether a request whose outcome is UNKNOWN (a 500/503 or a dropped
     # connection) is safe to transparently re-send.
     #

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.7.3"
+    VERSION = "5.7.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack-next
 version: !ruby/object:Gem::Version
-  version: 5.7.3
+  version: 5.7.4
 platform: ruby
 authors:
 - Adrian Curtin