activerecord 8.0.2 → 8.1.0

data/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb

@@ -40,6 +40,14 @@ module ActiveRecord
           end
         end
 
+        # Add +element+ to the back of the queue.  Never blocks.
+        def add_back(element)
+          synchronize do
+            @queue.unshift element
+            @cond.signal
+          end
+        end
+
         # If +element+ is in the queue, remove and return it, or +nil+.
         def delete(element)
           synchronize do
@@ -54,6 +62,13 @@ module ActiveRecord
           end
         end
 
+        # Number of elements in the queue.
+        def size
+          synchronize do
+            @queue.size
+          end
+        end
+
         # Remove the head of the queue.
         #
         # If +timeout+ is not given, remove and return the head of the
@@ -114,9 +129,7 @@ module ActiveRecord
             t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             elapsed = 0
             loop do
-              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                @cond.wait(timeout - elapsed)
-              end
+              @cond.wait(timeout - elapsed)
 
               return remove if any?
 

data/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb

@@ -7,12 +7,29 @@ module ActiveRecord
     class ConnectionPool
       # = Active Record Connection Pool \Reaper
       #
-      # Every +frequency+ seconds, the reaper will call +reap+ and +flush+ on
-      # +pool+. A reaper instantiated with a zero frequency will never reap
-      # the connection pool.
+      # The reaper is a singleton that exists in the background of the process
+      # and is responsible for general maintenance of all the connection pools.
       #
-      # Configure the frequency by setting +reaping_frequency+ in your database
-      # YAML file (default 60 seconds).
+      # It will reclaim connections that are leased to now-dead threads,
+      # ensuring that a bad thread can't leak a pool slot forever. By definition,
+      # this involves touching currently-leased connections, but that is safe
+      # because the owning thread is known to be dead.
+      #
+      # Beyond that, it manages the health of available / unleased connections:
+      #  * retiring connections that have been idle[1] for too long
+      #  * creating occasional activity on inactive[1] connections
+      #  * keeping the pool prepopulated up to its minimum size
+      #  * proactively connecting to the target database from any pooled
+      #    connections that had lazily deferred that step
+      #  * resetting or replacing connections that are known to be broken
+      #
+      #
+      # [1]: "idle" and "inactive" here distinguish between connections that
+      # have not been requested by the application in a while (idle) and those
+      # that have not spoken to their remote server in a while (inactive). The
+      # former is a desirable opportunity to reduce our connection count
+      # (`idle_timeout`); the latter is a risk that the server or a firewall may
+      # drop a connection we still anticipate using (avoided by `keepalive`).
       class Reaper
         attr_reader :pool, :frequency
 
@@ -36,6 +53,15 @@ module ActiveRecord
             end
           end
 
+          def pools(refs = nil) # :nodoc:
+            refs ||= @mutex.synchronize { @pools.values.flatten(1) }
+
+            refs.filter_map do |ref|
+              ref.__getobj__ if ref.weakref_alive?
+            rescue WeakRef::RefError
+            end.select(&:maintainable?)
+          end
+
           private
             def spawn_thread(frequency)
               Thread.new(frequency) do |t|
@@ -46,23 +72,36 @@ module ActiveRecord
                 running = true
                 while running
                   sleep t
+
+                  refs = nil
+
                   @mutex.synchronize do
-                    @pools[frequency].select! do |pool|
-                      pool.weakref_alive? && !pool.discarded?
-                    end
+                    refs = @pools[frequency]
 
-                    @pools[frequency].each do |p|
-                      p.reap
-                      p.flush
+                    refs.select! do |pool|
+                      pool.weakref_alive? && !pool.discarded?
                     rescue WeakRef::RefError
                     end
 
-                    if @pools[frequency].empty?
+                    if refs.empty?
                       @pools.delete(frequency)
                       @threads.delete(frequency)
                       running = false
                     end
                   end
+
+                  if running
+                    pools(refs).each do |pool|
+                      pool.reaper_lock do
+                        pool.reap
+                        pool.flush
+                        pool.prepopulate
+                        pool.retire_old_connections
+                        pool.keep_alive
+                        pool.preconnect
+                      end
+                    end
+                  end
                 end
               end
             end