rails-minify 0.1.3 → 0.3.0

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

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