duel-rails 0.1.0

data/lib/duel/rails/counter.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Duel
+  module Rails
+    # What the app's views and its cache did for each benchmark, from
+    # Rails's notifications:
+    #
+    # - rails_views: the templates, partials and layouts it rendered (each
+    #   of a collection's partials too)
+    # - rails_cache_reads: the keys it read from the cache
+    # - rails_cache_misses: the keys it read that weren't there
+    # - rails_cache_writes: the keys it wrote
+    #
+    # Where the views regressed, it says which a sample rendered most.
+    class Counter
+      # Counts. (Reading them renders nothing and touches no cache, so
+      # Duel finds that it costs nothing, and takes nothing away.)
+      MEASURES = {
+        "rails_views" => {kind: :counted, unit: %w[view views]},
+        "rails_cache_reads" => {kind: :counted, unit: %w[read reads]},
+        "rails_cache_misses" => {kind: :counted, unit: %w[miss misses]},
+        "rails_cache_writes" => {kind: :counted, unit: %w[write writes]}
+      }
+
+      # What each event it subscribes to is.
+      EVENTS = {
+        "render_template.action_view" => :view, "render_partial.action_view" => :view,
+        "render_layout.action_view" => :view, "render_collection.action_view" => :collection,
+        "cache_read.active_support" => :read, "cache_read_multi.active_support" => :read_multi,
+        "cache_write.active_support" => :write, "cache_write_multi.active_support" => :write_multi
+      }.freeze
+
+      # The most views shown, explaining a regression.
+      SHOWN = 3
+
+      # Adds the metrics, counted from when each worker opens them (once
+      # the app has booted) until it ends. Returns the Counter.
+      def self.configure(config)
+        counter = new
+        config.metric(MEASURES) { [counter.totals, counter.views] }
+          .open { counter.subscribe }
+          .close { counter.unsubscribe }
+          .details { |stretches, sample| counter.details(stretches, sample.n) }
+        counter
+      end
+
+      def initialize
+        @views = @reads = @misses = @writes = 0
+        # Each view rendered, by its template's path (as given: making
+        # another would allocate).
+        @rendered = Hash.new(0)
+        @subscriptions = [] #: Array[untyped]
+        @root = ""
+      end
+
+      # Subscribes to its EVENTS, in the booted app.
+      def subscribe
+        @root = File.join(::Rails.root, "app", "views", "")
+        @subscriptions = EVENTS.keys.map { |event| ActiveSupport::Notifications.subscribe(event, self) }
+      end
+
+      # Stops counting.
+      def unsubscribe = @subscriptions.each { |subscription| ActiveSupport::Notifications.unsubscribe(subscription) }
+
+      # The totals so far, by name.
+      def totals
+        {"rails_views" => @views, "rails_cache_reads" => @reads, "rails_cache_misses" => @misses,
+         "rails_cache_writes" => @writes}
+      end
+
+      # Each view rendered so far, how many times, by its template's
+      # path.
+      def views = @rendered.dup
+
+      # What explains the views a sample rendered, in its stretches (pairs
+      # of readings: see Snapshot#details) of +n+ iterations: the SHOWN
+      # rendered most, and how many times an iteration ("an iteration:
+      # 20× posts/_post.html.erb; 1× posts/index.html.erb"). Nothing
+      # where none were.
+      def details(stretches, n)
+        rendered = Hash.new(0)
+        stretches.each do |started, stopped|
+          stopped.context.each { |path, count| rendered[path] += count - started.context.fetch(path, 0) }
+        end
+        shown = rendered.select { |_, count| count.positive? }.sort_by { |path, count| [-count, path.to_s] }.first(SHOWN)
+        return if shown.empty?
+
+        said = shown.map { |path, count| "#{format("%.4g", count.fdiv(n))}× #{path.to_s.delete_prefix(@root)}" }
+        {"rails_views" => "an iteration: #{said.join("; ")}"}
+      end
+
+      # (Active Support's, for every event subscribed to. Nothing they do
+      # allocates: what a benchmark allocates is measured.)
+      def start(_name, _id, _payload)
+      end
+
+      def finish(name, _id, payload)
+        case EVENTS.fetch(name)
+        when :view then view(payload, 1)
+        when :collection then view(payload, payload[:count] || 0)
+        when :read then read(1, payload[:hit] ? 1 : 0)
+        when :read_multi then read(payload.fetch(:key).size, payload.fetch(:hits).size)
+        when :write then @writes += 1
+        else @writes += payload.fetch(:key).size
+        end
+      end
+
+      private
+
+      # +count+ views of the template at the payload's identifier.
+      def view(payload, count)
+        @views += count
+        @rendered[payload[:identifier]] += count
+      end
+
+      def read(keys, hits)
+        @reads += keys
+        @misses += keys - hits
+      end
+    end
+  end
+end

data/lib/duel/rails/database.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Duel
+  module Rails
+    # Each worker's own database, in DATABASE_URL (which Rails prefers to
+    # config/database.yml), with its version's schema and data loaded
+    # into it (see Rails.load_worker_data).
+    module Database
+      # The plugin that gives each worker a server, by database.
+      SERVERS = {postgresql: :postgresql, mysql2: :mysql, trilogy: :mysql}.freeze
+
+      # The URL's scheme (which Rails takes for the adapter), by database,
+      # where the plugin's own isn't it.
+      SCHEMES = {trilogy: "trilogy"}.freeze
+
+      # Gives each worker its own +database+: a file for :sqlite, or a
+      # server for :postgresql, :mysql2 or :trilogy, from its Duel plugin
+      # (used with +options+).
+      def self.configure(config, database, **options)
+        return config.prepare(:worker) { |w| {"DATABASE_URL" => "sqlite3:#{w.path("db.sqlite3")}"} } if database == :sqlite
+
+        plugin = SERVERS.fetch(database) do
+          raise ArgumentError, "database: must be :sqlite, :postgresql, :mysql2 or :trilogy, not #{database.inspect}"
+        end
+        config.use(plugin, **{scheme: SCHEMES[database]}.compact, **options)
+      end
+
+      # Loads the version's schema (db/schema.rb, or db/structure.sql)
+      # into the worker's database.
+      def self.load_schema
+        ::ActiveRecord::Tasks::DatabaseTasks.load_schema(::ActiveRecord::Base.connection_db_config)
+      end
+
+      # Empties every table of the worker's database (but Active Record's
+      # own: its schema's version, say).
+      def self.clear
+        ::ActiveRecord::Base.with_connection { |connection| connection.truncate_tables(*connection.tables) }
+      end
+
+      # Loads +names+ from the version's test/fixtures (every one, for
+      # :all): nothing for none. (Again, if they were loaded before: Active
+      # Record would take them for still there.)
+      def self.load_fixtures(names, path: ::Rails.root.join("test", "fixtures"))
+        case names
+        when :all then names = Dir.glob("**/*.yml", base: path).map { |file| file.delete_suffix(".yml") }.sort
+        end
+        return if names.empty?
+
+        ::ActiveRecord::FixtureSet.reset_cache
+        ::ActiveRecord::FixtureSet.create_fixtures(path, names)
+      end
+    end
+  end
+end

data/lib/duel/rails/jobs.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Duel
+  module Rails
+    # Active Job's queue while benchmarking: the jobs a benchmark enqueues
+    # are performed in an after_iterations hook (Config#after_iterations),
+    # after its iterations (or inside each, for a request rolled back:
+    # before what it wrote is rolled back), and measured with them. A request that enqueues a job
+    # is judged on the job's work too, as a server and its queue would do
+    # it.
+    #
+    # It's the queue adapter of ActiveJob::Base, in each worker: a job
+    # class with an adapter of its own keeps that one.
+    class Jobs
+      # Performs each version's jobs after its benchmarks' iterations.
+      # Returns the Jobs.
+      def self.configure(config)
+        jobs = new
+        config.in_worker { jobs.use }
+        config.before_sample { jobs.clear }
+        config.after_iterations { jobs.perform }
+        jobs
+      end
+
+      def initialize
+        # Each job enqueued, serialized (as a queue keeps it), in order.
+        @queue = [] #: Array[Hash[String, untyped]]
+      end
+
+      # Makes it Active Job's queue adapter, in the booted app, if it has
+      # Active Job.
+      def use
+        ::ActiveJob::Base.queue_adapter = self if defined?(::ActiveJob::Base)
+      end
+
+      # (An adapter's: the job is kept, serialized, until it's performed,
+      # whenever it's scheduled for.)
+      def enqueue(job) = @queue << job.serialize
+
+      def enqueue_at(job, _timestamp) = enqueue(job)
+
+      # (Rails 7.2 asks an adapter whether jobs enqueued in a transaction
+      # wait for it to commit, as Active Job's own adapters do. Rails 8.0
+      # and later ask the job.)
+      def enqueue_after_transaction_commit? = true
+
+      # (Rails 8.1 asks whether a continuable job should stop: never.)
+      def stopping? = false
+
+      # The jobs waiting to be performed.
+      def size = @queue.size
+
+      # Performs the jobs waiting, in order, and those they enqueue.
+      def perform
+        ::ActiveJob::Base.execute(@queue.shift) until @queue.empty?
+      end
+
+      # Forgets the jobs waiting (enqueued before a sample: by loading the
+      # worker's data, say).
+      def clear = @queue.clear
+    end
+  end
+end

data/lib/duel/rails/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Duel
+  module Rails
+    # In the app (Bundler requires the gem as it boots): `rake duel`, as
+    # Duel::RakeTask makes it, unless the app's Rakefile made one.
+    # `rails generate duel:install` is found by its path
+    # (lib/generators).
+    class Railtie < ::Rails::Railtie
+      rake_tasks { Railtie.define_task }
+
+      # Defines `rake duel`, unless there's one (Rake would run both).
+      def self.define_task
+        require "duel/rake_task"
+        RakeTask.new unless Rake::Task.task_defined?("duel")
+      end
+    end
+  end
+end

data/lib/duel/rails/request.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Duel
+  module Rails
+    # A request a benchmark sends the app, through its whole Rack stack
+    # (middleware, routing, the controller, its views), without a
+    # server; made from a description like "GET /posts".
+    class Request
+      METHODS = %w[GET HEAD POST PUT PATCH DELETE OPTIONS].freeze
+
+      # The statuses a request is expected to answer with, unless told:
+      # one that fails (a 404, or a 500) is benchmarking an error page.
+      OK = (200..399)
+
+      attr_reader :verb, :path
+
+      # +request+: the method and the path ("GET /posts?page=2").
+      # +params+: form parameters (in the query, for a GET), or +json+: a
+      # body, sent as JSON. +headers+: by name ("Accept"). +status+: what
+      # the response's must be (an Integer, or a Range of them).
+      # +rollback+: whether what the request writes to the database is
+      # rolled back after it (see #around_iteration), so every request
+      # finds the same data.
+      def initialize(request, params: nil, json: nil, headers: {}, status: OK, rollback: true)
+        verb, path = request.split(" ", 2)
+        unless METHODS.include?(verb) && path&.start_with?("/")
+          raise ArgumentError, "a request is a method and a path (\"GET /posts\"), not #{request.inspect}"
+        end
+        @verb = verb #: String
+        @path = path #: String
+        raise ArgumentError, "#{request}: params: or json:, not both" if params && json
+
+        @options = {method: @verb, params: params}
+        if json
+          @options[:input] = JSON.generate(json)
+          @options["CONTENT_TYPE"] = "application/json"
+        end
+        headers.each { |name, value| @options[header(name)] = value }
+        @status = status
+        @rollback = rollback
+      end
+
+      # A fresh Rack environment for the request (the app may change the
+      # one it's given).
+      def env = Rack::MockRequest.env_for(@path, @options)
+
+      # Sends the request (+rack_env+); fails unless the response's status
+      # is as expected. Returns the status.
+      def call(rack_env = env)
+        status = respond(rack_env)
+        raise Error, "#{@verb} #{@path}: status #{status}, not #{@status}" unless @status === status
+
+        status
+      end
+
+      # Its benchmark's own hooks (Duel::DSL#duel's options): ROLLBACK
+      # around each iteration (only the request is measured: pinning the
+      # connection, and rolling back, aren't), unless it isn't rolled back.
+      def hooks = @rollback ? {around_iteration: ROLLBACK} : {}
+
+      # Defines a benchmark (on +dsl+, a file of benchmarks' main object) of
+      # the request: see DSL#duel_request. +hooks+ are its own (as
+      # Duel::DSL#duel takes them): an around_iteration one, only for a request not
+      # rolled back (it would replace the rollback).
+      def self.duel(dsl, name, request, only: nil, peak_memory: false, **options, &prepare)
+        hooks = options.slice(*HOOKS)
+        sent = new(request, **options.except(*HOOKS))
+        if sent.hooks.key?(:around_iteration) && hooks.key?(:around_iteration)
+          raise ArgumentError, "duel_request #{name.inspect}: around_iteration: would replace its rollback: give rollback: false too, " \
+            "or give the hook to the file (around_iteration { |iteration| ... })"
+        end
+
+        dsl.duel(name, only:, peak_memory:, **sent.hooks, **hooks) do
+          env = sent.env
+          instance_exec(env, &prepare) if prepare
+          sent.call(env)
+        end
+      end
+
+      private
+
+      # The app's response's status, its body read through and closed (as
+      # a server's is: a streamed body does its work as it's read).
+      def respond(env)
+        response = ::Rails.application.call(env) #: [Integer, untyped, untyped]
+        status, _headers, body = response
+        begin
+          body.each do |_|
+            # (Read, and let go.)
+          end
+        ensure
+          body.close if body.respond_to?(:close)
+        end
+        status
+      end
+
+      # A header's name in a Rack environment: CONTENT_TYPE, HTTP_ACCEPT.
+      def header(name)
+        key = name.to_s.upcase.tr("-", "_")
+        %w[CONTENT_TYPE CONTENT_LENGTH].include?(key) ? key : "HTTP_#{key}"
+      end
+    end
+
+    # What files of benchmarks get, as .duel.rb uses the plugin (see
+    # Duel.plugin).
+    module DSL
+      # Defines a benchmark of a request to the app (see Request):
+      #
+      #   duel_request "posts: index", "GET /posts"
+      #   duel_request "posts: create", "POST /posts", params: {post: {title: "Hi"}}
+      #   duel_request "api: search", "POST /api/search", json: {q: "duel"}, headers: {"Accept" => "application/json"}
+      #
+      # Each iteration sends the request once, through the whole Rack
+      # stack, and (unless rollback: false) what it wrote is rolled back
+      # after it, unmeasured (see Rails::ROLLBACK). With a block, the block
+      # is given the request's Rack environment first, in the benchmark's
+      # context (to sign in, say, from an instance variable a setup hook
+      # set). +only+, +peak_memory+ and the hooks (setup:, say) are
+      # #duel's.
+      def duel_request(name, request = name, **options, &prepare) = Request.duel(self, name, request, **options, &prepare)
+    end
+  end
+end

data/lib/duel/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Duel
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/duel/rails.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "duel"
+require_relative "rails/version"
+require_relative "rails/bundle"
+require_relative "rails/database"
+require_relative "rails/request"
+require_relative "rails/counter"
+require_relative "rails/jobs"
+# (In an app, where Bundler requires the gem as Rails boots: `rake duel`.
+# A worker requires it from .duel.rb before the app boots, and needs no
+# Railtie.)
+defined?(::Rails::Railtie) && require_relative("rails/railtie")
+
+module Duel
+  # Duel for a Rails app: each version of the app booted in the benchmark
+  # environment, with a bundle and a database of its own, and benchmarks
+  # of requests (see DSL#duel_request), with the jobs they enqueue.
+  #
+  #   # .duel.rb
+  #   Duel.configure { |c| c.use :rails, database: :postgresql }
+  #
+  # Inside module Duel, ::Rails is Rails itself: Rails is this module.
+  module Rails
+    Duel.plugin(:rails, self)
+
+    # What a change must touch to be compared: the app's code, its
+    # configuration, its schema, its gems, and its Ruby. (From the app's
+    # own directory, in a monorepo's subdirectory too.)
+    WATCH = %w[app config db lib Gemfile Gemfile.lock .ruby-version].freeze
+
+    # The environment each version boots in (see the generator's
+    # config/environments/benchmark.rb).
+    ENVIRONMENT = "benchmark"
+
+    # What Ruby's random numbers, and Faker's, are seeded with in each
+    # worker, before its data is loaded.
+    SEED = 42
+
+    # An around_iteration hook (for .duel.rb, a file of benchmarks, or one
+    # benchmark): each iteration in a transaction, rolled back after it,
+    # unmeasured (see .rolled_back). Each request benchmark (see
+    # DSL#duel_request) has it, unless told not to.
+    #
+    #   c.around_iteration(&Duel::Rails::ROLLBACK)
+    ROLLBACK = ->(iteration) { Rails.rolled_back { iteration.call } }
+
+    # Configures Duel for the app (c.use :rails):
+    #
+    # - +database+: the worker's own database (see Database.configure), or
+    #   nil for none. +database_options+ go to its plugin.
+    # - +environment+: what each version boots in (its workers, and its
+    #   process benchmarks: RAILS_ENV).
+    # - +bundle+: whether each version runs its own bundle (see Bundle).
+    # - +fixtures+: the fixtures (test/fixtures) loaded into each worker's
+    #   database, by name, or :all. +seeds+: whether db/seeds.rb runs
+    #   too, after them. Both run once Ruby's random numbers are seeded
+    #   with +seed+.
+    # - +reset+: whether every table is emptied, and the fixtures and
+    #   seeds loaded again, before every sample (see .reset_data).
+    # - +jobs+: whether the jobs a benchmark enqueues are performed, and
+    #   measured with it (see Jobs).
+    # - +active_record+: whether Active Record's queries are counted too
+    #   (c.use :activerecord), and +query_time+ timed.
+    #
+    # Each version's schema is loaded into its workers' databases.
+    def self.configure(config, database: :sqlite, environment: ENVIRONMENT, bundle: true, fixtures: [], seeds: false,
+      seed: SEED, reset: false, jobs: true, active_record: true, query_time: false, **database_options)
+      raise ArgumentError, "reset: needs a database to reset" if reset && !database
+
+      config.watch = WATCH
+      config.load { |root| boot(root, environment) }
+      Bundle.configure(config) if bundle
+      config.prepare(:version) { |_version| {"RAILS_ENV" => environment} }
+      # (What .reset_data loads again.)
+      @data = ({fixtures:, seeds:, seed:} if database)
+      if database
+        Database.configure(config, database, **database_options)
+        config.in_worker { load_worker_data(fixtures:, seeds:, seed:) }
+        config.before_sample { reset_data } if reset
+      end
+      Jobs.configure(config) if jobs
+      # (Its options only where they aren't its own defaults: an app's own
+      # c.use :activerecord may have given others.)
+      if active_record
+        query_time ? config.use(:activerecord, query_time: true) : config.use(:activerecord)
+      end
+      Counter.configure(config)
+    end
+
+    # Boots the version at +root+ in +environment+, from its own tree (a
+    # relative path the app reads is the version's own).
+    def self.boot(root, environment)
+      ENV["RAILS_ENV"] = environment
+      Dir.chdir(root)
+      require File.join(root, "config", "environment")
+    end
+
+    # Loads the worker's data: the version's schema, then its data (see
+    # .load_data).
+    def self.load_worker_data(fixtures:, seeds:, seed:)
+      Database.load_schema
+      load_data(fixtures:, seeds:, seed:)
+    end
+
+    # Loads +fixtures+ and (if +seeds+) db/seeds.rb, with random numbers
+    # seeded with +seed+.
+    def self.load_data(fixtures:, seeds:, seed:)
+      seed_random(seed)
+      Database.load_fixtures(fixtures)
+      ::Rails.application.load_seed if seeds
+    end
+
+    # Puts the worker's data back as it was loaded: empties every table,
+    # then loads the fixtures and seeds it was given (c.use :rails's)
+    # again. For benchmarks that write what isn't rolled back, before each
+    # sample: reset: true does it for every benchmark, and a file's
+    # +before_sample { Duel::Rails.reset_data }+ for that file's.
+    def self.reset_data
+      data = @data or raise Error, "reset_data: c.use :rails gave the app no database to reset"
+      Database.clear
+      load_data(**data)
+    end
+
+    # Runs the block with each database connection Active Record writes
+    # through pinned, in a transaction rolled back after it (as Rails's
+    # own transactional tests do: the block's own transactions become
+    # savepoints, and ending a request doesn't release the connection).
+    # Without Active Record, it just runs the block. Returns what it does.
+    def self.rolled_back
+      return yield unless defined?(::ActiveRecord::Base)
+
+      pinned = [] #: Array[untyped]
+      begin
+        ::ActiveRecord::Base.connection_handler.connection_pool_list(:writing).each do |pool|
+          pool.pin_connection!(true)
+          pinned << pool
+        end
+        yield
+      ensure
+        pinned.each(&:unpin_connection!)
+      end
+    end
+
+    # Seeds Ruby's random numbers with +seed+, and Faker's, if it's
+    # loaded: the same data on both versions.
+    def self.seed_random(seed)
+      srand(seed)
+      Faker::Config.random = Random.new(seed) if defined?(Faker::Config)
+    end
+  end
+end

data/lib/generators/duel/install/install_generator.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+require "rails/generators"
+
+module Duel
+  module Generators
+    # `rails generate duel:install`: sets Duel up for the app, with
+    # .duel.rb, the benchmark environment, benchmarks of its requests and
+    # of its boot, and a GitHub Actions workflow, and adds StackProf (and
+    # the plugin for its database's server) to the Gemfile. An app in a
+    # subdirectory of its repository (a monorepo's) gets a workflow at the
+    # repository's root, run in the app's directory.
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.join(File.dirname(__FILE__), "templates")
+
+      desc "Sets Duel up for this app: .duel.rb, config/environments/benchmark.rb, " \
+        "benchmarks of its requests (duel/requests_duel.rb) and its boot (duel/boot_duel.rb), and a GitHub Actions workflow."
+
+      class_option :database, type: :string, enum: %w[sqlite postgresql mysql2 trilogy],
+        desc: "Each worker's database (default: as the app's own)"
+
+      # The adapters each worker's database can stand in for, by the
+      # database duel-rails calls it.
+      ADAPTERS = {"sqlite3" => "sqlite", "postgresql" => "postgresql", "postgis" => "postgresql",
+                  "mysql2" => "mysql2", "trilogy" => "trilogy"}.freeze
+
+      # The plugin each database's server comes from.
+      PLUGINS = {"postgresql" => "duel-postgresql", "mysql2" => "duel-mysql", "trilogy" => "duel-mysql"}.freeze
+
+      # The most requests benchmarked at first.
+      ROUTES = 10
+
+      # Controllers of Rails's own (its health check, Active Storage...).
+      FRAMEWORK = %r{\A(rails|active_storage|action_mailbox|turbo)/}
+
+      def create_config = template("duel.rb.tt", ".duel.rb")
+
+      def create_environment = template("benchmark.rb.tt", "config/environments/benchmark.rb")
+
+      def create_benchmarks = template("requests_duel.rb.tt", "duel/requests_duel.rb")
+
+      def create_boot_benchmark = template("boot_duel.rb.tt", "duel/boot_duel.rb")
+
+      # The workflow, at the repository's root: perf.yml, or, for an app in
+      # a subdirectory, perf-<its path>.yml (perf-apps-blog.yml), so that
+      # each of a monorepo's apps can have its own.
+      def create_workflow
+        dir = working_directory
+        name = dir ? "perf-#{dir.tr("/", "-")}.yml" : "perf.yml"
+        template("perf.yml.tt", File.join(repository, ".github", "workflows", name))
+      end
+
+      # The plugin that gives each worker its database's server.
+      def add_plugin
+        plugin = PLUGINS[database]
+        gem(plugin, group: :development) if plugin && !gemfile.include?(plugin)
+      end
+
+      # StackProf, for profiles of regressions: it runs on CRuby only, so
+      # it's left out of JRuby's and TruffleRuby's bundles.
+      def add_stackprof
+        gem("stackprof", platforms: :mri, group: :development) unless gemfile.include?("stackprof")
+      end
+
+      private
+
+      def gemfile = File.read(File.join(destination_root, "Gemfile"))
+
+      # The database each worker gets: as asked, or as the app's own
+      # primary database is, or nil for one Duel can't give it.
+      def database = options[:database] || ADAPTERS[adapter]
+
+      # The app's primary database's adapter (nil without Active Record).
+      def adapter
+        return unless defined?(::ActiveRecord::Base)
+
+        configs = ::ActiveRecord::Base.configurations.configs_for(env_name: ::Rails.env)
+        (configs.find { |config| config.name == "primary" } || configs.first)&.adapter
+      end
+
+      # The app's first ROUTES routes a GET without parameters reaches, as
+      # [name, request]: "posts: index", "GET /posts". Each path once, and
+      # each action once (a benchmark's name is its own): the root, say,
+      # that reaches what /posts does is benchmarked once.
+      def routes
+        found = ::Rails.application.routes.routes.filter_map do |route|
+          controller, action = route.requirements.values_at(:controller, :action)
+          path = route.path.spec.to_s.delete_suffix("(.:format)")
+          next unless route.verb == "GET" && controller && !controller.match?(FRAMEWORK) && !path.match?(/[:*(]/)
+
+          ["#{controller}: #{action}", "GET #{path}"]
+        end
+        found.uniq(&:last).uniq(&:first).first(ROUTES)
+      end
+
+      # Whether the app has fixtures (test/fixtures), for each worker's data.
+      def fixtures? = Dir.glob("test/fixtures/**/*.yml", base: destination_root).any?
+
+      # Whether the app names its Ruby in a .ruby-version: then each version
+      # runs on the Ruby its own names (c.ruby = :version_file), and the
+      # workflow installs the app's.
+      def version_file? = File.exist?(File.join(destination_root, ".ruby-version"))
+
+      # The Ruby the workflow runs: none, where .ruby-version says.
+      def ruby_version = (RUBY_VERSION.rpartition(".").first unless version_file?)
+
+      # The root of the app's git repository: the app's own directory,
+      # outside one (or without git).
+      def repository
+        top, _, status = Open3.capture3("git", "-C", destination_root, "rev-parse", "--show-toplevel")
+        status.success? ? top.chomp : destination_root
+      rescue SystemCallError
+        destination_root
+      end
+
+      # The app's directory, from its repository's root ("apps/blog"), or
+      # nil for an app at the root.
+      def working_directory
+        path = Pathname(File.realpath(destination_root)).relative_path_from(File.realpath(repository)).to_s
+        path unless path == "."
+      end
+    end
+  end
+end