rails-minify 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f089252dbde289b9e5cfeb25c2613e91544e92a1235369ec7c4457992e477b
-  data.tar.gz: c768e54a78cd0ee553f8732f019dc4eab9fff3c5c72d4ef9d30d23abc68b2994
+  metadata.gz: c682f7b5f509613697d35d78e163167b825525a03aae99fecb6ab430550f2429
+  data.tar.gz: dd258711680a2472583815a96af871f418d8fac5cf06f323c2dc7f102908e962
 SHA512:
-  metadata.gz: da6b92c40d4f1fada0154fb362cd52c8a56e458b67e5d959e20084bb4e37f25a8be93d7d86bc065d6a71ac09dc4763c79fbada65a4f7a73c281c8b9fef511d1b
-  data.tar.gz: 8cca5d4c9850e66798cdb80127907dbfc64cdf5643d1064a7ce01be6bfdd8f46b79bbf63e9e8c80775dd6c3453d9877537bd6951707cb434378049fdb0a92227
+  metadata.gz: 29a12e198162b3bd148f39d2f7be79e69aa32d471164120d1055a8c2960a97f7afee2a1dd2728b30dfe6e8f2d8f22b528a854420600f3ae1d3e325077265ce60
+  data.tar.gz: c2031ba5b96903be93f11d324afe736b18c476f420467e1a48503b4ac397ee24540812e7173819aa1ff6fd97e5025c7ac865616f7ad15d0db0498de29f2144eb

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.3.0 (2026-11-04)
+
+- `config.rails_minify.sql_profile = 0.01` samples requests and logs each distinct query and call site with its calls, time and rows, plus the request's SQL and instantiation time; `bin/rails minify:sql:report LOG=...` ranks actions and queries by total time, and with `EXPLAIN=1` adds SQLite query plans and flags full table scans and sorts without an index.
+- `config.rails_minify.async_queries = 0.01` samples requests for relations the controller leaves unloaded and the view then loads one after another, and logs one line per request; `bin/rails minify:async:report LOG=...` ranks actions by the estimated saving from starting those relations with `load_async`. `minify:doctor` also reports `load_async` without `config.active_record.async_query_executor`.
+- A/B in production, under the same traffic: `rails-minify-ab COMMAND` runs the server as groups A and B on one port (`SO_REUSEPORT`) with half the workers each when `RAILS_MINIFY_AB` is set; `config.rails_minify.ab` changes group B's configuration; both groups' log lines are tagged; `minify:ab:report` compares the groups from a request log (with B−A and a 95% interval) and `minify:ab:memory` reports their memory from `/proc`.
+- `bin/rails minify:doctor` reports production configuration that costs speed or memory, and never fails: a JIT turned on before boot (or JIT options without `--zjit-disable`/`--yjit-disable`), Falcon without `preload` or Puma with `preload_app! false`, a Falcon preload script without `Process.warmup` on async-service 0.25 and earlier, `WEB_CONCURRENCY` that `falcon.rb` doesn't read, and Sentry breadcrumbs on every notification. It reads the environment from `config/deploy.yml`, the `Dockerfile` and `bin/docker-entrypoint` too.
+
+## 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,33 @@ 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:doctor`: production configuration that costs speed or
+  memory. It only reports, and never fails. Each finding says where it was
+  found, why it matters (with the number from Japan Voyage) and the fix:
+  * a JIT turned on before boot (`RUBY_ZJIT_ENABLE`, `RUBY_YJIT_ENABLE`,
+    `--zjit`/`--yjit` in `RUBYOPT`), or ZJIT/YJIT options without
+    `--zjit-disable`/`--yjit-disable`, which turn it on at startup too;
+  * Falcon with more than one worker and no `preload`, or a
+    `config/preload.rb` it doesn't load; Puma with `workers` and
+    `preload_app! false`;
+  * a Falcon preload script without `Process.warmup`, while async-service
+    (0.25 and earlier) warms the heap up only after forking the workers
+    (socketry/async-service#13);
+  * `WEB_CONCURRENCY` set while `falcon.rb` sets no `count`: Falcon starts
+    one worker per CPU;
+  * Sentry's `breadcrumbs_logger` with `:active_support_logger`;
+  * `load_async` in `app/` without `config.active_record.async_query_executor`:
+    the query then runs in the foreground, as if `load_async` weren't there.
+
+  Doctor usually runs on your machine rather than the server, so it reads the
+  environment from `config/deploy.yml` (Kamal's `env.clear`), the
+  `Dockerfile`'s `ENV` lines and `bin/docker-entrypoint`'s `export`s as well
+  as its own. Run on Japan Voyage's history, it finds the three problems
+  fixed there: ZJIT turned on in the entrypoint, the preload file Falcon
+  didn't load (and `WEB_CONCURRENCY` it didn't read), and the heap warmed up
+  after the fork.
 * `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 +111,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 +122,224 @@ 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
+## Where Active Record time goes
+
+```ruby
+# config/environments/production.rb
+config.rails_minify.sql_profile = 0.01 # 1% of requests; true for all
+```
+
+For each sampled request, one log line per distinct query and call site
+(calls, time, rows, the first line in the app that ran it, the SQL with its
+values taken out) and one with the request's totals, SQL time against the
+time spent turning rows into records. `bin/rails minify:sql:report
+LOG=production.log` ranks actions and queries by total time; with
+`EXPLAIN=1` it loads the app and adds each SELECT's SQLite query plan,
+flagging full table scans and sorts without an index:
+
+```
+ 5.   5.2% of SQL time  TravelDestination Pluck  2.30 ms per call, 1.0 calls per request, 7.2 rows per call
+    SELECT "travel_destinations"."id", ... WHERE "travel_destinations"."published" = TRUE AND "travel_destinations"."latitude" BETWEEN ? AND ? ...
+    at app/models/concerns/nearby_venues.rb:39 (SkiResortsController#show 12x, GolfCoursesController#show 12x)
+    plan: SEARCH travel_destinations USING INDEX index_travel_destinations_on_published (published=?)
+```
+
+Many calls per request from one line is an N+1; a query on every page
+(a layout or footer) is worth caching. A sort without an index only matters
+when the query is slow; on a few rows it isn't. Run EXPLAIN against a
+database with production's schema and, ideally, its data: plans depend on
+both.
+
+## Queries load_async could start
+
+A page's queries usually run one after another, each where the view first
+needs it. But a relation the controller leaves unloaded in an instance
+variable already has its SQL fixed when rendering starts, so all of them
+could start at once with `load_async`, in the background, while the view
+renders. This finds them in production traffic:
+
+```ruby
+# config/environments/production.rb
+config.rails_minify.async_queries = 0.01 # 1% of requests; true for all
+```
+
+For each sampled request with such relations, one log line records which
+the view loaded, how long each main query took and how far into rendering
+it was first needed:
+
+```
+[rails-minify] load_async SpotsController#index sql=28.0 @spots=Spot:11.0@2.0 @areas=Area:4.0@14.0 @news=Article:-
+```
+
+`bin/rails minify:async:report LOG=production.log` adds them up per action,
+with the estimated saving:
+
+```
+SpotsController#index  n 2  saving mean 8.0 ms, p90 10.0 ms (foreground SQL mean 26.5 ms)
+  @spots                Spot                 loaded in 100%  query  10.0 ms  first used   1.5 ms into rendering
+  @areas                Area                 loaded in 100%  query   3.5 ms  first used  13.0 ms into rendering
+  @news                 Article              loaded in  50%  query   6.0 ms  first used  20.0 ms into rendering
+```
+
+The fix is `@spots = Spot.where(...).load_async` in the controller. The
+estimate assumes the database answers as fast in parallel; check the change
+with the [A/B](#ab-in-production) before keeping it. `load_async` needs
+`config.active_record.async_query_executor = :global_thread_pool` and a
+database pool big enough for it (`minify:doctor` reports a missing
+executor). Not counted: preloads (`includes`), which still run in the
+foreground when the relation is used; relations the view only counts
+(`size`, `any?`); and association proxies (`@user.posts`). A relation loaded
+in only some requests costs a query nobody reads in the others.
+
+Not for SQLite: the sqlite3 gem (2.10) holds the GVL while a query runs,
+so a query in the background stops the view rendering in the foreground and
+nothing overlaps (a 415 ms query and 136 ms of Ruby: 526 ms in two threads,
+551 ms one after the other). It needs a database the process waits on over
+a socket (PostgreSQL, MySQL).
+
+No production result yet.
+
+## 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.
+
+## A/B in production
+
+How the numbers above were measured, packaged: the server runs twice on one
+port, half the workers each, as groups A and B. The kernel spreads
+connections over both (`SO_REUSEPORT`), so the groups see the same traffic,
+and group B runs with one change. Comparing an hour before with an hour after
+mixes the change up with the traffic; this doesn't.
+
+```ruby
+# config/environments/production.rb: group B's change (any configuration)
+config.rails_minify.ab = ->(config) { config.ar_minimizer.small_records = true }
+```
+
+```ruby
+# config/falcon.rb: both groups bind the port, and count follows WEB_CONCURRENCY
+service ["myapp", ENV["RAILS_MINIFY_GROUP"]].compact.join("-") do
+  include Falcon::Environment::Rack
+  preload "config/preload.rb"
+  count ENV.fetch("WEB_CONCURRENCY", Etc.nprocessors).to_i
+  endpoint do
+    Async::HTTP::Endpoint.parse("http://0.0.0.0:3000")
+      .with(protocol: Async::HTTP::Protocol::HTTP11, reuse_port: true)
+  end
+end
+```
+
+```dockerfile
+CMD ["bundle", "exec", "rails-minify-ab", "falcon", "host", "config/falcon.rb"]
+```
+
+* `rails-minify-ab COMMAND` runs the command as it is. With
+  `RAILS_MINIFY_AB=1` it runs it twice instead, with `RAILS_MINIFY_GROUP=A`
+  and `=B` and `WEB_CONCURRENCY` split in half. It stops both on TERM/INT,
+  exiting 0 for a clean stop, and stops the other when one exits.
+* Each group's log lines get a tag, after the request id (which is added if
+  `config.log_tags` doesn't have it): `[<request id>] [minify:B] ...`.
+* `bin/rails minify:ab:report LOG=file` (or `LOG=-` for stdin) compares the
+  groups: requests and 5xx, latency p50/p90/p99 and mean, view, Active Record
+  and GC time, for all requests, HTML and the busiest actions, with B−A and a
+  95% interval. For example,
+  `bin/kamal app logs --since 60m --skip-timestamps | bin/rails minify:ab:report LOG=-`.
+* `bin/rails minify:ab:memory`, where the server runs
+  (`bin/kamal app exec --reuse 'bin/rails minify:ab:memory'`): RSS, PSS and
+  private memory per process and PSS per group, from `/proc`.
+* `RailsMinify::AB.group` is the process's group (nil outside an A/B run),
+  for changes that aren't configuration.
+
+Tried with Falcon only so far; Puma would need each cluster to bind with
+`SO_REUSEPORT`. An hour shows a large difference; run another before believing a small
+one.
+
+## 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
+
+`minify:doctor` checks for these.
 
 * sentry-rails' `breadcrumbs_logger = [:active_support_logger]` subscribes to
   every notification (each SQL query, render, instantiation) and takes

data/exe/rails-minify-ab

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# rails-minify-ab COMMAND...
+#
+# Runs COMMAND (the server, e.g. `bundle exec falcon host config/falcon.rb`).
+# With RAILS_MINIFY_AB set, runs it twice instead, as groups A and B:
+# RAILS_MINIFY_GROUP=A and =B, WEB_CONCURRENCY split in half. Both bind the
+# same port, so the server has to set SO_REUSEPORT (Falcon: an endpoint
+# `.with(reuse_port: true)`); the kernel then spreads connections over both,
+# and the groups see the same traffic. Stops both when told to (TERM, INT)
+# or when either exits.
+
+require "etc"
+
+abort "usage: rails-minify-ab COMMAND..." if ARGV.empty?
+exec(*ARGV) if ENV["RAILS_MINIFY_AB"].to_s.empty?
+
+workers = Integer(ENV.fetch("WEB_CONCURRENCY", Etc.nprocessors))
+half = workers / 2
+abort "rails-minify-ab: WEB_CONCURRENCY=#{workers}, needs at least 2 for two groups" if half.zero?
+
+pids = { "A" => half, "B" => workers - half }.to_h do |group, count|
+  [Process.spawn({ "RAILS_MINIFY_GROUP" => group, "WEB_CONCURRENCY" => count.to_s }, *ARGV), group]
+end
+
+stopping = false
+%w[TERM INT].each do |signal|
+  Signal.trap(signal) do
+    stopping = true
+    pids.each_key { Process.kill(signal, it) rescue nil }
+  end
+end
+
+# The first to exit, then the other: told to stop, exit with their own
+# status (0 for a clean stop); one exited by itself is never a clean stop.
+statuses = {}
+pid, status = Process.wait2
+statuses[pid] = status
+(pids.keys - [pid]).each do |other|
+  Process.kill("TERM", other)
+rescue Errno::ESRCH
+end
+(pids.keys - [pid]).each do |other|
+  statuses[other] = Process.wait2(other).last
+rescue Errno::ECHILD
+end
+
+codes = statuses.values.compact.map { it.exitstatus || 128 + it.termsig.to_i }
+if stopping
+  exit codes.find(&:nonzero?) || 0
+else
+  first = status.exitstatus || 128 + status.termsig.to_i
+  warn "rails-minify-ab: group #{pids[pid]} exited (#{first}), stopped the other"
+  exit first.zero? ? 1 : first
+end

data/lib/rails_minify/ab.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RailsMinify
+  # Compares a change against the app without it, under the same traffic: the
+  # server runs twice on one port (SO_REUSEPORT), half the workers each, as
+  # groups A and B (exe/rails-minify-ab). RAILS_MINIFY_GROUP tells a process
+  # its group, config.rails_minify.ab changes group B's configuration, and a
+  # log tag per group lets AB::Report compare them. One hour is enough to see
+  # a large difference, not to rule one out: run it again before believing a
+  # small one.
+  module AB
+    GROUPS = %w[A B].freeze
+
+    def self.group
+      group = ENV["RAILS_MINIFY_GROUP"].to_s.upcase
+      group if GROUPS.include?(group)
+    end
+
+    def self.log_tag(group = self.group) = "minify:#{group}"
+
+    # Request log lines, as Rails writes them with config.log_tags, from any
+    # log the tags survive in (kamal app logs, docker logs, a log file).
+    class Report
+      Request = Data.define(:group, :action, :status, :total, :views, :db, :gc)
+
+      TAGS = /((?:\[[^\]]*\] )+)/
+      PROCESSING = /#{TAGS}Processing by (\S+) as (\S+)/
+      COMPLETED = /#{TAGS}Completed (\d{3}) .*? in (\d+)ms(?: \((.*)\))?/
+
+      attr_reader :requests
+
+      def initialize(lines)
+        actions = {}
+        @requests = []
+        lines.each do |line|
+          line = line.scrub
+          if (m = PROCESSING.match(line))
+            group, key = tags(m[1])
+            actions[key] = "#{m[2]} #{m[3]}" if group
+          elsif (m = COMPLETED.match(line))
+            group, key = tags(m[1])
+            next unless group
+
+            details = m[4].to_s
+            ms = ->(name) { details[/#{name}: ([\d.]+)ms/, 1].to_f }
+            @requests << Request.new(group, actions.delete(key) || "?", m[2].to_i, m[3].to_i,
+              ms.("Views"), ms.("ActiveRecord"), ms.("GC"))
+          end
+        end
+      end
+
+      def report(io = $stdout, actions: 10)
+        ok = @requests.select { it.status < 400 }
+        io.puts "requests: #{GROUPS.map { |g| "#{g} #{@requests.count { it.group == g }}" }.join(", ")}; " \
+                "5xx: #{GROUPS.map { |g| "#{g} #{@requests.count { it.group == g && it.status >= 500 }}" }.join(", ")}"
+        if @requests.empty?
+          io.puts "no tagged requests: is the log from processes started by rails-minify-ab, with RAILS_MINIFY_AB set?"
+          return
+        end
+
+        io.puts
+        section(io, "all", ok)
+        section(io, "html", ok.select { it.action.end_with?(" HTML") })
+        by_action = ok.select { it.action.end_with?(" HTML") }.group_by(&:action)
+        by_action.max_by(actions) { |_, rs| rs.size }.each { |action, rs| section(io, action, rs) }
+        io.puts
+        io.puts "B-A: difference of the means with a 95% interval. An interval that includes 0 is no difference " \
+                "this window can show; one that doesn't is worth another window (requests aren't independent, " \
+                "so the interval is optimistic)."
+      end
+
+      private
+
+      def tags(text)
+        list = text.scan(/\[([^\]]*)\]/).flatten
+        group = list.find { it.start_with?("minify:") }&.delete_prefix("minify:")
+        [group, (list - ["minify:#{group}"]).join(" ")] if GROUPS.include?(group)
+      end
+
+      def section(io, title, requests)
+        a, b = GROUPS.map { |g| requests.select { it.group == g } }
+        io.puts title
+        { "A" => a, "B" => b }.each { |g, rs| io.puts "  #{g}: #{summary(rs)}" }
+        io.puts "  B-A: #{difference(a, b)}" unless a.empty? || b.empty?
+      end
+
+      def summary(rs)
+        return "-" if rs.empty?
+
+        t = rs.map(&:total)
+        format("n %5d  p50 %4d  p90 %4d  p99 %4d  mean %6.1f  views %5.1f  AR %5.1f  GC %4.2f ms",
+          t.size, pct(t, 50), pct(t, 90), pct(t, 99), mean(t), mean(rs.map(&:views)), mean(rs.map(&:db)), mean(rs.map(&:gc)))
+      end
+
+      def difference(a, b)
+        %i[total views db gc].map do |field|
+          x, y = a.map(&field), b.map(&field)
+          d = mean(y) - mean(x)
+          half = 1.96 * Math.sqrt(variance(x) / x.size + variance(y) / y.size)
+          label = { total: "mean", views: "views", db: "AR", gc: "GC" }[field]
+          format("%s %+.1f (%+.1f..%+.1f)", label, d, d - half, d + half)
+        end.join("  ")
+      end
+
+      def pct(xs, p)
+        xs = xs.sort
+        xs[[xs.size - 1, ((p / 100.0) * (xs.size - 1)).round].min]
+      end
+
+      def mean(xs) = xs.empty? ? 0.0 : xs.sum.to_f / xs.size
+
+      def variance(xs)
+        return 0.0 if xs.size < 2
+
+        m = mean(xs)
+        xs.sum { (it - m)**2 } / (xs.size - 1)
+      end
+    end
+
+    # Memory of the processes in each group, from /proc (Linux; run it where
+    # the server runs, e.g. bin/kamal app exec). PSS counts pages shared with
+    # other processes (the preloaded parent's) in part, so the groups' totals
+    # compare what each costs.
+    module Memory
+      Entry = Data.define(:pid, :group, :title, :rss, :pss, :private_dirty)
+
+      def self.processes(proc_dir = "/proc")
+        Dir["#{proc_dir}/[0-9]*"].filter_map do |dir|
+          environ = File.binread("#{dir}/environ") rescue next
+          group = environ.split("\0").find { it.start_with?("RAILS_MINIFY_GROUP=") }&.delete_prefix("RAILS_MINIFY_GROUP=")
+          next unless GROUPS.include?(group)
+
+          rollup = File.read("#{dir}/smaps_rollup") rescue next
+          kb = ->(name) { rollup[/^#{name}:\s+(\d+) kB/, 1].to_i }
+          title = (File.binread("#{dir}/cmdline").tr("\0", " ").strip rescue "")
+          Entry.new(File.basename(dir).to_i, group, title, kb.("Rss"), kb.("Pss"), kb.("Private_Dirty"))
+        end.sort_by { [it.group, it.pid] }
+      end
+
+      def self.report(io = $stdout, proc_dir: "/proc")
+        list = processes(proc_dir)
+        if list.empty?
+          io.puts "no processes with RAILS_MINIFY_GROUP in #{proc_dir}: run this where the server runs, with RAILS_MINIFY_AB set"
+          return
+        end
+
+        list.each do |p|
+          io.puts format("%-2s %7d  rss %5d  pss %5d  private %5d MB  %s", p.group, p.pid, p.rss / 1024, p.pss / 1024, p.private_dirty / 1024, p.title[0, 50])
+        end
+        io.puts GROUPS.map { |g| "#{g}: PSS #{list.select { it.group == g }.sum(&:pss) / 1024} MB" }.join(", ")
+      end
+    end
+  end
+end