ractor-rails-shim 0.2.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 515076a823c0767ce28d1bf35545a6ced10f2ef1f628f8e263cde654b58fb899
-  data.tar.gz: df743b8da60645f80569b646301d7d0fd5c197756ffb928921144f7fac161c5e
+  metadata.gz: f309da49240393f31079209d41e422a4f5fabde1428d344d6300ace7ffc5a94d
+  data.tar.gz: d6e330ac46078ff31534d594d5c90f7ae1c739bf765223fda27f03d546350fcb
 SHA512:
-  metadata.gz: c4c6fc83fc7fc61a0fecf603e26e2031d2876f20222c29717cc267fc99acfd7ed4e3e05cd98995099a62807bc37e37f34635c676c334caf2c99cc8d4acc50c0d
-  data.tar.gz: 53bb7cf546753b3bc7c6dc7313dc9b0bbf86b616f1e8f7fc1f0f45d0428988efeee0308bf93c7cf127e9219ebcd747f76340a86b750853a5fad81eaae5da4a0e
+  metadata.gz: 147c5795a7bf89b07dc1ebc19503cc12fd37c556d727a05a2c4c776c4bf3822def6c37e289343345fa6e861ecdf9a2ef331b13f69dee377cde97f5364dcd42d5
+  data.tar.gz: 3ef1bdce56de6ee989797f780c451f4a56d4ebd6427979a120cc25e90a16d3779e97fe83e2ef9fa48f2e011a7de21bd2df81e2731e77914c2b6d01dd7743460d

data/CHANGELOG.md

@@ -11,6 +11,71 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Improved the published gem summary and description (gemspec). Metadata-only
   release — no code changes.
 
+## [0.2.4]
+
+### Performance
+- **class_attribute reader (ractor mode) is now allocation-free.** The
+  generated `__class_attr_*` accessors previously walked `self.ancestors` and
+  built a fresh `Symbol` via string interpolation for *every* ancestor on
+  *every* read — the dominant allocation source for GET requests (a Rails class
+  has 20–40 ancestors, and class_attribute is read constantly: controller
+  filters, view partial paths, AR `strict_loading`, form builder, logger, …).
+  In ractor mode the writer already collapses every write to the defining
+  owner's single key, so the ancestor walk was dead code. The reader now does a
+  single literal-symbol lookup against `IsolatedExecutionState[key]` then
+  `SHAREABLE_FALLBACK[key]`, eliminating the per-read `Array` + `Symbol`
+  churn. This cuts request allocations substantially and, with them, the
+  garbage-collection share of CPU time (was ~33% of CPU on `GET /posts`).
+
+## [0.2.3]
+
+### Fixed
+- **Cold `GET /up` `SystemStackError` in worker Ractors (kino `:ractor`).**
+  Rails' `ActionDispatch::Routing::RouteSet#generate_url_helpers` builds a
+  module whose `self.included(base)` hook re-dups the module and re-includes
+  it while `!base._routes.equal?(@_proxy._routes)`. Under the frozen,
+  Ractor-shareable app graph a worker Ractor's controller reports
+  `base._routes` as `nil`, so the equality never holds and the hook
+  re-includes forever (empty Ruby backtrace, first request only; respawns and
+  later requests are fine). The shim's `route_helpers.rb` `generate_url_helpers`
+  override now bounds the reinclude to once per base, preserving the
+  route-alignment intent without the infinite loop. Verified: cold `GET /up`
+  returns 200 in `kino -m ractor`; both `:ractor` and `:threaded` modes clean.
+
+## [0.2.2]
+
+### Fixed
+- **Multi-threaded worker race in `WorkerApp#setup_once!` (kino `:ractor`,
+  `-wN -tM` with M > 1).** All threads inside a worker Ractor share
+  `Ractor.current`, so the previous `Ractor.current[:rrs_worker_ready]` guard
+  let multiple threads race through `rebind_constants` +
+  `init_worker_ar_connections!`, producing
+  `ActiveRecord::ConnectionNotEstablished` on the very first request. Setup is
+  now serialized with a per-Ractor `Thread::Mutex`, and `rebind_constants`
+  re-fetches each namespace parent so concurrent setup cannot clobber a module
+  out from under another thread.
+- **Per-thread ActiveRecord connection handler (intermittent
+  `ConnectionNotEstablished` on `kino :ractor -w5 -t5`).** `init_worker_ar_connections!`
+  stored the per-Ractor `ConnectionHandler` in `ActiveSupport::IsolatedExecutionState`,
+  which is **per-thread** (`Thread.attr_accessor`). The init thread set it, but
+  the other worker threads in the same Ractor saw `nil` →
+  `ConnectionNotEstablished: No connection handler for Ractor X` on a fraction of
+  requests. The handler now lives in `Ractor.current` (per-Ractor, shared by all
+  of the worker's threads), and `ActiveRecord::Base.connection_handler` reads it
+  there first.
+- **Write-path `Ractor::IsolationError` on `redirect_to @post`
+  (`kino :ractor -w5 -t5`, `POST /posts`).** `ActiveModel::AttributeMethods::
+  ClassMethods#attribute_method_patterns_cache` stored a mutable `Concurrent::Map`
+  in a class instance variable (unshareable). Hit via `redirect_to @post` →
+  `respond_to?` → `matched_attribute_method`, raising from worker Ractors. The
+  cache is now routed through `Ractor.current` (per-Ractor, keyed per class) and
+  populated lazily per Ractor — content is deterministic, so per-Ractor
+  recomputation is correct.
+
+  With these three fixes, `kino :ractor (-w5 -t5)` serves `/up`, `GET /posts`,
+  and `POST /posts` (authenticated write + 302) with 0 transport failures and 0
+  server errors under sustained load.
+
 ### Added — ActiveRecord query-path ractor-safety (Blocker 1 deep work)
 - `RactorRailsShim.worker_ar_init(app)` — a shareable Rack middleware that
   calls `init_worker_ar_connections!` on each worker's first request. Kino's
@@ -47,7 +112,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `TYPE_MAP` (Procs) and `QUOTED_*` `Concurrent::Map` quoting caches.
   These are intrinsically unshareable and require upstream Rails changes
   (shareable callables instead of Procs; per-Ractor quoting caches). See
-  `NEXT_STEPS.md` "The wall — deep AR ractor-unsafety".
+  the "deep AR ractor-unsafety" wall in the project notes.
 
 ## [0.2.0] - 2026-07-09
 

data/lib/ractor_rails_shim/patches/activerecord.rb

@@ -2,7 +2,7 @@
 
 # Patch ActiveRecord's connection handler to work in per-Ractor mode.
 #
-# Blocker 1 (from NEXT_STEPS.md):
+# Blocker 1:
 #   ActiveRecord::Base.connection_pool calls
 #   default_connection_handler.retrieve_connection_pool(...)
 #   at connection_handling.rb:346. The default_connection_handler
@@ -229,7 +229,14 @@ module RactorRailsShim
       return unless defined?(::ActiveRecord::Base)
 
       key = :active_record_connection_handler
-      existing = ActiveSupport::IsolatedExecutionState[key]
+      # Store the handler in Ractor-local storage (Ractor.current), NOT in
+      # ActiveSupport::IsolatedExecutionState. IES is per-THREAD (it is a
+      # Thread.attr_accessor), so a value set on the init thread is invisible
+      # to the other worker threads in the same worker Ractor ->
+      # ConnectionNotEstablished ("No connection handler for Ractor X").
+      # Ractor.current storage is per-Ractor and shared by every thread of the
+      # worker, so connection_handler resolves the same handler for all threads.
+      existing = Ractor.current[key]
       return if existing
 
       # Establish a fresh, per-Ractor connection handler + pool from the
@@ -256,7 +263,7 @@ module RactorRailsShim
           end
         end
 
-        ActiveSupport::IsolatedExecutionState[key] = handler
+        Ractor.current[key] = handler
       end
     end
 
@@ -320,6 +327,35 @@ module RactorRailsShim
       _share_relation_delegate_caches! if Ractor.main?
     end
 
+    # ActiveModel::AttributeMethods::ClassMethods#attribute_method_patterns_cache
+    # stores a mutable Concurrent::Map in a CLASS instance variable
+    # (@attribute_method_patterns_cache). That ivar is unshareable, so reading
+    # it from a worker Ractor raises Ractor::IsolationError ("can not get
+    # unshareable values from instance variables of classes/modules from
+    # non-main Ractors") — hit on the write path via redirect_to @post ->
+    # respond_to? -> matched_attribute_method -> attribute_method_patterns_cache.
+    #
+    # Unlike @relation_delegate_cache (populated once, freezable), this map is
+    # mutated lazily per method_name (compute_if_absent) during request handling,
+    # so it cannot be frozen. Instead route it through Ractor-local storage:
+    # each Ractor gets its own Concurrent::Map, shared by all of its threads.
+    # The cache content is deterministic (a pure function of the class's
+    # attribute_method_patterns), so per-Ractor recomputation is correct.
+    def _install_active_model_attribute_method_patterns_patch
+      return if @am_amp_patched
+      @am_amp_patched = true
+      _register_patch :active_model_attribute_method_patterns, "8.1"
+      return unless defined?(::ActiveModel::AttributeMethods)
+
+      mod = ::ActiveModel::AttributeMethods::ClassMethods
+      mod.module_eval do
+        def attribute_method_patterns_cache
+          store = Ractor.current[:__am_attribute_method_patterns_cache__] ||= {}
+          store[object_id] ||= Concurrent::Map.new(initial_capacity: 4)
+        end
+      end
+    end
+
     # Make every loaded AR model class's @relation_delegate_cache shareable.
     # Idempotent; must run in the main Ractor after eager_load so that all
     # model classes (and their caches) exist.
@@ -1310,6 +1346,19 @@ module RactorRailsShim
         def default_connection_handler=(val)
           ActiveSupport::IsolatedExecutionState[#{dch_key_str}] = val
         end
+        # Route the per-Ractor handler through Ractor-local storage. IES is
+        # per-thread, so a handler stored on the init thread is invisible to the
+        # worker's other threads; Ractor.current is per-Ractor and shared by all
+        # threads of the worker. Falls back to IES (legacy) then
+        # default_connection_handler (main Ractor only).
+        def connection_handler
+          v = Ractor.current[:active_record_connection_handler]
+          return v unless v.nil?
+          ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] || default_connection_handler
+        end
+        def connection_handler=(handler)
+          Ractor.current[:active_record_connection_handler] = handler
+        end
       RUBY
 
       # Also ensure connection_handler (which Rails already routes through IES

data/lib/ractor_rails_shim/patches/class_attribute.rb

@@ -135,50 +135,53 @@ module RactorRailsShim
                 end
               RUBY
             end
-           else
-            target.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{namespaced_name}
-                self.ancestors.each do |anc|
-                  k = :"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}"
-                  v = ActiveSupport::IsolatedExecutionState[k]
-                  return v unless v.nil?
-                  fb = RactorRailsShim::SHAREABLE_FALLBACK[k]
-                  return fb unless fb.nil?
-                end
-                RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
-              end
+            else
+             # Ractor mode: the writer (below) ALWAYS targets this owner's single
+             # `key` (#{key_str}), so there is no per-subclass copy-on-write to
+             # resolve by walking ancestors. The original `self.ancestors.each`
+             # + per-ancestor Symbol interpolation allocated a fresh Array AND a
+             # Symbol per ancestor on EVERY read — the dominant allocation source
+             # for GET requests. Replace it with a direct literal-key lookup
+             # (zero per-read allocation). The per-Ractor value already lives in
+             # ActiveSupport::IsolatedExecutionState[key]; SHAREABLE_FALLBACK[key]
+             # is the frozen, shared default built at prepare_for_ractors! time.
+             target.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+               def #{namespaced_name}
+                 v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+                 return v unless v.nil?
+                 fb = RactorRailsShim::SHAREABLE_FALLBACK[#{key_str}]
+                 return fb unless fb.nil?
+                 RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
+               end
 
-              def #{namespaced_name}=(new_value)
-                ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
-                RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
-                new_value
-              end
-            RUBY
+               def #{namespaced_name}=(new_value)
+                 ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
+                 RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
+                 new_value
+               end
+             RUBY
 
-            # When owner is a module's singleton class, the original also
-            # defines a public reader `def #{name} { value }` on owner directly
-            # (block-based). Override it with the IES-routed version + fallback.
-            if owner.singleton_class? && owner.attached_object.is_a?(Module)
-              owner.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{name}
-                  self.ancestors.each do |anc|
-                    k = :"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}"
-                    v = ActiveSupport::IsolatedExecutionState[k]
-                    return v unless v.nil?
-                    fb = RactorRailsShim::SHAREABLE_FALLBACK[k]
-                    return fb unless fb.nil?
-                  end
-                  RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
-                end
+             # When owner is a module's singleton class, the original also
+             # defines a public reader `def #{name} { value }` on owner directly
+             # (block-based). Override it with the IES-routed version + fallback.
+             if owner.singleton_class? && owner.attached_object.is_a?(Module)
+               owner.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                 def #{name}
+                   v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+                   return v unless v.nil?
+                   fb = RactorRailsShim::SHAREABLE_FALLBACK[#{key_str}]
+                   return fb unless fb.nil?
+                   RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
+                 end
 
-                def #{name}=(new_value)
-                  ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
-                  RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
-                  new_value
-                end
-              RUBY
-            end
-          end
+                 def #{name}=(new_value)
+                   ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
+                   RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
+                   new_value
+                 end
+               RUBY
+             end
+           end
         end
 
         # redefine_method is used by `redefine` internally and by other call

data/lib/ractor_rails_shim/patches/core.rb

@@ -377,6 +377,7 @@ module RactorRailsShim
       _install_activerecord_primary_key_patch
       _install_activerecord_query_constraints_patch
       _install_activerecord_relation_delegate_cache_patch
+      _install_active_model_attribute_method_patterns_patch
       _install_activerecord_model_classes_patch
       _install_active_model_naming_patch
       _install_active_record_core_patch
@@ -781,10 +782,18 @@ module RactorRailsShim
     private
 
     def setup_once!
-      return if Ractor.current[:rrs_worker_ready]
-      rebind_constants
-      RactorRailsShim.init_worker_ar_connections! if defined?(RactorRailsShim)
-      Ractor.current[:rrs_worker_ready] = true
+      # All threads inside a worker Ractor share Ractor.current, so a single
+      # per-Ractor mutex serializes the one-time init across the worker's
+      # threads. (The mutex is created under ||= which is racy under extreme
+      # contention, but both init steps below are themselves idempotent, so a
+      # rare double-init is harmless.)
+      m = Ractor.current[:rrs_worker_mutex] ||= Thread::Mutex.new
+      m.synchronize do
+        return if Ractor.current[:rrs_worker_ready]
+        rebind_constants
+        RactorRailsShim.init_worker_ar_connections! if defined?(RactorRailsShim)
+        Ractor.current[:rrs_worker_ready] = true
+      end
     end
 
     def rebind_constants
@@ -792,6 +801,9 @@ module RactorRailsShim
         parent = Object
         parts = cpath.split("::")
         parts[0...-1].each do |p|
+          # Re-fetch the parent each iteration so concurrent setup (multiple
+          # threads racing through setup_once! on the same worker) cannot
+          # clobber a namespace module out from under us.
           parent = if parent.const_defined?(p, false)
                      parent.const_get(p, false)
                    else

data/lib/ractor_rails_shim/patches/kaminari.rb

@@ -3,7 +3,7 @@
 # Patch Kaminari::config to not read the @_config class ivar from a worker
 # Ractor.
 #
-# Blocker 2 (from NEXT_STEPS.md):
+# Blocker 2:
 #   Kaminari.config reads @_config directly at kaminari/config.rb:14:
 #     def self.config; @_config ||= Kaminari::Configuration.new end
 #   Not mattr_accessor-backed, so the shim's mattr rewrite doesn't catch it.

data/lib/ractor_rails_shim/patches/route_helpers.rb

@@ -93,6 +93,27 @@ module RactorRailsShim
           mod = _rrs_orig_generate_url_helpers(supports_path)
           mod.module_eval("def _routes\n  @_routes || ::Rails.application.routes\nend", __FILE__, __LINE__ + 1)
           mod.module_eval("def _generate_paths_by_default\n  " + supports_path.inspect + "\nend", __FILE__, __LINE__ + 1)
+
+          # Bound the stock `self.included` reinclude (actionpack
+          # action_dispatch/routing/route_set.rb). That hook re-dups the module
+          # and re-includes it while `!base._routes.equal?(@_proxy._routes)`.
+          # Under the frozen, Ractor-shareable app graph a worker Ractor's
+          # controller can report `_routes` as nil, so the equality never holds
+          # and the reinclude loops forever (SystemStackError on the very first
+          # request, e.g. GET /up -> Rails::HealthController). The intent is to
+          # re-align `_routes` per base exactly once; bound it to one reinclude
+          # per base so the loop can never happen while preserving that intent.
+          seen = ::Set.new
+          mod.instance_variable_set(:@_rrs_reinclude_seen, seen)
+          mod.singleton_class.class_eval do
+            alias_method :_rrs_orig_self_included, :included
+            def included(base)
+              seen = instance_variable_get(:@_rrs_reinclude_seen)
+              return if seen.include?(base.object_id)
+              seen << base.object_id
+              _rrs_orig_self_included(base)
+            end
+          end
           mod
         end
       RUBY

data/lib/ractor_rails_shim/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RactorRailsShim
-  VERSION = "0.2.1"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractor-rails-shim
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.4
 platform: ruby
 authors:
 - dev
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Make Rails apps Ractor-safe so they can run in Ractor mode (e.g. under the
   kino web server).