railwatch 0.1.4 → 0.2.0

data/app/controllers/railwatch/dashboard_controller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Railwatch
+  # Base for every dashboard page: the prebuilt Inertia bundle, the shared
+  # props its layouts read, and per-controller Inertia config so a host that
+  # also uses Inertia keeps its own.
+  #
+  # Inherits from Railwatch.config.base_controller_class (default
+  # ActionController::Base) so a host can put its own admin gate in front of
+  # every page the way Mission Control Jobs allows: point it at a controller
+  # whose before_action requires an admin, and turn HTTP Basic off.
+  class DashboardController < Railwatch.config.base_controller_class.constantize
+    include Railwatch::AssetsHelper
+    helper Railwatch::AssetsHelper
+    include Railwatch::EnvironmentScoped
+
+    layout "railwatch/dashboard"
+    # The bundle's pages are named after the platform's controllers
+    # (overview/show, requests/index); strip the engine namespace so
+    # default_render finds them.
+    inertia_config version: -> { Railwatch::AssetsHelper.digest }, layout: "railwatch/dashboard",
+                   use_script_element_for_initial_page: true, always_include_errors_hash: true, default_render: true,
+                   component_path_resolver: ->(path:, action:) { "#{path.delete_prefix('railwatch/')}/#{action}" }
+    rescue_from Telemetry::CursorPage::InvalidCursor do |exception|
+      render plain: exception.message, status: :unprocessable_content
+    end
+
+    # HTTP Basic, on and closed by default (Configuration#http_basic_auth_*).
+    # Runs before anything reads telemetry; a host that authenticates in its
+    # base controller or a routes constraint turns it off.
+    before_action :authenticate_by_http_basic
+    before_action { Viewer.user = Railwatch.config.resolve_dashboard_user(request) }
+
+    inertia_share auth: -> { { user: Viewer.user.as_json, session: { id: "embedded", recently_authenticated: true } } },
+                  account: -> { Railwatch::Embedded::Account.as_json },
+                  accounts: -> { [ { id: 1, name: Railwatch::Embedded::Account.name } ] },
+                  applications: -> { [ { id: 1, name: Application.current.name, slug: Application.current.slug,
+                                       issue_prefix: Application.current.issue_prefix,
+                                       environments: [ { id: 1, name: Environment.current.name, slug: Environment.current.slug,
+                                                       last_seen_at: Environment.current.last_seen_at, paused: false } ] } ] },
+                  flash: -> { { alert: flash.alert, warning: flash[:warning], notice: flash.notice } },
+                  google_oauth: false,
+                  embedded: true
+
+    private
+
+    def authenticate_by_http_basic
+      config = Railwatch.config
+      return unless config.http_basic_auth_enabled
+
+      if config.http_basic_auth_configured?
+        http_basic_authenticate_or_request_with(name: config.http_basic_auth_user, password: config.http_basic_auth_password,
+                                                realm: "Railwatch")
+      else
+        # Closed, not open: same as Mission Control with no credentials. The
+        # challenge header is still sent so a client or a monitor sees the
+        # scheme, and the body says what to do, since a bare 401 looks like a
+        # broken install rather than an unconfigured one.
+        response.set_header("WWW-Authenticate", %(Basic realm="Railwatch"))
+        render plain: "Railwatch: HTTP Basic authentication is on and no credentials are configured, so the " \
+                      "dashboard is closed. Run `bin/rails railwatch:authentication:configure` (writes " \
+                      "railwatch.http_basic_auth_user/_password to Rails credentials), or set " \
+                      "RAILWATCH_HTTP_BASIC_AUTH_USER and _PASSWORD, or turn Basic off " \
+                      "(c.http_basic_auth_enabled = false) once your own auth gates the mount. See docs/embedded.md.",
+               status: :unauthorized
+      end
+    end
+  end
+end

data/app/controllers/railwatch/deploys_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class DeploysController < DashboardController
+    def index
+      render inertia: { deploys: environment.deploys.recent.limit(100).map { |d| deploy_row(d) } }
+    end
+
+    # Before/after comparison: the hour before the deploy versus the hour after.
+    def show
+      deploy = environment.deploys.find(params[:id])
+      before = [ deploy.deployed_at - 1.hour, deploy.deployed_at ]
+      after = [ deploy.deployed_at, deploy.deployed_at + 1.hour ]
+      compare, health = telemetry do
+        [ %w[request job_attempt].to_h do |type|
+          [ type, { before: Telemetry::Rollup.summarize(Telemetry::Rollup.for_type(type).where(bucket: before.first.beginning_of_hour..before.last)),
+                    after: Telemetry::Rollup.summarize(Telemetry::Rollup.for_type(type).where(bucket: after.first.beginning_of_hour..after.last)) } ]
+        end, Telemetry::ReleaseHealth.for_deploy(deploy.deploy, *deploy.window) ]
+      end
+      new_issues = environment.issues.where(first_seen_at: after.first..after.last + 23.hours).recent.map { |i| { id: i.id, key: i.key, title: i.title, status: i.status } }
+      resolved = environment.issues.where(resolved_in_deploy: deploy.deploy).map { |i| { id: i.id, key: i.key, title: i.title } }
+      render inertia: { deploy: deploy_row(deploy).merge(commits: deploy.commits, previous_ref: deploy.previous_ref,
+                          repository_ref: deploy.ref, detail: deploy.detail),
+                        compare: compare, health: health, new_issues: new_issues, resolved_issues: resolved }
+    end
+
+    private
+
+    def deploy_row(d)
+      { id: d.id, deploy: d.deploy, ref: d.short_ref, name: d.name, url: d.url, server: d.server, deployed_at: d.deployed_at,
+        commits_count: d.commits_count, performer: d.detail["performer"] }
+    end
+    end
+end

data/app/controllers/railwatch/deprecations_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class DeprecationsController < DashboardController
+    def index
+      from, to = window_range
+      parsed = FilterQuery.parse(params[:q])
+      fields = parsed[:fields]
+      data = telemetry do
+        scope = Telemetry::Deprecation.between(from, to)
+        scope = scope.where(gem_name: fields["gem"]) if fields["gem"].present?
+        scope = scope.where("message LIKE ?", "%#{Telemetry::Deprecation.sanitize_sql_like(parsed[:text])}%") if parsed[:text].present?
+        rows = scope.to_a
+        hashes = rows.map(&:group_hash).uniq
+        first_ever = Telemetry::Deprecation.where(group_hash: hashes).group(:group_hash).minimum(:occurred_at)
+        groups = rows.group_by(&:group_hash)
+                     .map { |group_hash, group_rows| deprecation_row(group_hash, group_rows, first_ever[group_hash], from, to) }
+                     .sort_by { |r| -r[:count] }
+        { groups: groups.first(200), distinct: groups.size, total_occurrences: groups.sum { |g| g[:count] },
+         new_this_window: groups.count { |g| g[:first_seen_at] && g[:first_seen_at] >= from } }
+      end
+      render inertia: { deprecations: data[:groups], distinct: data[:distinct], total_occurrences: data[:total_occurrences],
+                        new_this_window: data[:new_this_window], q: params[:q].to_s }
+    end
+
+    private
+
+    def deprecation_row(group_hash, group_rows, first_seen_at, from, to)
+      sorted = group_rows.sort_by(&:occurred_at)
+      { group_hash: group_hash, message: sorted.last.message, gem_name: sorted.last.gem_name, horizon: sorted.last.horizon,
+        source: sorted.last.source, count: group_rows.size, first_seen_at: first_seen_at, last_seen_at: sorted.last.occurred_at,
+        sparkline: hourly_sparkline(group_rows, from, to), occurrences: sorted.reverse.first(20).map { |r| occurrence_row(r) } }
+    end
+
+    def occurrence_row(r)
+      { id: r.id, occurred_at: r.occurred_at, execution_id: r.execution_id, execution_source: r.execution_source,
+        execution_preview: r.execution_preview }
+    end
+
+    # Hourly counts for raw (non-rollup) rows, zero-filled and coarsened to at
+    # most 30 points for wide windows -- deprecations have no duration column
+    # so they never land in Telemetry::Rollup and can't use
+    # EnvironmentScoped#sparkline, which keys off a rollup row's bucket/count.
+    def hourly_sparkline(rows, from, to)
+      hours = [ ((to - from) / 1.hour).ceil, 1 ].max
+      coarsen = (hours / 30.0).ceil
+      base = from.beginning_of_hour
+      buckets = Hash.new(0)
+      rows.each { |r| buckets[((r.occurred_at - base) / 1.hour).to_i / coarsen] += 1 }
+      bucket_count = (hours.to_f / coarsen).ceil
+      (0...bucket_count).map { |i| buckets[i] }
+    end
+    end
+end

data/app/controllers/railwatch/environment_scoped.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Railwatch
+  # The platform's EnvironmentScoped concern with the account lookup replaced
+  # by the embedded singleton. Everything below the seam is the platform's code.
+  module EnvironmentScoped
+    extend ActiveSupport::Concern
+
+    WINDOWS = { "1h" => 1.hour, "6h" => 6.hours, "24h" => 24.hours, "7d" => 7.days, "30d" => 30.days }.freeze
+    MAX_CUSTOM_RANGE = 90.days
+
+    included do
+      before_action :set_environment
+      inertia_share environment: -> { environment_props }
+      inertia_share window: -> { window_key }
+      inertia_share range: -> { from, to = window_range; { from: from.iso8601(6), to: to.iso8601(6) } }
+      inertia_share saved_views: -> { SavedView.props_for(environment, Viewer.user) }
+    end
+
+    private
+
+    attr_reader :environment
+
+    def set_environment
+      @environment = Environment.find(params[:environment_id] || Environment::ID)
+    end
+
+    def window_key
+      custom_range ? "custom" : (WINDOWS.key?(params[:window].to_s) ? params[:window].to_s : "24h")
+    end
+
+    def window_range
+      return @window_range if defined?(@window_range)
+      @window_range = custom_range || begin
+        key = WINDOWS.key?(params[:window].to_s) ? params[:window].to_s : "24h"
+        to = Time.current
+        [ to - WINDOWS[key], to ]
+      end
+    end
+
+    def custom_range
+      return @custom_range if defined?(@custom_range)
+      from = parse_time(params[:from])
+      to = from && (parse_time(params[:to]) || Time.current)
+      valid = from && to && to > from && (to - from) <= MAX_CUSTOM_RANGE
+      @custom_range = valid ? [ from, to ] : nil
+    end
+
+    def parse_time(value)
+      return nil if value.blank?
+      Time.zone.parse(value.to_s)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def previous_window_range
+      from, to = window_range
+      span = to - from
+      [ from - span, from ]
+    end
+
+    def telemetry(&block) = environment.with_telemetry(&block)
+
+    def telemetry_cursor_context(resource)
+      from, to = window_range
+      FilterQuery.cursor_context(environment_id: environment.id, resource: resource, query: params[:q], window: [ from.iso8601(6), to.iso8601(6) ])
+    end
+
+    def application = Application.current
+
+    def environment_props
+      { id: environment.id, name: environment.name, slug: environment.slug, application_id: application.id,
+        application_name: application.name, issue_prefix: application.issue_prefix, last_seen_at: environment.last_seen_at,
+        paused: false, token_prefix: environment.token_prefix,
+        repository_url: application.repository_url, default_branch: application.default_branch }
+    end
+
+    def deploys_in_window
+      environment.deploys.between(*window_range).recent.limit(50).map { |d| { deploy: d.deploy, ref: d.short_ref, at: d.deployed_at } }
+    end
+
+    def series(record_type, group_hash: nil, name: nil)
+      from, to = window_range
+      Telemetry::Aggregations.series(environment, record_type, from: from, to: to, group_hash: group_hash, name: name)
+    end
+
+    def grouped(record_type, limit: 100, order: nil, dir: nil)
+      from, to = window_range
+      Telemetry::Aggregations.grouped(environment, record_type, from: from, to: to, limit: limit, order: order, dir: dir)
+    end
+
+    def summary_with_delta(record_type, group_hash: nil)
+      from, to = window_range
+      previous_from, previous_to = previous_window_range
+      Telemetry::Aggregations.summary_with_delta(environment, record_type, from: from, to: to,
+                                                  previous_from: previous_from, previous_to: previous_to, group_hash: group_hash)
+    end
+  end
+end

data/app/controllers/railwatch/exceptions_controller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class ExceptionsController < DashboardController
+    def index
+      from, to = window_range
+      page_data = nil
+      page = lambda do
+        page_data ||= telemetry do
+          scope = FilterQuery.apply(Telemetry::Exception.all, resource: :exceptions, query: params[:q], from: from, to: to)
+          recent, pagination = Telemetry::CursorPage.call(scope, cursor: params[:cursor], limit: params[:limit],
+            context: telemetry_cursor_context(:exceptions))
+          issues_by_group = environment.issues.where(group_hash: recent.map(&:group_hash).uniq).index_by(&:group_hash)
+          [ recent.map { |e| exception_row(e, issues_by_group) }, pagination ]
+        end
+      end
+      render inertia: {
+        exceptions: InertiaRails.merge { page.call.first }, pagination: -> { page.call.last },
+        classes: -> { telemetry { Telemetry::Exception.between(from, to).group(:class_name).count.sort_by { |_class, n| -n }.first(15) } },
+        series: -> { telemetry { exception_series(from, to) } },
+        total: -> { telemetry { Telemetry::Exception.between(from, to).count } },
+        unhandled: -> { telemetry { Telemetry::Exception.between(from, to).unhandled.count } }, q: params[:q].to_s
+      }
+    end
+
+    private
+
+    def exception_row(e, issues_by_group)
+      issue = issues_by_group[e.group_hash]
+      { id: e.id, class_name: e.class_name, message: e.message.first(500), handled: e.handled, severity: e.severity, source: e.source,
+        file: e.file, line: e.line, occurred_at: e.occurred_at, execution_id: e.execution_id, execution_source: e.execution_source,
+        execution_preview: e.execution_preview, user_ref: e.user_ref, group_hash: e.group_hash, issue_id: issue&.id, issue_key: issue&.key }
+    end
+
+    # Telemetry::Rollup has no "exception" record type (exceptions carry no
+    # duration to absorb), so the chart is a plain bucketed count over the raw
+    # table instead of the usual EnvironmentScoped#series.
+    # `errors` carries the unhandled count so the chart legend (handled /
+    # unhandled) agrees with the Unhandled card above the table.
+    def exception_series(from, to)
+      buckets = Hash.new { |h, k| h[k] = { count: 0, errors: 0 } }
+      Telemetry::Exception.between(from, to)
+        .group(Arel.sql("strftime('%Y-%m-%dT%H:00:00Z', occurred_at)"), :handled)
+        .count
+        .each do |(bucket, handled), c|
+          buckets[bucket][:count] += c
+          buckets[bucket][:errors] += c unless handled
+        end
+      buckets.map { |bucket, b| { t: bucket, count: b[:count], errors: b[:errors], client_errors: 0, avg: 0, p50: 0, p95: 0, p99: 0 } }
+        .sort_by { |r| r[:t] }
+    end
+    end
+end

data/app/controllers/railwatch/executions_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Generic detail route for execution kinds that do not have a dedicated index
+# yet (for example Action Cable channel actions), and for legacy child records
+# whose execution_source was absent.
+module Railwatch
+    class ExecutionsController < DashboardController
+    def show
+      execution = telemetry { Telemetry::Execution.find_by!(execution_id: params[:id]) }
+      render inertia: "executions/show", props: ExecutionPresenter.new(execution, environment).props
+    end
+    end
+end

data/app/controllers/railwatch/issues_controller.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class IssuesController < DashboardController
+    BULK_LIMIT = 200
+
+    before_action :set_issue, only: %i[show update merge_candidates]
+    rescue_from Issue::InvalidMerge, with: :invalid_merge
+
+    def index
+      scope = Issue.all
+      scope = scope.where(status: params[:status]) if Issue::STATUSES.include?(params[:status].to_s)
+      scope = scope.where(status: "open") unless params.key?(:status)
+      scope = scope.where(application_id: params[:application_id]) if params[:application_id].present?
+      scope = scope.where(environment_id: params[:environment_id]) if params[:environment_id].present?
+      scope = scope.where(kind: params[:kind]) if Issue::KINDS.include?(params[:kind].to_s)
+      scope = scope.where(assignee_id: Viewer.user.id) if params[:mine] == "1"
+      # Same "key:value free text" grammar as the other list pages: today the
+      # only key is source, which is how you pull out the browser's own errors.
+      parsed = FilterQuery.parse(params[:q])
+      scope = scope.where(source: parsed[:fields]["source"]) if parsed[:fields]["source"].present?
+      scope = scope.where("title LIKE ?", "%#{Issue.sanitize_sql_like(parsed[:text])}%") if parsed[:text].present?
+      render inertia: { issues: scope.recent.limit(200).map { |i| row(i) },
+                        filters: params.permit(:status, :application_id, :environment_id, :kind, :mine, :q).to_h,
+                        counts: Issue.all.group(:status).count,
+                        kindCounts: Issue.all.open.group(:kind).count,
+                        members: User.default.then { |u| [ { id: u.id, name: u.name } ] } }
+    end
+
+    def show
+      env = @issue.environment
+      return render_detection_issue(env) unless @issue.kind == "exception"
+
+      from = 30.days.ago
+      occurrences = env.with_telemetry do
+        Telemetry::Exception.where(group_hash: @issue.group_hash).between(from, Time.current).recent.limit(50)
+          .map { |e| { id: e.id, message: e.message.first(300), handled: e.handled, occurred_at: e.occurred_at, execution_id: e.execution_id, execution_source: e.execution_source, execution_preview: e.execution_preview, user_ref: e.user_ref, tenant: e.app_tenant, deploy: e.deploy, server: e.server } }
+      end
+      latest = env.with_telemetry { Telemetry::Exception.where(group_hash: @issue.group_hash).recent.first }
+      browser_breadcrumbs = browser_breadcrumbs_for(latest)
+      breadcrumbs = latest&.execution_id ? env.with_telemetry { breadcrumbs_for(latest) } : []
+      daily_counts = env.with_telemetry { Telemetry::Exception.where(group_hash: @issue.group_hash).between(from, Time.current).group(Arel.sql("date(occurred_at)")).count }.transform_keys(&:to_s)
+      daily = (from.to_date..Date.current).map { |d| { day: d.to_s, count: daily_counts[d.to_s].to_i } }
+      by_deploy = env.with_telemetry { Telemetry::Exception.where(group_hash: @issue.group_hash).between(from, Time.current).group(:deploy).count }
+      by_tenant = env.with_telemetry { Telemetry::Exception.where(group_hash: @issue.group_hash).between(from, Time.current).where.not(app_tenant: nil).group(:app_tenant).count }
+      attachments = env.with_telemetry { attachments_for_issue }
+      # What a split by message would produce, and what the fingerprint that
+      # grouped these occurrences was -- both drive the Grouping panel.
+      messages = env.with_telemetry { Telemetry::Exception.where(group_hash: @issue.group_hash).recent.limit(Issue::SPLIT_SAMPLE).pluck(:message) }.tally
+      render inertia: {
+        issue: row(@issue).merge(first_seen_at: @issue.first_seen_at, resolved_at: @issue.resolved_at, resolved_in_deploy: @issue.resolved_in_deploy, regressed_at: @issue.regressed_at, sample: @issue.sample),
+        detection: nil,
+        latest: latest && { id: latest.id, class_name: latest.class_name, message: latest.message, handled: latest.handled, severity: latest.severity, source: latest.source, file: latest.file, line: latest.line, frames: latest.frames, cause: latest.cause, locals: latest.locals, context: context_without_breadcrumbs(latest), ruby_version: latest.ruby_version, rails_version: latest.rails_version, execution_id: latest.execution_id, execution_source: latest.execution_source, execution_preview: latest.execution_preview, deploy: latest.deploy },
+        breadcrumbs: breadcrumbs, browser_breadcrumbs: browser_breadcrumbs,
+        fingerprint: (latest&.fingerprint).presence || Array(@issue.sample["fingerprint"]),
+        fingerprint_source: latest&.fingerprint_source || @issue.sample["fingerprint_source"],
+        distinct_messages: messages.size,
+        top_messages: messages.sort_by { |_, n| -n }.first(5).map { |message, n| { message: message.to_s.first(200), count: n } },
+        occurrences: occurrences, daily: daily, by_deploy: by_deploy, by_tenant: by_tenant, attachments: attachments,
+        comments: @issue.comments.order(:created_at).map { |c| { id: c.id, body: c.body, user: c.user&.name || c.author_name || "Linear", source: c.source, created_at: c.created_at } },
+        activities: @issue.activities.order(:created_at).map { |a| activity_row(a) },
+        members: User.default.then { |u| [ { id: u.id, name: u.name } ] },
+        deploys: env.deploys.recent.limit(20).map { |d| { deploy: d.deploy, ref: d.short_ref, at: d.deployed_at } },
+        related_issues: related_issues,
+        merged_into: @issue.merged_into && { id: @issue.merged_into.id, key: @issue.merged_into.key, title: @issue.merged_into.title },
+        merged_issues: @issue.merged_issues.map { |i| { id: i.id, key: i.key, title: i.title } },
+        alerts: @issue.alerts.order(created_at: :desc).map { |a| alert_row(a) }
+      }
+    end
+
+    def merge_candidates
+      query = params[:q].to_s.strip.first(200)
+      scope = @issue.environment.issues.open.where.not(id: @issue.id)
+      if query.present?
+        pattern = "%#{Issue.sanitize_sql_like(query)}%"
+        key_match = query.upcase.match(/\A#{Regexp.escape(@issue.application.issue_prefix)}-(\d+)\z/)
+        scope = if key_match
+          scope.where("title LIKE :pattern OR number = :number", pattern: pattern, number: key_match[1].to_i)
+        else
+          scope.where("title LIKE ?", pattern)
+        end
+      end
+
+      render json: { issues: scope.order(last_seen_at: :desc, id: :desc).limit(20)
+        .map { |issue| { id: issue.id, key: issue.key, title: issue.title } } }
+    end
+
+    def update
+      notice = "Issue updated"
+      case params[:action_name]
+      when "resolve" then @issue.resolve!(deploy: params[:deploy].presence || @issue.environment.deploys.recent.first&.deploy)
+      when "ignore" then @issue.ignore!
+      when "reopen" then @issue.reopen!
+      when "assign" then @issue.update!(assignee: assignee_from(params[:assignee_id]))
+      when "assign_me" then @issue.update!(assignee_id: Viewer.user.id)
+      when "priority" then @issue.update!(priority: params[:priority])
+      when "merge" then @issue.merge_into!(@issue.environment.issues.open.find(params[:target_id]))
+      when "unmerge" then @issue.unmerge!
+      when "split" then notice = split_notice(@issue.split!(by: params[:by].to_s))
+      else @issue.update!(params.permit(:title))
+      end
+      redirect_to issue_path(@issue), notice: notice
+    end
+
+    def bulk
+      ids = Array(params[:ids]).first(BULK_LIMIT)
+      scope = Issue.all.where(id: ids)
+      if params[:action_name] == "merge"
+        bulk_merge(scope)
+      else
+        scope.find_each do |issue|
+          case params[:action_name]
+          when "resolve" then issue.resolve!(deploy: issue.environment.deploys.recent.first&.deploy)
+          when "ignore" then issue.ignore!
+          when "priority" then issue.update!(priority: params[:value])
+          end
+        end
+      end
+      redirect_back fallback_location: issues_path, notice: "#{ids.size} issue(s) updated"
+    end
+
+    private
+
+    # A stale selection can contain issues that have already been merged since
+    # the list rendered. Ignore those sources, choose an open target, and wrap
+    # the whole operation so a concurrent state change cannot partially fold a
+    # bulk selection before the model rejects it.
+    def bulk_merge(scope)
+      issues = scope.order(:first_seen_at, :id).to_a
+      target = issues.find(&:open?)
+      return unless target
+
+      Issue.transaction do
+        issues.each do |issue|
+          next if issue.id == target.id || issue.environment_id != target.environment_id || issue.merged?
+
+          issue.merge_into!(target)
+        end
+      end
+    end
+
+    def invalid_merge(error)
+      redirect_back fallback_location: (@issue ? issue_path(@issue) : issues_path), alert: error.message
+    end
+
+    def render_detection_issue(env)
+      render inertia: {
+        issue: row(@issue).merge(first_seen_at: @issue.first_seen_at, resolved_at: @issue.resolved_at,
+          resolved_in_deploy: @issue.resolved_in_deploy, regressed_at: @issue.regressed_at, sample: @issue.sample),
+        detection: IssueDetectionPresenter.new(@issue).as_json,
+        latest: nil, breadcrumbs: [], browser_breadcrumbs: [], fingerprint: [], fingerprint_source: nil,
+        distinct_messages: 0, top_messages: [], occurrences: [], daily: [], by_deploy: {}, by_tenant: {}, attachments: [],
+        comments: @issue.comments.order(:created_at).map { |c| { id: c.id, body: c.body, user: c.user.name, created_at: c.created_at } },
+        activities: @issue.activities.order(:created_at).map { |a| activity_row(a) },
+        members: User.default.then { |u| [ { id: u.id, name: u.name } ] },
+        deploys: env.deploys.recent.limit(20).map { |d| { deploy: d.deploy, ref: d.short_ref, at: d.deployed_at } },
+        related_issues: related_issues,
+        merged_into: @issue.merged_into && { id: @issue.merged_into.id, key: @issue.merged_into.key, title: @issue.merged_into.title },
+        merged_issues: @issue.merged_issues.map { |i| { id: i.id, key: i.key, title: i.title } },
+        alerts: @issue.alerts.order(created_at: :desc).map { |a| alert_row(a) }
+      }
+    end
+
+    # Sentry-style breadcrumbs: everything the execution did before it raised
+    # (queries, cache, outgoing calls, logs, jobs), newest last, capped at 30.
+    def breadcrumbs_for(exception)
+      exe = Telemetry::Execution.find_by(execution_id: exception.execution_id) or return []
+      ExecutionPresenter.new(exe, @issue.environment).timeline_entries
+        .select { |e| e[:offset] <= ((exception.occurred_at - exe.occurred_at) * 1000.0) + 1 }
+        .reject { |e| e[:type] == "exception" && e[:id] == exception.id }
+        .last(30)
+    end
+
+    # A browser exception's execution is the beacon POST that carried it, whose
+    # timeline says nothing about the crash. What it has instead is the trail
+    # the browser client recorded -- console errors, clicks, navigations --
+    # which the gem stores in the exception's context.
+    def browser_breadcrumbs_for(exception)
+      trail = browser_context(exception)["breadcrumbs"]
+      return [] unless trail.is_a?(Array)
+      trail.filter_map { |crumb| crumb.slice("at", "kind", "text") if crumb.is_a?(Hash) }
+    end
+
+    # The same context with the trail taken back out, since the page renders it
+    # as a breadcrumb list rather than as raw JSON in the context panel.
+    def context_without_breadcrumbs(exception)
+      context = parsed_context(exception)
+      return exception.context unless context["browser"].is_a?(Hash) && context["browser"].key?("breadcrumbs")
+      context.merge("browser" => context["browser"].except("breadcrumbs")).to_json
+    end
+
+    def browser_context(exception)
+      context = parsed_context(exception)
+      context["browser"].is_a?(Hash) ? context["browser"] : {}
+    end
+
+    # Exception context is a JSON string the gem built; anything else in that
+    # column is an older or garbled record, and reads as empty rather than 500.
+    def parsed_context(exception)
+      parsed = JSON.parse(exception&.context.to_s)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      {}
+    end
+
+    # Files the app attached while raising this exception, from any execution.
+    # `data` is left out of the select: it is the whole gzipped file and the
+    # page only links to the download.
+    def attachments_for_issue
+      Telemetry::Attachment.where(exception_group_hash: @issue.group_hash).recent.limit(20)
+        .select(:id, :name, :content_type, :bytes, :truncated, :occurred_at, :execution_id, :execution_preview)
+        .map { |a| { id: a.id, name: a.name, content_type: a.content_type, bytes: a.bytes, truncated: a.truncated,
+                     viewable: a.viewable?, occurred_at: a.occurred_at, execution_id: a.execution_id, execution_preview: a.execution_preview } }
+    end
+
+    # split! no-ops when there is nothing to split apart (the button is hidden
+    # then, but a stale page can still ask), so say which one happened.
+    def split_notice(created)
+      created.empty? ? "Nothing to split \u2014 every recent occurrence is already in its own issue" : "Split into #{created.size} issue(s)"
+    end
+
+    def set_issue
+      @issue = Issue.all.find(params[:id])
+    end
+
+    # Only a member of the current account can be assigned; nil clears.
+    def assignee_from(id)
+      id.present? ? User.find(id) : nil
+    end
+
+    # Same exception class seen in other environments of the same application:
+    # issue titles are stored as "ClassName: message", so we match on the
+    # "ClassName:" prefix.
+    def related_issues
+      class_name = @issue.title.to_s.split(":", 2).first
+      return [] if class_name.blank?
+      Issue.all.where.not(id: @issue.id)
+        .where("title LIKE ?", "#{Issue.sanitize_sql_like(class_name)}:%").limit(20)
+        .map { |i| { id: i.id, key: i.key, title: i.title, status: i.status, environment: { id: i.environment.id, name: i.environment.name } } }
+    end
+
+    def row(i)
+      { id: i.id, key: i.key, title: i.title, kind: i.kind, status: i.status, priority: i.priority, culprit: i.culprit, occurrences: i.occurrences,
+        affected_users: i.affected_users, first_seen_at: i.first_seen_at, last_seen_at: i.last_seen_at, assignee: i.assignee && { id: i.assignee.id, name: i.assignee.name },
+        fingerprint_source: i.sample["fingerprint_source"], source: i.source,
+        application: { id: i.application.id, name: i.application.name }, environment: { id: i.environment.id, name: i.environment.name } }
+    end
+
+    def activity_row(a)
+      { id: a.id, kind: a.kind, data: a.data, user: a.user && { id: a.user.id, name: a.user.name }, created_at: a.created_at }
+    end
+
+    def alert_row(a)
+      { id: a.id, event: a.event, status: a.status, sent_at: a.sent_at, error: a.error,
+        integration: { kind: a.integration.kind, name: a.integration.name } }
+    end
+    end
+end

data/app/controllers/railwatch/jobs_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Railwatch
+    class JobsController < DashboardController
+      include TelemetryIdentity
+
+    def index
+      from, to = window_range
+      page_data = nil
+      page = lambda do
+        page_data ||= telemetry do
+          scope = FilterQuery.apply(Telemetry::Execution.jobs, resource: :jobs, query: params[:q], from: from, to: to)
+          rows, meta = Telemetry::CursorPage.call(scope, cursor: params[:cursor], limit: params[:limit],
+            context: telemetry_cursor_context(:jobs))
+          people = origin_people(rows)
+          [ rows.map { |r| job_row(r, people) }, meta ]
+        end
+      end
+      render inertia: {
+        classes: -> { grouped("job_attempt", limit: 200) }, series: -> { series("job_attempt") },
+        queues: -> { queue_stats(from, to) }, recent: InertiaRails.merge { page.call.first },
+        pagination: -> { page.call.last }, deploys: -> { deploys_in_window }, q: params[:q].to_s
+      }
+    end
+
+    def klass
+      group_hash = params[:group_hash]
+      from, to = window_range
+      name, attempts = telemetry do
+        base = Telemetry::Execution.jobs.where(group_hash: group_hash)
+        rows = FilterQuery.apply(base, resource: :jobs,
+          query: params[:q], from: from, to: to).recent.limit(200).to_a
+        people = origin_people(rows)
+        [ base.between(from, to).pick(:name), rows.map { |row| job_row(row, people) } ]
+      end
+      render inertia: "jobs/klass", props: { name: name, group_hash: group_hash,
+                                             summary: summary_with_delta("job_attempt", group_hash: group_hash),
+                                             series: series("job_attempt", group_hash: group_hash), attempts: attempts,
+                                             deploys: deploys_in_window, q: params[:q].to_s }
+    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
+
+    def queue_stats(from, to)
+      telemetry do
+        Telemetry::Execution.jobs.between(from, to).group(:queue)
+          .pluck(:queue, Arel.sql("COUNT(*)"), Arel.sql("AVG(queue_latency)"), Arel.sql("SUM(CASE WHEN outcome = 'failed' THEN 1 ELSE 0 END)"))
+          .map { |q, c, lat, f| { queue: q, count: c, avg_latency: (lat.to_f / 1000.0).round(1), failed: f } }
+      end
+    end
+
+    def job_row(r, people)
+      { execution_id: r.execution_id, name: r.name, outcome: r.outcome, queue: r.queue, attempt: r.attempt, duration: r.duration_ms.round(2),
+        queue_latency: r.queue_latency && (r.queue_latency / 1000.0).round(1), occurred_at: r.occurred_at, exception_preview: r.exception_preview,
+        job_id: r.job_id, deploy: r.deploy }.merge(origin_identity(r, people))
+    end
+    end
+end