advanced_connection 0.5.1

data/advanced_connection.gemspec

@@ -0,0 +1,49 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "advanced_connection/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |spec|
+  spec.name        = "advanced_connection"
+  spec.version     = AdvancedConnection::VERSION
+  spec.authors     = ["Carl P. Corliss"]
+  spec.email       = ["carl.corliss@finalsite.com"]
+  spec.homepage    = "https://github.com/finalsite/advanced_connection"
+  spec.summary     = "Provides advanced connection options for rails connection pools"
+  spec.description = "Adds idle connection management, statement pooling, and other advanced connection features"
+  spec.license     = "LGPL"
+
+  spec.files = `git ls-files`.split($/)
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # eventually support this:
+  # spec.required_engine_version = {
+  #   :ruby     => '~> 2.0',
+  #   :jruby    => '~> 1.7',
+  # }
+
+  spec.add_runtime_dependency "rails",         ">= 4.1.0", "< 5.0"
+  spec.add_runtime_dependency "activerecord",  ">= 4.1.0", "< 5.0"
+  spec.add_runtime_dependency "activesupport", ">= 4.1.0", "< 5.0"
+
+  spec.add_development_dependency "rake",      '~> 10.5'
+  spec.add_development_dependency "rack",      '~> 1.6'
+  spec.add_development_dependency "rspec",     '~> 3.4'
+  spec.add_development_dependency "rspec-its", '~> 1.2'
+  spec.add_development_dependency "rspec-collection_matchers", '~> 1.1'
+
+  # optional dependencies
+  if RUBY_ENGINE == 'jruby'
+    spec.add_development_dependency "activerecord-jdbcpostgresql-adapter", "~> 1.3"
+  else
+    spec.add_development_dependency "pg",      "~> 0.18"
+    spec.add_development_dependency "pry",     '~> 0.10'
+    spec.add_development_dependency "pry-nav", '~> 0.2'
+  end
+
+  spec.add_development_dependency "guard-rspec", '~> 4.6'
+  spec.add_development_dependency "coveralls",   '~> 0.8'
+  spec.add_development_dependency 'copyright-header', '= 1.0.15'
+end

data/gemfiles/jruby/rails4_1.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.1.0"
+gem "activesupport", "~> 4.1.0"
+gem "activerecord-jdbcpostgresql-adapter", '~> 1.3.10'
+
+gemspec :path => "../../"

data/gemfiles/jruby/rails4_2.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.2.0"
+gem "activesupport", "~> 4.2.0"
+gem "activerecord-jdbcpostgresql-adapter", '~> 1.3.10'
+
+gemspec :path => "../../"

data/gemfiles/ruby/rails4_1.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.1.0"
+gem "activesupport", "~> 4.1.0"
+gem "pg", "~> 0.18.4"
+
+gemspec :path => "../../"

data/gemfiles/ruby/rails4_2.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.2.0"
+gem "activesupport", "~> 4.2.0"
+gem "pg", "~> 0.18.4"
+
+gemspec :path => "../../"

data/lib/advanced_connection/active_record_ext/abstract_adapter/statement_pooling.rb

@@ -0,0 +1,121 @@
+#
+# Copyright (C) 2016 Finalsite, LLC
+# Copyright (C) 2016 Carl P. Corliss <carl.corliss@finalsite.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+require 'active_record/connection_adapters/abstract_adapter'
+
+module AdvancedConnection::ActiveRecordExt
+  module AbstractAdapter
+    module StatementPooling
+      extend ActiveSupport::Concern
+
+      module ExecuteWrapper
+        def __wrap_adapter_exec_methods(*methods)
+          Array(methods).flatten.collect(&:to_sym).each { |exec_method|
+            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              def #{exec_method}_with_callback(sql, *args, &block)
+                if Thread.current[:without_callbacks] || sql =~ /^BEGIN/i || transaction_open? || pool.nil?
+                  #{exec_method}_without_callback(sql, *args, &block)
+                else
+                  run_callbacks(:statement_pooling_connection_checkin) do
+                    $stderr.puts "#{Thread.current.object_id} executing sql -> \#{sql.inspect}"
+                    #{exec_method}_without_callback(sql, *args, &block).tap {
+                      $stderr.puts "#{Thread.current.object_id} Releasing connection..."
+                      reset!
+                      pool.release_connection
+                      $stderr.puts "#{Thread.current.object_id} Connection Released..."
+                    }
+                  end
+                end
+              end
+            EOS
+            alias_method_chain exec_method, :callback
+          }
+        end
+        alias_method :__wrap_adapter_exec_method, :__wrap_adapter_exec_methods
+
+        def __wrap_without_callbacks(*methods)
+          Array(methods).flatten.collect(&:to_sym).each { |m|
+            target, punctuation = m.to_s.sub(/([?!=])$/, ''), $1
+            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              def #{target}_with_no_callbacks#{punctuation}(*args, &block)
+                # $stderr.puts "setting without_callbacks to true"
+                Thread.current[:without_callbacks] = true
+                #{target}_without_no_callbacks#{punctuation}(*args, &block)
+              ensure
+                Thread.current[:without_callbacks] = nil
+              end
+            EOS
+            alias_method_chain m, :no_callbacks
+          }
+        end
+        alias_method :__wrap_without_callback, :__wrap_without_callbacks
+      end
+
+      included do
+        include ::ActiveSupport::Callbacks
+        extend ExecuteWrapper
+
+        define_callbacks :statement_pooling_connection_checkin
+        set_callback :statement_pooling_connection_checkin, :around, :around_connection_checkin
+        set_callback :statement_pooling_connection_checkin, :before, :before_connection_checkin
+        set_callback :statement_pooling_connection_checkin, :after, :after_connection_checkin
+
+        DEFAULT_EXEC_METHODS = [ :execute, :exec_no_cache, :query ]
+        JDBC_EXEC_METHODS = %w[
+          execute
+          exec_query
+          exec_query_raw
+          exec_insert
+          exec_update
+          exec_delete
+          transaction
+        ].collect(&:to_sym)
+
+        if RUBY_ENGINE == 'jruby'
+          JDBC_EXEC_METHODS.each { |m| __wrap_adapter_exec_methods m }
+        else
+          DEFAULT_EXEC_METHODS.each { |m| __wrap_adapter_exec_methods m }
+        end
+
+        [ :active?, :reset!, :disconnect!, :reconnect! ].each { |m|
+          __wrap_without_callbacks m
+        }
+      end
+
+      def around_connection_checkin(&block)
+        callbacks = AdvancedConnection.callbacks.statement_pooling
+        if callbacks.around.respond_to? :call
+          callbacks.around.call() { block.call }
+        end
+      end
+
+      def before_connection_checkin
+        callbacks = AdvancedConnection.callbacks.statement_pooling
+        callbacks.before.call if callbacks.before.respond_to? :call
+      end
+
+      def after_connection_checkin
+        callbacks = AdvancedConnection.callbacks.statement_pooling
+        callbacks.after.call if callbacks.after.respond_to? :call
+      end
+    end
+  end
+end

data/lib/advanced_connection/active_record_ext/abstract_adapter.rb

@@ -0,0 +1,48 @@
+#
+# Copyright (C) 2016 Finalsite, LLC
+# Copyright (C) 2016 Carl P. Corliss <carl.corliss@finalsite.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+require 'active_record/connection_adapters/abstract_adapter'
+
+module AdvancedConnection::ActiveRecordExt
+  module AbstractAdapter
+    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
+
+    eager_autoload do
+      autoload :StatementPooling
+    end
+
+    included do
+      attr_accessor :last_checked_in, :instantiated_at
+      alias_method_chain :initialize, :advanced_connection
+    end
+
+    def initialize_with_advanced_connection(*args, &block)
+      @last_checked_in = Time.now - 1.year
+      @instantiated_at = Time.now
+      initialize_without_advanced_connection(*args, &block)
+    end
+
+    def instance_age
+      (Time.now - @instantiated_at).to_f
+    end
+  end
+end

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

@@ -0,0 +1,271 @@
+#
+# Copyright (C) 2016 Finalsite, LLC
+# Copyright (C) 2016 Carl P. Corliss <carl.corliss@finalsite.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module AdvancedConnection::ActiveRecordExt
+  module ConnectionPool
+    module IdleManager
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :initialize, :advanced_connection
+        alias_method_chain :checkin, :last_checked_in
+
+        class IdleManager
+          attr_reader :pool, :interval, :thread
+
+          def initialize(pool, interval)
+            @pool     = pool
+            @interval = interval.to_i
+            @thread   = nil
+          end
+
+          def run
+            return unless interval > 0
+
+            @thread ||= Thread.new(pool, interval) { |_pool, _interval|
+              _pool.send(:idle_info, "starting idle manager; running every #{_interval} seconds")
+
+              loop do
+                sleep _interval
+
+                begin
+                  start = Time.now
+                  _pool.send(:idle_info, "beginning idle connection cleanup")
+                  _pool.remove_idle_connections
+                  _pool.send(:idle_info, "beginning idle connection warmup")
+                  _pool.create_idle_connections
+                  finish = (Time.now - start).round(6)
+                  _pool.send(:idle_info, "finished idle connection tasks in #{finish} seconds.; next run in #{pool.max_idle_time} seconds")
+                rescue => e
+                  Rails.logger.error "#{e.class.name}: #{e.message}"
+                  e.backtrace.each { |line| Rails.logger.error line }
+                end
+              end
+            }
+          end
+        end
+      end
+
+      def initialize_with_advanced_connection(spec)
+        initialize_without_advanced_connection(spec)
+
+        @available  = case queue_type
+          when :prefer_older   then Queues::OldAgeBiased.new
+          when :prefer_younger then Queues::YoungAgeBiased.new
+          when :lifo, :stack   then Queues::Stack.new
+        else
+          Rails.logger.warn "Unknown queue_type #{queue_type.inspect} - using standard FIFO instead"
+          Queues::FIFO.new
+        end
+
+        @idle_manager = IdleManager.new(self, idle_check_interval).tap { |m| m.run }
+      end
+
+      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
+      end
+
+      def max_idle_connections
+        @max_idle_connections ||= begin
+          begin
+            (spec.config[:max_idle_connections] || \
+              AdvancedConnection.max_idle_connections).to_i
+          rescue FloatDomainError => e
+            raise unless e.message =~ /infinity/i
+            ::Float::INFINITY
+          end
+        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
+        end
+      end
+
+      def connection_limit
+        @size
+      end
+
+      def checkin_with_last_checked_in(conn)
+        conn.last_checked_in = Time.now
+        idle_debug "checking in connection #{conn.object_id} at #{conn.last_checked_in}"
+        checkin_without_last_checked_in(conn)
+      end
+
+      def active_connections
+        @connections.select(&:in_use?)
+      end
+
+      def available_connections
+        @connections.reject(&:in_use?)
+      end
+
+      def idle_connections
+        available_connections.select do |conn|
+          (Time.now - conn.last_checked_in).to_f > max_idle_time
+        end.sort { |a,b|
+          case queue_type
+            when :prefer_younger then
+              # when prefering younger, we sort oldest->youngest
+              # this ensures that older connections will be culled
+              # during #remove_idle_connections()
+              -(a.instance_age <=> b.instance_age)
+            when :prefer_older then
+              # when prefering older, we sort youngest->oldest
+              # this ensures that younger connections will be culled
+              # during #remove_idle_connections()
+              (a.instance_age <=> b.instance_age)
+            else
+              # 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.
+              -(a.last_checked_in <=> b.last_checked_in)
+          end
+        }
+      end
+
+      def pool_statistics
+        idle = active = available = 0
+        synchronize do
+          idle      = idle_connections.size
+          active    = active_connections.size
+          available = available_connections.size
+        end
+        total = active + available
+
+        ActiveSupport::OrderedOptions.new.merge({
+          total: total, idle: idle, active: active, available: available,
+        })
+      end
+
+      def warmup_connections(count = nil)
+        count ||= warmup_connection_count
+        slots = connection_limit - @connections.size
+        count = slots if slots < count
+
+        if slots >= count
+          idle_info "Warming up #{count} connection#{count > 1 ? 's' : ''}"
+          synchronize do
+            count.times {
+              conn = checkout_new_connection
+              @available.add conn
+            }
+          end
+        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)
+      end
+
+      def remove_idle_connections
+        # don't attempt to remove idle connections if we have threads waiting
+        return if @available.num_waiting > 0
+
+        idle_conns = idle_connections
+        idle_count = idle_conns.size
+
+        if idle_count > max_idle_connections
+          cull_count = (idle_count - max_idle_connections)
+
+          culled = 0
+          idle_conns.each_with_index do |conn, idx|
+            last_ci = (Time.now - conn.last_checked_in).to_f
+            if idx < cull_count
+              culled += remove_connection(conn) ? 1 : 0
+              idle_info "culled connection ##{idx} id##{conn.object_id} - age:#{conn.instance_age} last_checkin:#{last_ci}"
+            else
+              idle_info "kept connection ##{idx} id##{conn.object_id} - age:#{conn.instance_age} last_checkin:#{last_ci}"
+            end
+          end
+
+          idle_info "culled %d connections" % culled
+        end
+      end
+
+    private
+
+      def remove_connection(conn)
+        synchronize do
+          return false if conn.in_use?
+          remove conn
+          conn.disconnect!
+        end
+        true
+      end
+
+      def idle_message(format, *args)
+        stats = pool_statistics
+        format(
+          "IdleManager (Actv:%d,Avail:%d,Idle:%d,Total:%d): #{format}",
+          stats.active, stats.available, stats.idle, stats.total,
+          *args
+        )
+      end
+
+      def idle_debug(format, *args)
+        Rails.logger.debug idle_message(format, *args)
+      end
+
+      def idle_info(format, *args)
+        Rails.logger.info idle_message(format, *args)
+      end
+    end
+  end
+end