rails-minify 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f089252dbde289b9e5cfeb25c2613e91544e92a1235369ec7c4457992e477b
-  data.tar.gz: c768e54a78cd0ee553f8732f019dc4eab9fff3c5c72d4ef9d30d23abc68b2994
+  metadata.gz: 2e018dfbd1f9df88b770cd083ba94da47867f8199f88fd885d7bff62b2efb592
+  data.tar.gz: 6a0ac44911b837229cd36caa47bc4571dda38296952c33198542f12b79237d66
 SHA512:
-  metadata.gz: da6b92c40d4f1fada0154fb362cd52c8a56e458b67e5d959e20084bb4e37f25a8be93d7d86bc065d6a71ac09dc4763c79fbada65a4f7a73c281c8b9fef511d1b
-  data.tar.gz: 8cca5d4c9850e66798cdb80127907dbfc64cdf5643d1064a7ce01be6bfdd8f46b79bbf63e9e8c80775dd6c3453d9877537bd6951707cb434378049fdb0a92227
+  metadata.gz: e10f339acb5fe096a62873b7ffc292a0c5c322854eee25f856ebd09505e812f2d97b18b8427fc7f2ad5249404ec85dc9b7f2576cebcdb32b0b3285e0ba92c90c
+  data.tar.gz: be2ebd0fbfae79dc3f6217d792337261f517c06f882ab506867b262c576eaa1dd17fd313931e8625dfa0ccd2ffabedfc0dcb80659817f0b6ff1d4f7cfc3e6ee6

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.2.0 (2026-10-20)
+
+Narrowed to what held up in production (Japan Voyage, each part on half the workers under the same traffic; README, "What paid off in production").
+
+- `config.rails_minify.enabled` turns on only strict mode (`ar_minimizer.slim`), enums and ZJIT after boot. ZJIT only in production and from Ruby 4.1 (4.0's ZJIT isn't meant for production); set `config.rails_minify.zjit` yourself otherwise.
+- No longer turned on by `enabled`: `ar_minimizer.views`, `.load_time`, `.small_records`, `as_minimizer.unroll_callbacks`, `ap_minimizer.route_helpers`, `.views`, and the patches. Each still works when set on its own and is documented as experimental. Patches: `config.rails_minify.patches = true` for all, or a list.
+- actionpack-minimizer is no longer a dependency; rails-minify loads it, and `minify:census` covers it, when it's in the Gemfile.
+- Requires activerecord-minimizer and activesupport-minimizer 0.2.
+
 ## 0.1.3 (2026-10-18)
 
 - `config.rails_minify.zjit = true` turns ZJIT on after boot, as `config.yjit` does for YJIT, instead of `RUBY_ZJIT_ENABLE=1` compiling boot-only code too. Japan Voyage, per process: 24% fewer compiled methods, 18 MB less JIT memory, about 25 MB less RSS, the same speed.

data/README.md

@@ -1,6 +1,7 @@
 # rails-minify
 
-Cuts what Rails (and common gems) build or redo on every request.
+Fewer generated Active Record methods, ZJIT turned on after boot, and checks
+for callback problems.
 
 ```ruby
 # Gemfile
@@ -10,14 +11,19 @@ gem "rails-minify"
 config.rails_minify.enabled = true
 ```
 
-`enabled` turns on every part below; each can still be set on its own
-(`config.ar_minimizer.enums = false`, `config.rails_minify.patches = [:omniauth]`).
+`enabled` turns on what held up in production on a real app:
+
+* strict mode (`config.ar_minimizer.slim`): only readers and writers per column;
+* enum predicates and bang methods as plain methods (`config.ar_minimizer.enums`);
+* ZJIT after boot (`config.rails_minify.zjit`), in production on Ruby 4.1+.
+
+Each can still be set on its own (`config.ar_minimizer.enums = false`).
+Everything else is [experimental](#experimental) and off unless you set it.
 Ruby 3.4+, Rails 8.0, 8.1 and main.
 
 Turn it on in tests too, so a call to a method strict mode removed fails in CI
 rather than in production. In development, strict mode alone is enough: the
-same errors show up while you work, and the compiling parts, which don't
-follow code reloads, stay off.
+same errors show up while you work.
 
 ```ruby
 # config/environments/test.rb
@@ -27,7 +33,7 @@ config.rails_minify.enabled = true
 config.ar_minimizer.slim = true # strict mode, without the rest
 ```
 
-## Strict by default
+## Strict mode
 
 Active Record defines, for every column, a reader, a writer and 19 more
 methods (`name?`, `name_changed?`, `saved_change_to_name?`, ...). With
@@ -46,50 +52,17 @@ rubocop-minify rewrites those calls in your code. For calls in gems
 `config.ar_minimizer.strict = false` keeps the removed methods working
 instead, generated the first time each is called.
 
-## What's in it
-
-| part | does | gem |
-|---|---|---|
-| attribute methods | readers and writers only (strict) | activerecord-minimizer |
-| enums | predicates/bang methods as plain methods (1.3-1.6x) | activerecord-minimizer |
-| small records | no Hashes for records that never fill them (-22% per record) | activerecord-minimizer |
-| callbacks | chains as generated methods (`valid?` -33..45%) | activesupport-minimizer |
-| route helpers | `post_path(post)` as interpolation (3-14x) | actionpack-minimizer |
-| views | `render`/`link_to` without their machinery (2x per page of partials) | actionpack-minimizer |
-| patches | below | rails-minify |
-| rewrites | removed-method calls in Ruby and ERB, as RuboCop autocorrections | rubocop-minify (development) |
-
-## Patches
-
-For parts of Rails and common gems that redo work on every request.
-`config.rails_minify.patches = [...]` picks them; all by default.
-
-* `:action_text_plain_text`: `ActionText::Content#to_plain_text` parses the
-  HTML with Nokogiri, and looks up every attachment's record, on every call.
-  It's computed once per distinct HTML (cache capped at 8 MB of HTML).
-  Attachments that are Active Storage blobs, remote images or inline content
-  are cached too: a blob without a caption contributes its filename, which a
-  hit checks in one query (renamed or deleted: computed again). Other
-  attachables aren't cached. In [Japan Voyage](https://japanvoyage.jp), 13% of all allocations on its
-  pages came from it, and guides with images another 4.5%.
-* `:request_host`: `ActionDispatch::Request#host` runs a regexp substitution
-  on every call, port or not, and Rails reads it several times per request.
-  rails/rails#59104 (Rails 8.2) for 8.1: no substitution without a port, and
-  the host kept while the raw host is the same String. Not installed on 8.2.
-* `:omniauth`: every OmniAuth strategy middleware dups itself and its
-  options on every request before looking at the path. Requests that can't
-  be OmniAuth's go straight to the app. Only when that's certain up front:
-  a session is present, not in test mode, no `other_phase` or callable
-  paths, and the strategy doesn't override how paths are matched. Not
-  installed when OmniAuth already does this itself (it then has a public
-  `Strategy#passthrough?`, as in the version proposed upstream).
-
 ## ZJIT after boot
 
 ```ruby
 config.rails_minify.zjit = true # instead of RUBY_ZJIT_ENABLE=1 / --zjit
 ```
 
+`enabled` sets it in production on Ruby 4.1 and later; on 4.0, ZJIT isn't
+meant for production yet, so set it yourself if you want it there. ZJIT
+options still go in `RUBYOPT`, after `--zjit-disable` so they don't turn it
+on at startup: `RUBYOPT="--zjit-disable --zjit-call-threshold=2"`.
+
 `RUBY_ZJIT_ENABLE=1` turns ZJIT on before anything loads, so it also compiles
 what runs only while booting: RubyGems, requiring and eager loading, and the
 minimizers' own compiling. Rails turns YJIT on after boot (`config.yjit`) for
@@ -100,16 +73,8 @@ On Japan Voyage, per process after the same 132 pages: 12,612 → 9,557
 compiled methods, JIT code 45.9 → 35.3 MB, ZJIT memory 82.9 → 64.6 MB,
 RSS about 25 MB less, the same CPU time per page.
 
-## Numbers
-
-Japan Voyage, 132 production pages, with everything on (strict mode after
-rubocop-minify's rewrites, all patches): identical HTML, and
-1,561,283 → 1,224,141 allocations per pass (−21.6%). The machine was too
-loaded for wall-clock times to mean much.
-
 ## Checks
 
-* `bin/rails minify:census`: how much of the app runs compiled, and why the rest doesn't.
 * `bin/rails minify:check` (for CI; works whether or not the rest of
   rails-minify is on) fails on:
   * callbacks naming methods that don't exist;
@@ -121,7 +86,8 @@ loaded for wall-clock times to mean much.
     reported once, with the classes that inherit it;
   * model callbacks that call `save`, `update`, `touch`, ... on the record
     they run for, which runs the chain again;
-  * an out-of-date manifest.
+  * an out-of-date manifest, when there is one (only the experimental
+    compiling parts use it).
 
   ```ruby
   config.rails_minify.callback_limit = 8
@@ -131,7 +97,94 @@ loaded for wall-clock times to mean much.
   config.rails_minify.allow_callback_loops = ["Trip#recalculate"] # guarded on purpose
   ```
 
-## Things found that are app config, not patches
+## What paid off in production
+
+Each gem's README has benchmark numbers. In production, on
+[Japan Voyage](https://japanvoyage.jp) (Falcon, 6 workers, ZJIT, SQLite),
+each part ran for an hour on half the workers while the other half ran
+without it, under the same traffic (about 5,000 requests per half):
+
+| part | in production | in 0.2.0 |
+|---|---|---|
+| ZJIT after boot | HTML p50/p90/p99 75/131/231 → 70/126/208 ms, ~25 MB less per worker (an hour before against an hour after) | on with `enabled` (production, Ruby 4.1+) |
+| enums | the same medians; that hour's lower mean and p99 came from a few slow requests, as it changes no allocations on these pages | on with `enabled`: harmless, no measured gain |
+| strict | the same latency and memory; no calls to a removed method | on with `enabled`, so production runs what the tests run |
+| small records | no difference (tens of records per request) | experimental |
+| route helpers | no difference in view time | experimental |
+| views (`render`/`link_to`) | no difference in view time | experimental |
+| compiled call sites in views | ~22 MB more per worker, no faster | experimental |
+| compiled call sites at load time | ~12% more CPU per request (not reproduced locally) | experimental |
+| callbacks | no faster, ~20 MB more per worker | experimental |
+| patches | no difference (view time 25.3 vs 26.8 ms) | experimental |
+
+ZJIT after boot is the one part with a clear effect. What `enabled` turns on
+is what Japan Voyage runs.
+
+What the benchmarks speed up is per call: a method call, a Hash, a helper.
+A page there spends ~30 ms in Active Record and ~30 ms in views, and those
+savings were smaller than the difference between two halves of the same
+workers. Parts that generate or compile code in each worker (callbacks,
+compiled views) cost memory in every worker; most of these ran before the
+app was preloaded, and would cost less with preloading.
+
+Besides ZJIT after boot, what sped Japan Voyage up was outside this gem: a
+preloading server warming the heap up before it forks, and one query fixed.
+Together, HTML p50/p90/p99 went from 75/131/231 to 45/66/~105 ms.
+
+## Experimental
+
+Each was faster in benchmarks and made no measurable difference in
+production (above). They still work, each turned on by its own setting:
+
+| part | setting | gem |
+|---|---|---|
+| small records: no Hashes for records that never fill them (-22% per record) | `config.ar_minimizer.small_records` | activerecord-minimizer |
+| call sites compiled to what removed methods stood for | `config.ar_minimizer.views`, `.load_time` | activerecord-minimizer |
+| callback chains as generated methods (`valid?` -33..45%) | `config.as_minimizer.unroll_callbacks` | activesupport-minimizer |
+| route helpers as interpolation (3-14x) | `config.ap_minimizer.route_helpers` | actionpack-minimizer |
+| `render`/`link_to` without their machinery (2x per page of partials) | `config.ap_minimizer.views` | actionpack-minimizer |
+| patches | `config.rails_minify.patches` | rails-minify |
+
+actionpack-minimizer is no longer a dependency: add `gem "actionpack-minimizer"`
+to use it. `bin/rails minify:census` shows how much of the app the compiling
+parts cover, and why the rest isn't (actionpack-minimizer's part when it's
+installed).
+
+### Patches
+
+For parts of Rails and common gems that redo work on every request. Off
+unless `config.rails_minify.patches` is set: `true` for all of them, or a
+list (`[:omniauth]`). In production they made no difference in view time;
+each is on its way upstream.
+
+* `:action_text_plain_text`: `ActionText::Content#to_plain_text` parses the
+  HTML with Nokogiri, and looks up every attachment's record, on every call.
+  It's computed once per distinct HTML (cache capped at 8 MB of HTML).
+  Attachments that are Active Storage blobs, remote images or inline content
+  are cached too: a blob without a caption contributes its filename, which a
+  hit checks in one query (renamed or deleted: computed again). Other
+  attachables aren't cached. In [Japan Voyage](https://japanvoyage.jp), 13% of all allocations on its
+  pages came from it, and guides with images another 4.5%.
+* `:request_host`: `ActionDispatch::Request#host` runs a regexp substitution
+  on every call, port or not, and Rails reads it several times per request.
+  rails/rails#59104 (Rails 8.2) for 8.1: no substitution without a port, and
+  the host kept while the raw host is the same String. Not installed on 8.2.
+* `:omniauth`: every OmniAuth strategy middleware dups itself and its
+  options on every request before looking at the path. Requests that can't
+  be OmniAuth's go straight to the app. Only when that's certain up front:
+  a session is present, not in test mode, no `other_phase` or callable
+  paths, and the strategy doesn't override how paths are matched. Not
+  installed when OmniAuth already does this itself (it then has a public
+  `Strategy#passthrough?`, as in the version proposed upstream).
+
+### Allocations
+
+Japan Voyage, 132 production pages, with everything on (strict mode after
+rubocop-minify's rewrites, all patches): identical HTML, and
+1,561,283 → 1,224,141 allocations per pass (−21.6%). The machine was too
+loaded for wall-clock times to mean much.
+
+## Things found that are app config
 
 * sentry-rails' `breadcrumbs_logger = [:active_support_logger]` subscribes to
   every notification (each SQL query, render, instantiation) and takes

data/lib/rails_minify/railtie.rb

@@ -6,20 +6,22 @@ module RailsMinify
 
     # After config/environments/*.rb, before any initializer reads the
     # minimizers' options.
-    config.before_initialize do |app|
-      next unless app.config.rails_minify.enabled
-
-      ar = app.config.ar_minimizer
+    config.before_initialize { |app| Railtie.apply_enabled(app.config) }
+
+    # `enabled` turns on what made no page slower in production and is worth
+    # having for its own sake: strict mode (fewer generated methods, production
+    # runs what the tests run), enums and ZJIT after boot. Everything else stays
+    # off unless set on its own. ZJIT, like Rails' config.yjit default, not in
+    # development and test, and only from Ruby 4.1: 4.0's ZJIT isn't meant for
+    # production yet.
+    def self.apply_enabled(config, env: Rails.env, ruby: RUBY_VERSION)
+      options = config.rails_minify
+      return unless options.enabled
+
+      ar = config.ar_minimizer
       ar.slim = true if ar.slim.nil?
-      ar.views = true if ar.views.nil?
       ar.enums = true if ar.enums.nil?
-      ar.small_records = true if ar.small_records.nil?
-      ar.load_time = app.root.join("config/ar_minimizer.json").exist? if ar.load_time.nil?
-      as = app.config.as_minimizer
-      as.unroll_callbacks = true if as.unroll_callbacks.nil?
-      ap = app.config.ap_minimizer
-      ap.route_helpers = true if ap.route_helpers.nil?
-      ap.views = true if ap.views.nil?
+      options.zjit = !env.local? && Gem::Version.new(ruby) >= Gem::Version.new("4.1") if options.zjit.nil?
     end
 
     PATCHES = {
@@ -29,10 +31,10 @@ module RailsMinify
     }.freeze
 
     initializer "rails_minify.patches" do |app|
-      options = app.config.rails_minify
-      next unless options.enabled || options.patches
+      patches = app.config.rails_minify.patches
+      next unless patches
 
-      Array(options.patches || PATCHES.keys).each do |name|
+      (patches == true ? PATCHES.keys : Array(patches)).each do |name|
         constant, hook, install = PATCHES.fetch(name.to_sym)
         if hook
           ActiveSupport.on_load(hook) { install.call }
@@ -72,8 +74,10 @@ module RailsMinify
           sections = {
             "Active Record (activerecord-minimizer)" => ArMinimizer::Census.report(root: app.root),
             "Callbacks (activesupport-minimizer)" => AsMinimizer::Census.report(routed: routed),
-            "Routes and views (actionpack-minimizer)" => ApMinimizer::Census.report(app.routes, app.paths["app/views"].existent),
           }
+          if defined?(ApMinimizer::Census)
+            sections["Routes and views (actionpack-minimizer)"] = ApMinimizer::Census.report(app.routes, app.paths["app/views"].existent)
+          end
           sections.each do |title, result|
             puts title
             result.lines(verbose: verbose).each { puts "  #{it}" }

data/lib/rails_minify/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsMinify
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/lib/rails_minify.rb

@@ -3,22 +3,29 @@
 require "rails_minify/version"
 require "as_minimizer"
 require "ar_minimizer"
-require "ap_minimizer"
+begin
+  require "ap_minimizer" # optional: gem "actionpack-minimizer"
+rescue LoadError => e
+  raise unless e.path == "ap_minimizer"
+end
 
-# One switch for the minimizers:
+# One switch:
 #
 #   # config/environments/production.rb
 #   config.rails_minify.enabled = true
 #
 # turns on, unless set otherwise on their own:
-#   config.ar_minimizer.slim, .views, .load_time (load_time only with config/ar_minimizer.json)
-#   config.as_minimizer.unroll_callbacks
-#   config.ap_minimizer.route_helpers, .views
+#   config.ar_minimizer.slim   strict mode: only readers and writers per column
+#   config.ar_minimizer.enums  enum predicates/bang methods as plain methods
+#   config.rails_minify.zjit   ZJIT after boot
 #
-# and these patches, for parts of Rails and common gems that redo work on
-# every request (config.rails_minify.patches = [...] to choose):
+# Experimental, each off unless set: the other minimizer options
+# (ar_minimizer.views, .load_time, .small_records, as_minimizer.unroll_callbacks,
+# ap_minimizer.*) and the patches for parts of Rails and common gems that redo
+# work on every request (config.rails_minify.patches = true, or a list):
 #   :action_text_plain_text  ActionText::Content#to_plain_text, once per distinct HTML
 #   :omniauth                OmniAuth strategies skip their per-request dup off their paths
+#   :request_host            ActionDispatch::Request#host without a substitution per call
 module RailsMinify
   module Patches
     autoload :ActionTextPlainText, "rails_minify/patches/action_text_plain_text"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-minify
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Sampo Kuokkanen
@@ -15,51 +15,33 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: actionpack-minimizer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: activesupport-minimizer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-description: Turns on activerecord-, activesupport- and actionpack-minimizer, and
-  patches parts of Rails and common gems that redo work on every request (Action Text
-  plain text, Request#host, OmniAuth strategies).
+        version: '0.2'
+description: 'One switch for what held up in production: Active Record strict mode
+  (only readers and writers per column), enum methods without closures and ZJIT turned
+  on after boot. minify:check finds callback problems. Experimental: patches for parts
+  of Rails and common gems that redo work on every request, and the other minimizer
+  parts.'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -98,6 +80,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: 'Precompile what Rails works out at runtime: attribute methods, callback
-  chains'
+summary: Strict Active Record attribute methods, ZJIT after boot, and checks for callback
+  problems
 test_files: []