Maintain connection verification briefly after use

This means that a database connection that fails in between two requests
that are less than two seconds apart may cause the failure-following
request to die (if its first query is not retryable).

That's not a big concern in practice: per-request verification is
intended to protect against the case that the database connection failed
some large time before the request arrives. A request beginning within
seconds of the failure is morally equivalent to a request that was
already in flight.

Between automatically retryable select queries and BEGINs, the first
query of a request will very commonly be retryable anyway. This change's
value is in our new use of short-term leasing via with_connection, where
we can otherwise end up re-verifying for every non-retryable query.

Author: matthewd

activerecord/CHANGELOG.md

@@ -1,3 +1,13 @@
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
+
+    This should recreate a similar rate of verification as in Rails 7.1,
+    where connections are leased for the duration of a request, and thus
+    only verified once.
+
+    *Matthew Draper*
+
 *   Allow to reset cache counters for multiple records.
 
     ```

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -218,6 +218,10 @@ def connection_retries
         (@config[:connection_retries] || 1).to_i
       end
 
+      def verify_timeout
+        (@config[:verify_timeout] || 2).to_i
+      end
+
       def retry_deadline
         if @config[:retry_deadline]
           @config[:retry_deadline].to_f
@@ -1003,6 +1007,9 @@ def with_raw_connection(allow_retry: false, materialize_transactions: true)
             if @verified
               # Cool, we're confident the connection's ready to use. (Note this might have
               # become true during the above #materialize_transactions.)
+            elsif (last_activity = seconds_since_last_activity) && last_activity < verify_timeout
+              # We haven't actually verified the connection since we acquired it, but it
+              # has been used very recently. We're going to assume it's still okay.
             elsif reconnectable
               if allow_retry
                 # Not sure about the connection yet, but if anything goes wrong we can

activerecord/test/cases/adapter_test.rb

@@ -611,11 +611,14 @@ def teardown
         assert_predicate @connection, :active?
       end
 
-      test "querying a 'clean' failed connection restores and succeeds" do
+      test "querying a 'clean' long-failed connection restores and succeeds" do
         remote_disconnect @connection
 
         @connection.clean! # this simulates a fresh checkout from the pool
 
+        # Backdate last activity to simulate a connection we haven't used in a while
+        @connection.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 5.minutes)
+
         # Clean did not verify / fix the connection
         assert_not_predicate @connection, :active?
 
@@ -627,11 +630,30 @@ def teardown
         assert_predicate @connection, :active?
       end
 
+      test "querying a 'clean' recently-used but now-failed connection skips verification" do
+        remote_disconnect @connection
+
+        @connection.clean! # this simulates a fresh checkout from the pool
+
+        # Clean did not verify / fix the connection
+        assert_not_predicate @connection, :active?
+
+        # Because the query cannot be retried, and we (mistakenly) believe the
+        # connection is still good, the query will fail. This is what we want,
+        # because the alternative would be excessive reverification.
+        assert_raises(ActiveRecord::AdapterError) do
+          Post.delete_all
+        end
+      end
+
       test "quoting a string on a 'clean' failed connection will not prevent reconnecting" do
         remote_disconnect @connection
 
         @connection.clean! # this simulates a fresh checkout from the pool
 
+        # Backdate last activity to simulate a connection we haven't used in a while
+        @connection.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 5.minutes)
+
         # Clean did not verify / fix the connection
         assert_not_predicate @connection, :active?