rails-minify 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e018dfbd1f9df88b770cd083ba94da47867f8199f88fd885d7bff62b2efb592
-  data.tar.gz: 6a0ac44911b837229cd36caa47bc4571dda38296952c33198542f12b79237d66
+  metadata.gz: 0723afe45486f260e81aee94e48c979e29a863991b960203a55397c932871792
+  data.tar.gz: 3bfa12203cc106068fbb22c6d844eff0ed68f564886a74be94953f1e817bebe1
 SHA512:
-  metadata.gz: e10f339acb5fe096a62873b7ffc292a0c5c322854eee25f856ebd09505e812f2d97b18b8427fc7f2ad5249404ec85dc9b7f2576cebcdb32b0b3285e0ba92c90c
-  data.tar.gz: be2ebd0fbfae79dc3f6217d792337261f517c06f882ab506867b262c576eaa1dd17fd313931e8625dfa0ccd2ffabedfc0dcb80659817f0b6ff1d4f7cfc3e6ee6
+  metadata.gz: e000f5a93f901772654e1c4219ea36a171970de119b6f2ada233a614bf198deb66c6e79334016dba7a7be17338d4532dbce711ad2d4538e1f22172e129327767
+  data.tar.gz: '09466303155a247edecff33e03b9b1fc5569abce784b9e95b3f471990b34a56c6ed1e6bd8f5affc8b5bb8030528398dc1e00a97c187932932f3f3092c2545a7e'

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.4.0 (2026-11-05)
+
+- Requires activerecord-minimizer 0.3.
+- Removed `config.rails_minify.enabled` and `config.rails_minify.zjit`. ZJIT after boot is in Rails main as `config.zjit = true` (rails/rails#59183); with enums gone too (activerecord-minimizer removed them: no measured gain in production, and they no longer worked on Rails main), `enabled` only turned on strict mode, so set `config.ar_minimizer.slim = true` instead. Setting either removed option prints a warning saying what to set.
+- `minify:doctor` suggests Rails' `config.zjit = true` for a ZJIT turned on before boot.
+
+## 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").

data/README.md

@@ -1,37 +1,20 @@
 # rails-minify
 
-Fewer generated Active Record methods, ZJIT turned on after boot, and checks
-for callback problems.
+Fewer generated Active Record methods, production profiling and
+configuration checks, and checks for callback problems.
 
 ```ruby
 # Gemfile
 gem "rails-minify"
 
-# config/environments/production.rb
-config.rails_minify.enabled = true
+# config/application.rb
+config.ar_minimizer.slim = true # strict mode
 ```
 
-`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.
-
-```ruby
-# config/environments/test.rb
-config.rails_minify.enabled = true
-
-# config/environments/development.rb
-config.ar_minimizer.slim = true # strict mode, without the rest
-```
+Set strict mode in every environment, so a call to a method it removed fails
+while you work and in CI rather than in production. Everything else is
+[experimental](#experimental) and off unless you set it. Ruby 3.4+, Rails 8.0,
+8.1 and main.
 
 ## Strict mode
 
@@ -54,20 +37,16 @@ instead, generated the first time each is called.
 
 ## 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.
+Rails main has this now: `config.zjit = true`
+([rails/rails#59183](https://github.com/rails/rails/pull/59183)), the ZJIT
+counterpart of `config.yjit`, so rails-minify no longer has its own setting.
+Use it instead of `RUBY_ZJIT_ENABLE=1` or `--zjit`, which turn ZJIT on before
+anything loads, so it also compiles what runs only while booting: RubyGems,
+requiring and eager loading. 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"`. Use Ruby 4.1 or later;
+4.0's ZJIT isn't meant for production. `minify:doctor` reports a JIT turned on
+before boot.
 
 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,
@@ -75,6 +54,31 @@ RSS about 25 MB less, the same CPU time per page.
 
 ## Checks
 
+* `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;
@@ -97,6 +101,83 @@ RSS about 25 MB less, the same CPU time per page.
   config.rails_minify.allow_callback_loops = ["Trip#recalculate"] # guarded on purpose
   ```
 
+## 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
@@ -106,8 +187,8 @@ 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 |
+| 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+); now Rails' `config.zjit` |
+| 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`; removed since (no measured gain, and it broke on Rails main) |
 | 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 |
@@ -117,8 +198,8 @@ without it, under the same traffic (about 5,000 requests per half):
 | 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.
+ZJIT after boot is the one part with a clear effect, and it is in Rails now.
+Japan Voyage runs strict mode and Rails' `config.zjit`.
 
 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
@@ -131,6 +212,57 @@ 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
@@ -186,6 +318,8 @@ 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
   `Time.now` twice per event, Sentry enabled or not. `:monotonic_active_support_logger`

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