duel-activerecord 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56141f41f03d09cf171aeaa7097d59341a1b6b101c855de77ffc472ca0be405a
+  data.tar.gz: 2f8a62b553cfd1bd9432311b301ee93bb37fcdac462f2dd7cca83623d978d0c1
+SHA512:
+  metadata.gz: 652b932685d313d3a9a345fe2044e5c0ffd6c16b2a30491cac55cf498bb82591a5cb7d71d48e6f8969fced24a5fc5140e4e961dfa7a2e977a6109b4a244bc1dd
+  data.tar.gz: 695268da1a1371ff6a78e2021c29f338857321217f05dfe463f74de587242ffde9ba1365c4f44103741949871fae050de6afe9072d5e41f0c25eff4872170cad

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/2.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-24
+
+The first release. duel-activerecord is a Duel plugin, open source
+under the MIT license. It needs Duel 0.1, Active Record 7.2 or later,
+and Ruby 3.4 or later (or JRuby 10, or TruffleRuby 40).
+
+### Added
+
+- `c.use :activerecord`: the `active_record_queries`,
+  `active_record_cached_queries`, `active_record_transactions` and
+  `active_record_instantiations` metrics, from Active Record's
+  notifications, and `active_record_query_time` when asked for
+  (`query_time: true`), with `ignore:` to leave queries out. They're
+  running totals (Duel's `c.metric`), subscribed to in workers only, as
+  each worker opens the metric, and unsubscribed from as it closes it,
+  when the worker ends. Where the queries regressed, Duel shows the
+  statements each version sent most, and how many times an iteration
+  (Duel's `details`). `active_record_query_time` is in nanoseconds
+  (`unit: "ns"`), shown as time. The counts are in queries,
+  transactions and records (`unit:`, each with its plural), so reports
+  read "1 query → 2 queries".
+- Mutation tested: mutant kills every change to the plugin's code, in
+  CI.
+- RBS signatures in sig/, checked with Steep.
+
+[Unreleased]: https://github.com/sferik/duel-ruby/compare/duel-activerecord-v0.1.0...HEAD
+[0.1.0]: https://github.com/sferik/duel-ruby/releases/tag/duel-activerecord-v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erik Berlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,146 @@
+# duel-activerecord
+
+[![Duel](https://raw.githubusercontent.com/sferik/duel-ruby/main/assets/badge.svg)](https://github.com/sferik/duel-ruby)
+[![duel-activerecord](https://github.com/sferik/duel-ruby/actions/workflows/plugin-activerecord.yml/badge.svg)](https://github.com/sferik/duel-ruby/actions/workflows/plugin-activerecord.yml)
+[![Gem Version](https://badge.fury.io/rb/duel-activerecord.svg)](https://rubygems.org/gems/duel-activerecord)
+
+A [Duel](https://github.com/sferik/duel-ruby) plugin for code that uses
+Active Record: every benchmark is judged on what Active Record did for it
+too, whatever the database.
+
+| Metric | What it is | A regression |
+|---|---|---|
+| `active_record_queries` | the queries it sent the database: not schema queries, transactions' own statements (`BEGIN`, `COMMIT`...), or those the query cache answered | any increase |
+| `active_record_cached_queries` | the queries the query cache answered | any increase |
+| `active_record_transactions` | the transactions it opened, and savepoints | any increase |
+| `active_record_instantiations` | the records it instantiated | any increase |
+| `active_record_query_time` (when asked for) | how long its queries took, in elapsed time | > 5% slower, 99% confident |
+
+So a change that adds an N+1 query, or saves records one transaction at
+a time, fails on its counts, exactly, whatever its timings say. And on a
+database server, whose work the benchmark's CPU time doesn't include,
+the counts are the sign of it.
+
+## Installation
+
+```ruby
+# Gemfile
+group :development do
+  gem "duel-activerecord"
+end
+```
+
+> [!NOTE]
+> It needs Active Record 7.2 or later.
+
+## Usage
+
+```ruby
+# .duel.rb
+Duel.configure { |c| c.use :activerecord }
+```
+
+`c.use` requires the plugin, so `.duel.rb` doesn't need to.
+
+The plugin doesn't give workers a database: they connect as your
+benchmarks do (in `duel/duel_helper.rb`, say), to one of their own (an
+in-memory SQLite database, as here, or a file in the directory that
+`c.prepare(:worker)` gives each worker) or to one all of them share. Then any benchmark is judged on
+its queries:
+
+```ruby
+# duel/duel_helper.rb
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+load "db/schema.rb"
+10.times { |i| Post.create!(title: "post #{i}").comments.create! }
+
+# duel/posts_duel.rb
+require_relative "duel_helper"
+
+duel "posts: the index page" do
+  PostsPresenter.new(Post.all).rows # one query for posts, one for their comments
+end
+```
+
+A change that loads each post's comments on its own fails, and says
+which statements each version sent most, and how many times an
+iteration:
+
+```
+! posts: the index page   1.2s n=2   ...   active_record_queries 4→22  active_record_cached_queries 0  active_record_transactions 0  active_record_instantiations 40 records  ...
+REGRESSION posts: the index page: worse instructions, cpu, active_record_queries, allocations in every measurement
+  ...
+  active_record_queries: 2 queries → 11 queries an iteration
+  active_record_queries (candidate): an iteration: 10× SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = ?; 1× SELECT "posts".* FROM "posts"
+  active_record_queries (baseline): an iteration: 1× SELECT "comments".* FROM "comments" WHERE "comments"."post_id" IN (?, ?, ?, ?, ?, ?, ?, ?, ?, ?); 1× SELECT "posts".* FROM "posts"
+```
+
+> [!TIP]
+> Queries a benchmark makes to set itself up each time go in `untimed`,
+> which pauses every metric, these too.
+
+Options:
+
+```ruby
+c.use :activerecord,
+  query_time: true,                                            # active_record_query_time too (default: false)
+  ignore: ->(payload) { payload[:sql].start_with?("PRAGMA") } # queries not to count, nor time
+```
+
+`ignore` gets each query's `sql.active_record` payload (`:sql`, `:name`,
+`:binds`...). Duel's `c.measure` changes a measure's settings, or leaves
+it out (and the plugin doesn't subscribe to what no measure left needs):
+
+```ruby
+c.measure("active_record_query_time", limit: 1.1)
+c.measure("active_record_instantiations", skip: true)
+```
+
+## How it measures
+
+From Active Record's own notifications (`sql.active_record`,
+`transaction.active_record` and `instantiation.active_record`), in every
+thread of the worker, as running totals (Duel's `c.metric`). Reading
+them queries nothing, so there's nothing for Duel to take away
+(`calibrate: false`). Counts are shown in their units (queries,
+transactions, records: `1 query`, `2 queries`, though the summary line
+leaves out the one a name ends in), and
+`active_record_query_time` is in nanoseconds (`unit: "ns"`), shown as
+time.
+
+It subscribes in each worker as Duel opens its metric (the metric's
+`open`), once the benchmark files have loaded, so queries made while
+they load (a schema, seeds) aren't counted, and the runner, which loads
+`.duel.rb` too, never loads Active Support for it. It unsubscribes when
+the worker ends (the metric's `close`).
+
+It also keeps track of the statement each of the last 1,000 queries
+sent, by its SQL (with binds, `WHERE id = ?`, the same statement for
+every id). That's a hash of the SQL for each query, and no copy of it
+(nothing a benchmark's allocations would count), but it holds on to the
+SQL of the first eight statements sent since a sample was last
+explained (with [duel-retained](https://github.com/sferik/duel-ruby/tree/main/plugins/retained),
+that's within its allowance), and the rest are told as others. A regression
+shows the three a sample sent most, and how many times an iteration
+(and others'), of its last 1,000 queries, but those in `untimed` blocks,
+with at most 100 characters of each.
+
+`active_record_queries` counts what Rails' log counts as queries, but
+leaves out cached ones, which never reach the database: they're
+`active_record_cached_queries`. Transactions are counted on their own, once each
+(not their `BEGIN` and `COMMIT`), and only those Active Record opened
+(an empty `transaction` block opens none).
+
+### Why `active_record_query_time` is off unless asked for
+
+It's elapsed time, which Duel otherwise never judges: a busy machine
+adds to it, and so does anything else the database is doing. With
+SQLite, it's time the benchmark's CPU time already counts. With a
+database server, it's mostly waiting: on the network, and on a server
+that may be serving other workers too. Paired side by side, the two
+versions see much the same of that, so it can settle a large
+difference, and it's judged like CPU time but with a looser limit (5%),
+and only for samples with 0.3 ms of it. But for what the server did, its
+own statistics are the better measure (as
+[duel-redis](https://github.com/sferik/duel-ruby/tree/main/plugins/redis) reads Redis's), and
+the query counts catch most of what makes it slower.

data/lib/duel/activerecord/version.rb

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

data/lib/duel/activerecord.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "duel"
+require_relative "activerecord/version"
+
+module Duel
+  # What Active Record did for each benchmark, from its notifications,
+  # whatever the database:
+  #
+  # - active_record_queries: the queries it sent the database (counted),
+  #   but schema queries, transactions' own statements (BEGIN, COMMIT...)
+  #   and those the query cache answered
+  # - active_record_cached_queries: the queries the query cache answered
+  #   (counted)
+  # - active_record_transactions: the transactions, and savepoints, it
+  #   opened (counted)
+  # - active_record_instantiations: the records it instantiated (counted)
+  # - active_record_query_time, when asked for: how long the queries
+  #   took, in elapsed time (a ratio metric, in nanoseconds, like CPU
+  #   time)
+  #
+  #   # .duel.rb
+  #   Duel.configure { |c| c.use :activerecord }
+  #
+  # It subscribes to the notifications in workers only, as its metric is
+  # opened, once the benchmarks have loaded (so the runner never loads
+  # Active Support for it), and unsubscribes when the worker ends. Where the queries
+  # regressed, it says which statements a sample sent most, on each
+  # version (Counter#details).
+  module ActiveRecord
+    Duel.plugin(:activerecord, self)
+
+    # Counts. Reading them queries nothing, so there's nothing to take
+    # away.
+    MEASURES = {
+      "active_record_queries" => {kind: :counted, unit: %w[query queries], calibrate: false},
+      "active_record_cached_queries" => {kind: :counted, unit: %w[query queries], calibrate: false},
+      "active_record_transactions" => {kind: :counted, unit: %w[transaction transactions], calibrate: false},
+      "active_record_instantiations" => {kind: :counted, unit: %w[record records], calibrate: false}
+    }
+
+    # Elapsed time, measured when asked for (see the README).
+    QUERY_TIME = {"active_record_query_time" => {kind: :ratio, unit: "ns", floor: 300_000, limit: 1.05}}
+
+    # Configures Duel for the plugin (c.use :activerecord): its metrics,
+    # and +query_time+ too if true. +ignore+, if given, is called with
+    # each query's notification payload, and a query it's true for isn't
+    # counted, nor timed. Returns the Counter.
+    def self.configure(config, query_time: false, ignore: nil)
+      counter = Counter.new(query_time:, ignore:)
+      measures = query_time ? MEASURES.merge(QUERY_TIME) : MEASURES
+      config.metric(measures) { counter.totals }
+        .open { counter.subscribe(measures.keys.reject { |name| config.skip?(name) }) }
+        .close { counter.unsubscribe }
+        .details { |stretches, sample| counter.details(stretches, sample.n) }
+      counter
+    end
+
+    # Running totals, from the notifications it subscribes to. One object
+    # (Active Support calls its #start and #finish, the cheapest kind of
+    # subscriber) for every event.
+    class Counter
+      SQL = "sql.active_record"
+      TRANSACTION = "transaction.active_record"
+      INSTANTIATION = "instantiation.active_record"
+
+      # The events each measure needs.
+      EVENTS = {
+        "active_record_queries" => SQL, "active_record_cached_queries" => SQL, "active_record_query_time" => SQL,
+        "active_record_transactions" => TRANSACTION, "active_record_instantiations" => INSTANTIATION
+      }.freeze
+
+      # Where a query's start is kept until it finishes (queries in
+      # several threads or fibers at once each have their own).
+      STARTED = :duel_activerecord_started
+
+      # The queries counted last that it keeps track of (which statement
+      # each was), for #details.
+      KEPT = 1000
+
+      # The most statements whose SQL it keeps between two #details
+      # (the first sent: the rest are told as others).
+      STATEMENTS = 8
+
+      # The most statements shown, and the most shown of each one's SQL.
+      SHOWN = 3
+      LENGTH = 100
+
+      def initialize(query_time:, ignore:)
+        @query_time = query_time
+        @ignore = ignore
+        @queries = @cached = @transactions = @instantiations = @time = 0
+        @subscriptions = [] #: Array[untyped]
+        # Each query's SQL's hash, round (the first KEPT make it).
+        @recent = [] #: Array[Integer]
+        @sql = {} #: Hash[Integer, String]
+      end
+
+      # Subscribes to the events +measures+ need (see EVENTS).
+      def subscribe(measures)
+        @timing = measures.include?("active_record_query_time")
+        @subscriptions = measures.map { |measure| EVENTS.fetch(measure) }.uniq.map do |event|
+          notifications.subscribe(event, self)
+        end
+      end
+
+      # The totals so far, by name.
+      def totals
+        totals = {"active_record_queries" => @queries, "active_record_cached_queries" => @cached,
+                  "active_record_transactions" => @transactions, "active_record_instantiations" => @instantiations}
+        @query_time ? totals.merge("active_record_query_time" => @time) : totals
+      end
+
+      # What explains the queries a sample sent, in its stretches (pairs
+      # of readings of the totals: see Snapshot#details) of +n+
+      # iterations: the statements sent most (of the last KEPT), and how
+      # many times an iteration, the SHOWN most and others: "an
+      # iteration: 3× SELECT ...; 1× others". Nothing where none were. It
+      # forgets their SQL.
+      def details(stretches, n)
+        oldest = @queries - KEPT
+        keys = stretches.flat_map do |started, stopped|
+          ([queries(started), oldest].max...queries(stopped)).map { |i| @recent.fetch(i % KEPT) }
+        end
+        return if keys.empty?
+
+        sent = keys.tally.filter_map { |key, count| [count, @sql.fetch(key)] if @sql.key?(key) } #: Array[[Integer, String]]
+        shown = sent.sort_by { |count, sql| [-count, sql] }.first(SHOWN)
+        others = keys.size - shown.sum { |count, _| count }
+        shown << [others, "others"] if others.positive?
+        {"active_record_queries" => "an iteration: #{shown.map { |count, sql| "#{format("%.4g", count.fdiv(n))}× #{shorten(sql)}" }.join("; ")}"}
+      ensure
+        @sql.clear
+      end
+
+      # Stops counting.
+      def unsubscribe = @subscriptions.each { |subscription| notifications.unsubscribe(subscription) }
+
+      # (Active Support's, for every event subscribed to.)
+      def start(name, _id, _payload)
+        (Thread.current[STARTED] ||= []) << monotonic if @timing && name == SQL
+      end
+
+      def finish(name, _id, payload)
+        case name
+        when SQL then query(payload)
+        when TRANSACTION then @transactions += 1
+        else @instantiations += payload.fetch(:record_count)
+        end
+      end
+
+      private
+
+      def query(payload)
+        took = monotonic - Thread.current.fetch(STARTED).pop if @timing
+        name = payload[:name]
+        return if name == "SCHEMA" || @ignore&.call(payload)
+
+        @time += took if took
+        return if name == "TRANSACTION"
+        return @cached += 1 if payload[:cached]
+
+        sent(payload.fetch(:sql))
+        @queries += 1
+      end
+
+      # Keeps track of the statement a query sent, by its SQL's hash (no
+      # copy of it, and nothing allocated: what a benchmark allocates is
+      # measured), and its SQL, for the first STATEMENTS.
+      def sent(sql)
+        key = sql.hash
+        @recent[@queries % KEPT] = key
+        @sql[key] = sql if @sql.size < STATEMENTS
+      end
+
+      # The queries counted by a reading of the totals.
+      def queries(reading) = reading.total("active_record_queries")
+
+      # +sql+ on one line, and at most LENGTH long.
+      def shorten(sql)
+        line = sql.gsub(/\s+/, " ").strip
+        (line.length > LENGTH) ? "#{line[0, LENGTH - 3]}..." : line
+      end
+
+      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+
+      # Active Support's notifications, loaded when it first subscribes
+      # (in a worker: never in the runner).
+      # mutant:disable -- the tests have loaded Active Support, so leaving
+      # out the require can't fail them in their process
+      # (test_subscribes_in_the_worker checks it, in a process of its own)
+      def notifications
+        require "active_support/notifications"
+        ::ActiveSupport::Notifications
+      end
+    end
+  end
+end

data/sig/duel/activerecord.rbs

@@ -0,0 +1,99 @@
+module Duel
+  # What Active Record did for each benchmark, from its notifications
+  # (active_record_queries, active_record_cached_queries,
+  # active_record_transactions, active_record_instantiations and, when
+  # asked for, active_record_query_time).
+  module ActiveRecord
+    # A notification's payload, as Active Record gives it.
+    type payload = Hash[Symbol, untyped]
+
+    VERSION: String
+
+    # Counts.
+    MEASURES: Hash[String, Metric::settings]
+
+    # Elapsed time, measured when asked for.
+    QUERY_TIME: Hash[String, Metric::settings]
+
+    # Configures Duel for the plugin (c.use :activerecord): its metrics,
+    # and +query_time+ too if true. A query +ignore+ is true for isn't
+    # counted, nor timed. Returns the Counter.
+    def self.configure: (Config config, ?query_time: bool, ?ignore: (^(payload payload) -> boolish)?) -> Counter
+
+    # Running totals, from the notifications it subscribes to.
+    class Counter
+      SQL: String
+      TRANSACTION: String
+      INSTANTIATION: String
+
+      # The events each measure needs.
+      EVENTS: Hash[String, String]
+
+      # Where a query's start is kept until it finishes.
+      STARTED: Symbol
+
+      # The queries counted last that it keeps track of.
+      KEPT: Integer
+
+      # The most statements whose SQL it keeps between two #details.
+      STATEMENTS: Integer
+
+      # The most statements shown, and the most shown of each one's SQL.
+      SHOWN: Integer
+      LENGTH: Integer
+
+      @query_time: bool
+      @ignore: (^(payload payload) -> boolish)?
+      @timing: bool
+      @queries: Integer
+      @cached: Integer
+      @transactions: Integer
+      @instantiations: Integer
+      @time: Integer
+      @subscriptions: Array[untyped]
+      @recent: Array[Integer]
+      @sql: Hash[Integer, String]
+
+      def initialize: (query_time: bool, ignore: (^(payload payload) -> boolish)?) -> void
+
+      # Subscribes to the events +measures+ need.
+      def subscribe: (Array[String] measures) -> void
+
+      # The totals so far, by name.
+      def totals: () -> Hash[String, Integer]
+
+      # What explains the queries a sample of +n+ iterations sent, in its
+      # stretches: the statements sent most, and how many times an
+      # iteration. It forgets their SQL.
+      def details: (Snapshot::stretches[Integer, nil] stretches, Integer n) -> Hash[String, String]?
+
+      # Stops counting.
+      def unsubscribe: () -> void
+
+      # (Active Support's, for every event subscribed to.)
+      def start: (String name, String id, payload payload) -> void
+
+      def finish: (String name, String id, payload payload) -> void
+
+      private
+
+      def query: (payload payload) -> void
+
+      # Keeps track of the statement a query sent, and its SQL, for the
+      # first STATEMENTS.
+      def sent: (String sql) -> void
+
+      # The queries counted by a reading of the totals.
+      def queries: (Snapshot::Reading[Integer, nil] reading) -> Integer
+
+      # +sql+ on one line, and at most LENGTH long.
+      def shorten: (String sql) -> String
+
+      def monotonic: () -> Integer
+
+      # Active Support's notifications, loaded when it first subscribes
+      # (untyped: Active Support has no signatures of its own).
+      def notifications: () -> untyped
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: duel-activerecord
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Erik Berlin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: duel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+description: 'A Duel plugin: every benchmark is judged on the SQL queries, cached
+  queries, transactions and record instantiations Active Record did for it too, whatever
+  the database.'
+email:
+- sferik@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/duel/activerecord.rb
+- lib/duel/activerecord/version.rb
+- sig/duel/activerecord.rbs
+homepage: https://github.com/sferik/duel-ruby/tree/main/plugins/activerecord
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sferik/duel-ruby/tree/main/plugins/activerecord
+  changelog_uri: https://github.com/sferik/duel-ruby/blob/main/plugins/activerecord/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sferik/duel-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.23
+specification_version: 4
+summary: 'What Active Record did for each Duel benchmark: queries, transactions and
+  records'
+test_files: []