advanced_connection 0.5.14 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 177ee27347e2d89c59e62a37e9c4277581a98a3e
-  data.tar.gz: 5f986bcfddcf5aae95f198c9b83f9ca03f81d94f
+  metadata.gz: 9dd080219f299367a2de7b23c0e7ce0d83bc20d3
+  data.tar.gz: d3d6b6cca8b0fc5bd717843f00ac5eea6a922589
 SHA512:
-  metadata.gz: 65cc5f19566474a2f05244f5025a2f14046a15a07a0069ee0cf1134cdfd76ad73299544cd0676c2eb8ed8b7b56a4758616fa1989095374e7e774b608927ff2cd
-  data.tar.gz: fc36d53db639a0c22f2723421e924147b898226a917590ca97df10a2d26e243cca13adf798ded82c3b5abece1d683ba2a197187411d22fd670b24e161790beec
+  metadata.gz: df32536d7ff51cea3a0620211290ebec729ecb3c3bc21c6845cea8d2baf8ca300dcb296f6fb3c2704eb14bebc6515a3a305d0df10a1baef19bc48e5ebec8cbfc
+  data.tar.gz: dc871c1ee46031e645cfd0417a6c6261dcf708947cab05b7c400007cbdcf1f298eba9edf8ba97e6a188bc3e6c8fe3f398720d42e41d7f662fc89e19e3da9b788

data/.gitignore

@@ -6,3 +6,4 @@ test/dummy/db/*.sqlite3-journal
 test/dummy/log/*.log
 test/dummy/tmp/
 test/dummy/.sass-cache
+apartment

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    advanced_connection (0.5.14)
+    advanced_connection (0.6.0)
       activerecord (~> 4.1)
       activesupport (~> 4.1)
       rails (~> 4.1)

data/README.md

@@ -34,8 +34,7 @@ bundle exec rails generate advanced_connection:install
 #### Idle Connection Manager
 
 Enabling this will enable idle connection management. This allows you to specify settings
-to enable automatic warmup of connections on rails startup, min/max idle connections and
-idle connection culling.
+to enable automatic idle connection reaping.
 
 ```text
   enable_idle_connection_manager = true | false
@@ -61,16 +60,6 @@ Pool queue type determines both how free connections will be checkout out of the
   connection_pool_queue_type = :fifo | :lifo | :stack | :prefer_older | :prefer_younger
 ```
 
-How many connections to prestart on initial startup of rails. This can help to reduce the time it takes a restarted production node to start responding again.
-```text
-  warmup_connections = integer | false
-```
-
-Minimum number of connection to keep idle. If, during the idle check, you have fewer than this many connections idle, then a number of new connections will be created up to this this number.
-```text
-  min_idle_connections = integer
-```
-
 Maximum number of connections that can remain idle without being culled. If you have
 more idle conections than this, only the difference between the total idle and this
 maximum will be culled.

data/lib/advanced_connection/active_record_ext.rb

@@ -38,21 +38,12 @@ module AdvancedConnection
       end
 
       ActiveRecord::ConnectionAdapters::ConnectionPool.instance_exec do
-        if AdvancedConnection.enable_idle_connection_manager
-          include ConnectionPool::IdleManager
-        end
-
-        if AdvancedConnection.enable_statement_pooling
-          include ConnectionPool::StatementPooling
-        elsif AdvancedConnection.enable_without_connection
-          include ConnectionPool::WithoutConnection
-        end
+        include ConnectionPool::IdleManager if AdvancedConnection.enable_idle_connection_manager
+        include ConnectionPool::WithoutConnection
       end
 
       ActiveRecord::Base.instance_exec do
-        if AdvancedConnection.enable_without_connection
-          extend ActiveRecordExt::WithoutConnection unless AdvancedConnection.enable_statement_pooling
-        end
+        extend ActiveRecordExt::WithoutConnection
       end
     end
   end

data/lib/advanced_connection/active_record_ext/abstract_adapter.rb

@@ -31,16 +31,25 @@ module AdvancedConnection::ActiveRecordExt
     end
 
     included do
-      attr_accessor :last_checked_in, :instantiated_at
+      attr_accessor :last_checked_in, :last_checked_out, :instantiated_at
       alias_method_chain :initialize, :advanced_connection
+      alias_method_chain :lease, :advanced_connection
     end
 
     def initialize_with_advanced_connection(*args, &block)
-      @last_checked_in = Time.now - 1.year
-      @instantiated_at = Time.now
+      @instantiated_at  = Time.now
+      @last_checked_in  = @instantiated_at
+      @last_checked_out = false
       initialize_without_advanced_connection(*args, &block)
     end
 
+    def lease_with_advanced_connection
+      synchronize {
+        @last_checked_out = Time.now
+        lease_without_advanced_connection
+      }
+    end
+
     def instance_age
       (Time.now - @instantiated_at).to_f
     end
@@ -57,20 +66,20 @@ module AdvancedConnection::ActiveRecordExt
       case pool.queue_type
         when :prefer_younger then
           # when prefering younger, we sort oldest->youngest
-          # this ensures that older connections will be culled
+          # to ensure that older connections will be reaped
           # during #remove_idle_connections()
           -(instance_age <=> other.instance_age)
         when :prefer_older then
-          # when prefering older, we sort youngest->oldest
-          # this ensures that younger connections will be culled
+          # when prefering older, we sort youngest->oldest to
+          # ensure that younger connections will be reaped
           # during #remove_idle_connections()
           (instance_age <=> other.instance_age)
         else
-          # with fifo / lifo queues, we only care about the
+          # With fifo / lifo queues, we only care about the
           # last time a given connection was used (inferred
           # by when it was last checked into the pool).
           # This ensures that the longer idling connections
-          # will be culled.
+          # will be reaped.
           -(last_checked_in <=> other.last_checked_in)
       end
     end

data/lib/advanced_connection/active_record_ext/connection_pool/idle_manager.rb

@@ -1,4 +1,3 @@
-
 # Copyright (C) 2016 Finalsite, LLC
 # Copyright (C) 2016 Carl P. Corliss <carl.corliss@finalsite.com>
 #
@@ -32,95 +31,99 @@ module AdvancedConnection::ActiveRecordExt
 
         class IdleManager
           attr_accessor :interval
-          attr_reader :thread, :logger
-          private :thread
+          attr_reader :logger
 
           def initialize(pool, interval)
             @pool     = pool
             @interval = interval.to_i
-            @thread   = nil
             @logger   = ActiveSupport::Logger.new(Rails.root.join('log', 'idle_manager.log'))
-            @logger.level = Rails.logger.level
-          end
 
-          def log_info(format, *args)
-            @logger.info(format("#{idle_stats} #{format}", *args))
+            @logger.level = AdvancedConnection.idle_manager_log_level || ::Logger::INFO
           end
 
-          def log_debug(format, *args)
-            @logger.debug(format("#{idle_stats} #{format}", *args))
+          %w[debug info warn error].each do |level|
+            define_method("log_#{level}") do |fmt, *args|
+              @logger.send(level, format("[#{Time.now}] #{idle_stats} #{level.upcase}: #{fmt}", *args))
+            end
           end
 
-          def log_warn(format, *args)
-            @logger.debug(format("#{idle_stats} #{format}", *args))
+          def reserved_connections
+            reserved = @pool.instance_variable_get(:@reserved_connections).dup
+            Hash[reserved.keys.zip(reserved.values)]
           end
 
-          def dump_stats
-            if (stats_dump = Rails.root.join('tmp', 'dump-idle-stats.txt')).exist?
-              log_info "Dumping statistics"
-              id_size = self.object_id.to_s.size
-              @logger.info(format("%3s: %#{id_size}s\t%9s\t%9s", 'IDX', 'OID', 'AGE', 'IDLE'))
-              @pool.idle_connections.each_with_index do |connection, index|
-                @logger.info(format("%3d: %#{id_size}d\t%9d\t%9d",
-                                    index, connection.object_id, connection.instance_age, connection.idle_time))
+          def dump_connections
+            return unless (stats_dump = Rails.root.join('tmp', 'dump-connections.txt')).exist?
+
+            log_info "Dumping connections"
+
+            id_size = object_id.to_s.size
+            @logger.info(format("%3s: %#{id_size}s\t%9s\t%9s\t%4s\t%s", 'IDX', 'OID', 'AGE', 'IDLE', 'ACTV', 'OWNER'))
+
+            @pool.connections.dup.each_with_index do |connection, index|
+              if connection.in_use?
+                thread_id    = reserved_connections.index(connection) || 0
+                thread_hexid = "0x" << (thread_id << 1).to_s(16)
               end
-              !!(stats_dump.unlink rescue true)
+
+              @logger.info(format("%3d: %#{id_size}d\t%9d\t%9d\t%4s\t%s",
+                                  index, connection.object_id,
+                                  connection.instance_age, connection.idle_time,
+                                  connection.in_use?.to_s, thread_hexid))
             end
+
+            !!(stats_dump.unlink rescue true) # rubocop:disable Style/RescueModifier
           end
 
           def idle_stats
             stats = @pool.pool_statistics
-            format(
-              "[#{Time.now}] IdleManager (Actv:%d,Avail:%d,Idle:%d,Total:%d):",
-              stats.active, stats.available, stats.idle, stats.total,
-            )
+            format("[Act: %d / Avail: %d (%d idle) / Total: %d]",
+                   stats.active, stats.available, stats.idle, stats.total)
           end
 
-          def status
-            if @thread
-              @thread.alive? ? :running : :dead
-            else
-              :stopped
-            end
-          end
+          def safe_timed_run(last_run = nil)
+            return unless block_given?
 
-          def restart
-            stop.start
-          end
+            log_debug "last run was #{Time.now - last_run} seconds ago" if last_run
 
-          def stop
-            @thread.kill if @thread.alive?
-            @thread = nil
-            self
+            begin
+              start = Time.now
+              yield
+            rescue StandardError => e
+              log_error "#{e.class.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+            ensure
+              finish = ((last_run = Time.now) - start).round(6)
+              log_info("finished idle connection tasks in #{finish} seconds")
+            end
+
+            last_run
           end
 
-          def start
+          def run
             return unless @interval > 0
 
-            @thread ||= Thread.new(@pool, @interval) { |pool, interval|
+            Thread.new(@pool, @interval) do |pool, interval|
+              Thread.current.name = self.class.name if Thread.current.respond_to? :name=
+
+              begin
+                pool.release_connection if pool.active_connection?
+              rescue StandardError => e
+                log_error "#{e.class.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+              end
+
               log_info("starting idle manager; running every #{interval} seconds")
+              last_run = nil
 
-              loop do
+              loop {
                 sleep interval
 
-                begin
-                  start = Time.now
-                  dump_stats
-
-                  log_debug("beginning idle connection cleanup")
+                last_run = safe_timed_run(last_run) do
+                  dump_connections
                   pool.remove_idle_connections
-
-                  log_debug("beginning idle connection warmup")
-                  pool.create_idle_connections
-
-                  finish = (Time.now - start).round(6)
-                  log_info("finished idle connection tasks in #{finish} seconds; next run in #{interval} seconds")
-                rescue => e
-                  Rails.logger.error "#{e.class.name}: #{e.message}"
-                  e.backtrace.each { |line| Rails.logger.error line }
                 end
-              end
-            }
+              }
+            end
+
             self
           end
         end
@@ -139,41 +142,19 @@ module AdvancedConnection::ActiveRecordExt
             Queues::FIFO.new
         end
 
-        @idle_manager = IdleManager.new(self, idle_check_interval).tap(&:start)
+        @idle_manager = IdleManager.new(self, idle_check_interval).tap(&:run)
       end
 
-      #
-      ## SETINGS
-      #
-
       def queue_type
-        @queue_type ||= spec.config.fetch(:queue_type,
-                                          AdvancedConnection.connection_pool_queue_type).to_s.downcase.to_sym
-      end
-
-      def warmup_connection_count
-        @warmup_connection_count ||= begin
-          conns = spec.config[:warmup_connections] || AdvancedConnection.warmup_connections
-          conns.to_i > connection_limit ? connection_limit : conns.to_i
-        end
-      end
-
-      def max_idle_time
-        @max_idle_time ||= (spec.config[:max_idle_time] || \
-                           AdvancedConnection.max_idle_time).to_i
-      end
-
-      def idle_check_interval
-        @idle_check_interval ||= (spec.config[:idle_check_interval] || \
-                                 AdvancedConnection.idle_check_interval || \
-                                 max_idle_time).to_i
+        @queue_type ||= spec.config.fetch(
+          :queue_type, AdvancedConnection.connection_pool_queue_type
+        ).to_s.downcase.to_sym
       end
 
       def max_idle_connections
         @max_idle_connections ||= begin
           begin
-            (spec.config[:max_idle_connections] || \
-              AdvancedConnection.max_idle_connections).to_i
+            spec.config.fetch(:max_idle_connections, AdvancedConnection.max_idle_connections).to_i
           rescue FloatDomainError => e
             raise unless e.message =~ /infinity/i
             ::Float::INFINITY
@@ -181,120 +162,84 @@ module AdvancedConnection::ActiveRecordExt
         end
       end
 
-      def min_idle_connections
-        @min_idle_connections ||= begin
-          min_idle = (spec.config[:min_idle_connections] || AdvancedConnection.min_idle_connections).to_i
-          min_idle = (min_idle > 0 ? min_idle : 0)
-          min_idle <= max_idle_connections ? min_idle : max_idle_connections
+      def max_idle_time
+        @max_idle_time ||= begin
+          spec.config.fetch(:max_idle_time, AdvancedConnection.max_idle_time).to_i
         end
       end
 
-      def connection_limit
-        @size
+      def idle_check_interval
+        @idle_check_interval ||= begin
+          spec.config[:idle_check_interval]  || \
+          AdvancedConnection.idle_check_interval || \
+          max_idle_time
+        end.to_i
       end
 
       def checkin_with_last_checked_in(conn)
-        conn.last_checked_in = Time.now
-        idle_manager.log_debug "checking in connection #{conn.object_id} at #{conn.last_checked_in}"
-        checkin_without_last_checked_in(conn)
-      end
-
-      def idle_connections
-        synchronize { @connections.select(&:idle?).sort }
-      end
-
-      def pool_statistics
-        synchronize do
-          total     = @connections.size
-          idle      = @connections.count(&:idle?)
-          active    = @connections.count(&:in_use?)
-          available = total - active
-
-          ActiveSupport::OrderedOptions.new.merge(
-            total:     total,
-            idle:      idle,
-            active:    active,
-            available: available
-          )
+        begin
+          if conn.last_checked_out
+            previous_checkin, conn.last_checked_in = conn.last_checked_in, Time.now
+            idle_manager.log_debug "checking in connection %s at %s (checked out for %.3f seconds)",
+                                   conn.object_id, conn.last_checked_in,
+                                   (conn.last_checked_in - conn.last_checked_out).to_f.round(6)
+          else
+            idle_manager.log_debug "checking in connection #{conn.object_id}"
+          end
+        ensure
+          checkin_without_last_checked_in(conn)
         end
       end
 
-      def create_idle_connections
-        idle_count = idle_connections.size
-        open_slots = connection_limit - @connections.size
-
-        # if we already have enough idle connections, do nothing
-        return unless idle_count < min_idle_connections
-
-        # if we don't have enough available slots (i.e., current pool size
-        # is greater than max pool size) then do nothing
-        return unless open_slots > 0
-
-        # otherwise, spin up connections up to our min_idle_connections setting
-        create_count = min_idle_connections - idle_count
-        create_count = open_slots if create_count > open_slots
-
-        warmup_connections(create_count)
+      def pool_statistics
+        ActiveSupport::OrderedOptions.new.merge(
+          total:     (total  = @connections.size),
+          idle:      (idle   = @connections.count(&:idle?)),
+          active:    (active = @connections.count(&:in_use?)),
+          available: (total - active)
+        )
       end
 
-      def warmup_connections(count = nil)
-        count ||= warmup_connection_count
-        slots = connection_limit - @connections.size
-        count = slots if slots < count
-
-        return unless slots >= count
-
-        idle_manager.log_info "Warming up #{count} connection#{count > 1 ? 's' : ''}"
-        synchronize do
-          count.times {
-            conn = checkout_new_connection
-            @available.add conn
-          }
-        end
+      def idle_connections
+        @connections.select(&:idle?).sort
       end
 
       def remove_idle_connections
         # don't attempt to remove idle connections if we have threads waiting
         if @available.num_waiting > 0
-          idle_manager.log_warn "Cannot reap while threads actively waiting on db connections"
+          idle_manager.log_warn "Skipping reap while #{@available.num_waiting} thread(s) are actively waiting on database connections..."
           return
         end
 
-        idle_conns = idle_connections
-        idle_count = idle_conns.size
-
-        unless idle_count > max_idle_connections
-          idle_manager.log_warn "idle count (#{idle_count}) does not exceed max idle connections (#{max_idle_connections}); skipping reap."
-          return
-        end
+        return unless (candidates = idle_connections.size - max_idle_connections) > 0
+        idle_manager.log_info "attempting to reap #{candidates} candidate connections"
 
-        cull_count = (idle_count - max_idle_connections)
+        reaped = 0
 
-        culled = 0
-        idle_conns.each_with_index do |conn, idx|
-          if idx < cull_count
+        synchronize do
+          idle_connections[0...candidates].each_with_index { |conn, idx|
             if remove_connection(conn)
-              culled += 1
-              idle_manager.log_info "culled connection ##{idx} id##{conn.object_id} - age:#{conn.instance_age.to_i} idle_time:#{conn.idle_time.to_i}"
+              reaped += 1
+              idle_manager.log_info "reaped candidate connection #%d id#%d age:%d idle:%d" % [
+                idx, conn.object_id, conn.instance_age.to_i, conn.idle_time.to_i
+              ]
             else
-              idle_manager.log_info "kept connection ##{idx} id##{conn.object_id} - age:#{conn.instance_age.to_i} idle_time:#{conn.idle_time.to_i}"
+              idle_manager.log_info "kept candidate connection #%d id#%d age:%d idle:%d" % [
+                idx, conn.object_id, conn.instance_age.to_i, conn.idle_time.to_i
+              ]
             end
-          else
-            idle_manager.log_info "kept connection ##{idx} id##{conn.object_id} - age:#{conn.instance_age.to_i} idle_time:#{conn.idle_time.to_i}"
-          end
+          }
         end
 
-        idle_manager.log_info "culled %d connections" % culled
+        idle_manager.log_info "reaped #{reaped} of #{candidates} candidate connections"
       end
 
     private
 
       def remove_connection(conn)
-        synchronize do
-          return false if conn.in_use?
-          remove conn
-          conn.disconnect!
-        end
+        return false if conn.in_use?
+
+        remove(conn.tap { |c| c.disconnect! })
         true
       end
     end

data/lib/advanced_connection/active_record_ext/connection_pool/queues.rb

@@ -38,6 +38,7 @@ module AdvancedConnection::ActiveRecordExt
       class AgeSorted < Default
         def poll(timeout = nil)
           synchronize do
+            # always sort age based queues from youngest to oldest
             @queue.sort_by!(&:instance_age)
             no_wait_poll || (timeout && wait_poll(timeout))
           end
@@ -46,12 +47,16 @@ module AdvancedConnection::ActiveRecordExt
 
       class YoungAgeBiased < AgeSorted
         def remove
+          # Think of this like a stack, sorted youngest to oldest, bottom to top. To to
+          # aquire the youngest entry, we shift it off the bottom (i.e., the first element)
           @queue.shift
         end
       end
 
       class OldAgeBiased < AgeSorted
         def remove
+          # Think of this like a stack, sorted youngest to oldest, bottom to top. To to
+          # aquire the oldest entry, we pop it off the top (i.e., the last element)
           @queue.pop
         end
       end

data/lib/advanced_connection/active_record_ext/connection_pool/without_connection.rb

@@ -24,6 +24,8 @@ module AdvancedConnection::ActiveRecordExt
     module WithoutConnection
       extend ActiveSupport::Concern
 
+      MAX_REAQUIRE_ATTEMPTS = 3
+
       included do
         include ::ActiveSupport::Callbacks
         alias_method :retrieve_connection, :connection
@@ -34,19 +36,25 @@ module AdvancedConnection::ActiveRecordExt
         set_callback :without_connection, :after, :after_without_connection
       end
 
-      def without_connection
+      def without_connection(&block)
         return unless block_given?
 
+        # if we're not enabled just execute the block and return
+        return block.call unless AdvancedConnection.enable_without_connection
+
+        # if we have a transaction open, we can't release the database connection
+        # or Bad Things (tm) happen - so we just execute our block and return
+        if transaction_open?
+          Rails.logger.warn "WithoutConnection skipped due to open transaction."
+          return block.call
+        end
+
         if AdvancedConnection.callbacks.without_connection.present?
           run_callbacks(:without_connection) do
-            __without_connection do
-              yield
-            end
+            __without_connection { block.call }
           end
         else
-          __without_connection do
-            yield
-          end
+          __without_connection { block.call }
         end
       end
 
@@ -58,15 +66,19 @@ module AdvancedConnection::ActiveRecordExt
         raise Error::UnableToReleaseConnection if active_connection?
         yield
       ensure
-        tries = 3
+        attempt = 0
         begin
           # attempt to retrieve another connection
           retrieve_connection
         rescue ActiveRecord::ConnectionTimeoutError
-          Rails.logger.info "Failed to acquire a connection (#{Thread.current.object_id}) trying #{tries > 1 ? "#{tries} more times" : 'once more'}"
-          retry unless (tries -= 1) < 0
-          Rails.logger.info "Giving up on trying to acquire another connection"
-          raise
+          if attempt >= MAX_REAQUIRE_ATTEMPTS
+            Rails.logger.info "Giving up on trying to reacquire database connection"
+            raise Error::UnableToReaquireConnection
+          else
+            Rails.logger.warn "Failed to reaquire database connection - reattempt #{attempt += 1}/#{MAX_REAQUIRE_ATTEMPTS} ..."
+          end
+
+          retry
         end
       end
 

data/lib/advanced_connection/config.rb

@@ -21,10 +21,12 @@
 #
 require 'singleton'
 require 'monitor'
+require 'logger'
 
 module AdvancedConnection
   class Config
     include Singleton
+    include MonitorMixin
 
     VALID_QUEUE_TYPES = [
       :fifo, :lifo, :stack, :prefer_younger, :prefer_older
@@ -37,12 +39,13 @@ module AdvancedConnection
     ).freeze unless defined? CALLBACK_TYPES
 
     DEFAULT_CONFIG = ActiveSupport::OrderedOptions.new.merge(
+      idle_manager_log_level:         ::Logger::INFO,
       enable_without_connection:      false,
       enable_statement_pooling:       false,
       enable_idle_connection_manager: false,
       connection_pool_queue_type:     :fifo,
-      warmup_connections:             false,
-      min_idle_connections:           0,
+      warmup_connections:             nil,
+      min_idle_connections:           nil,
       max_idle_connections:           ::Float::INFINITY,
       max_idle_time:                  0,
       idle_check_interval:            nil,
@@ -140,6 +143,21 @@ module AdvancedConnection
       @config.callbacks
     end
 
+    def idle_manager_log_level
+      @config[:log_level]
+    end
+
+    def idle_manager_log_level=(level)
+      @config[:log_level] = case level
+        when :debug, /debug/i, ::Logger::DEBUG then ::Logger::DEBUG
+        when :info,  /info/i,  ::Logger::INFO  then ::Logger::INFO
+        when :warn,  /warn/i,  ::Logger::WARN  then ::Logger::WARN
+        when :error, /error/i, ::Logger::ERROR then ::Logger::ERROR
+        when :fatal, /fatal/i, ::Logger::FATAL then ::Logger::FATAL
+        else ::Logger::INFO
+      end
+    end
+
     def enable_without_connection
       @config[:enable_without_connection]
     end
@@ -171,28 +189,21 @@ module AdvancedConnection
     end
 
     def warmup_connections
-      @config[:warmup_connections]
+      # deprecated and not used
+      0
     end
 
     def warmup_connections=(value)
-      unless !!value || value.is_a?(Fixnum) || value =~ /^\d+$/
-        fail Error::ConfigError, 'Expected warmup_connections to be nil, false ' \
-                           "or a valid positive integer, but found `#{value.inspect}`"
-      end
-
-      synchronize { @config[:warmup_connections] = value.to_s =~ /^\d+$/ ? value.to_i : false }
+      # deprecated and not used
     end
 
     def min_idle_connections
-      @config[:min_idle_connections]
+      # deprecated and not used
+      0
     end
 
     def min_idle_connections=(value)
-      unless value.is_a?(Numeric) || value =~ /^\d+$/
-        fail Error::ConfigError, 'Expected min_idle_connections to be ' \
-                           "a valid integer value, but found `#{value.inspect}`"
-      end
-      synchronize { @config[:min_idle_connections] = value.to_i }
+      # deprecated and not used
     end
 
     def max_idle_connections

data/lib/advanced_connection/error.rb

@@ -23,5 +23,6 @@ module AdvancedConnection
   class Error < StandardError
     class ConfigError < Error; end
     class UnableToReleaseConnection < Error; end
+    class UnableToReaquireConnection < Error; end
   end
 end

data/lib/advanced_connection/railtie.rb

@@ -41,12 +41,6 @@ module AdvancedConnection
           ActiveRecord::Base.send(:include, AdvancedConnection::ActiveRecordExt)
         }
       end
-
-      config.after_initialize do
-        if AdvancedConnection.enable_idle_connection_manager && AdvancedConnection.warmup_connections
-          ActiveRecord::Base.connection_handler.connection_pool_list.each(&:warmup_connections)
-        end
-      end
     end
   end
 end

data/lib/advanced_connection/version.rb

@@ -21,8 +21,8 @@
 #
 module AdvancedConnection
   MAJOR = 0
-  MINOR = 5
-  PATCH = 14
+  MINOR = 6
+  PATCH = 0
 
   VERSION     = "%d.%d.%d" % [ MAJOR, MINOR, PATCH ]
   GEM_VERSION = Gem::Version.new(VERSION)

data/lib/generators/advanced_connection/install/templates/advanced_connection.rb

@@ -6,42 +6,33 @@ AdvancedConnection.configure do |config|
   ## Idle Manager
   #
   # Enabling this will enable idle connection management. This allows you to specify settings
-  # to enable automatic warmup of connections on rails startup, min/max idle connections and
-  # idle connection culling.
+  # to enable the automatic reaping of idle database connections.
+  #
   # config.enable_idle_connection_manager = <%= AdvancedConnection::Config::DEFAULT_CONFIG.enable_idle_connection_manager.inspect %>
 
   # Pool queue type determines both how free connections will be checkout out
-  # of the pool, as well as how idle connections will be culled. The options are:
+  # of the pool, as well as how idle connections will be reaped. The options are:
   #
-  #  :fifo           - All connections will have an equal opportunity to be used and culled (default)
+  #  :fifo           - All connections will have an equal opportunity to be used and reaped (default)
   #  :lifo/:stack    - More frequently used connections will be reused, leaving less frequently used
-  #                    connections to be culled
+  #                    connections to be reaped
   #  :prefer_older   - Longer lived connections will tend to stick around longer, with younger
-  #                    connections being culled
+  #                    connections being reaped
   #  :prefer_younger - Younger lived connections will tend to stick around longer, with older
-  #                    connections being culled
+  #                    connections being reaped
   #
   # config.connection_pool_queue_type     = <%= AdvancedConnection::Config::DEFAULT_CONFIG.connection_pool_queue_type.inspect %>
 
-  # How many connections to prestart on initial startup of rails. This can
-  # help to reduce the time it takes a restarted production node to start
-  # responding again.
-  #
-  # config.warmup_connections             = <%= AdvancedConnection::Config::DEFAULT_CONFIG.warmup_connections.inspect %>
-
-  # Minimum number of connection to keep idle. If, during the idle check, you have fewer
-  # than this many connections idle, then a number of new connections will be created
-  # up to this this number.
-  #
-  # config.min_idle_connections           = <%= AdvancedConnection::Config::DEFAULT_CONFIG.min_idle_connections.inspect %>
+  # What log level to log idle manager stats and details at (see ::Logger#level)
+  # config.idle_manager_log_level = ::Logger::INFO
 
-  # Maximum number of connections that can remain idle without being culled. If you have
+  # Maximum number of connections that can remain idle without being reaped. If you have
   # more idle conections than this, only the difference between the total idle and this
-  # maximum will be culled.
+  # maximum will be reaped.
   #
   # config.max_idle_connections           = ::Float::INFINITY
 
-  # How long (in seconds) a connection can remain idle before being culled
+  # How long (in seconds) a connection can remain idle before being reaped
   #
   # config.max_idle_time                  = 90
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: advanced_connection
 version: !ruby/object:Gem::Version
-  version: 0.5.14
+  version: 0.6.0
 platform: ruby
 authors:
 - Carl P. Corliss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails