railwatch 0.9.4 → 1.0.0

data/app/controllers/railwatch/issues_controller.rb

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

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

data/app/controllers/railwatch/llm_calls_controller.rb

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

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

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

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

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

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

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

@@ -1,33 +0,0 @@
-# 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, bucket: Telemetry::Aggregations::STEPS.fetch(step_key)), 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