railwatch 0.9.4 → 1.0.0

data/app/models/railwatch/telemetry/transaction.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  module Telemetry
-    class Transaction < TelemetryRecord
-      include Child
-
-      def timeline_label
-        outcome.to_s.first(120)
-      end
-    end
-  end
-end

data/app/models/railwatch/telemetry/view_render.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  module Telemetry
-    class ViewRender < TelemetryRecord
-      include Child
-
-      def timeline_label
-        identifier.to_s.first(120)
-      end
-    end
-  end
-end

data/app/models/railwatch/telemetry/visit.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  module Telemetry
-    class Visit < TelemetryRecord
-      include Child
-
-      # Core Web Vitals reported by the browser client, with Google's
-      # [good, poor] thresholds: at or below good is "good", above poor is
-      # "poor". lcp/inp/ttfb are milliseconds, cls is unitless.
-      VITALS = { lcp: [ 2500, 4000 ], cls: [ 0.1, 0.25 ], inp: [ 200, 500 ], ttfb: [ 800, 1800 ] }.freeze
-
-      def self.rating(metric, value)
-        good, poor = VITALS.fetch(metric)
-        return "good" if value <= good
-        (value > poor) ? "poor" : "needs-improvement"
-      end
-
-      def timeline_label
-        component.to_s.first(120)
-      end
-    end
-  end
-end

data/app/models/railwatch/telemetry_record.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Base class for everything the engine stores about the host application.
-  # An embedded install monitors exactly one application, so this is a plain
-  # second database (`railwatch_telemetry` in the host's database.yml),
-  # separate from the host's own primary and from the engine's meta tables.
-  # The hosted platform keeps one SQLite file per monitored environment
-  # instead: it calls `Railwatch::TelemetryRecord.tenanted("telemetry")`
-  # (activerecord-tenanted) from an initializer, which replaces the
-  # connection below with a per-tenant one, and every telemetry query runs
-  # inside Environment#with_telemetry so the code path is the same in both.
-  class TelemetryRecord < ActiveRecord::Base
-    self.abstract_class = true
-    begin
-      connects_to database: { writing: :railwatch_telemetry, reading: :railwatch_telemetry }
-    rescue ActiveRecord::AdapterNotSpecified, LoadError
-      # No `railwatch_telemetry` entry in this environment's database.yml, or an entry
-      # whose adapter gem is not in the bundle yet (LoadError). A cloud-transport
-      # app has none and still eager-loads this class in production, and so
-      # does the installer's own boot, before it has written the
-      # entry -- so loading must not raise. Using it must, though: without
-      # connects_to this class would inherit ActiveRecord::Base's PRIMARY
-      # connection, and its tables are unprefixed, so a query would read and
-      # a write would corrupt the host application's own tables. Every route
-      # into the connection goes through connection_pool, so refusing here
-      # fails closed for reads and writes alike.
-      def self.connection_pool
-        raise Railwatch::DatabaseNotConfigured,
-              "the `railwatch_telemetry` database (everything the app reports) is not configured for the " \
-              "#{Rails.env} environment; run `bin/rails generate railwatch:install` " \
-              "or add it to config/database.yml (docs/embedded.md)"
-      end
-    end
-
-    # SQLite's auto_vacuum modes. Deleted pages only leave the file in
-    # :incremental, and only when PRAGMA incremental_vacuum asks for them;
-    # :none (the default, and what every database created before
-    # EnableIncrementalVacuum is in) keeps them on the freelist forever.
-    AUTO_VACUUM_MODES = { 0 => :none, 1 => :full, 2 => :incremental }.freeze
-
-    # Everything below reads and writes THIS database, never the host's. The
-    # pragmas are per-database and there is no Active Record wrapper for them,
-    # so they go through this class's own connection on purpose: through
-    # ActiveRecord::Base they would report on, and vacuum, the application's
-    # primary database instead.
-    def self.sqlite? = connection.adapter_name.match?(/sqlite/i)
-
-    def self.auto_vacuum_mode = sqlite? ? AUTO_VACUUM_MODES.fetch(connection.select_value("PRAGMA auto_vacuum").to_i, :unknown) : nil
-
-    def self.freelist_pages = sqlite? ? connection.select_value("PRAGMA freelist_count").to_i : 0
-
-    def self.page_size = sqlite? ? connection.select_value("PRAGMA page_size").to_i : 0
-
-    # Hands freelist pages back to the filesystem, a slice at a time. Each
-    # PRAGMA is its own implicit transaction, so the write lock is taken and
-    # released once per slice rather than held for the whole reclaim -- the
-    # same reason PruneTelemetryJob deletes in bounded batches instead of one
-    # statement. Returns the pages actually reclaimed, which is 0 on a
-    # database that is not in incremental mode: there the pragma is accepted
-    # and does nothing, and calling it would look like work that happened.
-    def self.reclaim_freelist!(slice:, slices:)
-      return 0 unless sqlite? && auto_vacuum_mode == :incremental
-
-      before = freelist_pages
-      slices.times do
-        break if freelist_pages.zero?
-
-        incremental_vacuum(slice.to_i)
-      end
-      before - freelist_pages
-    end
-
-    # Through the raw connection on purpose. incremental_vacuum frees one page
-    # per sqlite3_step, and Active Record's execute steps a statement with no
-    # result columns exactly once -- so through it this pragma frees a single
-    # page whatever count it is handed, which is the kind of no-op that reads
-    # as work done. The sqlite3 gem's own execute steps to completion. Same
-    # raw_connection route Ingest::Writer already takes for its inserts.
-    def self.incremental_vacuum(pages = nil)
-      connection.raw_connection.execute("PRAGMA incremental_vacuum#{"(#{pages})" if pages}")
-    end
-
-    # Records arrive as the gem's wire hashes; this is the shared envelope.
-    def self.envelope_columns(t)
-      t.datetime :occurred_at, null: false, precision: 6
-      t.string :deploy, limit: 128
-      t.string :server, limit: 255
-      t.string :group_hash, limit: 32
-      t.string :trace_id, limit: 36
-      t.string :execution_source, limit: 20
-      t.string :execution_id, limit: 36
-      t.string :execution_preview, limit: 255
-      t.string :execution_stage, limit: 32
-      t.string :user_ref, limit: 255
-      t.string :app_tenant, limit: 255
-    end
-
-    # Platform parity: callers wrap telemetry work in with_tenant. There is one
-    # tenant here, so it is just the block.
-    def self.with_tenant(_slug)
-      yield
-    end
-
-    def self.tenant_exist?(_slug) = true
-  end
-end

data/app/models/railwatch/threshold.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # A performance rule: "requests to * must keep p95 under 2000 ms over 5
-  # minutes". Evaluated by DetectPerformanceIssuesJob against rollups.
-  class Threshold < ApplicationRecord
-    self.table_name = "railwatch_thresholds"
-    MAX_LIMIT = 1_000_000_000
-    MAX_WINDOW_MINUTES = 1_440
-    TARGET_KINDS = %w[requests jobs commands queries scheduled_tasks outgoing_requests
-                      llm_calls llm_tools].freeze
-    METRICS = %w[p95 max avg error_rate failure_rate missed spend tokens truncation_rate].freeze
-
-    # Duration and rate metrics read the same on any timed record, so they are
-    # allowed everywhere. Money and tokens only mean something where a record
-    # carries them: a spend rule on tool calls could never fire, and a rule
-    # that cannot fire is worse than no rule -- it reads as coverage.
-    SHARED_METRICS = %w[p95 max avg error_rate failure_rate missed].freeze
-    LLM_METRICS = %w[spend tokens truncation_rate].freeze
-
-    # Money leads with its symbol; milliseconds and percent follow the number.
-    # The old code assumed two units and branched on the metric name ending in
-    # "rate", which cannot express a dollar sign in front.
-    UNITS = { "spend" => "$", "tokens" => "", "truncation_rate" => "%",
-             "error_rate" => "%", "failure_rate" => "%" }.freeze
-
-    def environment = Environment.current
-
-    validates :target_kind, inclusion: { in: TARGET_KINDS }
-    validates :metric, inclusion: { in: METRICS }
-    validates :limit, numericality: { greater_than: 0, less_than_or_equal_to: MAX_LIMIT }
-    validates :window_minutes, numericality: { only_integer: true, greater_than: 0,
-                                               less_than_or_equal_to: MAX_WINDOW_MINUTES }
-    validates :target, presence: true, length: { maximum: 256 }
-    validates :limit, numericality: { less_than_or_equal_to: 100 }, if: -> { metric&.end_with?("rate") }
-    validates :target, uniqueness: { scope: %i[environment_id target_kind metric] }
-    validate :metric_applies_to_target_kind
-
-    def self.metrics_for(target_kind)
-      target_kind == "llm_calls" ? SHARED_METRICS + LLM_METRICS : SHARED_METRICS
-    end
-
-    def unit = UNITS.fetch(metric, "ms")
-
-    # "$4.50", "2000ms", "5%", "150000" -- the symbol's position is part of
-    # the unit, not something a caller should have to know.
-    def format_value(value)
-      return "$#{value.is_a?(Float) ? format('%.2f', value) : value}" if unit == "$"
-
-      "#{value}#{unit}"
-    end
-
-    def description
-      "#{target_kind} #{target == '*' ? 'all' : target}: #{metric} over #{format_value(limit)} in #{window_minutes}m"
-    end
-
-    private
-
-    def metric_applies_to_target_kind
-      return if metric.blank? || target_kind.blank?
-      return if Threshold.metrics_for(target_kind).include?(metric)
-
-      errors.add(:metric, "is not available for #{target_kind}")
-    end
-  end
-end

data/app/models/railwatch/user.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Who is looking at the dashboard. The platform has accounts and memberships;
-  # an embedded install sits behind the host's own authentication, so this is
-  # whatever the host says it is (Railwatch.config.dashboard_user), defaulting
-  # to a single anonymous operator. Comments, saved views and issue activity
-  # record this id.
-  class User
-    ID = 1
-
-    attr_reader :id, :name, :email
-
-    def self.current = Viewer.user
-    def self.find(id) = find_by(id: id) || raise(ActiveRecord::RecordNotFound, "User #{id}")
-
-    # A host's dashboard_user resolver hands back its own ids, and those ids
-    # are what comments, saved views and issue activity store. Resolving only
-    # ID meant a comment written by user 7 had no author, and assigning an
-    # issue to them raised RecordNotFound. There is no user table to look
-    # anyone up in, so: the viewer when it is them, the anonymous operator
-    # for the default id, and a bare identity carrying the stored id
-    # otherwise, which is everything that is actually known about them.
-    def self.find_by(id:)
-      return nil if id.nil? || id.to_s.empty?
-      viewer = Viewer.user
-      return viewer if viewer && viewer.id.to_s == id.to_s
-      return default if id.to_i == ID
-
-      new(id: id, name: "Operator", email: nil)
-    end
-
-    def self.default = @default ||= new(id: ID, name: "Operator", email: nil)
-
-    def initialize(id:, name:, email: nil)
-      @id = id
-      @name = name
-      @email = email
-    end
-
-    def as_json(*) = { id: id, name: name, email: email, provider: nil, verified: true, editor: "vscode", editor_root: nil }
-    def accounts = [ Railwatch::Embedded::Account ]
-    def ==(other) = other.is_a?(User) && other.id == id
-    alias eql? ==
-    def hash = id.hash
-  end
-end

data/app/models/railwatch/viewer.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Who is looking at the dashboard, request-scoped. The platform's code
-  # reads Current.user; the gem's own Railwatch::Current is the running
-  # execution, so this has a different name. Set from the host's
-  # dashboard_user resolver on every dashboard request.
-  class Viewer < ActiveSupport::CurrentAttributes
-    attribute :user, :environment, :account
-
-    def account = Railwatch::Embedded::Account
-  end
-end

data/app/models/railwatch/window.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # The time range a telemetry page, API call, or MCP tool looks at: one of the
-  # fixed presets ("1h" .. "30d") ending now, or a custom [from, to] pair. The
-  # dashboard, the JSON API, and MCP all resolve their ?window= / "window"
-  # argument through here so the presets and the default agree everywhere.
-  class Window
-    PRESETS = { "1h" => 1.hour, "6h" => 6.hours, "24h" => 24.hours, "7d" => 7.days, "30d" => 30.days }.freeze
-    DEFAULT = "24h"
-    MAX_CUSTOM_RANGE = 90.days
-
-    attr_reader :key, :from, :to
-
-    # A preset key, or anything else for the default.
-    def self.preset(key)
-      key = PRESETS.key?(key.to_s) ? key.to_s : DEFAULT
-      to = Time.current
-      new(key, to - PRESETS[key], to)
-    end
-
-    # A custom range from ?from=&to= when both parse, are in order, and span
-    # no more than MAX_CUSTOM_RANGE; otherwise the preset (or default).
-    def self.parse(window: nil, from: nil, to: nil)
-      custom(from, to) || preset(window)
-    end
-
-    def self.custom(from, to)
-      from = parse_time(from) or return
-      to = to.blank? ? Time.current : parse_time(to) or return
-      new("custom", from, to) if to > from && (to - from) <= MAX_CUSTOM_RANGE
-    end
-
-    def self.parse_time(value)
-      return if value.blank?
-      Time.zone.parse(value.to_s)
-    rescue ArgumentError, TypeError
-      nil
-    end
-    private_class_method :parse_time
-
-    def initialize(key, from, to)
-      @key = key
-      @from = from
-      @to = to
-    end
-
-    def custom? = key == "custom"
-    def range = [ from, to ]
-    def span = to - from
-
-    # The same length immediately before this one, for "vs. previous period".
-    def previous
-      self.class.new(key, from - span, from)
-    end
-
-    def to_h
-      { from: from.iso8601(6), to: to.iso8601(6) }
-    end
-
-    # Query params that reproduce this window on another page.
-    def to_params
-      custom? ? to_h : { window: key }
-    end
-  end
-end

data/app/views/layouts/railwatch/dashboard.html.erb

@@ -1,25 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title inertia><%= content_for(:title) || "Railwatch" %></title>
-    <meta name="viewport" content="width=device-width,initial-scale=1">
-    <meta name="application-name" content="Railwatch">
-    <meta name="railwatch-mount" content="<%= request.script_name %>">
-    <link rel="icon" href="/railwatch/icon.svg" type="image/svg+xml">
-    <link rel="apple-touch-icon" href="/railwatch/icon.png">
-    <%= csrf_meta_tags %>
-    <%= csp_meta_tag %>
-    <script nonce="<%= content_security_policy_nonce %>">
-      document.documentElement.classList.toggle(
-        "dark",
-        localStorage.appearance === "dark" ||
-          (!("appearance" in localStorage) && window.matchMedia("(prefers-color-scheme: dark)").matches),
-      );
-    </script>
-    <%= railwatch_font_preloads %>
-    <%= railwatch_asset_tags(nonce: content_security_policy_nonce) %>
-  </head>
-  <body>
-    <%= yield %>
-  </body>
-</html>

data/db/railwatch_migrate/20260916000000_create_railwatch_tables.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-# The engine's own record of the monitored application: issues and what
-# people did about them, saved views, thresholds, anomaly and alert rules,
-# deploy markers. Authored and permanent where telemetry is derived and
-# pruned, so it lives in the host's `railwatch` database, never its primary.
-#
-# Nothing here references the host's tables. `viewer_id` on comments,
-# activity and saved views is whatever the host's dashboard_user resolver
-# returned as `id`, stored as an integer and never joined; `assignee_id`
-# on issues is the same. application_id and environment_id are always 1 in
-# an embedded install and exist so the dashboard's URLs and the hosted
-# platform's code stay identical.
-class CreateRailwatchTables < ActiveRecord::Migration[8.1]
-  def change
-    create_table :railwatch_issues do |t|
-      t.integer :application_id, null: false
-      t.integer :environment_id, null: false
-      t.integer :number, null: false
-      t.string :group_hash, limit: 32, null: false
-      t.string :kind, default: "exception", null: false
-      t.string :title, null: false
-      t.string :culprit
-      t.string :source, limit: 128
-      t.string :status, default: "open", null: false
-      t.string :priority, default: "normal", null: false
-      t.integer :assignee_id
-      t.integer :merged_into_id
-      t.bigint :occurrences, default: 0, null: false
-      t.integer :affected_users, default: 0, null: false
-      t.datetime :first_seen_at, null: false
-      t.datetime :last_seen_at, null: false
-      t.datetime :resolved_at
-      t.string :resolved_in_deploy, limit: 128
-      t.datetime :regressed_at
-      t.json :sample, default: {}, null: false
-      t.timestamps
-    end
-    add_index :railwatch_issues, [ :application_id, :number ], unique: true
-    add_index :railwatch_issues, [ :environment_id, :group_hash ], unique: true
-    add_index :railwatch_issues, [ :environment_id, :status, :last_seen_at ]
-    add_index :railwatch_issues, :merged_into_id
-
-    create_table :railwatch_comments do |t|
-      t.integer :issue_id, null: false
-      t.integer :viewer_id
-      t.string :author_name
-      t.text :body, null: false
-      t.string :source, default: "railwatch", null: false
-      t.string :external_id
-      t.datetime :external_updated_at
-      t.timestamps
-    end
-    add_index :railwatch_comments, :issue_id
-
-    create_table :railwatch_issue_activities do |t|
-      t.integer :issue_id, null: false
-      t.integer :viewer_id
-      t.string :kind, null: false
-      t.json :data, default: {}, null: false
-      t.datetime :created_at, null: false
-    end
-    add_index :railwatch_issue_activities, [ :issue_id, :created_at ]
-
-    create_table :railwatch_deploys do |t|
-      t.integer :environment_id, null: false
-      t.string :deploy, limit: 128, null: false
-      t.string :ref, limit: 128
-      t.string :previous_ref, limit: 128
-      t.string :name
-      t.string :url
-      t.string :server
-      t.datetime :deployed_at, null: false
-      t.json :commits, default: [], null: false
-      t.json :detail, default: {}, null: false
-      t.timestamps
-    end
-    add_index :railwatch_deploys, [ :environment_id, :deploy ], unique: true
-    add_index :railwatch_deploys, [ :environment_id, :deployed_at ]
-
-    create_table :railwatch_saved_views do |t|
-      t.integer :environment_id, null: false
-      t.integer :viewer_id, null: false
-      t.string :name, null: false
-      t.string :page, null: false
-      t.string :query
-      t.string :window, limit: 8
-      t.json :params, default: {}, null: false
-      t.boolean :pinned, default: true, null: false
-      t.boolean :shared, default: true, null: false
-      t.timestamps
-    end
-    add_index :railwatch_saved_views, [ :environment_id, :page ]
-
-    create_table :railwatch_thresholds do |t|
-      t.integer :environment_id, null: false
-      t.string :target_kind, null: false
-      t.string :target, default: "*", null: false
-      t.string :metric, default: "p95", null: false
-      t.float :limit, null: false
-      t.integer :window_minutes, default: 5, null: false
-      t.timestamps
-    end
-    add_index :railwatch_thresholds, [ :environment_id, :target_kind, :target, :metric ], unique: true, name: "index_railwatch_thresholds_unique"
-
-    create_table :railwatch_anomaly_rules do |t|
-      t.integer :environment_id, null: false
-      t.string :target_kind, null: false
-      t.string :target, default: "*", null: false
-      t.string :metric, null: false
-      t.float :deviation, default: 3.0, null: false
-      t.integer :baseline_days, default: 7, null: false
-      t.integer :window_minutes, default: 15, null: false
-      t.boolean :enabled, default: true, null: false
-      t.datetime :last_fired_at
-      t.timestamps
-    end
-    add_index :railwatch_anomaly_rules, :environment_id
-
-    create_table :railwatch_alert_rules do |t|
-      t.integer :application_id, null: false
-      t.string :event, null: false
-      t.json :filters, default: {}, null: false
-      t.timestamps
-    end
-    add_index :railwatch_alert_rules, :application_id
-
-    create_table :railwatch_alerts do |t|
-      t.integer :alert_rule_id
-      t.integer :issue_id
-      t.integer :summary_alert_id
-      t.string :event, null: false
-      t.string :status, default: "pending", null: false
-      t.json :payload, default: {}, null: false
-      t.text :error
-      t.datetime :sent_at
-      t.string :burst_key
-      t.string :delivery_key
-      t.integer :delivery_attempts, default: 0, null: false
-      t.datetime :next_delivery_at
-      t.datetime :delivery_enqueued_until
-      t.string :delivery_lease_id
-      t.datetime :delivery_lease_expires_at
-      t.timestamps
-    end
-    add_index :railwatch_alerts, :burst_key, unique: true
-    add_index :railwatch_alerts, :delivery_key, unique: true
-    add_index :railwatch_alerts, [ :issue_id, :event, :created_at ]
-    add_index :railwatch_alerts, [ :status, :created_at, :alert_rule_id ], name: "index_railwatch_alerts_for_burst_reconciliation"
-  end
-end

data/db/railwatch_migrate/20260917000000_create_railwatch_maintenance_tasks.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# The embedded install's maintenance lease table: one row per task in
-# Railwatch::Maintenance::TASKS, recording when it last ran and which process
-# holds it now. Lives in the railwatch database with the other permanent,
-# operator-facing state rather than in the pruned telemetry file.
-class CreateRailwatchMaintenanceTasks < ActiveRecord::Migration[8.1]
-  def change
-    create_table :railwatch_maintenance_tasks do |t|
-      t.string :name, null: false
-      t.datetime :last_run_at
-      t.string :lease_owner
-      t.datetime :lease_expires_at
-      t.timestamps
-    end
-    add_index :railwatch_maintenance_tasks, :name, unique: true
-  end
-end

data/db/railwatch_migrate/20260917120000_create_railwatch_followup_receipts.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-# What makes replaying a batch's follow-ups safe. Exception grouping bumps an
-# issue's occurrence count in this database, but the "done" mark lives on the
-# batch's ledger row in the OTHER database, so a crash between the two (or
-# the inline drain racing the maintenance drain) would count the same
-# exceptions twice. A receipt per (batch, group) is inserted in the same
-# transaction as the issue update; the unique index turns a second attempt
-# into a no-op.
-class CreateRailwatchFollowupReceipts < ActiveRecord::Migration[8.1]
-  def change
-    create_table :railwatch_followup_receipts do |t|
-      t.string :batch_id, limit: 36, null: false
-      t.string :group_hash, limit: 32, null: false
-      t.datetime :created_at, null: false
-    end
-    add_index :railwatch_followup_receipts, [ :batch_id, :group_hash ], unique: true
-    add_index :railwatch_followup_receipts, :created_at
-  end
-end

data/db/railwatch_migrate/20260918120000_widen_host_user_ids.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# The ids on comments, issue activity, saved views and issue assignment are
-# whatever the host's `dashboard_user` resolver returned. They were integer
-# columns, which quietly assumed every application numbers its users. An app
-# with UUID primary keys could not store a comment at all, and one with ids
-# past the signed range could not either.
-#
-# Nothing joins on these columns and nothing indexes them; they are an opaque
-# handle the host gave us and hands back. A string says that, and costs
-# nothing in a database that is a few thousand rows of authored content.
-#
-# Existing values convert cleanly: SQLite rewrites 7 as "7", and the models
-# compare with to_s on both sides, so a row written before this migration
-# still matches the same viewer after it.
-class WidenHostUserIds < ActiveRecord::Migration[8.1]
-  COLUMNS = {
-    railwatch_issues: :assignee_id,
-    railwatch_comments: :viewer_id,
-    railwatch_issue_activities: :viewer_id,
-    railwatch_saved_views: :viewer_id
-  }.freeze
-
-  # SQLite rebuilds a table to change a column type, and a rebuild inside a
-  # transaction ignores `PRAGMA foreign_keys = OFF`. This database declares no
-  # foreign keys, so there is nothing to cascade, but the rebuild is kept out
-  # of the migrator's transaction anyway: it is the cheap half of a habit
-  # whose expensive half is deleted rows.
-  disable_ddl_transaction!
-
-  def up
-    COLUMNS.each do |table, column|
-      null = column == :viewer_id && table == :railwatch_saved_views ? false : true
-      change_column table, column, :string, limit: 255, null: null
-    end
-  end
-
-  # Reversible only while every stored id still looks like a number. Once a
-  # host with UUIDs (or emails, or anything else) has written one, there is
-  # no integer to go back to: the column would either refuse the value or
-  # quietly coerce it to something that is no longer that person. Say so and
-  # stop, rather than losing the identity on the way down. These tables are
-  # authored content, a few thousand rows at most, so reading them is cheap.
-  INTEGERISH = /\A-?\d+\z/
-  MAX_REPORTED = 3
-
-  def down
-    blocking = COLUMNS.filter_map do |table, column|
-      next unless connection.table_exists?(table)
-
-      values = connection.select_values(
-        "SELECT DISTINCT #{connection.quote_column_name(column)} FROM #{connection.quote_table_name(table)} " \
-        "WHERE #{connection.quote_column_name(column)} IS NOT NULL"
-      )
-      offenders = values.reject { |value| INTEGERISH.match?(value.to_s) }
-      "#{table}.#{column} (#{offenders.first(MAX_REPORTED).join(', ')}#{"..." if offenders.size > MAX_REPORTED})" if offenders.any?
-    end
-
-    if blocking.any?
-      raise ActiveRecord::IrreversibleMigration,
-            "cannot narrow host user ids back to integers: #{blocking.join('; ')}. " \
-            "Those ids came from this application's own dashboard_user resolver and have no integer form; " \
-            "rolling back would discard them."
-    end
-
-    COLUMNS.each do |table, column|
-      null = column == :viewer_id && table == :railwatch_saved_views ? false : true
-      change_column table, column, :integer, null: null
-    end
-  end
-end