ractor-rails-shim 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ca69607b89c8817a961657ddccd6a3c1a3e87084ef0ec34090b91bce396b22
-  data.tar.gz: cc35444b2078ea06545412a8c6e0d44dd03d2e07c3c2fd99f7a9e930a6fb897e
+  metadata.gz: f309da49240393f31079209d41e422a4f5fabde1428d344d6300ace7ffc5a94d
+  data.tar.gz: d6e330ac46078ff31534d594d5c90f7ae1c739bf765223fda27f03d546350fcb
 SHA512:
-  metadata.gz: 88badfc12887a028b39500559256df576e7317e2dbb9f9e4ee170f116279724a07aef6d3ab4a2bae848c12e04bbc56eb6ffc5c487a54f400aa60ff8b8ef3b0fe
-  data.tar.gz: 95751eb76405f35d3fa1b2f53c89f2d459af19e7503156597d282f23a3c7da2ac71d6836dc54d80c7991b1e623d66c30fd72e67001530d4636fc7846177ed89d
+  metadata.gz: 147c5795a7bf89b07dc1ebc19503cc12fd37c556d727a05a2c4c776c4bf3822def6c37e289343345fa6e861ecdf9a2ef331b13f69dee377cde97f5364dcd42d5
+  data.tar.gz: 3ef1bdce56de6ee989797f780c451f4a56d4ebd6427979a120cc25e90a16d3779e97fe83e2ef9fa48f2e011a7de21bd2df81e2731e77914c2b6d01dd7743460d

data/CHANGELOG.md

@@ -11,6 +11,37 @@ 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
@@ -22,8 +53,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `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. `kino :ractor (-w5 -t5)` now serves all
-  endpoints with 0 failures.
+  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

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/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.2"
+  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.2
+  version: 0.2.4
 platform: ruby
 authors:
 - dev