hecks 2.7.0 → 2.9.0

data/lib/hecks/bench/ruby_runner.rb

@@ -1,151 +0,0 @@
-require_relative "run"
-
-module Hecks
-  module Bench
-    # Measures the Ruby runtime, in-process, on one persistence adapter.
-    #
-    # The domain is booted from a throwaway copy through `Fuzzing::IsolatedBoot`, so a
-    # run always starts from an empty store and never touches the example's own data.
-    # That is the same isolation `bin/fuzz --adapter` uses. Both Postgres adapters write
-    # to a uniquely named schema in the `hecks_bench` database, which is dropped after the
-    # run, so a concurrent `bin/fuzz` and its shared `hecks_fuzz` schema are never touched.
-    #
-    # Only `dispatch_flat` is inside the timer. Boot, setup commands and warmup are not.
-    module RubyRunner
-      # The adapters this runner can bind, as `IsolatedBoot` names them.
-      ADAPTERS = %i[memory sqlite postgres postgres_era].freeze
-
-      # The adapters that need a server and a scratch schema.
-      POSTGRES_ADAPTERS = %i[postgres postgres_era].freeze
-
-      # The scratch database both Postgres adapters run in.
-      DATABASE = "hecks_bench".freeze
-
-      module_function
-
-      # Boots the workload's domain on `adapter` and times its commands.
-      #
-      # @param workload [Workload] the commands to dispatch
-      # @param adapter [Symbol] one of `ADAPTERS`
-      # @param warmup [Integer] cycles dispatched and discarded before timing starts
-      # @param iterations [Integer] cycles timed
-      # @return [Run] the timings of the measured cycles
-      # @raise [ArgumentError] if `adapter` is not one of `ADAPTERS`
-      # @raise [StandardError] whatever refusal a command raises, warmup included, since a
-      #   benchmark that swallowed one would be timing something other than its workload
-      def call(workload, adapter:, warmup:, iterations:)
-        unless ADAPTERS.include?(adapter)
-          raise ArgumentError, "unknown adapter #{adapter.inspect} — one of #{ADAPTERS.join(', ')}"
-        end
-
-        load_dependencies
-        schema = "bench_#{Process.pid}_#{rand(1 << 32).to_s(16)}"
-        quietly_for_postgres do
-          boot(workload, adapter, schema) do |runtime|
-            workload.setup.each { |step| dispatch(runtime, step) }
-            measure(runtime, workload, warmup: warmup, iterations: iterations)
-          end
-        end
-      ensure
-        drop_schema(schema) if schema && POSTGRES_ADAPTERS.include?(adapter)
-      end
-
-      # Boots the workload's domain on `adapter` in an isolated copy.
-      #
-      # @param workload [Workload] the domain to boot
-      # @param adapter [Symbol] one of `ADAPTERS`
-      # @param schema [String] the scratch schema name, used only by the Postgres adapters
-      # @yield [Hecks::Runtime] the booted domain
-      # @return [Object] whatever the block returns
-      def boot(workload, adapter, schema)
-        Hecks::Fuzzing::IsolatedBoot.call(workload.domain_path, adapter: adapter, database: DATABASE,
-                                          schema: schema, scratch: { database: DATABASE, schema: schema }) do |copy|
-          yield Hecks.boot(copy, install_facade: false)
-        end
-      end
-
-      # Keeps Postgres's `schema already exists` notices off stderr while a block runs.
-      #
-      # Every aggregate opens its own connection and each one repeats the notice, which
-      # buries the progress lines. The server setting is restored afterwards.
-      #
-      # @yield the work to run with notices quieted
-      # @return [Object] whatever the block returns
-      def quietly_for_postgres
-        previous = ENV.fetch("PGOPTIONS", nil)
-        ENV["PGOPTIONS"] = [previous, "-c client_min_messages=warning"].compact.join(" ")
-        yield
-      ensure
-        ENV["PGOPTIONS"] = previous
-      end
-
-      # Dispatches warmup cycles untimed, then times the measured ones.
-      #
-      # @param runtime [Hecks::Runtime] the booted domain
-      # @param workload [Workload] the commands to dispatch
-      # @param warmup [Integer] cycles to discard
-      # @param iterations [Integer] cycles to time
-      # @return [Run] the timings of the measured cycles
-      def measure(runtime, workload, warmup:, iterations:)
-        warmup.times { |n| workload.cycle(n).each { |step| dispatch(runtime, step) } }
-        GC.start
-        samples = []
-        started = now
-        iterations.times do |n|
-          workload.cycle(warmup + n).each { |step| samples << [step.verb, time { dispatch(runtime, step) }] }
-        end
-        Run.new(samples: samples, wall_seconds: now - started)
-      end
-
-      # Sends one step to the runtime.
-      #
-      # @param runtime [Hecks::Runtime] the booted domain
-      # @param step [Workload::Step] the command to dispatch
-      # @return [Object] whatever `dispatch_flat` answers
-      def dispatch(runtime, step)
-        runtime.dispatch_flat(step.verb, step.ruby_args)
-      end
-
-      # Reads the monotonic clock.
-      #
-      # @return [Float] seconds on the monotonic clock
-      def now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      # Times a block.
-      #
-      # @yield the work to time
-      # @return [Float] seconds the block took
-      def time
-        started = now
-        yield
-        now - started
-      end
-
-      # Loads what booting a domain on every adapter needs.
-      #
-      # @return [void]
-      def load_dependencies
-        require "hecks"
-        require "hecks/fuzzing"
-        require "hecks/ports/persistence/plugins/era"
-      end
-
-      # Removes the schema a Postgres run created, so repeated runs do not accumulate.
-      #
-      # @param schema [String] the schema name this run used
-      # @return [void]
-      def drop_schema(schema)
-        require "pg"
-        connection = PG.connect(dbname: DATABASE, connect_timeout: 2)
-        connection.exec("SET client_min_messages = warning")
-        connection.exec("DROP SCHEMA IF EXISTS #{connection.quote_ident(schema)} CASCADE")
-      rescue LoadError, PG::Error
-        nil
-      ensure
-        connection&.close
-      end
-    end
-  end
-end

data/lib/hecks/bench/run.rb

@@ -1,55 +0,0 @@
-module Hecks
-  module Bench
-    # The raw timings of one measured pass over a workload on one runtime.
-    #
-    # Runners produce these and know nothing about reporting. {#summary} is the only
-    # place raw samples become the figures a report prints.
-    class Run
-      # @return [Array<Array(String, Float)>] each timed command's verb and latency in
-      #   seconds, in dispatch order
-      attr_reader :samples
-
-      # @return [Float] seconds from the first timed command's start to the last one's end
-      attr_reader :wall_seconds
-
-      # @return [Hash{Symbol => Object}] facts a runner wants reported alongside the timings
-      attr_reader :extras
-
-      # Builds a run.
-      #
-      # @param samples [Array<Array(String, Float)>] verb and latency seconds per command
-      # @param wall_seconds [Float] the wall-clock duration of the whole timed pass
-      # @param extras [Hash{Symbol => Object}] runner-specific facts, such as a round-trip floor
-      def initialize(samples:, wall_seconds:, extras: {})
-        @samples = samples
-        @wall_seconds = wall_seconds
-        @extras = extras
-      end
-
-      # Reduces the samples to the figures a report prints.
-      #
-      # @return [Hash{Symbol => Object}] `:commands`, `:wall_seconds`, `:throughput_per_s`,
-      #   the `Stats.latency` figures, `:drift`, `:by_verb` (each verb's count, p50 and p99),
-      #   and any `extras`
-      def summary
-        seconds = samples.map(&:last)
-        {
-          commands:         samples.size,
-          wall_seconds:     wall_seconds.round(4),
-          throughput_per_s: (samples.size / wall_seconds).round(1),
-          **Stats.latency(seconds),
-          drift:            Stats.drift(seconds),
-          by_verb:          by_verb
-        }.merge(extras)
-      end
-
-      private
-
-      def by_verb
-        samples.group_by(&:first).transform_values do |group|
-          Stats.latency(group.map(&:last)).slice(:count, :p50_us, :p99_us)
-        end
-      end
-    end
-  end
-end

data/lib/hecks/bench/rust_runner.rb

@@ -1,165 +0,0 @@
-require "fileutils"
-require "open3"
-require_relative "run"
-
-module Hecks
-  module Bench
-    # Measures the native Rust binary through its streaming mode.
-    #
-    # `rust --serve` reads one JSON step per line and answers one JSON line each, keeping
-    # its in-memory store alive between them. This runner writes a step, waits for the
-    # answer line, and times the whole round trip, so the figures include two pipe
-    # crossings and the binary's own JSON parse and print. Process start-up is outside
-    # the timer.
-    #
-    # Alongside each run it measures a **round-trip floor**: the same round trip for a
-    # step the binary refuses immediately, which is what the pipes cost with almost no
-    # domain work behind them.
-    module RustRunner
-      # Where the Rust crate lives.
-      RUST_DIR = File.expand_path("../../../rust", __dir__)
-
-      # How many refused-at-once steps make up the round-trip floor's sample.
-      FLOOR_SAMPLES = 500
-
-      # A `cargo build` that exited non-zero.
-      class BuildFailed < StandardError; end
-
-      # A benchmarked step the binary refused or could not answer.
-      class StepRefused < StandardError; end
-
-      module_function
-
-      # Says why the Rust target cannot run, if it cannot.
-      #
-      # @param binary [String, nil] an explicit pre-built binary, which needs no toolchain
-      # @return [String, nil] nil when the target can run, otherwise one sentence saying why
-      def unavailable_reason(binary: nil)
-        return "the binary #{binary} does not exist or is not executable" if binary && !File.executable?(binary)
-        return nil if binary || Environment.capture("cargo", "-V") != "unknown"
-
-        "`cargo` is not on PATH and no --rust-binary was given"
-      end
-
-      # Builds the release binary for one domain's Cargo feature and pins a copy of it.
-      #
-      # The copy has its own name so building another domain's feature afterwards cannot
-      # replace it.
-      #
-      # @param feature [String] the domain's Cargo feature, its directory name
-      # @param rust_dir [String] the Rust crate's directory
-      # @return [String] the path of the pinned release binary
-      # @raise [BuildFailed] if cargo exits non-zero or leaves no binary
-      def build(feature, rust_dir: RUST_DIR)
-        output, status = Open3.capture2e("cargo", "build", "--release", "--no-default-features",
-                                         "--features", feature, chdir: rust_dir)
-        unless status.success?
-          raise BuildFailed,
-                "cargo build --release --features #{feature} failed:\n#{output.lines.last(15).join}"
-        end
-
-        target = File.join(ENV.fetch("CARGO_TARGET_DIR", File.join(rust_dir, "target")), "release")
-        pinned = File.join(target, "rust-bench-#{feature}")
-        FileUtils.cp(File.join(target, "rust"), pinned)
-        pinned
-      end
-
-      # Starts the binary in serve mode and times the workload's commands.
-      #
-      # @param workload [Workload] the commands to send
-      # @param binary [String] the path of a binary built for `workload`'s domain
-      # @param warmup [Integer] cycles sent and discarded before timing starts
-      # @param iterations [Integer] cycles timed
-      # @return [Run] the timings, with the round-trip floor in its extras as
-      #   `:roundtrip_floor_p50_us`
-      # @raise [StepRefused] if the binary refuses any step, warmup included
-      def call(workload, binary:, warmup:, iterations:)
-        IO.popen([binary, "--serve"], "r+") do |pipe|
-          pipe.sync = true
-          workload.setup.each { |step| ask(pipe, step.to_json_line) }
-          warmup.times { |n| workload.cycle(n).each { |step| ask(pipe, step.to_json_line) } }
-          run = measure(pipe, workload, warmup: warmup, iterations: iterations)
-          Run.new(samples: run.samples, wall_seconds: run.wall_seconds,
-                  extras: { roundtrip_floor_p50_us: floor(pipe) })
-        ensure
-          pipe.close_write unless pipe.closed?
-        end
-      end
-
-      # Times the measured cycles.
-      #
-      # @param pipe [IO] the binary's stdin and stdout
-      # @param workload [Workload] the commands to send
-      # @param warmup [Integer] cycles already sent, so record names continue from there
-      # @param iterations [Integer] cycles to time
-      # @return [Run] the timings, without extras
-      def measure(pipe, workload, warmup:, iterations:)
-        samples = []
-        started = now
-        iterations.times do |n|
-          workload.cycle(warmup + n).each do |step|
-            line = step.to_json_line
-            began = now
-            answer = round_trip(pipe, line)
-            samples << [step.verb, now - began]
-            check(answer, step.verb)
-          end
-        end
-        Run.new(samples: samples, wall_seconds: now - started)
-      end
-
-      # Measures the pipes with almost no work behind them.
-      #
-      # @param pipe [IO] the binary's stdin and stdout
-      # @return [Float] the p50 microseconds of {FLOOR_SAMPLES} round trips for an empty step,
-      #   which the binary refuses without touching its store
-      def floor(pipe)
-        seconds = Array.new(FLOOR_SAMPLES) do
-          began = now
-          round_trip(pipe, "{}")
-          now - began
-        end
-        Stats.micros(Stats.percentile(seconds, 0.5))
-      end
-
-      # Sends one step and returns the answer line, untimed.
-      #
-      # @param pipe [IO] the binary's stdin and stdout
-      # @param line [String] the step as one JSON line
-      # @return [void]
-      # @raise [StepRefused] if the binary refuses the step
-      def ask(pipe, line)
-        check(round_trip(pipe, line), line[0, 80])
-      end
-
-      # Writes one line and reads one line back.
-      #
-      # @param pipe [IO] the binary's stdin and stdout
-      # @param line [String] the step as one JSON line
-      # @return [String] the answer line, or an empty string if the binary closed its output
-      def round_trip(pipe, line)
-        pipe.write(line, "\n")
-        pipe.gets.to_s
-      end
-
-      # Refuses an answer that is not a success.
-      #
-      # @param answer [String] the binary's answer line
-      # @param what [String] what was asked, for the error message
-      # @return [void]
-      # @raise [StepRefused] unless `answer` starts with `{"ok":true`
-      def check(answer, what)
-        return if answer.start_with?('{"ok":true')
-
-        raise StepRefused, "#{what} was not accepted: #{answer.strip.empty? ? 'the binary closed its output' : answer.strip}"
-      end
-
-      # Reads the monotonic clock.
-      #
-      # @return [Float] seconds on the monotonic clock
-      def now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    end
-  end
-end

data/lib/hecks/bench/stats.rb

@@ -1,75 +0,0 @@
-module Hecks
-  module Bench
-    # Order statistics over a list of latency samples.
-    #
-    # Percentiles use the nearest-rank method: the smallest sample with at least
-    # that fraction of the samples at or below it. It never interpolates, so every
-    # reported figure is a latency that actually happened. With fewer than 100
-    # samples the p99 is simply the maximum.
-    module Stats
-      module_function
-
-      # Reads one percentile from a list of samples.
-      #
-      # @param samples [Array<Float>] the samples, in any order
-      # @param fraction [Float] the percentile as a fraction, e.g. `0.99`
-      # @return [Float, nil] the nearest-rank percentile, or nil when `samples` is empty
-      def percentile(samples, fraction)
-        return nil if samples.empty?
-
-        sorted = samples.sort
-        sorted[[(fraction * sorted.size).ceil - 1, 0].max]
-      end
-
-      # Finds the middle value of a list, averaging the two middle values of an even one.
-      #
-      # @param values [Array<Numeric>] the values, in any order
-      # @return [Float, nil] the median, or nil when `values` is empty
-      def median(values)
-        return nil if values.empty?
-
-        sorted = values.sort
-        middle = sorted.size / 2
-        sorted.size.odd? ? sorted[middle].to_f : (sorted[middle - 1] + sorted[middle]) / 2.0
-      end
-
-      # Summarizes one run's latency samples.
-      #
-      # @param seconds [Array<Float>] per-command latencies in seconds, in dispatch order
-      # @return [Hash{Symbol => Numeric}] `:count`, and `:p50_us`, `:p99_us`, `:mean_us` and
-      #   `:max_us` in microseconds
-      def latency(seconds)
-        {
-          count:   seconds.size,
-          p50_us:  micros(percentile(seconds, 0.50)),
-          p99_us:  micros(percentile(seconds, 0.99)),
-          mean_us: micros(seconds.sum / seconds.size),
-          max_us:  micros(seconds.max)
-        }
-      end
-
-      # Compares how slow the last tenth of a run was against its first tenth.
-      #
-      # A ratio well above 1.0 means latency grows as the store fills, which a single
-      # p50 over the whole run would hide.
-      #
-      # @param seconds [Array<Float>] per-command latencies in dispatch order
-      # @return [Float, nil] the last tenth's p50 over the first tenth's, or nil when there
-      #   are fewer than ten samples
-      def drift(seconds)
-        tenth = seconds.size / 10
-        return nil if tenth.zero?
-
-        (percentile(seconds.last(tenth), 0.5) / percentile(seconds.first(tenth), 0.5)).round(2)
-      end
-
-      # Converts seconds to microseconds, rounded to a tenth.
-      #
-      # @param seconds [Float, nil] a duration in seconds
-      # @return [Float, nil] the duration in microseconds, or nil when `seconds` is nil
-      def micros(seconds)
-        seconds && (seconds * 1_000_000).round(1)
-      end
-    end
-  end
-end

data/lib/hecks/bench/suite.rb

@@ -1,172 +0,0 @@
-module Hecks
-  module Bench
-    # Runs every requested target against every requested domain and aggregates the runs.
-    #
-    # Each domain's runs are interleaved across targets (memory, sqlite, ..., memory,
-    # sqlite, ...) rather than finished one target at a time, so a burst of unrelated load on
-    # the machine lands on every target instead of flattering one of them. Each figure in the
-    # result is the median across runs, with the fastest and slowest throughput kept so a noisy
-    # measurement shows.
-    module Suite
-      # Every target `bin/bench` can measure.
-      TARGETS = %w[ruby:memory ruby:sqlite ruby:postgres ruby:postgres_era rust].freeze
-
-      # What to measure and how hard.
-      #
-      # @!attribute domains
-      #   @return [Array<String>] workload names, keys of `Workload.all`
-      # @!attribute targets
-      #   @return [Array<String>] members of `TARGETS`
-      # @!attribute warmup
-      #   @return [Integer] cycles discarded before each run is timed
-      # @!attribute iterations
-      #   @return [Integer] cycles timed in each run
-      # @!attribute runs
-      #   @return [Integer] how many fresh boots of each target to measure per domain
-      # @!attribute rust_binary
-      #   @return [String, nil] a pre-built binary to use instead of building one; only valid
-      #     with a single domain, since a binary embeds exactly one
-      Config = Struct.new(:domains, :targets, :warmup, :iterations, :runs, :rust_binary, keyword_init: true)
-
-      module_function
-
-      # Measures everything `config` asks for.
-      #
-      # @param config [Config] what to measure
-      # @param log [#puts] where progress lines go; one line per run
-      # @return [Hash{Symbol => Object}] `:environment`, `:config`, `:results` (one entry per
-      #   domain and target, see `.aggregate`) and `:skipped` (each skipped target and why)
-      # @raise [ArgumentError] if a target or domain is unknown, a count is not positive, or
-      #   `rust_binary` is combined with more than one domain
-      def call(config, log: $stderr)
-        validate(config)
-        load_before = Environment.load_average
-        skipped = unavailable_targets(config)
-        active = config.targets - skipped.map { |entry| entry[:target] }
-        skipped.each { |entry| log.puts "skip #{entry[:target]}: #{entry[:reason]}" }
-        results = config.domains.flat_map { |domain| measure_domain(Workload.fetch(domain), active, config, log) }
-        environment = Environment.describe
-        environment[:load_average] = { before: load_before, after: environment[:load_average] }
-        { environment: environment.merge(postgres: postgres_version(active)),
-          config: config.to_h, results: results, skipped: skipped }
-      end
-
-      # Checks a configuration before anything is booted.
-      #
-      # @param config [Config] the configuration to check
-      # @return [void]
-      # @raise [ArgumentError] on the first problem found
-      def validate(config)
-        unknown = config.targets - TARGETS
-        raise ArgumentError, "unknown target #{unknown.first.inspect} — one of #{TARGETS.join(', ')}" if unknown.any?
-
-        config.domains.each { |domain| Workload.fetch(domain) }
-        if config.iterations < 1 || config.runs < 1 || config.warmup.negative?
-          raise ArgumentError, "iterations and runs must be at least 1, and warmup at least 0"
-        end
-        return unless config.rust_binary && config.domains.size > 1
-
-        raise ArgumentError, "--rust-binary embeds one domain, so it needs exactly one --domain"
-      end
-
-      # Finds the targets this machine cannot run.
-      #
-      # @param config [Config] the configuration whose targets to check
-      # @return [Array<Hash{Symbol => String}>] `{target:, reason:}` for each unavailable target
-      def unavailable_targets(config)
-        postgres = PostgresProbe.unavailable_reason if config.targets.any? { |t| t.start_with?("ruby:postgres") }
-        rust = RustRunner.unavailable_reason(binary: config.rust_binary) if config.targets.include?("rust")
-        config.targets.filter_map do |target|
-          reason = target == "rust" ? rust : (postgres if target.start_with?("ruby:postgres"))
-          { target: target, reason: reason } if reason
-        end
-      end
-
-      # Measures one domain across every active target, `config.runs` times each.
-      #
-      # @param workload [Workload] the domain's commands
-      # @param targets [Array<String>] the targets that can run here
-      # @param config [Config] warmup, iterations, runs and any binary override
-      # @param log [#puts] where progress lines go
-      # @return [Array<Hash>] one aggregated entry per target
-      def measure_domain(workload, targets, config, log)
-        binaries = {}
-        summaries = Hash.new { |hash, target| hash[target] = [] }
-        config.runs.times do |index|
-          targets.each do |target|
-            run = measure_once(workload, target, config, binaries)
-            summaries[target] << run.summary
-            log.puts progress_line("#{workload.name} #{target}", "run #{index + 1}/#{config.runs}", summaries[target].last)
-          end
-        end
-        targets.map { |target| aggregate(workload.name, target, summaries[target]) }
-      end
-
-      # Formats the one line printed as each run finishes.
-      #
-      # @param label [String] the domain and target
-      # @param position [String] which run of how many, e.g. `"2/3"`
-      # @param summary [Hash] the run's `Run#summary`
-      # @return [String] the progress line
-      def progress_line(label, position, summary)
-        "#{label.ljust(27)} #{position}  #{summary[:throughput_per_s].round.to_s.rjust(8)} cmds/s  " \
-          "p50 #{summary[:p50_us].to_s.rjust(9)} us  p99 #{summary[:p99_us].to_s.rjust(9)} us"
-      end
-
-      # Runs one target once.
-      #
-      # @param workload [Workload] the domain's commands
-      # @param target [String] a member of `TARGETS`
-      # @param config [Config] warmup, iterations and any binary override
-      # @param binaries [Hash{String => String}] Rust binaries already built, by domain name;
-      #   filled in as they are built
-      # @return [Run] the run's timings
-      def measure_once(workload, target, config, binaries)
-        if target == "rust"
-          binary = config.rust_binary || (binaries[workload.name] ||= RustRunner.build(workload.name))
-          RustRunner.call(workload, binary: binary, warmup: config.warmup, iterations: config.iterations)
-        else
-          RubyRunner.call(workload, adapter: target.delete_prefix("ruby:").to_sym,
-                                    warmup: config.warmup, iterations: config.iterations)
-        end
-      end
-
-      # Reduces one target's runs to a single entry.
-      #
-      # @param domain [String] the workload name
-      # @param target [String] the target name
-      # @param summaries [Array<Hash>] each run's `Run#summary`
-      # @return [Hash{Symbol => Object}] `:domain`, `:target`, `:runs` (the raw summaries),
-      #   `:median` (the median of each run's throughput, p50, p99 and drift, plus
-      #   `:by_verb`), and `:throughput_range` (`[slowest, fastest]` across runs)
-      def aggregate(domain, target, summaries)
-        rates = summaries.map { |summary| summary[:throughput_per_s] }
-        median = %i[throughput_per_s p50_us p99_us mean_us max_us drift].to_h do |key|
-          [key, Stats.median(summaries.filter_map { |summary| summary[key] })]
-        end
-        median[:roundtrip_floor_p50_us] = Stats.median(summaries.filter_map { |s| s[:roundtrip_floor_p50_us] })
-        median[:by_verb] = median_by_verb(summaries)
-        { domain: domain, target: target, runs: summaries, median: median.compact,
-          throughput_range: rates.minmax }
-      end
-
-      # Takes each verb's median p50 and p99 across runs.
-      #
-      # @param summaries [Array<Hash>] each run's `Run#summary`
-      # @return [Hash{String => Hash{Symbol => Float}}] `:p50_us` and `:p99_us` per verb
-      def median_by_verb(summaries)
-        summaries.first[:by_verb].keys.to_h do |verb|
-          [verb, %i[p50_us p99_us].to_h { |key| [key, Stats.median(summaries.map { |s| s[:by_verb][verb][key] })] }]
-        end
-      end
-
-      # Reads the Postgres server version if a Postgres target ran.
-      #
-      # @param active [Array<String>] the targets that ran
-      # @return [String, nil] the server version, or nil when no Postgres target ran
-      def postgres_version(active)
-        PostgresProbe.server_version if active.any? { |target| target.start_with?("ruby:postgres") }
-      end
-    end
-  end
-end