railwatch 0.1.4 → 0.2.0

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    # A tenant of the monitored application, as seen in its telemetry. Not an
+    # Active Record table: `app_tenant` is a column on every telemetry row (the
+    # gem fills it from Railwatch::Context.current_tenant, which multi-tenant
+    # Rails apps get from ActiveRecord::Tenanted / TenantRecord.current_tenant),
+    # so a "tenant" only exists as a GROUP BY over the raw tables.
+    #
+    # Telemetry::Rollup -- what every other page's numbers come from -- is keyed
+    # by record type and group_hash only and has no tenant dimension, so all of
+    # this is computed from raw rows in the window. Every method must run inside
+    # environment.with_telemetry { }.
+    class Tenant
+      MAX_TENANTS = 200
+      # A p95 costs one ordered query per tenant (SQLite has no percentile
+      # aggregate), so only the busiest tenants get one; the rest report 0.
+      P95_TENANTS = 50
+      SPARKLINE_BUCKETS = 12
+      SERIES_BUCKETS = 48
+      SORTS = { "requests" => :requests, "errors" => :errors, "p95" => :p95, "users" => :users }.freeze
+
+      ERRORS_SQL = Arel.sql("SUM(CASE WHEN status >= 500 THEN 1 ELSE 0 END)")
+      CLIENT_ERRORS_SQL = Arel.sql("SUM(CASE WHEN status BETWEEN 400 AND 499 THEN 1 ELSE 0 END)")
+      FAILED_SQL = Arel.sql("SUM(CASE WHEN outcome = 'failed' THEN 1 ELSE 0 END)")
+      COUNT_SQL = Arel.sql("COUNT(*)")
+      USERS_SQL = Arel.sql("COUNT(DISTINCT user_ref)")
+
+      # One aggregate row per tenant seen in the window, filtered by `q`
+      # (a substring of the tenant name), sorted, and capped at MAX_TENANTS.
+      def self.index(from, to, q: nil, sort: nil, dir: nil)
+        rows = Hash.new { |h, tenant| h[tenant] = blank_row(tenant) }
+        absorb_requests(rows, from, to, q)
+        absorb_jobs(rows, from, to, q)
+        absorb_counts(rows, filtered(Telemetry::Exception.between(from, to), q), :exceptions)
+        absorb_counts(rows, filtered(Telemetry::Log.between(from, to), q), :logs)
+        absorb_last_seen(rows, from, to, q)
+        absorb_sparklines(rows, from, to, q)
+        absorb_p95s(rows.values.max_by(P95_TENANTS) { |r| r[:requests] }, from, to)
+        sorted(rows.values, sort, dir)
+      end
+
+      # Headline numbers for the index page, computed from the rows it shows
+      # (so the top-tenant share is a share of the listed tenants' requests)
+      # plus the share of requests in the window that carry no tenant at all.
+      def self.overview(rows, from, to)
+        requests = Telemetry::Execution.requests.between(from, to)
+        total = requests.count
+        untagged = requests.where(app_tenant: nil).count
+        tagged = rows.sum { |r| r[:requests] }
+        top = rows.max_by { |r| r[:requests] }
+        {
+          tenants: rows.size, top_tenant: top && top[:tenant],
+          top_share: tagged.zero? ? 0.0 : (top[:requests] * 100.0 / tagged).round(1),
+          with_errors: rows.count { |r| r[:errors].positive? },
+          untagged_share: total.zero? ? 0.0 : (untagged * 100.0 / total).round(1)
+        }
+      end
+
+      # Window totals for one tenant. Durations in milliseconds, like the rest
+      # of the tenant props.
+      def self.summary(tenant, from, to)
+        requests = Telemetry::Execution.requests.between(from, to).where(app_tenant: tenant)
+        count, errors, users = requests.pick(COUNT_SQL, ERRORS_SQL, USERS_SQL)
+        jobs, failed_jobs = Telemetry::Execution.jobs.between(from, to).where(app_tenant: tenant).pick(COUNT_SQL, FAILED_SQL)
+        {
+          requests: count, errors: errors.to_i, p95: p95_ms(requests, count), jobs: jobs, failed_jobs: failed_jobs.to_i,
+          exceptions: Telemetry::Exception.between(from, to).where(app_tenant: tenant).count,
+          users: users, logs: Telemetry::Log.between(from, to).where(app_tenant: tenant).count
+        }
+      end
+
+      # Request volume and duration bucketed over the window, SeriesPoint-shaped
+      # so the same charts render it. Percentiles are approximations: these
+      # buckets come from raw rows, without the per-bucket t-digest
+      # Telemetry::Rollup keeps, so p50 is the bucket's average and p95/p99 its
+      # max.
+      def self.series(tenant, from, to)
+        width = bucket_width(from, to, SERIES_BUCKETS)
+        bucket = bucket_sql(from, width)
+        Telemetry::Execution.requests.between(from, to).where(app_tenant: tenant).group(bucket)
+          .pluck(bucket, COUNT_SQL, ERRORS_SQL, CLIENT_ERRORS_SQL, Arel.sql("SUM(duration)"), Arel.sql("MAX(duration)"))
+          .map { |index, count, errors, client_errors, sum, max|
+            avg = ms(sum / count)
+            { t: bucket_at(from, width, index, SERIES_BUCKETS).iso8601, count: count, errors: errors, client_errors: client_errors,
+              avg: avg, p50: avg, p95: ms(max), p99: ms(max) }
+          }.sort_by { |point| point[:t] }
+      end
+
+      def self.routes(tenant, from, to, limit: 20)
+        grouped_executions(Telemetry::Execution.requests, tenant, from, to, ERRORS_SQL, :errors, limit)
+      end
+
+      def self.job_classes(tenant, from, to, limit: 10)
+        grouped_executions(Telemetry::Execution.jobs, tenant, from, to, FAILED_SQL, :failed, limit)
+      end
+
+      def self.exceptions(tenant, from, to, limit: 20)
+        Telemetry::Exception.between(from, to).where(app_tenant: tenant).recent.limit(limit).map do |e|
+          { id: e.id, class_name: e.class_name, message: e.message.first(500), occurred_at: e.occurred_at,
+            execution_id: e.execution_id, group_hash: e.group_hash }
+        end
+      end
+
+      def self.people(tenant, limit: 20)
+        Telemetry::Person.where(app_tenant: tenant).recent.limit(limit).map do |person|
+          { ref: person.ref, name: person.display_name, email: person.email, last_seen_at: person.last_seen_at }
+        end
+      end
+
+      # Same field shape as RequestsController#execution_row, for the tenant
+      # page's "Recent requests" table.
+      def self.recent_requests(tenant, from, to, limit: 50)
+        Telemetry::Execution.requests.between(from, to).where(app_tenant: tenant).recent.limit(limit).map do |r|
+          { execution_id: r.execution_id, name: r.name, status: r.status, duration: r.duration_ms.round(2), occurred_at: r.occurred_at,
+            user_ref: r.user_ref, tenant: r.app_tenant, exception_preview: r.exception_preview, inertia_component: r.inertia_component,
+            queries: r.counters["queries"], deploy: r.deploy }
+        end
+      end
+
+      # -- Aggregation steps -----------------------------------------------------
+
+      def self.absorb_requests(rows, from, to, q)
+        filtered(Telemetry::Execution.requests.between(from, to), q).group(:app_tenant)
+          .pluck(:app_tenant, COUNT_SQL, ERRORS_SQL, Arel.sql("AVG(duration)"), Arel.sql("MAX(duration)"), USERS_SQL)
+          .each do |tenant, count, errors, avg, max, users|
+            rows[tenant].merge!(requests: count, errors: errors, avg: ms(avg), max: ms(max), users: users)
+          end
+      end
+
+      def self.absorb_jobs(rows, from, to, q)
+        filtered(Telemetry::Execution.jobs.between(from, to), q).group(:app_tenant)
+          .pluck(:app_tenant, COUNT_SQL, FAILED_SQL)
+          .each { |tenant, count, failed| rows[tenant].merge!(jobs: count, failed_jobs: failed) }
+      end
+
+      def self.absorb_counts(rows, scope, key)
+        scope.group(:app_tenant).count.each { |tenant, count| rows[tenant][key] = count }
+      end
+
+      def self.absorb_last_seen(rows, from, to, q)
+        filtered(Telemetry::Execution.between(from, to), q).group(:app_tenant).maximum(:occurred_at)
+          .each { |tenant, at| rows[tenant][:last_seen_at] = at }
+      end
+
+      def self.absorb_sparklines(rows, from, to, q)
+        width = bucket_width(from, to, SPARKLINE_BUCKETS)
+        counts = filtered(Telemetry::Execution.requests.between(from, to), q).group(:app_tenant, bucket_sql(from, width)).count
+        counts.each do |(tenant, index), count|
+          rows[tenant][:sparkline][[ index.to_i, SPARKLINE_BUCKETS - 1 ].min] += count
+        end
+      end
+
+      def self.absorb_p95s(rows, from, to)
+        rows.each do |row|
+          scope = Telemetry::Execution.requests.between(from, to).where(app_tenant: row[:tenant])
+          row[:p95] = p95_ms(scope, row[:requests])
+        end
+      end
+
+      # -- Helpers ---------------------------------------------------------------
+
+      def self.blank_row(tenant)
+        { tenant: tenant, requests: 0, errors: 0, avg: 0.0, max: 0.0, p95: 0.0, jobs: 0, failed_jobs: 0,
+          exceptions: 0, logs: 0, users: 0, last_seen_at: nil, sparkline: Array.new(SPARKLINE_BUCKETS, 0) }
+      end
+
+      # Tenant-tagged rows only: a NULL app_tenant never matches LIKE either.
+      def self.filtered(scope, q)
+        return scope.where.not(app_tenant: nil) if q.blank?
+        scope.where("app_tenant LIKE ?", "%#{TelemetryRecord.sanitize_sql_like(q.to_s)}%")
+      end
+
+      def self.sorted(rows, sort, dir)
+        key = SORTS.fetch(sort.to_s, :requests)
+        sign = dir.to_s == "asc" ? 1 : -1
+        rows.sort_by { |row| row[key] * sign }.first(MAX_TENANTS)
+      end
+
+      # The 95th percentile as the duration `count * 5%` rows from the slowest
+      # end -- one indexed query, no percentile function needed.
+      def self.p95_ms(scope, count)
+        return 0.0 if count.to_i.zero?
+        ms(scope.order(duration: :desc).offset((count * 0.05).floor).limit(1).pluck(:duration).first)
+      end
+
+      def self.grouped_executions(scope, tenant, from, to, error_sql, error_key, limit)
+        scope.between(from, to).where(app_tenant: tenant).group(:group_hash, :name)
+          .pluck(:group_hash, :name, COUNT_SQL, error_sql, Arel.sql("AVG(duration)"), Arel.sql("MAX(duration)"))
+          .map { |group_hash, name, count, errors, avg, max|
+            { group_hash: group_hash, name: name, count: count, error_key => errors, avg: ms(avg), max: ms(max) }
+          }.sort_by { |row| -row[:count] }.first(limit)
+      end
+
+      # Microseconds on the wire, milliseconds in every prop.
+      def self.ms(duration)
+        duration ? (duration / 1000.0).round(2) : 0.0
+      end
+
+      def self.bucket_width(from, to, buckets)
+        [ (to - from) / buckets, 1.0 ].max
+      end
+
+      # Bucket index per row: epoch seconds since `from` over the bucket width.
+      # Windows are an hour or more, so second resolution is plenty.
+      # Both interpolations are coerced to numbers first (`from` is a Time, `width`
+      # a Float from bucket_width), so the fragment can only ever contain two
+      # numeric literals -- never a caller-supplied string.
+      def self.bucket_sql(from, width)
+        Arel.sql("CAST((strftime('%s', occurred_at) - #{Integer(from.to_i)}) / #{Float(width)} AS INTEGER)")
+      end
+
+      # A row landing exactly on `to` indexes one bucket past the end; clamp it
+      # into the last one.
+      def self.bucket_at(from, width, index, buckets)
+        from + ([ index.to_i, buckets - 1 ].min * width)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Railwatch
+  # Base class for everything the engine stores about the host application.
+  # The hosted platform keeps one SQLite file per monitored environment through
+  # activerecord-tenanted; 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. Every telemetry query still runs inside
+  # Environment#with_telemetry so the code path matches the platform's.
+  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 --local 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 --local` " \
+              "or add it to config/database.yml (docs/embedded.md)"
+      end
+    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

@@ -0,0 +1,29 @@
+# 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].freeze
+    METRICS = %w[p95 max avg error_rate failure_rate missed].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] }
+
+    def description
+      unit = metric.end_with?("rate") ? "%" : "ms"
+      "#{target_kind} #{target == '*' ? 'all' : target}: #{metric} over #{limit}#{unit} in #{window_minutes}m"
+    end
+  end
+end

data/app/models/railwatch/user.rb

@@ -0,0 +1,47 @@
+# 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

@@ -0,0 +1,13 @@
+# 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/views/layouts/railwatch/dashboard.html.erb

@@ -0,0 +1,25 @@
+<!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/config/routes.rb

@@ -2,4 +2,63 @@
 
 Railwatch::Engine.routes.draw do
   post "beacon", to: "beacon#create"
+
+  # The embedded dashboard. Same URL shape as the hosted platform so the
+  # prebuilt bundle's route helpers resolve unchanged once js-routes knows
+  # the mount point; a singleton install always answers for app 1, env 1.
+  root to: redirect { |_p, req| "#{req.script_name}/apps/1/envs/1" }
+  get "dashboard", to: redirect { |_p, req| "#{req.script_name}/apps/1/envs/1" }
+  get "docs", to: redirect("https://railwatch.rebulk.com/docs")
+
+  scope "apps/:application_id", as: :application do
+    get "/", to: redirect { |p, req| "#{req.script_name}/apps/#{p[:application_id]}/envs/1" }
+    scope "envs/:environment_id", as: :environment do
+      get "/", to: "overview#show", as: :overview
+      resources :requests, only: [ :index, :show ] do
+        get "routes/:group_hash", to: "requests#route", on: :collection, as: :route
+      end
+      resources :jobs, only: [ :index, :show ] do
+        get "classes/:group_hash", to: "jobs#klass", on: :collection, as: :klass
+      end
+      resources :scheduled_tasks, only: [ :index, :show ]
+      resources :commands, only: [ :index, :show ]
+      resources :executions, only: [ :show ]
+      resources :queries, only: [ :index, :show ]
+      resources :spans, only: [ :index, :show ]
+      resources :profiles, only: [ :index, :show ]
+      resources :attachments, only: [ :show ]
+      get "traces/:trace_id", to: "traces#show", as: :trace
+      resources :view_renders, path: "views", only: [ :index ]
+      resources :transactions, only: [ :index ]
+      resources :deprecations, only: [ :index ]
+      resources :exceptions, only: [ :index ]
+      resources :cache_events, path: "cache", only: [ :index ]
+      resources :mails, path: "mail", only: [ :index ]
+      resources :notifications, only: [ :index ]
+      resources :broadcasts, only: [ :index ]
+      resources :outgoing_requests, only: [ :index ]
+      resources :llm_calls, path: "llm", only: [ :index ]
+      resources :storage_ops, path: "storage", only: [ :index ]
+      resources :logs, only: [ :index ]
+      resources :people, path: "users", only: [ :index, :show ]
+      resources :deploys, only: [ :index, :show ]
+      resources :releases, only: [ :index, :show ]
+      resources :visits, only: [ :index ]
+      resources :processes, only: [ :index ]
+      resources :tenants, only: [ :index, :show ]
+      resources :saved_views, only: [ :create, :update, :destroy ]
+      resources :thresholds, only: [ :index, :create, :update, :destroy ]
+      resources :anomaly_rules, only: [ :create, :update, :destroy ]
+      resources :alerts, only: [ :index ]
+    end
+  end
+
+  resources :issues, only: [ :index, :show, :update ] do
+    resources :comments, only: [ :create ]
+    post :bulk, on: :collection
+    get :merge_candidates, on: :member
+  end
+  resources :alerts, only: [ :index ] do
+    post :retry, on: :member
+  end
 end

data/db/railwatch_migrate/20260916000000_create_railwatch_tables.rb

@@ -0,0 +1,151 @@
+# 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