connection_pool 2.1.3 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec91685df50fe18b79ef2cd2ed2fb038e322ff81
-  data.tar.gz: 99b88e1aa01811e18c2737e8e062c4726ce54666
+  metadata.gz: cf8177bf07f6c8e68b13f28416f6ccc0c64803af
+  data.tar.gz: ff9c836ce5576d4d0cb1edf8d858a761f982e437
 SHA512:
-  metadata.gz: 53d34f8ca6a7d51ce535a83e2821dd33eb15a623df3022b89775c232876c8fec28a2b33adda24248136014d99f0ebe9f09c1f49e1f0ced76435db26538e907a7
-  data.tar.gz: 660f22d0f828c789942da1da3d7c4131e008dd383a83c74e59ea03f306a59b966e879d42f9704ffa3b7de6accb6c114cfff982d3343bbe34c5e60ecc8f705ac5
+  metadata.gz: 73bda4d8d0b3cc9daef5c93bb98b7649d811bd5c8f467e25c3aaf7d3353541225e7b30e1efd481a14e45f5c56b5fc846d49dabdd9a167702a71c4a9631a9b6a2
+  data.tar.gz: a331275f67b3635e09792e646113e32bdc74254a2cdff032e972c6f2ebedd6391a1e508c36be7c4e33b40e2a07efe029a2ad0267c3ba4dc20b22813df86427bb

data/.travis.yml

@@ -3,12 +3,8 @@ sudo: false
 cache: bundler
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - 2.2.0
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
   - jruby
-  - rbx-2
-notifications:
-  email:
-    - drbrain@segment7.net

data/Changes.md

@@ -1,3 +1,25 @@
+connection\_pool changelog
+---------------------------
+
+2.2.2
+------
+
+- Add pool `size` and `available` accessors for metrics and monitoring
+  purposes [#97, robholland]
+
+2.2.1
+------
+
+- Allow CP::Wrapper to use an existing pool [#87, etiennebarrie]
+- Use monotonic time for more accurate timeouts [#84, jdantonio]
+
+2.2.0
+------
+
+- Rollback `Timeout` handling introduced in 2.1.1 and 2.1.2.  It seems
+  impossible to safely work around the issue. Please never, ever use
+  `Timeout.timeout` in your code or you will see rare but mysterious bugs. [#75]
+
 2.1.3
 ------
 

data/README.md

@@ -45,8 +45,10 @@ sections when a resource is not available, or conversely if you are comfortable
 blocking longer on a particular resource. This is not implemented in the below
 `ConnectionPool::Wrapper` class.
 
+## Migrating to a Connection Pool
+
 You can use `ConnectionPool::Wrapper` to wrap a single global connection,
-making it easier to port your connection code over time:
+making it easier to migrate existing connection code over time:
 
 ``` ruby
 $redis = ConnectionPool::Wrapper.new(size: 5, timeout: 3) { Redis.connect }
@@ -69,17 +71,20 @@ end
 Once you've ported your entire system to use `with`, you can simply remove
 `Wrapper` and use the simpler and faster `ConnectionPool`.
 
+
+## Shutdown
+
 You can shut down a ConnectionPool instance once it should no longer be used.
 Further checkout attempts will immediately raise an error but existing checkouts
 will work.
 
 ```ruby
 cp = ConnectionPool.new { Redis.new }
-cp.shutdown { |conn| conn.close }
+cp.shutdown { |conn| conn.quit }
 ```
 
 Shutting down a connection pool will block until all connections are checked in and closed.
-Note that shutting down is completely optional; Ruby's garbage collector will reclaim
+**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim
 unreferenced pools under normal circumstances.
 
 
@@ -90,14 +95,10 @@ Notes
 - There is no provision for repairing or checking the health of a connection;
   connections should be self-repairing.  This is true of the Dalli and Redis
   clients.
-
-
-Install
--------
-
-```
-$ gem install connection_pool
-```
+- **WARNING**: Don't ever use `Timeout.timeout` in your Ruby code or you will see
+  occasional silent corruption and mysterious errors.  The Timeout API is unsafe
+  and cannot be used correctly, ever.  Use proper socket timeout options as
+  exposed by Net::HTTP, Redis, Dalli, etc.
 
 
 Author

data/lib/connection_pool.rb

@@ -1,6 +1,7 @@
 require_relative 'connection_pool/version'
 require_relative 'connection_pool/timed_stack'
 
+
 # Generic connection pool class for e.g. sharing a limited number of network connections
 # among many threads.  Note: Connections are lazily created.
 #
@@ -14,7 +15,7 @@ require_relative 'connection_pool/timed_stack'
 #
 # Using optional timeout override (for that single invocation)
 #
-#    @pool.with(:timeout => 2.0) do |redis|
+#    @pool.with(timeout: 2.0) do |redis|
 #      redis.lpop('my-list') if redis.llen('my-list') > 0
 #    end
 #
@@ -50,43 +51,60 @@ class ConnectionPool
 
     @available = TimedStack.new(@size, &block)
     @key = :"current-#{@available.object_id}"
+    @key_count = :"current-#{@available.object_id}-count"
+  end
+
+if Thread.respond_to?(:handle_interrupt)
+
+  # MRI
+  def with(options = {})
+    Thread.handle_interrupt(Exception => :never) do
+      conn = checkout(options)
+      begin
+        Thread.handle_interrupt(Exception => :immediate) do
+          yield conn
+        end
+      ensure
+        checkin
+      end
+    end
   end
 
+else
+
+  # jruby 1.7.x
   def with(options = {})
-    # Connections can become corrupted via Timeout::Error.  Discard
-    # any connection whose usage after checkout does not finish as expected.
-    # See #67
-    success = false
     conn = checkout(options)
     begin
-      result = yield conn
-      success = true # means the connection wasn't interrupted
-      result
+      yield conn
     ensure
-      if success
-        # everything is roses, we can safely check the connection back in
-        checkin
-      else
-        @available.discard!(pop_connection)
-      end
+      checkin
     end
   end
 
+end
+
   def checkout(options = {})
-    conn = if stack.empty?
-      timeout = options[:timeout] || @timeout
-      @available.pop(timeout: timeout)
+    if ::Thread.current[@key]
+      ::Thread.current[@key_count]+= 1
+      ::Thread.current[@key]
     else
-      stack.last
+      ::Thread.current[@key_count]= 1
+      ::Thread.current[@key]= @available.pop(options[:timeout] || @timeout)
     end
-
-    stack.push conn
-    conn
   end
 
   def checkin
-    conn = pop_connection # mutates stack, must be on its own line
-    @available.push(conn) if stack.empty?
+    if ::Thread.current[@key]
+      if ::Thread.current[@key_count] == 1
+        @available.push(::Thread.current[@key])
+        ::Thread.current[@key]= nil
+      else
+        ::Thread.current[@key_count]-= 1
+      end
+    else
+      raise ConnectionPool::Error, 'no connections are checked out'
+    end
 
     nil
   end
@@ -95,25 +113,23 @@ class ConnectionPool
     @available.shutdown(&block)
   end
 
-  private
-
-  def pop_connection
-    if stack.empty?
-      raise ConnectionPool::Error, 'no connections are checked out'
-    else
-      stack.pop
-    end
+  # Size of this connection pool
+  def size
+    @size
   end
 
-  def stack
-    ::Thread.current[@key] ||= []
+  # Number of pool entries available for checkout at this instant.
+  def available
+    @available.length
   end
 
+  private
+
   class Wrapper < ::BasicObject
     METHODS = [:with, :pool_shutdown]
 
     def initialize(options = {}, &block)
-      @pool = ::ConnectionPool.new(options, &block)
+      @pool = options.fetch(:pool) { ::ConnectionPool.new(options, &block) }
     end
 
     def with(&block)
@@ -124,6 +140,14 @@ class ConnectionPool
       @pool.shutdown(&block)
     end
 
+    def pool_size
+      @pool.size
+    end
+
+    def pool_available
+      @pool.available
+    end
+
     def respond_to?(id, *args)
       METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
     end

data/lib/connection_pool/monotonic_time.rb

@@ -0,0 +1,66 @@
+# Global monotonic clock from Concurrent Ruby 1.0.
+# Copyright (c) Jerry D'Antonio -- released under the MIT license.
+# Slightly modified; used with permission.
+# https://github.com/ruby-concurrency/concurrent-ruby
+
+require 'thread'
+
+class ConnectionPool
+
+  class_definition = Class.new do
+
+    if defined?(Process::CLOCK_MONOTONIC)
+
+      # @!visibility private
+      def get_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+      # @!visibility private
+      def get_time
+        java.lang.System.nanoTime() / 1_000_000_000.0
+      end
+
+    else
+
+      # @!visibility private
+      def initialize
+        @mutex = Mutex.new
+        @last_time = Time.now.to_f
+      end
+
+      # @!visibility private
+      def get_time
+        @mutex.synchronize do
+          now = Time.now.to_f
+          if @last_time < now
+            @last_time = now
+          else # clock has moved back in time
+            @last_time += 0.000_001
+          end
+        end
+      end
+    end
+  end
+
+  ##
+  # Clock that cannot be set and represents monotonic time since
+  # some unspecified starting point.
+  #
+  # @!visibility private
+  GLOBAL_MONOTONIC_CLOCK = class_definition.new
+  private_constant :GLOBAL_MONOTONIC_CLOCK
+
+  class << self
+    ##
+    # Returns the current time a tracked by the application monotonic clock.
+    #
+    # @return [Float] The current monotonic time when `since` not given else
+    #   the elapsed monotonic time between `since` and the current time
+    def monotonic_time
+      GLOBAL_MONOTONIC_CLOCK.get_time
+    end
+  end
+end

data/lib/connection_pool/timed_stack.rb

@@ -1,5 +1,6 @@
 require 'thread'
 require 'timeout'
+require_relative 'monotonic_time'
 
 ##
 # Raised when you attempt to retrieve a connection from a pool that has been
@@ -27,6 +28,7 @@ class ConnectionPool::PoolShuttingDownError < RuntimeError; end
 #    #=> raises Timeout::Error after 5 seconds
 
 class ConnectionPool::TimedStack
+  attr_reader :max
 
   ##
   # Creates a new pool with +size+ connections that are created from the given
@@ -72,7 +74,7 @@ class ConnectionPool::TimedStack
     options, timeout = timeout, 0.5 if Hash === timeout
     timeout = options.fetch :timeout, timeout
 
-    deadline = Time.now + timeout
+    deadline = ConnectionPool.monotonic_time + timeout
     @mutex.synchronize do
       loop do
         raise ConnectionPool::PoolShuttingDownError if @shutdown_block
@@ -81,7 +83,7 @@ class ConnectionPool::TimedStack
         connection = try_create(options)
         return connection if connection
 
-        to_wait = deadline - Time.now
+        to_wait = deadline - ConnectionPool.monotonic_time
         raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
         @resource.wait(@mutex, to_wait)
       end
@@ -117,28 +119,6 @@ class ConnectionPool::TimedStack
     @max - @created + @que.length
   end
 
-  ##
-  # Indicates that a connection isn't coming back, allowing a new one to be
-  # created to replace it.
-
-  def discard!(obj)
-    @mutex.synchronize do
-      if @shutdown_block
-        @shutdown_block.call(obj)
-      else
-        # try to shut down the connection before throwing it away
-        if obj.respond_to?(:close) # Dalli::Client
-          obj.close rescue nil
-        elsif obj.respond_to?(:disconnect!) # Redis
-          obj.disconnect! rescue nil
-        end
-        @created -= 1
-      end
-
-      @resource.broadcast
-    end
-  end
-
   private
 
   ##

data/lib/connection_pool/version.rb

@@ -1,3 +1,3 @@
 class ConnectionPool
-  VERSION = "2.1.3"
+  VERSION = "2.2.2"
 end

data/test/test_connection_pool.rb

@@ -3,13 +3,15 @@ require_relative 'helper'
 class TestConnectionPool < Minitest::Test
 
   class NetworkConnection
+    SLEEP_TIME = 0.1
+
     def initialize
       @x = 0
     end
 
     def do_something
       @x += 1
-      sleep 0.05
+      sleep SLEEP_TIME
       @x
     end
 
@@ -19,7 +21,7 @@ class TestConnectionPool < Minitest::Test
 
     def do_something_with_block
       @x += yield
-      sleep 0.05
+      sleep SLEEP_TIME
       @x
     end
 
@@ -58,25 +60,30 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_basic_multithreaded_usage
-    pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
+    pool_size = 5
+    pool = ConnectionPool.new(size: pool_size) { NetworkConnection.new }
+
+    start = Time.new
 
-    threads = Array.new(15) do
+    generations = 3
+
+    result = Array.new(pool_size * generations) do
       Thread.new do
         pool.with do |net|
           net.do_something
         end
       end
-    end
+    end.map(&:value)
 
-    a = Time.now
-    result = threads.map(&:value)
-    b = Time.now
-    assert_operator((b - a), :>, 0.125)
-    assert_equal([1,2,3].cycle(5).sort, result.sort)
+    finish = Time.new
+
+    assert_equal((1..generations).cycle(pool_size).sort, result.sort)
+
+    assert_operator(finish - start, :>, generations * NetworkConnection::SLEEP_TIME)
   end
 
   def test_timeout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
     thread = Thread.new do
       pool.with do |net|
         net.do_something
@@ -98,7 +105,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_with
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.with do
       assert_raises Timeout::Error do
@@ -109,42 +116,62 @@ class TestConnectionPool < Minitest::Test
     assert Thread.new { pool.checkout }.join
   end
 
-  def test_with_with_dangerous_timeouts
-    case RUBY_ENGINE.to_sym
-    when :jruby
-      skip('JRuby GC dislikes this test')
-    when :ruby
-      if RUBY_VERSION == '2.0.0' && RUBY_PATCHLEVEL == 598
-        skip("#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} GC dislikes this test")
+  def test_with_timeout
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
+
+    assert_raises Timeout::Error do
+      Timeout.timeout(0.01) do
+        pool.with do |obj|
+          assert_equal 0, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
+          sleep 0.015
+        end
       end
     end
+    assert_equal 1, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
+  end
 
-    marker_class = Class.new
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { marker_class.new }
-
-    # no "connections" allocated yet
-    assert_equal [], ObjectSpace.each_object(marker_class).to_a
+  def test_checkout_ignores_timeout
+    skip("Thread.handle_interrupt not available") unless Thread.respond_to?(:handle_interrupt)
 
-    checkin_time = 0.05
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
+    def pool.checkout(options)
+      sleep 0.015
+      super
+    end
 
+    did_something = false
     assert_raises Timeout::Error do
-      Timeout.timeout(checkin_time) do
-        pool.with do
-          # a "connection" has been allocated
-          refute_equal [], ObjectSpace.each_object(marker_class).to_a
-          sleep 2 * checkin_time
+      Timeout.timeout(0.01) do
+        pool.with do |obj|
+          did_something = true
+          # Timeout::Error will be triggered by any non-trivial Ruby code
+          # executed here since it couldn't be raised during checkout.
+          # It looks like setting the local variable above does not trigger
+          # the Timeout check in MRI 2.2.1.
+          obj.tap { obj.hash }
         end
       end
     end
+    assert did_something
+    assert_equal 1, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
+  end
 
-    GC.start
+  def test_explicit_return
+    pool = ConnectionPool.new(timeout: 0, size: 1) do
+      mock = Minitest::Mock.new
+      def mock.disconnect!
+        raise "should not disconnect upon explicit return"
+      end
+      mock
+    end
 
-    # no dangling references to this "connection" remain
-    assert_equal [], ObjectSpace.each_object(marker_class).to_a
+    pool.with do |conn|
+      return true
+    end
   end
 
   def test_with_timeout_override
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
 
     t = Thread.new do
       pool.with do |net|
@@ -159,13 +186,13 @@ class TestConnectionPool < Minitest::Test
       pool.with { |net| net.do_something }
     end
 
-    pool.with(:timeout => 0.1) do |conn|
+    pool.with(timeout: 2 * NetworkConnection::SLEEP_TIME) do |conn|
       refute_nil conn
     end
   end
 
   def test_checkin
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
     conn = pool.checkout
 
     assert_raises Timeout::Error do
@@ -178,12 +205,12 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_returns_value
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
     assert_equal 1, pool.with {|o| 1 }
   end
 
   def test_checkin_never_checkout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     e = assert_raises ConnectionPool::Error do
       pool.checkin
@@ -193,7 +220,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkin_no_current_checkout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.checkout
     pool.checkin
@@ -204,7 +231,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkin_twice
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.checkout
     pool.checkout
@@ -223,7 +250,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout
-    pool = ConnectionPool.new(:size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 1) { NetworkConnection.new }
 
     conn = pool.checkout
 
@@ -233,7 +260,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_multithread
-    pool = ConnectionPool.new(:size => 2) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
     conn = pool.checkout
 
     t = Thread.new do
@@ -244,7 +271,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_timeout
-    pool = ConnectionPool.new(:timeout => 0, :size => 0) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 0) { Object.new }
 
     assert_raises Timeout::Error do
       pool.checkout
@@ -252,7 +279,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_timeout_override
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
 
     thread = Thread.new do
       pool.with do |net|
@@ -267,11 +294,11 @@ class TestConnectionPool < Minitest::Test
       pool.checkout
     end
 
-    assert pool.checkout :timeout => 0.1
+    assert pool.checkout timeout: 2 * NetworkConnection::SLEEP_TIME
   end
 
   def test_passthru
-    pool = ConnectionPool.wrap(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
     assert_equal 1, pool.do_something
     assert_equal 2, pool.do_something
     assert_equal 5, pool.do_something_with_block { 3 }
@@ -279,7 +306,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_passthru_respond_to
-    pool = ConnectionPool.wrap(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
     assert pool.respond_to?(:with)
     assert pool.respond_to?(:do_something)
     assert pool.respond_to?(:do_magic)
@@ -287,7 +314,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_return_value
-    pool = ConnectionPool.new(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
     result = pool.with do |net|
       net.fast
     end
@@ -295,7 +322,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_heavy_threading
-    pool = ConnectionPool.new(:timeout => 0.5, :size => 3) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0.5, size: 3) { NetworkConnection.new }
 
     threads = Array.new(20) do
       Thread.new do
@@ -309,7 +336,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_reuses_objects_when_pool_not_saturated
-    pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 5) { NetworkConnection.new }
 
     ids = 10.times.map do
       pool.with { |c| c.object_id }
@@ -320,7 +347,7 @@ class TestConnectionPool < Minitest::Test
 
   def test_nested_checkout
     recorder = Recorder.new
-    pool = ConnectionPool.new(:size => 1) { recorder }
+    pool = ConnectionPool.new(size: 1) { recorder }
     pool.with do |r_outer|
       @other = Thread.new do |t|
         pool.with do |r_other|
@@ -345,7 +372,7 @@ class TestConnectionPool < Minitest::Test
   def test_shutdown_is_executed_for_all_connections
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) do
       Recorder.new.tap { |r| recorders << r }
     end
 
@@ -361,7 +388,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_raises_error_after_shutting_down
-    pool = ConnectionPool.new(:size => 1) { true }
+    pool = ConnectionPool.new(size: 1) { true }
 
     pool.shutdown { }
 
@@ -373,7 +400,7 @@ class TestConnectionPool < Minitest::Test
   def test_runs_shutdown_block_asynchronously_if_connection_was_in_use
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) do
       Recorder.new.tap { |r| recorders << r }
     end
 
@@ -395,7 +422,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_raises_an_error_if_shutdown_is_called_without_a_block
-    pool = ConnectionPool.new(:size => 1) { }
+    pool = ConnectionPool.new(size: 1) { }
 
     assert_raises ArgumentError do
       pool.shutdown
@@ -405,7 +432,7 @@ class TestConnectionPool < Minitest::Test
   def test_shutdown_is_executed_for_all_connections_in_wrapped_pool
     recorders = []
 
-    wrapper = ConnectionPool::Wrapper.new(:size => 3) do
+    wrapper = ConnectionPool::Wrapper.new(size: 3) do
       Recorder.new.tap { |r| recorders << r }
     end
 
@@ -436,7 +463,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_wrapper_with
-    wrapper = ConnectionPool::Wrapper.new(:timeout => 0, :size => 1) { Object.new }
+    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { Object.new }
 
     wrapper.with do
       assert_raises Timeout::Error do
@@ -461,4 +488,29 @@ class TestConnectionPool < Minitest::Test
     assert_equal "eval'ed 1", wrapper.eval(1)
   end
 
+  def test_wrapper_with_connection_pool
+    recorder = Recorder.new
+    pool = ConnectionPool.new(size: 1) { recorder }
+    wrapper = ConnectionPool::Wrapper.new(pool: pool)
+
+    pool.with { |r| r.do_work('with') }
+    wrapper.do_work('wrapped')
+
+    assert_equal ['with', 'wrapped'], recorder.calls
+  end
+
+  def test_stats_without_active_connection
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
+
+    assert_equal(2, pool.size)
+    assert_equal(2, pool.available)
+  end
+
+  def test_stats_with_active_connection
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
+
+    pool.with do
+      assert_equal(1, pool.available)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_pool
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.2
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-19 00:00:00.000000000 Z
+date: 2018-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,6 +70,7 @@ files:
 - Rakefile
 - connection_pool.gemspec
 - lib/connection_pool.rb
+- lib/connection_pool/monotonic_time.rb
 - lib/connection_pool/timed_stack.rb
 - lib/connection_pool/version.rb
 - test/helper.rb
@@ -95,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Generic connection pool for Ruby