railwatch 0.1.4 → 0.2.0.pre1

data/app/controllers/railwatch/llm_calls_controller.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class LlmCallsController < DashboardController
+    NANOS_PER_DOLLAR = 1_000_000_000.0
+
+    def index
+      from, to = window_range
+      fields = FilterQuery.parse(params[:q]).fetch(:fields)
+      models = telemetry { model_rows(from, to) }
+      tools = telemetry { tool_rows(from, to) }
+      rows = telemetry { recent_rows(fields) }
+      render inertia: { models: models, tools: tools, recent: rows,
+                       totals: totals(models, tools),
+                       # Two record types over one table, the way Execution
+                       # feeds request/job_attempt/... Waiting on a model is
+                       # seconds of somebody else's compute; a tool call is
+                       # your own code in milliseconds. One p95 over both
+                       # describes neither.
+                       series: series("llm_call"), tool_series: series("llm_tool"),
+                       q: params[:q].to_s }
+    end
+
+    private
+
+    # One row per provider/model/operation group, from rollups: tokens and
+    # spend come out of Rollup#extra, which sums them on merge, so a 30-day
+    # window costs the same few rows as an hour.
+    def model_rows(from, to)
+      Telemetry::Rollup.for_type("llm_call").between(from, to).to_a
+        .group_by(&:group_hash).map { |group_hash, group_rows| model_row(group_hash, group_rows, from, to) }
+        .sort_by { |r| [ -(r[:cost] || 0), -r[:count] ] }.first(200)
+    end
+
+    # Tools have no tokens and no price, so they rank by how much time they
+    # actually cost the request: slowest first.
+    def tool_rows(from, to)
+      Telemetry::Rollup.for_type("llm_tool").between(from, to).to_a
+        .group_by(&:group_hash).map do |group_hash, group_rows|
+          summary = Telemetry::Rollup.summarize(group_rows)
+          { group_hash: group_hash, name: group_rows.max_by(&:bucket).name,
+           count: group_rows.sum(&:count), errors: group_rows.sum(&:error_count),
+           avg: (summary[:avg] / 1000.0).round(2), p95: (summary[:p95] / 1000.0).round(2),
+           max: (summary[:max] / 1000.0).round(2),
+           sparkline: Telemetry::Aggregations.sparkline(group_rows, from, to) }
+        end.sort_by { |r| -r[:p95] }.first(200)
+    end
+
+    def model_row(group_hash, group_rows, from, to)
+      count = group_rows.sum(&:count)
+      summary = Telemetry::Rollup.summarize(group_rows)
+      nanos = sum_extra(group_rows, "cost_nanos")
+      priced = sum_extra(group_rows, "priced")
+      unpriced = sum_extra(group_rows, "unpriced")
+      {
+        group_hash: group_hash, name: group_rows.max_by(&:bucket).name, count: count,
+        errors: group_rows.sum(&:error_count),
+        input_tokens: sum_extra(group_rows, "input_tokens"), output_tokens: sum_extra(group_rows, "output_tokens"),
+        cache_read_tokens: sum_extra(group_rows, "cache_read_tokens"),
+        cache_write_tokens: sum_extra(group_rows, "cache_write_tokens"),
+        # nil, not 0, when nothing in the group was priced: a table that shows
+        # $0.00 for an unpriced model is lying about the bill. `unpriced`
+        # carries how many calls the figure leaves out when it is partial.
+        cost: priced.zero? ? nil : nanos / NANOS_PER_DOLLAR, unpriced: unpriced,
+        # Neither of these is an error, so neither shows in the error rate.
+        truncated: sum_extra(group_rows, "truncated"),
+        with_attachments: sum_extra(group_rows, "with_attachments"),
+        avg: (summary[:avg] / 1000.0).round(2), p95: (summary[:p95] / 1000.0).round(2),
+        sparkline: Telemetry::Aggregations.sparkline(group_rows, from, to)
+      }
+    end
+
+    def sum_extra(rows, key)
+      rows.sum { |r| r.extra[key].to_i }
+    end
+
+    # `count` is model calls only. Tool calls are counted separately rather
+    # than folded in: they cost no tokens and no money, so adding them to the
+    # headline number inflates it with work that never reached a provider.
+    def totals(models, tools)
+      priced = models.reject { |m| m[:cost].nil? }
+      {
+        count: models.sum { |m| m[:count] }, errors: models.sum { |m| m[:errors] },
+        tool_count: tools.sum { |t| t[:count] }, tool_errors: tools.sum { |t| t[:errors] },
+        input_tokens: models.sum { |m| m[:input_tokens] }, output_tokens: models.sum { |m| m[:output_tokens] },
+        cost: priced.empty? ? nil : priced.sum { |m| m[:cost] }, unpriced: models.sum { |m| m[:unpriced] }
+      }
+    end
+
+    def recent_rows(fields)
+      scope = Telemetry::LlmCall.between(*window_range)
+      scope = scope.where("model LIKE ?", "%#{Telemetry::LlmCall.sanitize_sql_like(fields['model'])}%") if fields["model"].present?
+      scope = scope.where(provider: fields["provider"]) if fields["provider"].present?
+      scope = scope.where(operation: fields["operation"]) if fields["operation"].present?
+      scope = scope.where(workflow_id: fields["workflow"]) if fields["workflow"].present?
+      scope = scope.where(finish_reason: fields["finish"]) if fields["finish"].present?
+      # "attachments:image" is the question a document-heavy app actually asks.
+      if fields["attachments"].present?
+        scope = if fields["attachments"] == "any"
+          scope.where.not(attachments: nil)
+        else
+          scope.where("attachment_types LIKE ?", "%#{Telemetry::LlmCall.sanitize_sql_like(fields['attachments'])}%")
+        end
+      end
+      scope.recent.limit(200).map { |r| row_props(r) }
+    end
+
+    def row_props(call)
+      { id: call.id, operation: call.operation, provider: call.provider, model: call.model,
+       response_model: call.response_model, tool_name: call.tool_name, duration: call.duration_ms.round(1),
+       status: call.status, error: call.error, streaming: call.streaming, message_count: call.message_count,
+       tool_count: call.tool_count, input_tokens: call.input_tokens, output_tokens: call.output_tokens,
+       cache_read_tokens: call.cache_read_tokens, cache_write_tokens: call.cache_write_tokens,
+       thinking_tokens: call.thinking_tokens, cost: call.cost, cost_reported: call.cost_reported,
+       workflow_id: call.workflow_id, workflow_name: call.workflow_name,
+       workflow_step_name: call.workflow_step_name,
+       finish_reason: call.finish_reason, provider_request_id: call.provider_request_id,
+       tools: call.tools, attachments: call.attachments, attachment_types: call.attachment_types,
+       attachment_names: call.attachment_names, tool_call_id: call.tool_call_id, params: call.params,
+       prompt: call.prompt, completion: call.completion, occurred_at: call.occurred_at,
+       execution_id: call.execution_id, execution_preview: call.execution_preview }
+    end
+    end
+end

data/app/controllers/railwatch/logs_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class LogsController < DashboardController
+    def index
+      from, to = window_range
+      parsed = FilterQuery.parse(params[:q])
+      page_data = nil
+      page = lambda do
+        page_data ||= telemetry do
+          filtered = FilterQuery.apply(Telemetry::Log.all, resource: :logs, query: params[:q], from: from, to: to)
+          rows, meta = Telemetry::CursorPage.call(filtered, cursor: params[:cursor], limit: params[:limit],
+            context: telemetry_cursor_context(:logs))
+          [ rows.map { |l| log_row(l) }, meta, Telemetry::Log.fts_snippets(rows.map(&:id), parsed[:text]) ]
+        end
+      end
+      render inertia: {
+        logs: InertiaRails.merge { page.call[0] }, pagination: -> { page.call[1] },
+        counts: -> { level_counts(from, to) }, highlights: InertiaRails.deep_merge { page.call[2] }, q: params[:q].to_s
+      }
+    end
+
+    private
+
+    # The level facet counts the same rows the search does, except for the
+    # selected level itself, so switching level never disagrees with the table.
+    def level_counts(from, to)
+      telemetry do
+        FilterQuery.apply(Telemetry::Log.all, resource: :logs, query: params[:q], from: from, to: to,
+          except: %w[level status]).group(:level).count
+      end
+    end
+
+    def log_row(log)
+      { id: log.id, level: log.level, message: log.message.first(2000), tags: log.tags, occurred_at: log.occurred_at,
+       execution_id: log.execution_id, execution_source: log.execution_source, execution_preview: log.execution_preview,
+       source: log.source, tenant: log.app_tenant, user_ref: log.user_ref, context: log.context }
+    end
+    end
+end

data/app/controllers/railwatch/mails_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class MailsController < DashboardController
+    def index
+      fields = FilterQuery.parse(params[:q]).fetch(:fields)
+      rows = telemetry do
+        scope = Telemetry::Mail.between(*window_range)
+        scope = scope.where(mailer: fields["mailer"]) if fields["mailer"].present?
+        # Mail rows have no "kind" column; delivery_method (smtp/test/deliver_later
+        # etc.) is the closest fit for a kind: filter token.
+        scope = scope.where(delivery_method: fields["kind"]) if fields["kind"].present?
+        scope.recent.limit(200).to_a
+      end
+      render inertia: { mailers: grouped("mail", limit: 100), series: series("mail"), q: params[:q].to_s,
+                        recent: rows.map { |m| { id: m.id, mailer: m.mailer, subject: m.subject, to: m.to, cc: m.cc, bcc: m.bcc, attachments: m.attachments, delivery_method: m.delivery_method, duration: m.duration_ms.round(1), failed: m.failed, occurred_at: m.occurred_at, execution_id: m.execution_id, execution_preview: m.execution_preview } } }
+    end
+    end
+end

data/app/controllers/railwatch/notifications_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class NotificationsController < DashboardController
+    def index
+      rows = telemetry { Telemetry::Notification.between(*window_range).recent.limit(200).to_a }
+      render inertia: { groups: grouped("notification", limit: 100),
+                        recent: rows.map { |n| { id: n.id, notifier: n.notifier, delivery_method: n.delivery_method, duration: n.duration_ms.round(1), failed: n.failed, occurred_at: n.occurred_at, execution_id: n.execution_id, execution_preview: n.execution_preview } } }
+    end
+    end
+end

data/app/controllers/railwatch/outgoing_requests_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class OutgoingRequestsController < DashboardController
+    def index
+      fields = FilterQuery.parse(params[:q]).fetch(:fields)
+      rows = telemetry do
+        scope = Telemetry::OutgoingRequest.between(*window_range)
+        scope = scope.where("host LIKE ?", "%#{Telemetry::OutgoingRequest.sanitize_sql_like(fields['host'])}%") if fields["host"].present?
+        if (range = FilterQuery.status_range(fields["status"]))
+          scope = scope.where(status_code: range)
+        end
+        scope.recent.limit(200).to_a
+      end
+      render inertia: { hosts: grouped("outgoing_request", limit: 100), series: series("outgoing_request"), q: params[:q].to_s,
+                        recent: rows.map { |r| { id: r.id, host: r.host, method: r.method, url: r.url, status_code: r.status_code, duration: r.duration_ms.round(1), request_size: r.request_size, response_size: r.response_size, error: r.error, source: r.source, occurred_at: r.occurred_at, execution_id: r.execution_id, execution_preview: r.execution_preview, response_body: r.response_body } } }
+    end
+    end
+end

data/app/controllers/railwatch/overview_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class OverviewController < DashboardController
+    def show
+      requests = grouped("request", limit: 8, order: :p95)
+      jobs = grouped("job_attempt", limit: 8)
+      render inertia: {
+        totals: { requests: summary_with_delta("request"), jobs: summary_with_delta("job_attempt") },
+        request_series: series("request"),
+        job_series: series("job_attempt"),
+        slow_routes: requests,
+        top_jobs: jobs,
+        issues: environment.issues.open.recent.limit(8).map { |i| issue_row(i) },
+        deploys: deploys_in_window,
+        release_health: release_health,
+        processes: telemetry { Telemetry::Process.recent.limit(20).group_by(&:server).transform_values { |ps| ps.first.slice(:role, :deploy, :ruby_version, :rails_version, :railwatch_version, :booted_at) } }
+      }
+    end
+
+    private
+
+    # Crash-free sessions for the release that is live now, over the page's
+    # window. nil (and the stat is not rendered) until the environment reports
+    # sessions at all.
+    def release_health
+      deploy = environment.deploys.recent.first or return nil
+      health = telemetry { Telemetry::ReleaseHealth.for_deploy(deploy.deploy, *window_range) }
+      return nil if health[:crash_free_sessions].nil?
+      health.slice(:sessions, :crash_free_sessions).merge(deploy: deploy.deploy, ref: deploy.short_ref)
+    end
+
+    def issue_row(i)
+      { id: i.id, key: i.key, title: i.title, kind: i.kind, status: i.status, priority: i.priority, occurrences: i.occurrences,
+        affected_users: i.affected_users, last_seen_at: i.last_seen_at, culprit: i.culprit }
+    end
+    end
+end

data/app/controllers/railwatch/people_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class PeopleController < DashboardController
+    def index
+      from, to = window_range
+      active = telemetry do
+        Telemetry::Execution.requests.between(from, to).where.not(user_ref: nil).group(:user_ref)
+          .pluck(:user_ref, Arel.sql("COUNT(*)"), Arel.sql("SUM(CASE WHEN status >= 500 THEN 1 ELSE 0 END)"), Arel.sql("MAX(occurred_at)"))
+          .map { |ref, c, e, last| { ref: ref, requests: c, errors: e, last_seen_at: last } }.sort_by { |r| -r[:requests] }.first(200)
+      end
+      people = telemetry { Telemetry::Person.where(ref: active.map { |a| a[:ref] }).index_by(&:ref) }
+      render inertia: { people: active.map { |a| a.merge(name: people[a[:ref]]&.display_name, email: people[a[:ref]]&.email, tenant: people[a[:ref]]&.app_tenant) } }
+    end
+
+    def show
+      ref = params[:id]
+      person = telemetry { Telemetry::Person.find_by(ref: ref) }
+      executions = telemetry { Telemetry::Execution.where(user_ref: ref).between(*window_range).recent.limit(100).map { |r| { execution_id: r.execution_id, kind: r.kind, name: r.name, status: r.status, outcome: r.outcome, duration: r.duration_ms.round(1), occurred_at: r.occurred_at, exception_preview: r.exception_preview } } }
+      exception_groups = telemetry { Telemetry::Exception.where(user_ref: ref).between(*window_range).group(:group_hash).count }
+      issues = environment.issues.where(group_hash: exception_groups.keys).map { |i| { id: i.id, key: i.key, title: i.title, status: i.status, count: exception_groups[i.group_hash] } }
+      render inertia: { person: person && { person_ref: person.ref, name: person.display_name, email: person.email, tenant: person.app_tenant, first_seen_at: person.first_seen_at, last_seen_at: person.last_seen_at }, person_ref: ref, executions: executions, issues: issues }
+    end
+    end
+end

data/app/controllers/railwatch/processes_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class ProcessesController < DashboardController
+    def index
+      live_since = Telemetry::HealthSample::LIVE_WINDOW.ago
+      samples, series, queues, live_servers, processes = telemetry do
+        live = Telemetry::HealthSample.live(live_since).to_a
+        [ live, Telemetry::HealthSample.series(*window_range), Telemetry::HealthSample.queue_depths(live),
+          live.map(&:server) | Telemetry::Execution.servers_since(live_since),
+          Telemetry::Process.recent.limit(200).to_a ]
+      end
+      render inertia: { samples: samples.map { |s| sample_row(s) }, series: series, queues: queues,
+                        silent_servers: environment.expected_servers - live_servers.compact,
+                        processes: processes.map { |p| process_row(p) } }
+    end
+
+    private
+
+    def sample_row(s)
+      { id: s.id, server: s.server, role: s.role, pid: s.pid, deploy: s.deploy, sampled_at: s.sampled_at,
+        threads_busy: s.threads_busy, threads_max: s.threads_max, backlog: s.backlog,
+        pool_busy: s.pool_busy, pool_size: s.pool_size, pool_waiting: s.pool_waiting,
+        queue_depth: s.queue_depth, queue_latency: s.queue_latency && (s.queue_latency / 1000.0).round(1), memory: s.memory }
+    end
+
+    def process_row(p)
+      { id: p.id, booted_at: p.booted_at, pid: p.pid, role: p.role, server: p.server, deploy: p.deploy,
+        ruby_version: p.ruby_version, rails_version: p.rails_version, railwatch_version: p.railwatch_version,
+        boot_seconds: p.boot_seconds, detail: p.detail }
+    end
+    end
+end

data/app/controllers/railwatch/profiles_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class ProfilesController < DashboardController
+    # Profiles are never rolled up (they are opt-in and sampled, so a rollup
+    # row would be noise), which means every number on these pages comes from
+    # the raw table. This caps how many rows the grouping pass reads; the
+    # StatStrip totals still come from SQL aggregates over the whole window.
+    SCAN_LIMIT = 5_000
+
+    def index
+      from, to = window_range
+      rows, count, avg_samples, profiled, executions = telemetry do
+        scope = Telemetry::Profile.between(from, to)
+        [ scope.recent.limit(SCAN_LIMIT).select(:id, :group_hash, :execution_preview, :duration, :samples, :occurred_at).to_a,
+          scope.count, scope.average(:samples), scope.distinct.count(:execution_id), Telemetry::Execution.between(from, to).count ]
+      end
+      render inertia: { profiles: groups(rows),
+                        summary: { profiles: count, executions: executions, profiled: profiled, avg_samples: avg_samples.to_f.round(0) } }
+    end
+
+    def show
+      profile = telemetry { Telemetry::Profile.find(params[:id]) }
+      collapsed, truncated = profile.collapsed_capped
+      render inertia: { profile: profile_row(profile), collapsed: collapsed, truncated: truncated }
+    rescue Telemetry::BoundedGzip::Error
+      head :unprocessable_content
+    end
+
+    private
+
+    # Rows arrive newest-first, so the head of each group is the profile the
+    # page links to.
+    def groups(rows)
+      rows.group_by(&:group_hash).map { |group_hash, group|
+        newest = group.first
+        { group_hash: group_hash, name: newest.execution_preview, profile_id: newest.id, count: group.size,
+          avg_duration: (group.sum { |row| row.duration.to_i } / group.size.to_f / 1000.0).round(2),
+          max_samples: group.filter_map(&:samples).max, last_seen_at: newest.occurred_at }
+      }.sort_by { |g| -g[:count] }.first(100)
+    end
+
+    def profile_row(row)
+      { id: row.id, profiler: row.profiler, mode: row.mode, interval: row.interval, duration: row.duration_ms.round(2),
+        samples: row.samples, stacks_bytes: row.stacks_bytes, group_hash: row.group_hash, execution_id: row.execution_id,
+        execution_preview: row.execution_preview, execution_source: row.execution_source, occurred_at: row.occurred_at,
+        deploy: row.deploy, server: row.server }
+    end
+    end
+end

data/app/controllers/railwatch/queries_controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class QueriesController < DashboardController
+    def index
+      from, to = window_range
+      page_data = nil
+      page = lambda do
+        page_data ||= telemetry do
+          scope = FilterQuery.apply(Telemetry::Query.with_sql, resource: :queries, query: params[:q], from: from, to: to)
+          rows, meta = Telemetry::CursorPage.call(scope, cursor: params[:cursor], limit: params[:limit], order: :slowest,
+            context: telemetry_cursor_context(:queries))
+          [ rows.map { |q| query_row(q) }, meta ]
+        end
+      end
+      render inertia: {
+        queries: -> { grouped("query", limit: 200, order: params[:sort], dir: params[:dir]) },
+        n_plus_ones: -> { n_plus_ones(from, to) }, slowest: InertiaRails.merge { page.call.first },
+        pagination: -> { page.call.last }, q: params[:q].to_s, summary: -> { summary_with_delta("query") },
+        sort: params[:sort] || "count", dir: params[:dir] || "desc"
+      }
+    end
+
+    def show
+      group_hash = params[:id]
+      rows = telemetry { Telemetry::Query.where(group_hash: group_hash).between(*window_range).recent.limit(100).with_sql.to_a }
+      summary = telemetry { Telemetry::Rollup.summarize(Telemetry::Rollup.for_type("query").where(group_hash: group_hash).between(*window_range)) }
+      sources = rows.filter_map(&:source).tally.sort_by { |_s, c| -c }.first(10)
+      callers = rows.map(&:execution_preview).compact.tally.sort_by { |_s, c| -c }.first(10)
+      render inertia: { group_hash: group_hash, sql: rows.first&.sql, summary: summary, series: series("query", group_hash: group_hash),
+                        sources: sources, callers: callers, roles: rows.filter_map(&:role).tally.sort_by { |_r, c| -c },
+                        explain: explain_sample(group_hash), samples: rows.first(50).map { |q| query_row(q) } }
+    end
+
+    private
+
+    def n_plus_ones(from, to)
+      telemetry do
+        Telemetry::NPlusOne.between(from, to).group(:group_hash).pluck(:group_hash, Arel.sql("COUNT(*)"), Arel.sql("MAX(sql)"), Arel.sql("MAX(source)"), Arel.sql("MAX(count)"))
+          .map { |g, c, sql, src, mx| { group_hash: g, occurrences: c, sql: sql, source: src, max_count: mx, suggestion: Telemetry::NPlusOne.new(sql: sql, source: src).suggestion } }
+          .sort_by { |r| -r[:occurrences] }.first(50)
+      end
+    end
+
+    # The newest sample in the group that the gem attached a query plan to.
+    # Only slow queries get one (RAILWATCH_CAPTURE_QUERY_EXPLAIN), so this is
+    # usually a different row than the newest sample overall.
+    def explain_sample(group_hash)
+      q = telemetry { Telemetry::Query.where(group_hash: group_hash).between(*window_range).where.not(explain: nil).recent.with_sql.first }
+      return nil if q.nil?
+      { plan: q.explain, occurred_at: q.occurred_at, duration: q.duration_ms.round(3), execution_id: q.execution_id }
+    end
+
+    def query_row(q)
+      { id: q.id, sql: q.sql.first(300), duration: q.duration_ms.round(3), occurred_at: q.occurred_at, execution_id: q.execution_id,
+        execution_preview: q.execution_preview, source: q.source, connection: q.connection, row_count: q.row_count, group_hash: q.group_hash }
+    end
+    end
+end

data/app/controllers/railwatch/releases_controller.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Sentry-style release health: sessions per deploy, and the crash-free rates
+# read off them. The release is the deploy string the gem stamps on every
+# record it ships, so `show`'s :id is that string rather than a Deploy id.
+module Railwatch
+    class ReleasesController < DashboardController
+    SESSIONS_SHOWN = 50
+    RELEASES_SHOWN = 50
+    # SQLite reads the deploy back out of an issue's sample payload, which is
+    # the release its latest occurrence came from.
+    SAMPLE_DEPLOY = "json_extract(sample, '$.deploy') = ?"
+
+    def index
+      from, to = window_range
+      deploys = environment.deploys.between(from, to).recent.limit(RELEASES_SHOWN).to_a
+      new_issues = new_issue_counts(deploys, to)
+      summary, series, adoption, health = telemetry do
+        [ Telemetry::ReleaseHealth.for_deploy(nil, from, to),
+          Telemetry::ReleaseHealth.series(nil, from, to),
+          Telemetry::ReleaseHealth.adoption(from, to),
+          deploys.to_h { |d| [ d.deploy, Telemetry::ReleaseHealth.for_deploy(d.deploy, from, to) ] } ]
+      end
+      releases = deploys.map do |d|
+        health.fetch(d.deploy).merge(deploy: d.deploy, ref: d.short_ref, name: d.name, deployed_at: d.deployed_at,
+                                      adoption: adoption[d.deploy] || 0.0, new_issues: new_issues[d.id].to_i)
+      end
+      render inertia: { releases: releases, series: series,
+                        summary: summary.merge(releases: adoption.count { |_deploy, share| share.positive? }) }
+    end
+
+    def show
+      release = params[:id]
+      deploy = environment.deploys.find_by(deploy: release)
+      previous = deploy&.previous_deploy
+      from, to = deploy ? deploy.window : window_range
+      data = telemetry do
+        { summary: Telemetry::ReleaseHealth.for_deploy(release, from, to),
+          previous_summary: previous && Telemetry::ReleaseHealth.for_deploy(previous.deploy, *previous.window),
+          series: Telemetry::ReleaseHealth.series(release, from, to),
+          sessions: Telemetry::Session.where(deploy: release).recent.limit(SESSIONS_SHOWN).map { |s| session_row(s) } }
+      end
+      render inertia: data.merge(
+        release: { deploy: release, ref: deploy&.short_ref || release.first(12), name: deploy&.name, deploy_id: deploy&.id,
+                  deployed_at: deploy&.deployed_at, previous_ref: previous&.short_ref },
+        range: { from: from.iso8601, to: to.iso8601 },
+        new_issues: issue_rows(environment.issues.where(first_seen_at: from..to).or(environment.issues.where(SAMPLE_DEPLOY, release))),
+        resolved_issues: issue_rows(environment.issues.where(resolved_in_deploy: release)))
+    end
+
+    private
+
+    def session_row(s)
+      { id: s.id, session_id: s.session_id, source: s.source, status: s.status, user_ref: s.user_ref,
+        duration: s.duration_ms, requests: s.requests, visits: s.visits, errors: s.error_count, occurred_at: s.occurred_at,
+        started_at: s.started_at }
+    end
+
+    def issue_rows(scope)
+      scope.recent.limit(50).map { |i| { id: i.id, key: i.key, title: i.title, status: i.status } }
+    end
+
+    # Issues first seen while each release was live -- one query for the table,
+    # not one per row. A release is live until the next one deploys.
+    def new_issue_counts(deploys, to)
+      return {} if deploys.empty?
+
+      ordered = deploys.sort_by(&:deployed_at)
+      windows = ordered.each_cons(2).to_h { |release, following| [ release.id, release.deployed_at...following.deployed_at ] }
+      windows[ordered.last.id] = ordered.last.deployed_at...to
+      first_seen = environment.issues.where(first_seen_at: ordered.first.deployed_at..to).pluck(:first_seen_at)
+      windows.transform_values { |window| first_seen.count { |at| window.cover?(at) } }
+    end
+    end
+end

data/app/controllers/railwatch/requests_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class RequestsController < DashboardController
+    def index
+      routes = grouped("request", limit: 200, order: params[:sort], dir: params[:dir])
+      routes = apply_filters(routes, FilterQuery.parse(params[:q]).fetch(:fields))
+      render inertia: { routes: routes, series: series("request"), deploys: deploys_in_window,
+                        sort: params[:sort] || "count", dir: params[:dir] || "desc", q: params[:q].to_s }
+    end
+
+    # All requests to one route in the window.
+    def route
+      group_hash = params[:group_hash]
+      rows = telemetry { Telemetry::Execution.requests.where(group_hash: group_hash).between(*window_range).recent.limit(200).to_a }
+      render inertia: "requests/route", props: {
+        route: rows.first&.name || telemetry { Telemetry::Rollup.for_type("request").where(group_hash: group_hash).pick(:name) },
+        group_hash: group_hash, summary: summary_with_delta("request", group_hash: group_hash),
+        series: series("request", group_hash: group_hash), deploys: deploys_in_window,
+        requests: rows.map { |r| execution_row(r) }
+      }
+    end
+
+    def show
+      exe = telemetry { Telemetry::Execution.find_by!(execution_id: params[:id]) }
+      render inertia: "executions/show", props: ExecutionPresenter.new(exe, environment).props
+    end
+
+    private
+
+    # Rollup rows for "request" carry no raw status codes, only aggregated
+    # count/errors/client_errors, so status:5xx etc. is a family match against
+    # those buckets rather than an exact code lookup.
+    def apply_filters(routes, fields)
+      routes = routes.select { |r| r[:name].start_with?("#{fields['method'].upcase} ") } if fields["method"].present?
+      routes = routes.select { |r| r[:name].include?(fields["route"]) } if fields["route"].present?
+      if (range = FilterQuery.status_range(fields["status"]))
+        routes = routes.select do |r|
+          case range.begin
+          when 500..599 then r[:errors].positive?
+          when 400..499 then r[:client_errors].positive?
+          else (r[:count] - r[:errors] - r[:client_errors]).positive?
+          end
+        end
+      end
+      routes
+    end
+
+    def execution_row(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
+end

data/app/controllers/railwatch/saved_views_controller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class SavedViewsController < DashboardController
+    def create
+      view = environment.saved_views.new(create_params.merge(user: Viewer.user))
+      if view.save
+        redirect_back fallback_location: fallback, notice: "View saved"
+      else
+        redirect_back fallback_location: fallback, inertia: { errors: view.errors }
+      end
+    end
+
+    def update
+      view = environment.saved_views.find(params[:id])
+      return head :forbidden unless editable?(view)
+      if view.update(update_params)
+        redirect_back fallback_location: fallback, notice: "View updated"
+      else
+        redirect_back fallback_location: fallback, inertia: { errors: view.errors }
+      end
+    end
+
+    def destroy
+      view = environment.saved_views.find(params[:id])
+      return head :forbidden unless editable?(view)
+      view.destroy
+      redirect_back fallback_location: fallback, notice: "View deleted"
+    end
+
+    private
+
+    # Its owner can change a view, and only its owner. The platform also lets
+    # an account admin, so a shared view does not outlive the person who made
+    # it; embedded mode has no account and no admin, and `|| true` here let
+    # every dashboard user edit and delete everyone else's views. An app whose
+    # dashboard_user resolver returns one identity for everybody is unaffected
+    # either way: one owner, one editor.
+    def editable?(view)
+      view.viewer_id == Viewer.user.id
+    end
+
+    def fallback = application_environment_overview_path(application, environment)
+
+    def create_params
+      params.permit(:name, :page, :query, :window, :pinned, :shared, params: {})
+    end
+
+    def update_params
+      params.permit(:name, :pinned, :shared)
+    end
+    end
+end

data/app/controllers/railwatch/scheduled_tasks_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class ScheduledTasksController < DashboardController
+      include TelemetryIdentity
+
+    def index
+      from, to = window_range
+      tasks = telemetry do
+        rows = Telemetry::Execution.scheduled.between(from, to).group(:task_key)
+          .pluck(:task_key, Arel.sql("COUNT(*)"), Arel.sql("SUM(CASE WHEN outcome = 'failed' THEN 1 ELSE 0 END)"), Arel.sql("AVG(duration)"), Arel.sql("MAX(occurred_at)"))
+        schedules = Telemetry::Execution.latest_schedules(rows.map(&:first))
+        rows.map { |k, c, f, d, last| { task_key: k, runs: c, failed: f, avg: (d.to_f / 1000.0).round(1), last_run_at: last, schedule: schedules[k] } }
+      end
+      tasks.each { |t| t[:next_run_at] = next_run(t[:schedule]) }
+      recent = telemetry do
+        rows = Telemetry::Execution.scheduled.between(from, to).recent.limit(100).to_a
+        people = origin_people(rows)
+        rows.map do |row|
+          { execution_id: row.execution_id, task_key: row.task_key, name: row.name, outcome: row.outcome,
+           duration: row.duration_ms.round(1), occurred_at: row.occurred_at,
+           exception_preview: row.exception_preview }.merge(origin_identity(row, people))
+        end
+      end
+      render inertia: { tasks: tasks, runs: recent, missed: environment.issues.open.where("group_hash LIKE 'missed:%'").map { |i| { key: i.key, title: i.title, id: i.id } } }
+    end
+
+    def show
+      exe = telemetry { Telemetry::Execution.find_by!(execution_id: params[:id]) }
+      render inertia: "executions/show", props: ExecutionPresenter.new(exe, environment).props
+    end
+
+    private
+
+    # Solid Queue schedules are cron or natural language ("every 5 minutes"),
+    # both of which fugit parses; anything it can't parse has no next run.
+    def next_run(schedule)
+      return nil if schedule.blank?
+      require "fugit"
+      Fugit.parse(schedule)&.next_time&.to_t
+    rescue StandardError
+      nil
+    end
+    end
+end