rails-minify 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e018dfbd1f9df88b770cd083ba94da47867f8199f88fd885d7bff62b2efb592
-  data.tar.gz: 6a0ac44911b837229cd36caa47bc4571dda38296952c33198542f12b79237d66
+  metadata.gz: c682f7b5f509613697d35d78e163167b825525a03aae99fecb6ab430550f2429
+  data.tar.gz: dd258711680a2472583815a96af871f418d8fac5cf06f323c2dc7f102908e962
 SHA512:
-  metadata.gz: e10f339acb5fe096a62873b7ffc292a0c5c322854eee25f856ebd09505e812f2d97b18b8427fc7f2ad5249404ec85dc9b7f2576cebcdb32b0b3285e0ba92c90c
-  data.tar.gz: be2ebd0fbfae79dc3f6217d792337261f517c06f882ab506867b262c576eaa1dd17fd313931e8625dfa0ccd2ffabedfc0dcb80659817f0b6ff1d4f7cfc3e6ee6
+  metadata.gz: 29a12e198162b3bd148f39d2f7be79e69aa32d471164120d1055a8c2960a97f7afee2a1dd2728b30dfe6e8f2d8f22b528a854420600f3ae1d3e325077265ce60
+  data.tar.gz: c2031ba5b96903be93f11d324afe736b18c476f420467e1a48503b4ac397ee24540812e7173819aa1ff6fd97e5025c7ac865616f7ad15d0db0498de29f2144eb

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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").

data/README.md

@@ -75,6 +75,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 +122,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
@@ -131,6 +233,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 +339,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

data/lib/rails_minify/async_queries.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module RailsMinify
+  # Finds queries a page could run with load_async, from production traffic
+  # (config.rails_minify.async_queries = 0.01 samples 1% of requests).
+  #
+  # When a controller renders, every relation it left in an instance variable
+  # unloaded already has its SQL fixed: nothing the view does can change it.
+  # So all of them can start at once, in the background, while the view
+  # renders, instead of one after another where the view first uses each.
+  # For each sampled request that has such relations, one log line records
+  # which the view loaded, the time its main query took and when the view
+  # first needed it; bin/rails minify:async:report LOG=... adds the lines up
+  # and estimates what load_async would save per action.
+  #
+  # Only main queries move to the background: a relation's preloads
+  # (includes/preload) still run in the foreground when it's used, so they
+  # aren't counted. Relations the view counts (size, any?) without loading
+  # aren't candidates. Association proxies (@user.posts) aren't either.
+  module AsyncQueries
+    TAG = "[rails-minify] load_async"
+
+    class << self
+      attr_reader :rate, :logger
+
+      # rate: true or 1.0 for every request, a Float for a share of them,
+      # nil/false to stop.
+      def install!(rate:, logger: nil)
+        @rate = rate == true ? 1.0 : rate
+        @logger = logger
+        return if @installed
+
+        @installed = true
+        ActiveSupport.on_load(:action_controller_base) { prepend ControllerHook }
+        ActiveSupport.on_load(:active_record) { ActiveRecord::Relation.prepend RelationHook }
+        ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |_, start, finish, _, payload|
+          current&.sql((finish - start) * 1000.0, payload)
+        end
+      end
+
+      def current = ActiveSupport::IsolatedExecutionState[:rails_minify_async_queries]
+
+      def sample? = rate && (rate >= 1.0 || rand < rate)
+
+      def track(action)
+        request = Request.new(action)
+        ActiveSupport::IsolatedExecutionState[:rails_minify_async_queries] = request
+        yield
+      ensure
+        ActiveSupport::IsolatedExecutionState[:rails_minify_async_queries] = nil
+        line = request&.log_line
+        (logger || ActiveRecord::Base.logger)&.info(line) if line
+      end
+    end
+
+    Candidate = Struct.new(:name, :relation, :model, :query_ms, :offset_ms)
+
+    # One sampled request.
+    class Request
+      attr_reader :action, :candidates, :sql_ms
+
+      def initialize(action)
+        @action = action
+        @candidates = []
+        @sql_ms = 0.0
+      end
+
+      # The controller's assigns, as the view gets them.
+      def rendering(assigns)
+        return if @render_start
+
+        @render_start = now
+        assigns.each do |name, value|
+          next unless value.is_a?(ActiveRecord::Relation) && !value.loaded?
+          next if value.is_a?(ActiveRecord::Associations::CollectionProxy)
+
+          @candidates << Candidate.new(name, value, value.model.name)
+        end
+      end
+
+      def loading(relation)
+        candidate = @candidates.find { it.relation.equal?(relation) } if @render_start && !@measuring
+        return yield unless candidate && !candidate.query_ms
+
+        offset = now - @render_start
+        @measuring = []
+        begin
+          yield
+        ensure
+          candidate.query_ms = @measuring.first || 0.0
+          candidate.offset_ms = offset
+          @measuring = nil
+        end
+      end
+
+      def sql(ms, payload)
+        return if payload[:cached] || payload[:name] == "SCHEMA" || payload[:async]
+
+        @sql_ms += ms
+        @measuring&.<<(ms)
+      end
+
+      def log_line
+        return if @candidates.empty?
+
+        list = @candidates.map do |c|
+          c.query_ms ? format("@%s=%s:%.1f@%.1f", c.name, c.model, c.query_ms, c.offset_ms) : "@#{c.name}=#{c.model}:-"
+        end
+        format("%s %s sql=%.1f %s", TAG, action, @sql_ms, list.join(" "))
+      end
+
+      private
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0
+    end
+
+    module ControllerHook
+      def process_action(...)
+        return super unless AsyncQueries.sample?
+
+        AsyncQueries.track("#{self.class.name}##{action_name}") { super }
+      end
+
+      def view_assigns
+        assigns = super
+        AsyncQueries.current&.rendering(assigns)
+        assigns
+      end
+    end
+
+    module RelationHook
+      def load(&)
+        request = AsyncQueries.current
+        return super unless request && !loaded?
+
+        request.loading(self) { super }
+      end
+    end
+
+    # Adds up the log lines from sampled requests.
+    class Report
+      Seen = Data.define(:name, :model, :query_ms, :offset_ms) do
+        def loaded? = !query_ms.nil?
+      end
+      Sample = Data.define(:action, :sql_ms, :seen) do
+        # Milliseconds the request would have saved with every loaded
+        # candidate started when rendering began: in the order the view used
+        # them, each one waits only for what's left of its query.
+        def saving
+          saved = 0.0
+          seen.select(&:loaded?).sort_by(&:offset_ms).each do |c|
+            wait = [c.query_ms - (c.offset_ms - saved), 0.0].max
+            saved += c.query_ms - wait
+          end
+          saved
+        end
+      end
+
+      LINE = /#{Regexp.escape(TAG)} (\S+) sql=([\d.]+) (.+)$/
+      ITEM = /\A@(\w+)=([\w:]+):(?:-|([\d.]+)@([\d.]+))\z/
+
+      attr_reader :samples
+
+      def initialize(lines)
+        @samples = lines.filter_map do |line|
+          m = LINE.match(line.scrub) or next
+          seen = m[3].split.filter_map do |item|
+            i = ITEM.match(item) or next
+            Seen.new(i[1], i[2], i[3]&.to_f, i[4]&.to_f)
+          end
+          Sample.new(m[1], m[2].to_f, seen)
+        end
+      end
+
+      def report(io = $stdout, actions: 10)
+        if @samples.empty?
+          io.puts "no #{TAG} lines: set config.rails_minify.async_queries (e.g. 0.01) and collect the production log"
+          return
+        end
+
+        io.puts "#{@samples.size} sampled requests with relations left unloaded for the view"
+        by_action = @samples.group_by(&:action)
+        ranked = by_action.max_by(actions) { |_, ss| ss.sum(&:saving) }
+        ranked.each do |action, ss|
+          savings = ss.map(&:saving)
+          io.puts
+          io.puts format("%s  n %d  saving mean %.1f ms, p90 %.1f ms (foreground SQL mean %.1f ms)",
+            action, ss.size, mean(savings), pct(savings, 90), mean(ss.map(&:sql_ms)))
+          ss.flat_map(&:seen).group_by(&:name).each do |name, cs|
+            loaded = cs.select(&:loaded?)
+            share = loaded.size * 100.0 / cs.size
+            detail = if loaded.empty?
+              "never loaded in the view"
+            else
+              format("loaded in %3.0f%%  query %5.1f ms  first used %5.1f ms into rendering",
+                share, mean(loaded.map(&:query_ms)), mean(loaded.map(&:offset_ms)))
+            end
+            io.puts format("  @%-20s %-20s %s", name, cs.first.model, detail)
+          end
+        end
+        io.puts
+        io.puts "Saving: with each loaded relation's main query started with load_async in the controller, as an " \
+                "estimate that assumes the database answers as fast in parallel. Worth it where it's a few ms or more " \
+                "and the relation is loaded in most requests (otherwise load_async runs a query nobody reads). " \
+                "load_async needs config.active_record.async_query_executor; check the result with minify:ab:report."
+      end
+
+      private
+
+      def mean(xs) = xs.empty? ? 0.0 : xs.sum / xs.size
+
+      def pct(xs, p)
+        xs = xs.sort
+        xs[[xs.size - 1, ((p / 100.0) * (xs.size - 1)).round].min]
+      end
+    end
+  end
+end

data/lib/rails_minify/doctor.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "erb"
+require "pathname"
+require "shellwords"
+require "yaml"
+
+module RailsMinify
+  # Production configuration that costs speed or memory, found by reading
+  # the app's files and environment (bin/rails minify:doctor). It only
+  # reports: nothing here fails a build.
+  #
+  # The environment is read from this process, config/deploy.yml (Kamal's
+  # env.clear, top level and per role), the Dockerfile's ENV lines and
+  # bin/docker-entrypoint's exports, since
+  # doctor usually runs somewhere other than the server.
+  class Doctor
+    Finding = Data.define(:check, :found, :why, :fix) do
+      def to_s = "#{found}\n   Why: #{why}\n   Fix: #{fix}"
+    end
+
+    CHECKS = %i[jit_before_boot jit_options falcon_preload puma_preload heap_warmup worker_count sentry_breadcrumbs load_async_executor].freeze
+    ENV_KEYS = %w[RUBYOPT RUBY_YJIT_ENABLE RUBY_ZJIT_ENABLE WEB_CONCURRENCY].freeze
+
+    # jit_at_boot: the JITs already on when rails-minify was required, before
+    # Rails configured anything (RailsMinify.jit_at_boot).
+    # gems: name => version of the bundled gems.
+    # sentry_breadcrumbs: Sentry's configured breadcrumbs_logger, if Sentry is set up.
+    # async_executor: ActiveRecord.async_query_executor (:global_thread_pool, ...); false when unknown.
+    def initialize(root:, env: ENV, jit_at_boot: [], gems: {}, sentry_breadcrumbs: nil, async_executor: false)
+      @root = Pathname(root)
+      @env = env
+      @jit_at_boot = jit_at_boot
+      @gems = gems
+      @sentry_breadcrumbs = sentry_breadcrumbs
+      @async_executor = async_executor
+    end
+
+    def findings = CHECKS.flat_map { Array(send(it)) }
+
+    def report(io = $stdout)
+      found = findings
+      io.puts "minify:doctor: #{CHECKS.size} checks, #{found.empty? ? "nothing found" : "#{found.size} found"}"
+      found.each.with_index(1) { |finding, i| io.puts "\n#{i}. #{finding}" }
+      found
+    end
+
+    # [label, {key => value}] for each place the environment is set.
+    def env_sources
+      @env_sources ||= [
+        ["this process", @env.to_h.slice(*ENV_KEYS)],
+        ["config/deploy.yml", deploy_env],
+        ["Dockerfile", dockerfile_env],
+        ["bin/docker-entrypoint", entrypoint_env],
+      ].reject { |_, values| values.empty? }
+    end
+
+    private
+
+    JIT_NAMES = { "yjit" => "YJIT", "zjit" => "ZJIT" }.freeze
+    WHY_BOOT = "a JIT turned on at startup also compiles what only runs while booting " \
+      "(RubyGems, requiring, eager loading). On Japan Voyage, ZJIT turned on after boot " \
+      "compiled 12,612 → 9,557 methods and used about 25 MB less memory per process, at the same speed."
+
+    def jit_before_boot
+      found = env_sources.flat_map do |label, values|
+        names = []
+        names << "RUBY_YJIT_ENABLE=#{values["RUBY_YJIT_ENABLE"]}" if truthy?(values["RUBY_YJIT_ENABLE"])
+        names << "RUBY_ZJIT_ENABLE=#{values["RUBY_ZJIT_ENABLE"]}" if truthy?(values["RUBY_ZJIT_ENABLE"])
+        names += rubyopt(values).grep(/\A--(yjit|zjit|jit)\z/)
+        names.map { "#{it} (#{label})" }
+      end
+      found += @jit_at_boot.map { "#{JIT_NAMES.fetch(it.to_s, it.to_s)} was already on when Rails loaded (this process)" }
+      return if found.empty?
+
+      Finding.new(:jit_before_boot, "JIT turned on before boot: #{found.join(", ")}", WHY_BOOT,
+        "drop it and turn the JIT on after boot: config.yjit = true for YJIT, " \
+        "config.rails_minify.zjit = true for ZJIT.")
+    end
+
+    def jit_options
+      env_sources.filter_map do |label, values|
+        tokens = rubyopt(values)
+        JIT_NAMES.filter_map do |jit, name|
+          options = tokens.grep(/\A--#{jit}-/) - ["--#{jit}-disable"]
+          next if options.empty? || tokens.include?("--#{jit}-disable") || tokens.include?("--#{jit}")
+
+          Finding.new(:jit_options, "#{name} options without --#{jit}-disable: RUBYOPT=#{values["RUBYOPT"]} (#{label})",
+            "any --#{jit}-* option turns #{name} on at startup, before boot. #{WHY_BOOT}",
+            "put --#{jit}-disable before them (RUBYOPT=\"--#{jit}-disable #{options.join(" ")}\"); " \
+            "they still apply when #{name} is turned on after boot.")
+        end
+      end.flatten
+    end
+
+    def falcon_preload
+      return unless falcon_config && falcon_count != 1 && !falcon_config[/^\s*preload\b/]
+
+      preload = %w[config/preload.rb preload.rb].find { @root.join(it).exist? }
+      found = preload ? "#{preload} exists, but #{falcon_path} doesn't preload it" : "#{falcon_path} doesn't preload the app"
+      Finding.new(:falcon_preload, found,
+        "without preload every worker boots the app and holds its own copy; preloaded, the workers " \
+        "share the parent's memory. On Japan Voyage, preloading with the heap warmed up, ZJIT " \
+        "after boot and one query fix together took HTML p50 from 75 to 45 ms.",
+        "add `preload \"config/preload.rb\"` to the service in #{falcon_path}, with that file requiring " \
+        "config/environment and calling Process.warmup.")
+    end
+
+    def puma_preload
+      config = read("config/puma.rb") or return
+      return unless config[/^\s*workers\b/] && config[/^\s*preload_app!\s*\(?\s*false/]
+
+      Finding.new(:puma_preload, "config/puma.rb has workers and preload_app! false",
+        "every worker boots the app and holds its own copy instead of sharing the parent's.",
+        "remove preload_app! false (Puma preloads by default with more than one worker).")
+    end
+
+    def heap_warmup
+      return unless falcon_config
+      return unless (version = @gems["async-service"]) && Gem::Version.new(version) <= Gem::Version.new("0.25.0")
+
+      path = falcon_config[/^\s*preload\s*\(?\s*["']([^"']+)["']/, 1] or return
+      script = read(path) or return
+      return if script.include?("Process.warmup")
+
+      Finding.new(:heap_warmup, "#{path} doesn't call Process.warmup (async-service #{version})",
+        "async-service #{version} warms the heap up after forking the workers " \
+        "(socketry/async-service#13), so each worker compacts its own copy and loses copy-on-write sharing.",
+        "end #{path} with Process.warmup, after requiring config/environment.")
+    end
+
+    def worker_count
+      return unless falcon_config && !falcon_config[/^\s*count\b/]
+
+      set = env_sources.filter_map { |label, values| "WEB_CONCURRENCY=#{values["WEB_CONCURRENCY"]} (#{label})" if values["WEB_CONCURRENCY"] }
+      return if set.empty?
+
+      Finding.new(:worker_count, "#{falcon_path} sets no count, but #{set.join(", ")}",
+        "Falcon doesn't read WEB_CONCURRENCY: it starts one worker per CPU.",
+        "add `count ENV.fetch(\"WEB_CONCURRENCY\", Etc.nprocessors).to_i` to the service.")
+    end
+
+    def sentry_breadcrumbs
+      loggers = Array(@sentry_breadcrumbs).map(&:to_sym)
+      configured = loggers.include?(:active_support_logger) ? "config.breadcrumbs_logger" : nil
+      configured ||= Dir[@root.join("config/initializers/*.rb").to_s].sort.find do |file|
+        File.read(file).match?(/breadcrumbs_logger\s*=.*[:"']active_support_logger\b/)
+      end&.then { Pathname(it).relative_path_from(@root).to_s }
+      return unless configured
+
+      Finding.new(:sentry_breadcrumbs, "Sentry breadcrumbs_logger includes :active_support_logger (#{configured})",
+        "it subscribes to every notification (each SQL query, render, instantiation) and reads the clock " \
+        "twice per event, whether Sentry is sending anything or not.",
+        "use :monotonic_active_support_logger (no clock calls), or drop it if you don't read those breadcrumbs.")
+    end
+
+    def load_async_executor
+      return unless @async_executor.nil?
+
+      file = Dir[@root.join("app/**/*.rb").to_s].sort.find { File.read(it).include?("load_async") } or return
+      Finding.new(:load_async_executor, "#{Pathname(file).relative_path_from(@root)} calls load_async, " \
+        "but config.active_record.async_query_executor isn't set",
+        "without an executor load_async runs the query in the foreground, where it is, as if it weren't there.",
+        "set config.active_record.async_query_executor = :global_thread_pool, and make the database pool " \
+        "big enough for the requests plus global_executor_concurrency (default 4).")
+    end
+
+    def falcon_path = %w[falcon.rb config/falcon.rb].find { @root.join(it).exist? }
+    def falcon_config = (@falcon_config ||= [falcon_path && read(falcon_path)]).first
+
+    # nil when it can't be told from the file.
+    def falcon_count
+      value = falcon_config[/^\s*count\s*\(?\s*(\d+)\s*\)?\s*$/, 1]
+      value&.to_i
+    end
+
+    def read(path)
+      file = @root.join(path)
+      file.read if file.file?
+    end
+
+    def rubyopt(values) = values["RUBYOPT"].to_s.split
+    def truthy?(value) = value && !%w[0 false no].include?(value.to_s.strip.downcase) && !value.to_s.strip.empty?
+
+    def deploy_env
+      text = read("config/deploy.yml") or return {}
+      config = YAML.safe_load(ERB.new(text).result, aliases: true)
+      return {} unless config.is_a?(Hash)
+
+      roles = config["servers"].is_a?(Hash) ? config["servers"].values.grep(Hash) : []
+      [config, *roles].each_with_object({}) do |section, env|
+        clear = section.dig("env", "clear") if section["env"].is_a?(Hash)
+        env.merge!(clear.transform_values(&:to_s).slice(*ENV_KEYS)) if clear.is_a?(Hash)
+      end
+    rescue StandardError, SyntaxError
+      {}
+    end
+
+    def entrypoint_env
+      text = read("bin/docker-entrypoint") or return {}
+      text.scan(/^\s*export\s+(\w+)=(.*)$/).each_with_object({}) do |(key, value), env|
+        env[key] = (Shellwords.split(value).first.to_s rescue value) if ENV_KEYS.include?(key)
+      end
+    end
+
+    def dockerfile_env
+      text = read("Dockerfile") or return {}
+      text.gsub(/\\\r?\n/, " ").lines.each_with_object({}) do |line, env|
+        next unless (args = line[/\A\s*ENV\s+(.*)/i, 1])
+
+        words = Shellwords.split(args) rescue next
+        if words.first&.include?("=")
+          words.each { |word| key, value = word.split("=", 2); env[key] = value.to_s if ENV_KEYS.include?(key) }
+        elsif ENV_KEYS.include?(words.first)
+          env[words.first] = words.drop(1).join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/rails_minify/railtie.rb

@@ -6,7 +6,22 @@ module RailsMinify
 
     # After config/environments/*.rb, before any initializer reads the
     # minimizers' options.
-    config.before_initialize { |app| Railtie.apply_enabled(app.config) }
+    config.before_initialize do |app|
+      Railtie.apply_ab(app.config)
+      Railtie.apply_enabled(app.config)
+    end
+
+    # In an A/B run (rails-minify-ab), group B gets config.rails_minify.ab
+    # (called with the app's config) and both groups a log tag, after the
+    # request id, which minify:ab:report reads.
+    def self.apply_ab(config, group: AB.group)
+      return unless group
+
+      config.rails_minify.ab&.call(config) if group == "B"
+      tags = Array(config.log_tags)
+      tags = [:request_id, *tags] unless tags.include?(:request_id)
+      config.log_tags = [*tags, AB.log_tag(group)]
+    end
 
     # `enabled` turns on what made no page slower in production and is worth
     # having for its own sake: strict mode (fewer generated methods, production
@@ -44,6 +59,19 @@ module RailsMinify
       end
     end
 
+    # Sampled: which relations the views load that load_async could start
+    # in the controller (RailsMinify::AsyncQueries).
+    initializer "rails_minify.async_queries" do |app|
+      rate = app.config.rails_minify.async_queries
+      AsyncQueries.install!(rate: rate) if rate
+    end
+
+    # Sampled: each query's time, rows and call site (RailsMinify::SqlProfile).
+    initializer "rails_minify.sql_profile" do |app|
+      rate = app.config.rails_minify.sql_profile
+      SqlProfile.install!(rate: rate) if rate
+    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
@@ -85,6 +113,56 @@ module RailsMinify
           end
         end
 
+        namespace :ab do
+          desc "Compare groups A and B in a request log from an A/B run (LOG=file, - for stdin; ACTIONS=10)"
+          task :report do
+            path = ENV.fetch("LOG") { abort "LOG=path/to/log (or LOG=- for stdin)" }
+            lines = path == "-" ? $stdin.each_line : File.foreach(path)
+            RailsMinify::AB::Report.new(lines).report(actions: Integer(ENV.fetch("ACTIONS", "10")))
+          end
+
+          desc "Memory (RSS, PSS) of each A/B group's processes, from /proc; run where the server runs"
+          task :memory do
+            RailsMinify::AB::Memory.report
+          end
+        end
+
+        namespace :sql do
+          desc "Queries ranked by total time, from a log with config.rails_minify.sql_profile set " \
+               "(LOG=file, - for stdin; QUERIES=20, ACTIONS=10; EXPLAIN=1 adds SQLite query plans)"
+          task :report do
+            path = ENV.fetch("LOG") { abort "LOG=path/to/log (or LOG=- for stdin)" }
+            explain = nil
+            if ENV["EXPLAIN"] == "1"
+              Rake::Task[:environment].invoke
+              explain = RailsMinify::SqlProfile::Report.sqlite_explainer
+            end
+            lines = path == "-" ? $stdin.each_line : File.foreach(path)
+            RailsMinify::SqlProfile::Report.new(lines).report(queries: Integer(ENV.fetch("QUERIES", "20")),
+              actions: Integer(ENV.fetch("ACTIONS", "10")), explain: explain)
+          end
+        end
+
+        namespace :async do
+          desc "Relations the views load that load_async could start in the controller, from a log with " \
+               "config.rails_minify.async_queries set (LOG=file, - for stdin; ACTIONS=10)"
+          task :report do
+            path = ENV.fetch("LOG") { abort "LOG=path/to/log (or LOG=- for stdin)" }
+            lines = path == "-" ? $stdin.each_line : File.foreach(path)
+            RailsMinify::AsyncQueries::Report.new(lines).report(actions: Integer(ENV.fetch("ACTIONS", "10")))
+          end
+        end
+
+        desc "Report production configuration that costs speed or memory (JIT before boot, " \
+             "no preload, heap warmed up after the fork, ...); never fails"
+        task doctor: :environment do
+          app = Rails.application
+          sentry = Sentry.configuration&.breadcrumbs_logger if defined?(Sentry) && Sentry.respond_to?(:initialized?) && Sentry.initialized?
+          RailsMinify::Doctor.new(root: app.root, jit_at_boot: RailsMinify::JIT_AT_BOOT,
+            gems: Gem.loaded_specs.transform_values { it.version.to_s }, sentry_breadcrumbs: sentry,
+            async_executor: (ActiveRecord.async_query_executor if defined?(ActiveRecord))).report
+        end
+
         desc "Fail on callback problems (missing targets, chains longer than callback_limit, " \
              "callbacks that save their own record) and an out-of-date manifest"
         task check: :environment do

data/lib/rails_minify/sql_profile.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module RailsMinify
+  # Where a page's Active Record time goes, from production traffic
+  # (config.rails_minify.sql_profile = 0.01 samples 1% of requests).
+  #
+  # For each sampled request it logs one line per distinct query and call
+  # site (how many times, total time, rows, the first line in the app that
+  # ran it, the SQL with its values taken out) and one line with the
+  # request's totals: SQL time against the time spent turning rows into
+  # records. bin/rails minify:sql:report LOG=... ranks the queries by their
+  # total time; with EXPLAIN=1 it also asks the database (SQLite) for each
+  # one's plan and flags full table scans and sorts without an index.
+  module SqlProfile
+    TAG = "[rails-minify] sql"
+    MAX_SQL = 2000
+    OWN_DIR = __dir__
+
+    class << self
+      attr_reader :rate, :logger
+
+      def install!(rate:, logger: nil)
+        @rate = rate == true ? 1.0 : rate
+        @logger = logger
+        return if @installed
+
+        @installed = true
+        ActiveSupport.on_load(:action_controller_base) { prepend ControllerHook }
+        ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |_, start, finish, _, payload|
+          current&.sql((finish - start) * 1000.0, payload)
+        end
+        ActiveSupport::Notifications.monotonic_subscribe("instantiation.active_record") do |_, start, finish, _, payload|
+          current&.instantiation((finish - start) * 1000.0, payload)
+        end
+      end
+
+      def current = ActiveSupport::IsolatedExecutionState[:rails_minify_sql_profile]
+
+      def sample? = rate && (rate >= 1.0 || rand < rate)
+
+      def track(action)
+        request = Request.new(action)
+        ActiveSupport::IsolatedExecutionState[:rails_minify_sql_profile] = request
+        yield
+      ensure
+        ActiveSupport::IsolatedExecutionState[:rails_minify_sql_profile] = nil
+        lines = request&.log_lines
+        target = logger || ActiveRecord::Base.logger
+        lines&.each { target&.info(it) }
+      end
+
+      # The SQL with its literal values replaced by ?, so the same query
+      # with other values is the same line.
+      def fingerprint(sql)
+        sql = sql.gsub(%r{/\*.*?\*/}m, " ") # query log comments
+        sql = sql.gsub(/'(?:[^']|'')*'/, "?")
+        sql = sql.gsub(/(?<![\w"`.$])-?\d+(?:\.\d+)?\b/, "?")
+        sql = sql.gsub(/\b(IN\s*)\(\s*\?(?:\s*,\s*\?)*\s*\)/i, '\1(?)')
+        sql = sql.gsub(/\s+/, " ").strip
+        sql.length > MAX_SQL ? "#{sql[0, MAX_SQL]}..." : sql
+      end
+
+      # The first line in the app (as Rails' backtrace cleaner sees it, so
+      # not in a gem) that led to the query, without the method name.
+      def call_site
+        cleaner = Rails.backtrace_cleaner
+        Thread.each_caller_location do |location|
+          next if location.path.start_with?(OWN_DIR)
+
+          frame = cleaner.clean_frame(location)
+          return frame.sub(/:in .*\z/, "").delete_prefix("./") if frame
+        end
+        "-"
+      end
+    end
+
+    Query = Struct.new(:name, :site, :sql, :count, :ms, :rows)
+
+    class Request
+      IGNORED = %w[SCHEMA TRANSACTION].freeze
+
+      def initialize(action)
+        @action = action
+        @queries = {}
+        @sql_ms = 0.0
+        @count = 0
+        @instantiation_ms = 0.0
+        @records = 0
+      end
+
+      def sql(ms, payload)
+        return if payload[:cached] || IGNORED.include?(payload[:name])
+
+        @sql_ms += ms
+        @count += 1
+        sql = SqlProfile.fingerprint(payload[:sql].to_s)
+        site = SqlProfile.call_site
+        query = (@queries[[sql, site]] ||= Query.new(payload[:name] || "SQL", site, sql, 0, 0.0, 0))
+        query.count += 1
+        query.ms += ms
+        query.rows += payload[:row_count].to_i
+      end
+
+      def instantiation(ms, payload)
+        @instantiation_ms += ms
+        @records += payload[:record_count].to_i
+      end
+
+      def log_lines
+        return [] if @count.zero?
+
+        totals = format("%s %s total queries=%d sql=%.1f instantiation=%.1f records=%d",
+          TAG, @action, @count, @sql_ms, @instantiation_ms, @records)
+        queries = @queries.values.map do |q|
+          format("%s %s query %dx %.2fms rows=%d %s | %s | %s", TAG, @action, q.count, q.ms, q.rows, q.site, q.name, q.sql)
+        end
+        [totals, *queries]
+      end
+    end
+
+    module ControllerHook
+      def process_action(...)
+        return super unless SqlProfile.sample?
+
+        SqlProfile.track("#{self.class.name}##{action_name}") { super }
+      end
+    end
+
+    # Adds up the log lines from sampled requests.
+    class Report
+      Total = Data.define(:action, :count, :sql_ms, :instantiation_ms, :records)
+      Line = Data.define(:action, :count, :ms, :rows, :site, :name, :sql)
+      Plan = Data.define(:lines, :flags, :error)
+
+      TOTAL = /#{Regexp.escape(TAG)} (\S+) total queries=(\d+) sql=([\d.]+) instantiation=([\d.]+) records=(\d+)/
+      QUERY = /#{Regexp.escape(TAG)} (\S+) query (\d+)x ([\d.]+)ms rows=(\d+) (\S+) \| (.*?) \| (.*)$/
+
+      attr_reader :totals, :lines
+
+      def initialize(lines)
+        @totals = []
+        @lines = []
+        lines.each do |line|
+          line = line.scrub.chomp
+          if (m = TOTAL.match(line))
+            @totals << Total.new(m[1], m[2].to_i, m[3].to_f, m[4].to_f, m[5].to_i)
+          elsif (m = QUERY.match(line))
+            @lines << Line.new(m[1], m[2].to_i, m[3].to_f, m[4].to_i, m[5], m[6], m[7])
+          end
+        end
+      end
+
+      # explain: a callable taking a Line and returning a Plan, or nil.
+      def report(io = $stdout, queries: 20, actions: 10, explain: nil)
+        if @totals.empty?
+          io.puts "no #{TAG} lines: set config.rails_minify.sql_profile (e.g. 0.01) and collect the production log"
+          return
+        end
+
+        sql_all = @totals.sum(&:sql_ms)
+        io.puts format("%d sampled requests: SQL %.1f ms, instantiation %.1f ms, %.0f queries, %.0f records per request",
+          @totals.size, sql_all / @totals.size, mean(@totals.map(&:instantiation_ms)), mean(@totals.map(&:count)), mean(@totals.map(&:records)))
+
+        io.puts
+        io.puts "Actions by SQL time (share of all sampled SQL time)"
+        @totals.group_by(&:action).max_by(actions) { |_, ts| ts.sum(&:sql_ms) }.each do |action, ts|
+          io.puts format("  %5.1f%%  %-45s n %4d  SQL %6.1f  instantiation %5.1f ms  queries %5.1f  records %6.0f",
+            share(ts.sum(&:sql_ms), sql_all), action, ts.size, mean(ts.map(&:sql_ms)), mean(ts.map(&:instantiation_ms)),
+            mean(ts.map(&:count)), mean(ts.map(&:records)))
+        end
+
+        requests = @totals.group_by(&:action).transform_values(&:size)
+        io.puts
+        io.puts "Queries by total time"
+        @lines.group_by(&:sql).max_by(queries) { |_, ls| ls.sum(&:ms) }.each.with_index(1) do |(sql, ls), i|
+          calls = ls.sum(&:count)
+          per_request = calls.to_f / [ls.map(&:action).uniq.sum { requests.fetch(it, 0) }, 1].max
+          io.puts
+          io.puts format("%2d. %5.1f%% of SQL time  %s  %.2f ms per call, %.1f calls per request, %.1f rows per call",
+            i, share(ls.sum(&:ms), sql_all), ls.first.name, ls.sum(&:ms) / calls, per_request, ls.sum(&:rows).to_f / calls)
+          io.puts "    #{sql}"
+          ls.group_by(&:site).max_by(3) { |_, s| s.sum(&:ms) }.each do |site, s|
+            io.puts format("    at %s (%s)", site, s.map(&:action).tally.max_by(2) { _2 }.map { "#{_1} #{_2}x" }.join(", "))
+          end
+          next unless explain
+
+          plan = explain.call(ls.first)
+          if plan.error
+            io.puts "    plan: #{plan.error}"
+          else
+            plan.lines.each { io.puts "    plan: #{it}" }
+            plan.flags.each { io.puts "    ! #{it}" }
+          end
+        end
+        io.puts
+        io.puts "Calls per request: per sampled request of the actions it runs in. Many calls of one query from one line is " \
+                "an N+1 (preload or includes); a full table scan wants an index. Instantiation is turning rows into " \
+                "records: high there, with many records, means a page loads more rows than it shows."
+      end
+
+      # EXPLAIN QUERY PLAN for SELECTs, on the connection of the model the
+      # query's name points to ("Spot Load"). SQLite only.
+      def self.sqlite_explainer
+        lambda do |line|
+          next Plan.new([], [], "not a SELECT") unless line.sql.match?(/\A\s*(WITH|SELECT)\b/i)
+
+          model = line.name.split.first.to_s.safe_constantize
+          model = ActiveRecord::Base unless model.is_a?(Class) && model < ActiveRecord::Base
+          model.with_connection do |c|
+            next Plan.new([], [], "#{c.adapter_name}: only SQLite plans are read") unless c.adapter_name.match?(/sqlite/i)
+
+            details = c.select_rows("EXPLAIN QUERY PLAN #{line.sql}").map(&:last)
+            Plan.new(details, flags(details), nil)
+          end
+        rescue StandardError => e
+          Plan.new([], [], "#{e.class}: #{e.message.lines.first&.strip}")
+        end
+      end
+
+      def self.flags(details)
+        details.filter_map do |d|
+          if (table = d[/\ASCAN (\S+)\z/, 1])
+            "full table scan of #{table}"
+          elsif d.start_with?("USE TEMP B-TREE")
+            "sorted or grouped without an index (#{d.delete_prefix("USE TEMP B-TREE FOR ").downcase})"
+          end
+        end
+      end
+
+      private
+
+      def mean(xs) = xs.empty? ? 0.0 : xs.sum.to_f / xs.size
+      def share(part, all) = all.zero? ? 0.0 : part * 100.0 / all
+    end
+  end
+end

data/lib/rails_minify/version.rb

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

data/lib/rails_minify.rb

@@ -27,6 +27,16 @@ end
 #   :omniauth                OmniAuth strategies skip their per-request dup off their paths
 #   :request_host            ActionDispatch::Request#host without a substitution per call
 module RailsMinify
+  autoload :AB, "rails_minify/ab"
+  autoload :AsyncQueries, "rails_minify/async_queries"
+  autoload :Doctor, "rails_minify/doctor"
+  autoload :SqlProfile, "rails_minify/sql_profile"
+
+  # The JITs already on when this file is required (Bundler.require, before
+  # Rails configures anything): turned on from the command line or the
+  # environment, so they compile boot too. minify:doctor reports them.
+  JIT_AT_BOOT = %i[yjit zjit].select { |jit| RubyVM.const_defined?(jit.upcase) && RubyVM.const_get(jit.upcase).enabled? }.freeze
+
   module Patches
     autoload :ActionTextPlainText, "rails_minify/patches/action_text_plain_text"
     autoload :OmniAuthPassthrough, "rails_minify/patches/omniauth_passthrough"

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: rails-minify
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sampo Kuokkanen
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -42,19 +42,25 @@ description: 'One switch for what held up in production: Active Record strict mo
   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: []
+executables:
+- rails-minify-ab
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- exe/rails-minify-ab
 - lib/rails-minify.rb
 - lib/rails_minify.rb
+- lib/rails_minify/ab.rb
+- lib/rails_minify/async_queries.rb
+- lib/rails_minify/doctor.rb
 - lib/rails_minify/patches/action_text_plain_text.rb
 - lib/rails_minify/patches/omniauth_passthrough.rb
 - lib/rails_minify/patches/request_host.rb
 - lib/rails_minify/railtie.rb
+- lib/rails_minify/sql_profile.rb
 - lib/rails_minify/version.rb
 homepage: https://github.com/sampokuokkanen/rails-minify/tree/main/rails-minify
 licenses: