rails-minify 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf98d2d12a8005e5ef2755cd6bba97a32122a7dd2514518e9a749d1ba367af00
-  data.tar.gz: 878a2fab37d90963eb4b4d5924d7b3437847672741471d84ea6cefc686cb7ca1
+  metadata.gz: 2e018dfbd1f9df88b770cd083ba94da47867f8199f88fd885d7bff62b2efb592
+  data.tar.gz: 6a0ac44911b837229cd36caa47bc4571dda38296952c33198542f12b79237d66
 SHA512:
-  metadata.gz: 2baf13ba8db10c35cfaccfaf86b6c966b11555b9b232c1710da044a37dad166f96dee80cdc2380db98321a845c612e80f3a3648dbc515b31f9402a54bc393599
-  data.tar.gz: b26a83ac5f86fc456c18444e7eba578cb095fa897ee4bac9a508a10047a9164fc8d22197dc0ae6f7f2c7193ca32a437fe1b8fc35c7c9ab873d9091c936be57a0
+  metadata.gz: e10f339acb5fe096a62873b7ffc292a0c5c322854eee25f856ebd09505e812f2d97b18b8427fc7f2ad5249404ec85dc9b7f2576cebcdb32b0b3285e0ba92c90c
+  data.tar.gz: be2ebd0fbfae79dc3f6217d792337261f517c06f882ab506867b262c576eaa1dd17fd313931e8625dfa0ccd2ffabedfc0dcb80659817f0b6ff1d4f7cfc3e6ee6

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # 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.
+
 ## 0.1.2 (2026-10-18)
 
 - `minify:check` also fails on callback chains longer than `callback_limit` (default 5, `ApplicationController`'s callbacks excluded) and on model callbacks that save their own record again; `callback_limit_mode` and `callback_loops` set either to `:warn`. Works without the rest of rails-minify turned on; the manifest check runs only when there is a manifest.

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,23 +52,110 @@ 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
+## 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
+this reason, but has no such setting for ZJIT; this is that one. It works on
+its own, without the rest of rails-minify.
+
+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.
+
+## Checks
+
+* `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;
+  * callback chains with more than `callback_limit` (default 5) of the app's
+    own callbacks (Rails' and gems' don't count; controllers per action).
+    Callbacks inherited from `callback_limit_exclude` (default
+    `["ApplicationController"]`: time zone, locale, current user, the
+    per-request basics) don't count either. A base class over the limit is
+    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, when there is one (only the experimental
+    compiling parts use it).
+
+  ```ruby
+  config.rails_minify.callback_limit = 8
+  config.rails_minify.callback_limit_exclude = ["ApplicationController", "Admin::BaseController"] # [] counts everything
+  config.rails_minify.callback_limit_mode = :warn # report, don't fail
+  config.rails_minify.callback_loops = :warn
+  config.rails_minify.allow_callback_loops = ["Trip#recalculate"] # guarded on purpose
+  ```
+
+## 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 | does | gem |
+| part | in production | in 0.2.0 |
 |---|---|---|
-| 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) |
+| 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
+### Patches
 
-For parts of Rails and common gems that redo work on every request.
-`config.rails_minify.patches = [...]` picks them; all by default.
+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.
@@ -84,38 +177,14 @@ For parts of Rails and common gems that redo work on every request.
   installed when OmniAuth already does this itself (it then has a public
   `Strategy#passthrough?`, as in the version proposed upstream).
 
-## Numbers
+### 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.
 
-## 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;
-  * callback chains with more than `callback_limit` (default 5) of the app's
-    own callbacks (Rails' and gems' don't count; controllers per action).
-    Callbacks inherited from `callback_limit_exclude` (default
-    `["ApplicationController"]`: time zone, locale, current user, the
-    per-request basics) don't count either. A base class over the limit is
-    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.
-
-  ```ruby
-  config.rails_minify.callback_limit = 8
-  config.rails_minify.callback_limit_exclude = ["ApplicationController", "Admin::BaseController"] # [] counts everything
-  config.rails_minify.callback_limit_mode = :warn # report, don't fail
-  config.rails_minify.callback_loops = :warn
-  config.rails_minify.allow_callback_loops = ["Trip#recalculate"] # guarded on purpose
-  ```
-
-## Things found that are app config, not patches
+## 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
+    config.before_initialize { |app| Railtie.apply_enabled(app.config) }
 
-      ar = app.config.ar_minimizer
+    # `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 }
@@ -42,6 +44,18 @@ module RailsMinify
       end
     end
 
+    # ZJIT from after boot, as Rails does for YJIT (config.yjit): the code
+    # that only runs while booting (requiring, eager loading, the minimizers'
+    # compiling) isn't compiled. Japan Voyage, per process: 24% fewer
+    # compiled methods, 18 MB less JIT memory, the same speed.
+    initializer "rails_minify.zjit" do |app|
+      config.after_initialize do
+        next unless app.config.rails_minify.zjit && defined?(RubyVM::ZJIT.enable) && !RubyVM::ZJIT.enabled?
+
+        RubyVM::ZJIT.enable
+      end
+    end
+
     rake_tasks do
       namespace :minify do
         prepare = lambda do
@@ -60,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.2"
+  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.2
+  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: []