schema_reaper 2.0.0 → 2.1.0

data/lib/schema_reaper/baseline.rb

@@ -2,34 +2,119 @@
 
 require "json"
 require "fileutils"
+require "date"
 
 module SchemaReaper
   # Persists known finding ids so CI only fails on *new* dead weight.
+  #
+  # Each accepted finding can carry a reason and an expiry date. Once an entry
+  # expires, `scan --ci` treats the finding as new again, so "we'll deal with
+  # it later" comes back around instead of living in the file forever.
+  #
+  # Reads the 2.0 format ({"ids": [...]}) as entries with no reason or expiry,
+  # and keeps writing "ids" alongside "entries" so a 2.0.x gem sharing the
+  # file (mixed versions across a team or CI) still sees the accepted set.
+  #
+  # scope: analyzer types (e.g. %w[dead_column]) a write or prune is limited
+  # to -- what `--only` / `--except` selected. Entries of other analyzers
+  # were not looked at in this run, so they are left exactly as they are.
   class Baseline
+    Entry = Struct.new(:id, :reason, :expires_on, keyword_init: true) do
+      def expired?(today = Date.today)
+        !expires_on.nil? && expires_on < today
+      end
+
+      def type
+        id.split("/").first
+      end
+
+      def to_h
+        { "id" => id, "reason" => reason, "expires_on" => expires_on&.iso8601 }.compact
+      end
+    end
+
     def initialize(path)
       @path = path
     end
 
+    def entries
+      @entries ||= read_entries
+    end
+
+    # Ids still accepted today (expired entries excluded).
     def ids
-      return [] unless File.exist?(@path)
+      entries.reject(&:expired?).map(&:id)
+    end
 
-      JSON.parse(File.read(@path)).fetch("ids", [])
-    rescue JSON::ParserError
-      []
+    def expired
+      entries.select(&:expired?)
+    end
+
+    # Replaces the (in-scope part of the) baseline with exactly these
+    # findings. A reason / expiry passed in applies to new entries and to
+    # expired ones being re-accepted -- that is how an expired entry gets
+    # renewed; unexpired entries keep what they had.
+    def write(findings, reason: nil, expires_on: nil, scope: nil)
+      known = entries.to_h { |e| [e.id, e] }
+      kept = entries.reject { |e| in_scope?(e, scope) }
+      written = findings.map(&:id).uniq.map do |id|
+        entry = known[id]
+        next Entry.new(id: id, reason: reason, expires_on: expires_on) unless entry
+        next renew(entry, reason, expires_on) if entry.expired?
+
+        entry
+      end
+      @entries = (kept + written).uniq(&:id).sort_by(&:id)
+      save
     end
 
-    def write(findings)
+    # Drops entries for findings that no longer occur, without accepting any
+    # new ones -- so a fixed finding can't hide a later regression with the
+    # same id. @return [Array<String>] dropped ids
+    def prune(findings, scope: nil)
+      current = findings.map(&:id)
+      dropped = entries.select { |e| in_scope?(e, scope) && !current.include?(e.id) }.map(&:id)
+      @entries = entries.reject { |e| dropped.include?(e.id) }
+      save
+      dropped
+    end
+
+    # findings not present in the stored baseline (or whose entry expired)
+    def new_among(findings)
+      known = ids
+      findings.reject { |f| known.include?(f.id) }
+    end
+
+    private
+
+    def in_scope?(entry, scope)
+      scope.nil? || scope.include?(entry.type)
+    end
+
+    def renew(entry, reason, expires_on)
+      Entry.new(id: entry.id, reason: reason || entry.reason, expires_on: expires_on)
+    end
+
+    def save
       FileUtils.mkdir_p(File.dirname(@path))
       File.write(@path, JSON.pretty_generate(
                           "generated_at" => Time.now.utc.iso8601,
-                          "ids" => findings.map(&:id).sort
+                          "ids" => ids.sort, # read by 2.0.x; unexpired only
+                          "entries" => entries.map(&:to_h)
                         ))
     end
 
-    # findings not present in the stored baseline
-    def new_among(findings)
-      known = ids
-      findings.reject { |f| known.include?(f.id) }
+    def read_entries
+      return [] unless File.exist?(@path)
+
+      data = JSON.parse(File.read(@path))
+      return data.fetch("ids", []).map { |id| Entry.new(id: id) } unless data.key?("entries")
+
+      data["entries"].map do |e|
+        Entry.new(id: e["id"], reason: e["reason"], expires_on: e["expires_on"] && Date.parse(e["expires_on"]))
+      end
+    rescue JSON::ParserError, ArgumentError
+      []
     end
   end
 end

data/lib/schema_reaper/cli/baseline_support.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "date"
+
+module SchemaReaper
+  class CLI < Thor
+    # Output helpers for `baseline` and the `scan --ci` gate.
+    module BaselineSupport
+      private
+
+      def report_written(findings, scope)
+        console.ok("recorded #{findings.size} finding#{"s" unless findings.size == 1} " \
+                   "as the accepted baseline")
+        console.info("file: #{config.baseline_path}")
+        console.info("only #{scope.join(", ")} entries were replaced; other analyzers' are unchanged") if scope
+        console.info("`scan --ci` now fails only on findings that appear after this point.")
+      end
+
+      def report_pruned(dropped)
+        return console.ok("nothing to prune -- every baseline entry still occurs") if dropped.empty?
+
+        console.ok("dropped #{dropped.size} resolved entr#{dropped.size == 1 ? "y" : "ies"}")
+        dropped.each { |id| console.info("  #{id}") }
+      end
+
+      def parse_date(value)
+        return nil unless value
+
+        Date.iso8601(value)
+      rescue ArgumentError
+        console.problem("--expires must be a date like 2027-01-31, got #{value.inspect}")
+        exit 1
+      end
+
+      def warn_expired(expired, findings)
+        current = findings.map(&:id)
+        live = expired.select { |e| current.include?(e.id) }
+        return if live.empty?
+
+        console.notice("#{live.size} baseline entr#{live.size == 1 ? "y has" : "ies have"} expired and count as new:")
+        live.each { |e| console.info("  #{e.id} (expired #{e.expires_on}#{" -- #{e.reason}" if e.reason})") }
+      end
+    end
+  end
+end

data/lib/schema_reaper/cli.rb

@@ -2,16 +2,23 @@
 
 require "thor"
 require_relative "../schema_reaper"
+require_relative "cli/baseline_support"
 
 module SchemaReaper
   # Command-line entry point. See `exe/schema_reaper`.
   class CLI < Thor
+    include BaselineSupport
+
     def self.exit_on_failure?
       true
     end
 
     class_option :config, type: :string, default: ".schema_reaper.yml",
                           desc: "path to config file"
+    class_option :color, type: :boolean, default: nil,
+                         desc: "force colour on/off (default: auto)"
+    class_option :only, type: :array, desc: "run only these analyzers (e.g. dead_column unused_index)"
+    class_option :except, type: :array, desc: "skip these analyzers"
 
     desc "scan", "Scan schema + code and report dead weight"
     option :format, type: :string, default: "table",
@@ -20,11 +27,10 @@ module SchemaReaper
                 desc: "exit non-zero on findings not in the baseline"
     option :record, type: :boolean, default: false,
                     desc: "append this run to the history log"
-    option :min_confidence, type: :numeric, default: 0.0
-    option :color, type: :boolean, default: nil,
-                   desc: "force colour on/off for the table report (default: auto)"
+    option :min_confidence, type: :numeric,
+                            desc: "hide findings below this confidence (default: min_confidence in config, 0.0)"
     def scan
-      findings = run.select { |f| f.confidence >= options[:min_confidence] }
+      findings = run(min_confidence: options[:min_confidence])
       render_report(findings)
 
       History.new(config.history_log).record(findings) if options[:record]
@@ -32,14 +38,20 @@ module SchemaReaper
     end
 
     desc "baseline", "Write current findings to the baseline file"
+    option :reason, type: :string, desc: "why these findings are accepted (set on new and expired entries)"
+    option :expires, type: :string, desc: "YYYY-MM-DD after which `scan --ci` fails on them again " \
+                                          "(renews expired entries)"
+    option :prune, type: :boolean, default: false,
+                   desc: "only drop entries for findings that no longer occur; accept nothing new"
     def baseline
       findings = run
-      Baseline.new(config.baseline_path).write(findings)
+      store = Baseline.new(config.baseline_path)
       console.title("baseline")
-      console.ok("recorded #{findings.size} finding#{"s" unless findings.size == 1} " \
-                 "as the accepted baseline")
-      console.info("file: #{config.baseline_path}")
-      console.info("`scan --ci` now fails only on findings that appear after this point.")
+      scope = runner.selected_types
+      return report_pruned(store.prune(findings, scope: scope)) if options[:prune]
+
+      store.write(findings, reason: options[:reason], expires_on: parse_date(options[:expires]), scope: scope)
+      report_written(findings, scope)
     end
 
     desc "trend", "Append a snapshot and print progress over time"
@@ -49,8 +61,17 @@ module SchemaReaper
       Reporters::Trend.new(history.trend, color: options[:color]).render
     end
 
-    desc "generate-migration TABLE COLUMN", "Emit a staged removal migration pair"
-    def generate_migration(table, column)
+    desc "generate-migration TABLE [COLUMN]",
+         "Emit a staged removal migration pair for a column, or a removal migration for an index (--index) or table"
+    option :index, type: :string, desc: "name of an index on TABLE to remove instead of a column"
+    def generate_migration(table, column = nil)
+      if options[:index] && column
+        console.problem("pass either COLUMN or --index, not both")
+        exit 1
+      end
+      return generate_index_migration(table, options[:index]) if options[:index]
+      return generate_table_migration(table) unless column
+
       paths = MigrationGenerator.new(table: table, column: column).call
       console.title("generate-migration", "#{table}.#{column}")
       console.ok("created two migrations:")
@@ -62,6 +83,16 @@ module SchemaReaper
                    ])
     end
 
+    desc "explain ID", "Show everything known about one finding and the command to act on it"
+    def explain(id)
+      exit 1 unless Explain.new(run, config: config, console: console).call(id)
+    end
+
+    desc "doctor", "Check the database, statistics, runtime log, baseline and alert setup"
+    def doctor
+      exit 1 unless Doctor.new(config: config, console: console).call
+    end
+
     desc "version", "Print version"
     def version
       say(SchemaReaper::VERSION)
@@ -69,12 +100,34 @@ module SchemaReaper
 
     private
 
+    def generate_index_migration(table, index)
+      path = MigrationGenerator.new(table: table, index: index).call.first
+      console.title("generate-migration", "#{table} · #{index}")
+      console.ok("created #{path}")
+      console.info("runs with algorithm: :concurrently, so it does not lock writes to #{table}")
+    end
+
+    def generate_table_migration(table)
+      path = MigrationGenerator.new(table: table).call.first
+      console.title("generate-migration", table)
+      console.ok("created #{path}")
+      console.list("before running it:", [
+                     "confirm no external consumer (reports, ETL, other services) reads #{table}",
+                     "take a backup -- its `down` cannot bring the data back"
+                   ])
+    end
+
     def config
       @config ||= Config.load(options[:config])
     end
 
-    def run
-      Runner.new(config: config).run
+    def runner(min_confidence: nil)
+      @runner ||= Runner.new(config: config, only: options[:only], except: options[:except],
+                             min_confidence: min_confidence)
+    end
+
+    def run(min_confidence: nil)
+      runner(min_confidence: min_confidence).run
     rescue SchemaReaper::Error => e
       console.problem(e.message)
       exit 1
@@ -93,7 +146,9 @@ module SchemaReaper
     end
 
     def enforce_baseline(findings)
-      new_ones = Baseline.new(config.baseline_path).new_among(findings)
+      store = Baseline.new(config.baseline_path)
+      warn_expired(store.expired, findings)
+      new_ones = store.new_among(findings)
       return if new_ones.empty?
 
       console.problem(

data/lib/schema_reaper/config.rb

@@ -9,6 +9,7 @@ module SchemaReaper
   class Config
     DEFAULTS = {
       "database_url" => nil,          # falls back to ENV["DATABASE_URL"]
+      "schemas" => %w[public],        # PostgreSQL schemas to introspect
       "scan_paths" => %w[app lib config],
       "view_globs" => %w[
         app/**/*.erb app/**/*.haml app/**/*.slim app/**/*.jbuilder
@@ -20,9 +21,16 @@ module SchemaReaper
       "always_keep_columns" => %w[id created_at updated_at type],
       "gem_awareness" => true,        # auto-whitelist columns owned by known gems
       "min_age_days" => 14,
+      "min_confidence" => 0.0,        # drop findings below this from every command
+      "runtime_log_max_bytes" => 50 * 1024 * 1024, # rotate the usage log past this size
       "runtime_log" => ".schema_reaper/runtime.jsonl",
       "history_log" => ".schema_reaper/history.jsonl",
       "baseline" => ".schema_reaper/baseline.json",
+      "scan_cache" => ".schema_reaper/scan_cache.json", # per-file scan cache; null disables
+      # global: a column counts as used if its name appears anywhere.
+      # model:  a name in an app/models file only counts for that model's
+      #         table and the tables it mentions -- stricter, finds more.
+      "column_scope" => "global",
       "database_yml" => "config/database.yml", # Rails fallback for the connection
       "require" => [] # extra files to load (custom analyzers)
     }.freeze
@@ -74,6 +82,18 @@ module SchemaReaper
       @data.dig("ignore", "tables").to_a
     end
 
+    def schemas
+      Array(@data["schemas"]).map(&:to_s)
+    end
+
+    def min_confidence
+      @data["min_confidence"].to_f
+    end
+
+    def runtime_log_max_bytes
+      @data["runtime_log_max_bytes"]
+    end
+
     def min_age_days
       @data["min_age_days"]
     end
@@ -90,6 +110,14 @@ module SchemaReaper
       @data["history_log"]
     end
 
+    def scan_cache
+      @data["scan_cache"]
+    end
+
+    def column_scope
+      @data["column_scope"].to_s == "model" ? :model : :global
+    end
+
     def gem_awareness?
       @data["gem_awareness"] != false
     end

data/lib/schema_reaper/doctor.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "time"
+
+module SchemaReaper
+  # `schema_reaper doctor`: checks everything a scan's accuracy depends on and
+  # says what to fix, so a quiet report can be trusted to mean "nothing dead"
+  # rather than "nothing measured".
+  class Doctor
+    Check = Struct.new(:status, :label, :detail, keyword_init: true) # status: :ok | :warn | :fail
+
+    STATS_FRESH_DAYS = 7
+    ICON = { ok: "✓", warn: "!", fail: "✗" }.freeze
+
+    def initialize(config:, root: Dir.pwd, introspector: nil, console: Reporters::Console.new)
+      @config = config
+      @root = root
+      @introspector = introspector
+      @console = console
+      @checks = []
+    end
+
+    # @return [Boolean] true unless a check failed outright
+    def call
+      check_scan_paths
+      check_database
+      check_runtime_log
+      check_baseline
+      check_schema_file
+      check_alerts
+      render
+      @checks.none? { |c| c.status == :fail }
+    end
+
+    private
+
+    def ok(label, detail = nil)
+      @checks << Check.new(status: :ok, label: label, detail: detail)
+    end
+
+    def warn_check(label, detail)
+      @checks << Check.new(status: :warn, label: label, detail: detail)
+    end
+
+    def fail_check(label, detail)
+      @checks << Check.new(status: :fail, label: label, detail: detail)
+    end
+
+    def check_scan_paths
+      missing = @config.scan_paths.reject { |p| Dir.exist?(File.join(@root, p)) }
+      return ok("scan paths", @config.scan_paths.join(", ")) if missing.empty?
+
+      warn_check("scan paths", "not found: #{missing.join(", ")} -- code there can't mark anything as used")
+    end
+
+    def check_database
+      intro = @introspector || Introspect::Postgres.new(@config.database_url, schemas: @config.schemas)
+      diag = intro.diagnostics
+      ok("database", "connected, PostgreSQL #{diag[:server_version]}")
+      check_stats_reset(diag[:stats_reset])
+      check_analyze(diag[:never_analyzed])
+      check_query_history(intro.call)
+      if diag[:in_recovery]
+        warn_check("replica", "this is a read replica -- index usage here doesn't cover the primary")
+      end
+    rescue Error => e
+      fail_check("database", e.message)
+    end
+
+    def check_stats_reset(reset_at)
+      return ok("statistics", "never reset") if reset_at.nil?
+
+      days = ((Time.now - Time.parse(reset_at.to_s)) / 86_400).floor
+      return ok("statistics", "collected for #{days} day(s)") if days >= STATS_FRESH_DAYS
+
+      warn_check("statistics", "reset #{days} day(s) ago -- unused_index needs a longer window to be trusted")
+    end
+
+    def check_analyze(tables)
+      return ok("ANALYZE", "every table has planner statistics") if tables.empty?
+
+      sample = tables.first(5).join(", ") + (tables.size > 5 ? ", ..." : "")
+      warn_check("ANALYZE", "#{tables.size} table(s) never analysed (#{sample}) -- " \
+                            "row counts and null/distinct checks are blind there; run ANALYZE")
+    end
+
+    def check_query_history(schema)
+      return ok("query history", "#{schema.index_scan_total} index scans recorded") if schema.query_history?
+
+      warn_check("query history", "only #{schema.index_scan_total} index scan(s) -- unused_index will sit out; " \
+                                  "scan a database that serves real traffic")
+    end
+
+    def check_runtime_log
+      report = Runtime::Report.load(@config.runtime_log)
+      need = @config.min_age_days || Config::DEFAULTS["min_age_days"]
+      if report.empty?
+        warn_check("runtime log", "none at #{@config.runtime_log} -- dead_column confidence stays capped at " \
+                                  "#{Analyzers::DeadColumn::STATIC_ONLY_CAP}; see README > Runtime signal")
+      elsif report.observed_days < need
+        warn_check("runtime log", "#{report.observed_days} of #{need} day(s) observed -- not trusted yet")
+      else
+        ok("runtime log", "#{report.observed_days} day(s), #{report.accessed.size} column(s) seen")
+      end
+    end
+
+    def check_baseline
+      base = Baseline.new(@config.baseline_path)
+      return ok("baseline", "none (scan --ci would fail on every finding)") if base.entries.empty?
+
+      expired = base.expired
+      return ok("baseline", "#{base.entries.size} accepted finding(s)") if expired.empty?
+
+      warn_check("baseline", "#{expired.size} entr#{expired.size == 1 ? "y has" : "ies have"} expired: " \
+                             "#{expired.map(&:id).first(3).join(", ")}")
+    end
+
+    def check_schema_file
+      path = SchemaLocator::CANDIDATES.find { |p| File.exist?(File.join(@root, p)) }
+      return ok("schema file", path) if path
+
+      warn_check("schema file", "no db/schema.rb or db/structure.sql -- SARIF results can't point at a line")
+    end
+
+    # Only meaningful inside a Rails app with the install generator's
+    # initializer loaded.
+    def check_alerts
+      return unless defined?(AlertConfig) && defined?(Rails)
+
+      cfg = AlertConfig.instance
+      unless cfg.configured?
+        return warn_check("alerts", "no emails or webhook_url configured -- scheduled scans report nowhere")
+      end
+
+      channels = [("email (#{cfg.emails.size})" if cfg.emails?), ("webhook" if cfg.webhook?)].compact
+      ok("alerts", "#{channels.join(" + ")}, alert_on: #{cfg.alert_on}")
+    end
+
+    def render
+      @console.title("doctor")
+      @checks.each do |c|
+        line = format("%<icon>s %<label>-14s %<detail>s", icon: ICON[c.status], label: c.label, detail: c.detail)
+        @console.info(line)
+      end
+      @console.blank
+      counts = @checks.group_by(&:status).transform_values(&:size)
+      @console.info("#{counts.fetch(:ok, 0)} ok, #{counts.fetch(:warn, 0)} warning(s), " \
+                    "#{counts.fetch(:fail, 0)} failed")
+    end
+  end
+end

data/lib/schema_reaper/explain.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module SchemaReaper
+  # `schema_reaper explain ID`: everything known about one finding, and the
+  # exact command to act on it.
+  class Explain
+    def initialize(findings, config:, root: Dir.pwd, console: Reporters::Console.new)
+      @findings = findings
+      @config = config
+      @root = root
+      @console = console
+    end
+
+    # @return [Boolean] false when no finding matches
+    def call(query)
+      matches = match(query)
+      if matches.size == 1
+        render(matches.first)
+      elsif matches.empty?
+        report_not_found(query)
+      else
+        report_ambiguous(query, matches)
+      end
+      matches.size == 1
+    end
+
+    private
+
+    # An exact id, else every finding whose id contains the query
+    # ("users/legacy_token" finds dead_column/users/legacy_token).
+    def match(query)
+      exact = @findings.select { |f| f.id == query }
+      exact.any? ? exact : @findings.select { |f| f.id.include?(query) }
+    end
+
+    def report_not_found(query)
+      @console.problem("no current finding matches #{query.inspect}")
+      table_finding = @findings.find { |f| f.type == :dead_table && query.split("/").include?(f.table) }
+      if table_finding
+        @console.info("its table is reported whole as #{table_finding.id} -- per-column and per-index " \
+                      "findings on a dead table are folded into that one")
+        return
+      end
+
+      @console.info("list them with `schema_reaper scan --format json` -- ids look like dead_column/users/legacy_token")
+    end
+
+    def report_ambiguous(query, matches)
+      @console.problem("#{matches.size} findings match #{query.inspect} -- be more specific:",
+                       items: matches.map(&:id))
+    end
+
+    def render(finding)
+      @console.title("explain", finding.id)
+      @console.row("type", finding.type)
+      @console.row("severity", finding.severity)
+      @console.row("confidence", format("%.2f", finding.confidence))
+      @console.row("reclaimable", reclaim(finding))
+      @console.row("defined at", location(finding)) if location(finding)
+      @console.row("baseline", baseline_status(finding))
+      @console.blank
+      @console.list("evidence", finding.evidence, colour: :reset)
+      @console.blank
+      @console.list("fix", [finding.suggested_fix], colour: :reset)
+      next_step = next_command(finding)
+      @console.list("next", [next_step], colour: :reset) if next_step
+    end
+
+    def reclaim(finding)
+      return "unknown (row count unavailable -- run ANALYZE)" unless finding.reclaim_known?
+
+      Reporters::Bytes.human(finding.reclaimable_bytes)
+    end
+
+    def location(finding)
+      @location ||= {}
+      @location[finding.id] ||= begin
+        loc = SchemaLocator.new(root: @root).locate(finding)
+        loc && "#{loc.path}:#{loc.line}"
+      end
+    end
+
+    def baseline_status(finding)
+      entry = Baseline.new(@config.baseline_path).entries.find { |e| e.id == finding.id }
+      return "not accepted (fails `scan --ci`)" unless entry
+      return "accepted, but expired #{entry.expires_on}" if entry.expired?
+
+      ["accepted", entry.reason, entry.expires_on && "until #{entry.expires_on}"].compact.join(" -- ")
+    end
+
+    def next_command(finding)
+      case finding.type
+      when :dead_column, :always_null_column, :single_value_column
+        "bundle exec schema_reaper generate-migration #{finding.table} #{finding.column}"
+      when :unused_index, :duplicate_index
+        "bundle exec schema_reaper generate-migration #{finding.table} --index #{finding.index}"
+      when :dead_table
+        "bundle exec schema_reaper generate-migration #{finding.table}"
+      end
+    end
+  end
+end

data/lib/schema_reaper/gem_awareness.rb

@@ -9,6 +9,18 @@ module SchemaReaper
   module GemAwareness
     # gem name => { table_glob => [column names] }.  "*" table_glob matches any
     # table; an exact name matches only that table.
+    def self.owned(tables)
+      tables.to_h { |t| [t, []] }
+    end
+    private_class_method :owned
+
+    SOLID_QUEUE_TABLES = %w[
+      solid_queue_jobs solid_queue_ready_executions solid_queue_scheduled_executions
+      solid_queue_claimed_executions solid_queue_blocked_executions solid_queue_failed_executions
+      solid_queue_recurring_executions solid_queue_recurring_tasks solid_queue_pauses
+      solid_queue_processes solid_queue_semaphores
+    ].freeze
+
     MAP = {
       "devise" => { "*" => %w[
         encrypted_password reset_password_token reset_password_sent_at
@@ -42,7 +54,25 @@ module SchemaReaper
           resource_owner_type resource_owner_id access_token refresh_token
           expires_in revoked_at previous_refresh_token
         ]
-      }
+      },
+      # Gems below own their tables outright and touch every column from
+      # their own code, so the tables are listed with no columns: ownership
+      # alone keeps every analyzer off them (see Base#gem_reserved?).
+      "solid_queue" => owned(SOLID_QUEUE_TABLES),
+      "solid_cache" => owned(%w[solid_cache_entries]),
+      "solid_cable" => owned(%w[solid_cable_messages]),
+      "good_job" => owned(%w[good_jobs good_job_executions good_job_processes good_job_settings
+                             good_job_batches]),
+      "delayed_job_active_record" => owned(%w[delayed_jobs]),
+      "flipper-active_record" => owned(%w[flipper_features flipper_gates]),
+      "acts-as-taggable-on" => owned(%w[tags taggings]),
+      "doorkeeper" => owned(%w[oauth_applications oauth_access_grants oauth_access_tokens]),
+      "noticed" => owned(%w[noticed_events noticed_notifications]),
+      "activerecord-session_store" => owned(%w[sessions]),
+      # Columns these gems add to app tables; the first is the anchor.
+      "discard" => { "*" => %w[discarded_at] },
+      "acts_as_list" => { "*" => %w[position] },
+      "ancestry" => { "*" => %w[ancestry ancestry_depth children_count] }
     }.freeze
 
     # Table names an installed gem creates and owns outright -- as opposed to