ros-apartment 4.0.0.alpha10 → 4.0.0.alpha11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d24210e257a6f61365a496b60f54762e4b0e9d5ef6f652d77891455fba01d6a4
-  data.tar.gz: dd1eb795e6ca4c9bc2b22377b2feb7fd8bd9fc66efdd3d1eaaeab891bd4fa7d3
+  metadata.gz: ad60ba3db98c859ff52e1aa0f312d18a8a3e99a6b2703518a94f1ab4abc95eb5
+  data.tar.gz: a782d5dc9690202676d2e30529da89aeb226961bffaf9af7fc821292266d97c6
 SHA512:
-  metadata.gz: 2397d625268ff6c241eb7886834f99383e650a9613048d0c8d99594083d7cb450e3b328279f56d7c14b3babf70e9ca03069b5c5c507f3a3f06591a429c8283e8
-  data.tar.gz: 57ef4cf17beff1ee06a8abdaff9303b114be190c962f829de2465e766b1235664718e1bb534c8bee715657dbea45512c116f1467d20a287f7ea7c55e164822aa
+  metadata.gz: 18aaad1312c4eb812c1a7f4a1bcd676325a90db1326efcd2bb4aa71961f38e689240a589497ae6fa7bb16f362276649b36610d76b4b63284567d1999a4a20b5f
+  data.tar.gz: 2f445f6e7d07ef0c4146242aadbb724636fa55184e4c16400daf5870e84a46a6566530cca0a10e130813709c27a08dfed1ba8b6eb4589ab97087b37966ce0b24

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010-2026 Ryan Brunner, Brad Robertson, Rui Baltazar, Mauricio Novelo, and the ros-apartment contributors
+
+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.

data/README.md

@@ -3,6 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/ros-apartment.svg)](https://badge.fury.io/rb/ros-apartment)
 [![CI](https://github.com/rails-on-services/apartment/actions/workflows/ci.yml/badge.svg)](https://github.com/rails-on-services/apartment/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/rails-on-services/apartment/graph/badge.svg?token=Q4I5QL78SA)](https://codecov.io/gh/rails-on-services/apartment)
+[![Greptile: The War on Bugs](https://www.greptile.com/badge.svg)](https://www.greptile.com/?utm_source=oss_badge&utm_medium=readme&utm_campaign=greptile_for_open_source)
 
 *Database-level multitenancy for Rails and ActiveRecord*
 
@@ -487,4 +488,4 @@ application code with the standard `Exclude:` keys if needed. See
 
 ## License
 
-[MIT License](http://www.opensource.org/licenses/MIT)
+MIT — see [LICENSE](LICENSE). SPDX identifier: `MIT`.

data/lib/apartment/CLAUDE.md

@@ -21,6 +21,7 @@ lib/apartment/
 ├── elevators/             # Rack middleware for tenant detection (see CLAUDE.md); v4 uses constructor keyword args, no class-level state; Generic, Subdomain, FirstSubdomain, Domain, Host, HostHash, Header
 ├── patches/               # ActiveRecord patches for tenant-aware connections
 │   ├── connection_handling.rb # Prepends on AR::Base — tenant-aware connection_pool
+│   ├── connection_registry.rb # Prepends on AR's PoolManager + ConnectionHandler — serializes the pool registry
 │   └── postgresql_sequence_name.rb # Prepends on the PG adapter — schema-agnostic Model.sequence_name memoization
 ├── tasks/                 # Rake task utilities; v4.rake for apartment:create/drop/migrate/seed/rollback
 ├── config.rb              # Configuration with validate!/freeze!
@@ -62,6 +63,16 @@ lib/apartment/
 
 `Concurrent::Map` storing connection pools by tenant key. Monotonic clock timestamps for idle/LRU tracking. `stats_for` returns `{ seconds_idle: N }`. `clear` disconnects all pools before clearing. When a pool budget is configured (`max_tenant_pools` and/or `max_tenant_connections`, resolved by `Config#effective_pool_budget`; `max_total_connections` is the deprecated alias of `max_tenant_pools`), `Apartment.configure` wires an `admission_controller` (the reaper) so cold creates route through a serialized, capacity-bounded path; otherwise the lock-free `compute_if_absent` fast path is used. See `docs/designs/pool-connection-budget.md` and `docs/designs/pool-admission-control.md`.
 
+### patches/connection_registry.rb — AR Registry Serialization
+
+Rails' `ActiveRecord::ConnectionAdapters::PoolManager` (**not** Apartment's same-named class — always fully qualify inside `Apartment::Patches`) stores every pool in a plain nested Hash, unsynchronized, because upstream only writes it at boot. Pool-per-tenant writes it forever, so a cold tenant switch could add a shard key while another thread was iterating, and MRI's iteration guard (per-Hash, not per-thread) failed the *switch* with `RuntimeError: can't add a new key into hash during iteration`.
+
+The readers are Rails' own, all reaching the registry through `ConnectionHandler#each_connection_pool`: `ActiveRecord::QueryCache.run` (every executor run — the start of every request and job), `ConnectionPool::ExecutorHooks.complete` (every executor completion), `Base.clear_query_caches_for_current_thread` (after writes), `ActiveRecord.all_open_transactions`, and `clear_active_connections!` / `clear_all_connections!` / `flush_idle_connections!`. **Not** AR's `ConnectionPool::Reaper` — verified across 7.2/8.0/8.1, it keeps a private mutex-protected `WeakRef` list per reaping frequency and never touches this registry. Target the readers above when reasoning about synchronization or writing regression tests.
+
+`ConnectionRegistry.apply!` (called by `activate!`) prepends two wrappers sharing one process-wide `Monitor`: `PoolManagerSync` over all eight `PoolManager` accessors — reads included, because the outer Hash's default proc mutates on a miss — and `HandlerSync` over `ConnectionHandler#set_pool_manager` (kept `private`), whose `||=` is a non-atomic upsert. `each_pool_config` snapshots under the lock and yields outside it; never hold this lock across a caller's block, since Rails disconnects pools inside those blocks. `SYNC` is a **leaf lock** — nothing acquired under it, no IO under it — which is the whole deadlock-freedom argument.
+
+`serialize!` **fails closed**: it resolves each guarded method with `method_defined?` / `private_method_defined?` (matching what `super` actually needs, so an upstream method merely *moved* to a superclass or module still counts) and raises `Apartment::ConfigurationError` at `activate!` when one is genuinely gone. It only *warns* when upstream has grown a public accessor we do not guard — a hole beats a boot failure. See `docs/designs/ar-connection-registry-thread-safety.md`.
+
 ### pool_reaper.rb — Pool Eviction + Admission
 
 Background `Concurrent::TimerTask` that evicts idle and excess tenant pools, and also serves as the pool manager's synchronous admission controller (`admit!`) when a cap is configured — evicting the LRU idle pool inline before a new one is established, applying `pool_overflow_policy` (`:evict_idle` / `:raise`) when no idle pool can be freed. A single `evict_tenant` primitive backs the timer (idle/LRU) and admission paths. Reap cadence (`interval`/`reaper_interval`) is decoupled from the idle window (`idle_timeout`/`pool_idle_timeout`). Created by `Apartment.configure`, stored as `Apartment.pool_reaper`. Deregisters evicted pools from AR's ConnectionHandler. Default tenant is never evicted.

data/lib/apartment/patches/connection_registry.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'monitor'
+require_relative '../errors'
+
+module Apartment
+  module Patches
+    # Serializes access to ActiveRecord's connection registry so pool-per-tenant
+    # can register and discard shards from many threads at once.
+    #
+    # THE REGISTRY. ActiveRecord::ConnectionAdapters::PoolManager (the Rails
+    # class, not Apartment's same-named one) indexes every pool AR knows about as
+    # a plain nested Hash, +{ role => { shard => pool_config } }+, with no
+    # synchronization of any kind. Rails can afford that because upstream writes
+    # it only at boot: +establish_connection+ runs from initializers and from
+    # +connects_to+, single-threaded, and after boot the structure is read-only.
+    #
+    # WHY v4 CANNOT. A tenant pool is established lazily, on the thread that
+    # first routes to that tenant, for the life of the process — so every cold
+    # tenant switch adds a shard key to that Hash while other threads are reading
+    # it. MRI's per-Hash iteration guard turns the collision into a hard failure
+    # in the WRITER: `RuntimeError: can't add a new key into hash during
+    # iteration`, surfaced by Apartment as a failed tenant switch. The readers are
+    # routine and unavoidable, all via ConnectionHandler#each_connection_pool:
+    # ActiveRecord::QueryCache.run on every executor run (the start of every
+    # request and job), ConnectionPool::ExecutorHooks.complete on every executor
+    # completion, Base.clear_query_caches_for_current_thread after writes,
+    # ActiveRecord.all_open_transactions for transaction-callback bookkeeping, and
+    # clear_active_connections! / clear_all_connections! /
+    # flush_idle_connections!. (AR's own ConnectionPool::Reaper is NOT one of
+    # them — it keeps a private WeakRef list and never reads this registry.)
+    # Parallel migration is simply the densest producer of cold creates (one
+    # thread per tenant, all establishing at once) and therefore the easiest place
+    # to see it.
+    #
+    # A read can write, too: +get_pool_config+ / +pool_configs+ /
+    # +each_pool_config+ reach the outer Hash through +[]+, whose default proc
+    # (+Hash.new { |h, k| h[k] = {} }+) INSERTS an empty shard map on a miss. So a
+    # lookup for a not-yet-seen role is itself a write, and the guarded set below
+    # is every public accessor rather than only the obvious mutators.
+    #
+    # WHY NOT JUST LOCK APARTMENT'S OWN CALL SITES. Apartment's cold creates are
+    # already serialized against each other — Concurrent::Map's MRI backend holds
+    # a write lock across +compute_if_absent+, and the capacity-bounded path holds
+    # PoolManager's own create mutex. Neither excludes AR's readers, which is the
+    # side of the race that matters, and neither covers the discard half
+    # (+remove_connection_pool+ from Apartment::PoolReaper's timer thread — ours,
+    # not AR's — from AbstractAdapter#drop, from Migrator eviction). The registry
+    # itself is the only place that sees all of it.
+    #
+    # SCOPE. Applied from +Apartment.activate!+, not at gem load: an app that
+    # merely has the gem in its Gemfile should not pay for a lock it does not
+    # need. Prepending affects instances already created (the primary pool's
+    # manager is built during Rails' database initializer, before activate!),
+    # which is why the lock is module-level rather than per-instance state.
+    #
+    # NO DEADLOCK, BY CONSTRUCTION. SYNC is a LEAF lock: every guarded body is an
+    # in-memory Hash operation that acquires nothing else, performs no IO, and
+    # yields to no caller. Keep it that way — it is the entire deadlock-freedom
+    # argument, and Apartment's cold-create path already establishes the one lock
+    # ordering that exists (Concurrent::Map's write lock, or the capped path's
+    # create mutex, is taken FIRST and SYNC underneath it via
+    # establish_connection). Nothing acquires SYNC and then reaches for either.
+    # Upstream cooperates: +remove_pool_config+ returns the pool_config and
+    # +disconnect_pool_from_pool_manager+ calls +disconnect!+ on it only after the
+    # guarded call has returned, and +establish_connection+ builds the pool
+    # (PoolConfig#pool, under PoolConfig's own monitor) after +set_pool_config+
+    # returns — so no pool IO and no other monitor is ever nested under SYNC.
+    #
+    # COST. One uncontended monitor acquire, measured at ~90ns, on registry
+    # operations only. +get_pool_config+ is the hot one (AR resolves it per query
+    # for default-tenant and pinned traffic), where it is noise against even a
+    # cached query. Iteration copies its pool_config list under the lock and
+    # yields outside it, so per-request hooks hold the lock for the length of a
+    # Hash walk and never for the length of a caller's block.
+    module ConnectionRegistry
+      # One monitor for every registry in the process. Instances are few (one per
+      # connection name, so typically one or two) and every guarded operation is
+      # an in-memory Hash op with no IO and no yielding, so per-instance locks
+      # would buy negligible parallelism in exchange for lazy-init state on
+      # objects that already exist by the time the patch is applied.
+      #
+      # Monitor, not Mutex, purely defensively: no guarded method re-enters
+      # another today (each accessor's +super+ reads the Hash directly, and
+      # #each_pool_config yields outside the lock), and establish_connection's
+      # several acquisitions are sequential rather than nested — a Mutex would
+      # work. Reentrance costs nothing measurable here (~90ns either way) and
+      # buys tolerance for an upstream implementation in which one accessor
+      # dispatches through another.
+      SYNC = Monitor.new
+
+      # Every public accessor AR::ConnectionAdapters::PoolManager defines. Both
+      # halves of this claim are enforced at activate! time: a method that has
+      # gone missing raises, and an accessor upstream has ADDED that we therefore
+      # do not guard warns (the patch still works, but there is a hole in it).
+      POOL_MANAGER_METHODS = %i[
+        shard_names
+        role_names
+        pool_configs
+        each_pool_config
+        remove_role
+        remove_pool_config
+        get_pool_config
+        set_pool_config
+      ].freeze
+
+      HANDLER_METHODS = %i[set_pool_manager].freeze
+
+      class << self
+        # Idempotent — prepend on an already-prepended module is a no-op.
+        def apply!
+          serialize!(ActiveRecord::ConnectionAdapters::PoolManager, POOL_MANAGER_METHODS, PoolManagerSync,
+                     exhaustive: true)
+          serialize!(ActiveRecord::ConnectionAdapters::ConnectionHandler, HANDLER_METHODS, HandlerSync)
+          nil
+        end
+
+        private
+
+        # FAILS CLOSED on a shape we cannot serialize. Both wrapper modules work by
+        # +super+, so a guarded method that no longer exists anywhere in the MRO
+        # would be a NoMethodError at first call. Raising here instead is louder and
+        # earlier: activate! runs at boot, from an explicit call, so the operator
+        # learns on deploy that this gem version does not support this ActiveRecord
+        # version. The alternative — warn and continue unpatched — reinstates a race
+        # that fails a fraction of cold tenant switches under load, which is far
+        # harder to attribute. It would also be effectively silent: the Rails-main
+        # CI canary is continue-on-error, so a warning blocks nothing.
+        #
+        # Resolution deliberately uses +method_defined?+, not +instance_methods(false)+:
+        # +super+ dispatches through the whole ancestor chain, so a method upstream
+        # merely MOVED to a superclass or an included module still works through the
+        # wrapper. Testing for a direct definition would refuse a refactor that is
+        # entirely benign, and refusing is now fatal.
+        #
+        # +exhaustive+ additionally warns (never raises) when upstream has grown a
+        # public accessor we do not guard: the patch still does its job, but that
+        # method touches the registry unsynchronized. A warning, not a raise,
+        # because a hole is strictly better than a boot failure — and the unit spec
+        # pins the exact set so it fails in CI first.
+        def serialize!(klass, method_names, wrapper, exhaustive: false)
+          missing = method_names.reject do |name|
+            klass.method_defined?(name) || klass.private_method_defined?(name)
+          end
+
+          unless missing.empty?
+            raise(Apartment::ConfigurationError,
+                  "Apartment cannot serialize #{klass} on ActiveRecord " \
+                  "#{ActiveRecord::VERSION::STRING}: expected method(s) #{missing.join(', ')} " \
+                  'are gone. Pool-per-tenant registers connection pools concurrently and ' \
+                  'this registry is not thread-safe without them. Upgrade ros-apartment to a ' \
+                  'version that supports this ActiveRecord release.')
+          end
+
+          warn_unguarded(klass, method_names, wrapper) if exhaustive
+
+          klass.prepend(wrapper)
+        end
+
+        def warn_unguarded(klass, method_names, wrapper)
+          # instance_methods(false) is the right question HERE (unlike above): it asks
+          # what this class itself declares, and stays correct after prepending
+          # because a prepended module's methods are not the class's own.
+          unguarded = klass.instance_methods(false) - method_names
+          return if unguarded.empty?
+
+          warn "[Apartment] #{klass} on ActiveRecord #{ActiveRecord::VERSION::STRING} declares " \
+               "method(s) #{unguarded.join(', ')} that #{wrapper.name} does not serialize. " \
+               'Concurrent tenant pool creation is protected, but those methods reach the ' \
+               'registry unsynchronized.'
+        end
+      end
+
+      # Guards AR::ConnectionAdapters::PoolManager. Fully qualified everywhere
+      # because the bare constant would resolve to Apartment::PoolManager.
+      module PoolManagerSync
+        def shard_names
+          SYNC.synchronize { super }
+        end
+
+        def role_names
+          SYNC.synchronize { super }
+        end
+
+        def pool_configs(role = nil)
+          SYNC.synchronize { super }
+        end
+
+        def remove_role(role)
+          SYNC.synchronize { super }
+        end
+
+        def remove_pool_config(role, shard)
+          SYNC.synchronize { super }
+        end
+
+        def get_pool_config(role, shard)
+          SYNC.synchronize { super }
+        end
+
+        def set_pool_config(role, shard, pool_config)
+          SYNC.synchronize { super }
+        end
+
+        # Snapshot under the lock, yield outside it. Holding the registry lock
+        # across the caller's block is what makes this dangerous rather than
+        # merely slow: AR's own iterating callers disconnect pools and release
+        # connections inside the block, so the lock would be held across pool
+        # IO while cold creates queue behind it.
+        #
+        # Collected by delegating to +super+ rather than by reading the Hash, so
+        # the snapshot is exactly what upstream would have yielded on this Rails
+        # version. One visible consequence, deliberate: a shard registered
+        # mid-iteration is not yielded (a snapshot, like Concurrent::Map's
+        # iterators elsewhere in Apartment).
+        #
+        # THE RETURN VALUE IS UPSTREAM'S, NOT THE SNAPSHOT. Measured identical on
+        # 7.2 / 8.0 / 8.1: with a block, upstream returns the very Hash it walked
+        # — the inner shard map when a role is given, the outer role map when not
+        # — and the block-less form returns an Enumerator for a role but the outer
+        # Hash (having enumerated nothing) without one. A lock is no reason to
+        # narrow the contract of the method it wraps, and this is a `:nodoc:`
+        # internal that other gems wrap too, so returning our Array would be a
+        # gratuitous difference for anything that ever reads it. AR's own single
+        # caller (ConnectionHandler#each_connection_pool) discards it.
+        #
+        # The two block-less forms need opposite treatment, which is why they are
+        # not one branch:
+        #
+        # WITH a role, upstream's Enumerator is a live view of the inner Hash, and
+        # iterating it later bypasses this wrapper completely — a concurrent
+        # +set_pool_config+ takes SYNC and still mutates the Hash being walked, so
+        # MRI raises in the writer. Probed: the failure is IDENTICAL patched and
+        # unpatched, i.e. delegating here left the original race fully intact on
+        # this path. So we substitute an Enumerator over this method; its deferred
+        # traversal re-enters with a block and goes through the snapshot path
+        # above. Contract preserved — upstream's is an Enumerator too, and +size+
+        # is supplied because upstream's reports the shard count rather than nil.
+        # (Repeated iteration re-snapshots, so it stays a live view like
+        # upstream's, not a frozen one.)
+        #
+        # WITHOUT a role, upstream returns the outer role map and enumerates
+        # nothing whatsoever. There is no traversal to protect and no Enumerator to
+        # match, so substituting one would invent behavior; delegate untouched.
+        def each_pool_config(role = nil, &block)
+          unless block
+            return enum_for(__method__, role) { pool_configs(role).size } if role
+
+            return super
+          end
+
+          snapshot = []
+          upstream_result = SYNC.synchronize { super(role) { |pool_config| snapshot << pool_config } }
+          snapshot.each(&block)
+
+          upstream_result
+        end
+      end
+
+      # Guards the handler's manager cache. +set_pool_manager+ upserts with
+      # +||=+ on a Concurrent::Map: atomic per operation, but a read-then-write
+      # across two, so two threads establishing the first connection for the same
+      # connection name can each build a PoolManager and one is discarded —
+      # silently taking any shard already registered in it with it. Serializing
+      # the whole method makes the upsert atomic.
+      #
+      # Wrapped with argument forwarding rather than a reimplementation because
+      # the signature is version-dependent (AR >= 8.0 passes a ConnectionDescriptor
+      # where 7.2 passed the connection-name String) and the key derivation is
+      # upstream's business, not ours.
+      #
+      # Declared private to match upstream. A prepended method is public by
+      # default, and leaving it so would widen a Rails internal into public API
+      # from a patch whose only job is a lock.
+      module HandlerSync
+        def set_pool_manager(...)
+          SYNC.synchronize { super }
+        end
+
+        private :set_pool_manager
+      end
+    end
+  end
+end

data/lib/apartment/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Apartment
-  VERSION = '4.0.0.alpha10'
+  VERSION = '4.0.0.alpha11'
 end

data/lib/apartment.rb

@@ -191,11 +191,24 @@ module Apartment # rubocop:disable Metrics/ModuleLength
       @activated = false
     end
 
-    # Activate the ConnectionHandling patch on ActiveRecord::Base.
+    # Activate the ActiveRecord patches pool-per-tenant depends on.
     # Idempotent — prepend on an already-prepended module is a no-op.
+    #
+    # ConnectionHandling routes AR::Base.connection_pool to the current tenant's
+    # pool; ConnectionRegistry makes AR's own pool registry safe for the
+    # concurrent shard registration that routing produces. The second is not
+    # optional given the first: without it, a cold tenant switch can fail whenever
+    # any thread happens to be iterating AR's pools — which Rails does through
+    # ConnectionHandler#each_connection_pool at the start of every request or job
+    # (ActiveRecord::QueryCache.run), at the end of every one
+    # (ConnectionPool::ExecutorHooks.complete), and after writes
+    # (clear_query_caches_for_current_thread). NOT from AR's ConnectionPool::Reaper,
+    # which reads a private WeakRef list rather than the registry.
     def activate!
       require_relative('apartment/patches/connection_handling')
+      require_relative('apartment/patches/connection_registry')
       ActiveRecord::Base.singleton_class.prepend(Patches::ConnectionHandling)
+      Patches::ConnectionRegistry.apply!
       @activated = true
     end
 

data/ros-apartment.gemspec

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# SPDX-License-Identifier: MIT
+
 $LOAD_PATH << File.expand_path('lib', __dir__)
 require 'apartment/version'
 
@@ -13,7 +15,9 @@ Gem::Specification.new do |s|
                     'through schema-based or database-based isolation strategies.'
   s.email         = ['ryan@influitive.com', 'brad@influitive.com', 'rui.p.baltazar@gmail.com', 'mauricio@campusesp.com']
 
-  s.files = %w[ros-apartment.gemspec README.md] + `git ls-files -- lib config`.split("\n")
+  # LICENSE ships in the gem deliberately: MIT requires the notice to travel with
+  # every distribution, and RubyGems has no other copy of it.
+  s.files = %w[ros-apartment.gemspec README.md LICENSE] + `git ls-files -- lib config`.split("\n")
   s.require_paths = ['lib']
 
   s.homepage = 'https://github.com/rails-on-services/apartment'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ros-apartment
 version: !ruby/object:Gem::Version
-  version: 4.0.0.alpha10
+  version: 4.0.0.alpha11
 platform: ruby
 authors:
 - Ryan Brunner
@@ -159,6 +159,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - config/default.yml
 - lib/apartment.rb
@@ -194,6 +195,7 @@ files:
 - lib/apartment/lifecycle.rb
 - lib/apartment/migrator.rb
 - lib/apartment/patches/connection_handling.rb
+- lib/apartment/patches/connection_registry.rb
 - lib/apartment/patches/live_tenant_propagation.rb
 - lib/apartment/patches/postgresql_sequence_name.rb
 - lib/apartment/pool_manager.rb