railwatch 0.9.4 → 1.0.0

data/app/controllers/railwatch/profiles_controller.rb

@@ -1,65 +0,0 @@
-# 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), executions_in(from, to) ]
-      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
-
-    # How many executions the window holds, as the profiled share's
-    # denominator. Every kind is rolled up, so whole hours come from a few
-    # hundred rollup rows rather than counting every execution (1.2 s over a
-    # week of the platform's own). A rollup holds its whole hour, so the
-    # partial hours at either end of the window are counted from the rows.
-    def executions_in(from, to)
-      first = from.beginning_of_hour == from ? from : from.beginning_of_hour + 1.hour
-      last = to.beginning_of_hour
-      return Telemetry::Execution.between(from, to).count if first >= last
-
-      Telemetry::Execution.where(occurred_at: from...first).count +
-        Telemetry::Rollup.for_type(Telemetry::Execution::KINDS).where(bucket: first...last).sum(:count) +
-        Telemetry::Execution.where(occurred_at: last..to).count
-    end
-
-    # 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

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

@@ -1,75 +0,0 @@
-# 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, step: step_key),
-          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, step: step_key),
-          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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class RequestsController < DashboardController
-    def index
-      routes = grouped("request", limit: 200, order: params[:sort], dir: params[:dir])
-      routes = FilterQuery.filter_routes(routes, params[:q])
-      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
-
-    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

@@ -1,53 +0,0 @@
-# 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.to_s == Viewer.user.id.to_s
-    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

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

data/app/controllers/railwatch/spans_controller.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class SpansController < DashboardController
-    def index
-      spans = grouped("span", limit: 200, order: params[:sort], dir: params[:dir])
-      spans = apply_filters(spans, FilterQuery.parse(params[:q]).fetch(:fields))
-      render inertia: { spans: spans, series: series("span"), summary: summary_with_delta("span"),
-                        sort: params[:sort] || "count", dir: params[:dir] || "desc", q: params[:q].to_s }
-    end
-
-    def show
-      group_hash = params[:id]
-      rows = telemetry { Telemetry::Span.where(group_hash: group_hash).between(*window_range).recent.limit(200).to_a }
-      render inertia: {
-        group_hash: group_hash,
-        name: rows.first&.name || telemetry { Telemetry::Rollup.for_type("span").where(group_hash: group_hash).pick(:name) },
-        summary: summary_with_delta("span", group_hash: group_hash), series: series("span", group_hash: group_hash),
-        facets: attribute_facets(rows), samples: rows.first(50).map { |s| span_row(s) }
-      }
-    end
-
-    private
-
-    # Rollup rows for "span" carry the span name and a failure count, so
-    # status:failed is "this group failed at least once in the window" rather
-    # than a per-span lookup.
-    def apply_filters(spans, fields)
-      spans = spans.select { |s| s[:name].to_s.include?(fields["name"]) } if fields["name"].present?
-      spans = spans.select { |s| s[:errors].positive? } if fields["status"] == "failed"
-      spans
-    end
-
-    # Which attribute keys these spans carry, and the most common values for
-    # each -- the span equivalent of the query page's "called from" breakdown.
-    def attribute_facets(rows)
-      rows.flat_map { |r| r.payload.to_a }.group_by(&:first).map { |key, pairs|
-        { key: key, count: pairs.size, values: pairs.map { |_k, value| value.to_s }.tally.sort_by { |_v, c| -c }.first(5) }
-      }.sort_by { |facet| -facet[:count] }.first(10)
-    end
-
-    def span_row(s)
-      { id: s.id, name: s.name, duration: s.duration_ms.round(3), status: s.status, attributes: s.payload,
-        occurred_at: s.occurred_at, execution_id: s.execution_id, execution_preview: s.execution_preview }
-    end
-    end
-end

data/app/controllers/railwatch/storage_ops_controller.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class StorageOpsController < DashboardController
-    def index
-      from, to = window_range
-      ops = telemetry do
-        Telemetry::StorageOp.between(from, to).group(:service, :op).pluck(:service, :op, Arel.sql("COUNT(*)"), Arel.sql("AVG(duration)"), Arel.sql("MAX(duration)"))
-          .map { |s, o, c, avg, mx| { service: s, op: o, count: c, avg: (avg.to_f / 1000.0).round(1), max: (mx.to_f / 1000.0).round(1) } }
-      end
-      recent = telemetry { Telemetry::StorageOp.between(from, to).recent.limit(100).map { |r| { id: r.id, service: r.service, op: r.op, key: r.key, duration: r.duration_ms.round(1), occurred_at: r.occurred_at, execution_id: r.execution_id, execution_preview: r.execution_preview } } }
-      render inertia: { ops: ops, recent: recent }
-    end
-    end
-end

data/app/controllers/railwatch/tenants_controller.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class TenantsController < DashboardController
-    def index
-      from, to = window_range
-      tenants, summary = telemetry do
-        rows = Telemetry::Tenant.index(from, to, q: params[:q], sort: params[:sort], dir: params[:dir])
-        [ rows, Telemetry::Tenant.overview(rows, from, to) ]
-      end
-      render inertia: { tenants: tenants, summary: summary,
-                        sort: params[:sort] || "requests", dir: params[:dir] || "desc", q: params[:q].to_s }
-    end
-
-    # :id is the tenant string. Rails reads a dot in a path segment as a format
-    # separator, so tenants like "acme.co" arrive percent-encoded (see the
-    # tenants index page's tenantPath).
-    def show
-      tenant = params[:id]
-      from, to = window_range
-      data = telemetry do
-        { tenant: tenant, summary: { current: Telemetry::Tenant.summary(tenant, from, to),
-                                    previous: Telemetry::Tenant.summary(tenant, *window.previous.range) },
-          series: Telemetry::Tenant.series(tenant, from, to, step: step_key), routes: Telemetry::Tenant.routes(tenant, from, to),
-          jobs: Telemetry::Tenant.job_classes(tenant, from, to), exceptions: Telemetry::Tenant.exceptions(tenant, from, to),
-          people: Telemetry::Tenant.people(tenant), recent_requests: Telemetry::Tenant.recent_requests(tenant, from, to) }
-      end
-      issues = environment.issues.where(group_hash: data[:exceptions].map { |e| e[:group_hash] }.uniq).index_by(&:group_hash)
-      render inertia: data.merge(exceptions: data[:exceptions].map { |e| with_issue(e, issues) }, links: links(tenant))
-    end
-
-    private
-
-    def with_issue(exception, issues)
-      issue = issues[exception[:group_hash]]
-      exception.merge(issue_id: issue&.id, issue_key: issue&.key)
-    end
-
-    def links(tenant)
-      { logs: application_environment_logs_path(application, environment, window: window_key, q: "tenant:#{tenant}"),
-        people: application_environment_people_path(application, environment, window: window_key) }
-    end
-    end
-end

data/app/controllers/railwatch/thresholds_controller.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class ThresholdsController < DashboardController
-    def index
-      render inertia: { thresholds: environment.thresholds.order(:target_kind, :target).map { |t| t.slice(:id, :target_kind, :target, :metric, :limit, :window_minutes).merge(description: t.description) },
-                        routes: telemetry { Telemetry::Rollup.for_type("request").where("bucket > ?", 7.days.ago).distinct.pluck(:name).sort },
-                        jobs: telemetry { Telemetry::Rollup.for_type("job_attempt").where("bucket > ?", 7.days.ago).distinct.pluck(:name).sort },
-                        kinds: Threshold::TARGET_KINDS, metrics: Threshold::METRICS,
-                        anomaly_rules: environment.anomaly_rules.order(:target_kind, :target).map { |r| r.slice(:id, :target_kind, :target, :metric, :deviation, :window_minutes, :baseline_days, :enabled, :last_fired_at).merge(description: r.description) },
-                        # Spend and tokens only exist on llm_calls, so the form
-                        # narrows with the kind rather than offering a rule that
-                        # could never fire.
-                        metrics_for_kind: Threshold::TARGET_KINDS.index_with { |k| Threshold.metrics_for(k) },
-                        units: Threshold::UNITS,
-                        llm_models: telemetry { Telemetry::Rollup.for_type("llm_call").where("bucket > ?", 7.days.ago).distinct.pluck(:name).compact.sort },
-                        anomaly_target_kinds: AnomalyRule::TARGET_KINDS, anomaly_metrics: AnomalyRule::METRICS,
-                        anomaly_metrics_for_kind: AnomalyRule::TARGET_KINDS.index_with { |k| AnomalyRule.metrics_for(k) } }
-    end
-
-    def create
-      threshold = environment.thresholds.new(threshold_params)
-      if threshold.save
-        redirect_to application_environment_thresholds_path(application, environment), notice: "Threshold added"
-      else
-        redirect_to application_environment_thresholds_path(application, environment), inertia: { errors: threshold.errors }
-      end
-    end
-
-    def update
-      threshold = environment.thresholds.find(params[:id])
-      threshold.update(threshold_params)
-      redirect_to application_environment_thresholds_path(application, environment), notice: "Threshold updated"
-    end
-
-    def destroy
-      environment.thresholds.find(params[:id]).destroy
-      redirect_to application_environment_thresholds_path(application, environment), notice: "Threshold removed"
-    end
-
-    private
-
-    def threshold_params
-      params.permit(:target_kind, :target, :metric, :limit, :window_minutes)
-    end
-    end
-end

data/app/controllers/railwatch/traces_controller.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-# One distributed trace: every execution that shares a trace_id, nested by
-# the parent_id the gem propagates (the enqueuing execution's id for jobs,
-# the W3C traceparent parent-id for HTTP hops).
-module Railwatch
-    class TracesController < DashboardController
-    LIMIT = 200
-
-    def show
-      trace_id = params[:trace_id]
-      executions, outgoing = telemetry do
-        rows = Telemetry::Execution.where(trace_id: trace_id).order(:occurred_at).limit(LIMIT).to_a
-        [ rows, Telemetry::OutgoingRequest.where(execution_id: rows.map(&:execution_id)).order(:occurred_at).group_by(&:execution_id) ]
-      end
-      raise ActiveRecord::RecordNotFound if executions.empty?
-
-      @start = executions.first.occurred_at
-      @outgoing = outgoing
-      render inertia: { trace_id: trace_id, roots: tree(executions),
-                        span_count: executions.size + outgoing.values.sum(&:size),
-                        services: executions.filter_map(&:server).uniq, duration: total_duration(executions) }
-    end
-
-    private
-
-    # An execution's parent is the one whose execution_id matches its
-    # parent_id outright (a job enqueued by that execution) or whose id
-    # matches once dashes are dropped and it is cut to the 16 hex chars a
-    # W3C traceparent carries (an incoming HTTP hop). Anything whose parent
-    # is missing -- the trace's entry point, or a hop whose caller was not
-    # reported -- is a root.
-    def tree(executions)
-      by_id = executions.index_by(&:execution_id)
-      by_short_id = executions.index_by { |e| e.execution_id.to_s.delete("-").first(16) }
-      children = Hash.new { |hash, key| hash[key] = [] }
-      roots = []
-      executions.each do |exe|
-        parent = exe.parent_id.presence && (by_id[exe.parent_id] || by_short_id[exe.parent_id])
-        parent = nil if parent && parent.execution_id == exe.execution_id
-        parent ? children[parent.execution_id] << exe : roots << exe
-      end
-      roots.map { |exe| node(exe, children) }
-    end
-
-    def node(exe, children)
-      { execution: execution_row(exe), children: children[exe.execution_id].map { |child| node(child, children) } }
-    end
-
-    def execution_row(exe)
-      { execution_id: exe.execution_id, kind: exe.kind, name: exe.name, status: exe.status, outcome: exe.outcome,
-        parent_id: exe.parent_id, server: exe.server, occurred_at: exe.occurred_at,
-        duration: exe.duration_ms.round(2), offset: offset(exe.occurred_at),
-        outgoing: @outgoing.fetch(exe.execution_id, []).map { |o| outgoing_row(o) } }
-    end
-
-    def outgoing_row(o)
-      { id: o.id, method: o.method, url: o.url.to_s.first(200), status_code: o.status_code,
-        duration: o.duration_ms&.round(2), offset: offset(o.occurred_at) }
-    end
-
-    def offset(time)
-      ((time - @start) * 1000.0).round(2)
-    end
-
-    # Wall-clock span of the whole trace: the last thing to finish, minus the
-    # first thing to start.
-    def total_duration(executions)
-      executions.map { |e| offset(e.occurred_at) + e.duration_ms }.max.round(2)
-    end
-    end
-end

data/app/controllers/railwatch/transactions_controller.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class TransactionsController < DashboardController
-    def index
-      from, to = window_range
-      rows = grouped("transaction", limit: 200, order: params[:sort], dir: params[:dir])
-      recent = telemetry { Telemetry::Transaction.between(from, to).recent.limit(50).map { |t| transaction_row(t) } }
-      render inertia: { transactions: rows, series: series("transaction"), recent: recent,
-                        sort: params[:sort] || "count", dir: params[:dir] || "desc" }
-    end
-
-    private
-
-    def transaction_row(t)
-      { id: t.id, outcome: t.outcome, connection: t.connection, duration: t.duration_ms.round(3), statement_count: t.statement_count, occurred_at: t.occurred_at,
-        execution_id: t.execution_id, execution_source: t.execution_source, execution_preview: t.execution_preview,
-        group_hash: t.group_hash }
-    end
-    end
-end

data/app/controllers/railwatch/view_renders_controller.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class ViewRendersController < DashboardController
-    def index
-      from, to = window_range
-      fields = FilterQuery.parse(params[:q]).fetch(:fields)
-      rows = grouped("view_render", limit: 200, order: params[:sort], dir: params[:dir])
-      rows = rows.select { |r| r[:name].include?(fields["template"]) } if fields["template"].present?
-      kinds = telemetry do
-        Telemetry::Rollup.for_type("view_render").between(from, to).to_a.group_by(&:group_hash)
-          .transform_values { |group_rows| group_rows.max_by(&:bucket).extra["kind"] }
-      end
-      rows.each { |r| r[:kind] = kinds[r[:group_hash]] }
-      slowest = telemetry { Telemetry::ViewRender.between(from, to).order(duration: :desc).limit(30).map { |v| render_row(v) } }
-      render inertia: { renders: rows, series: series("view_render"), slowest: slowest,
-                        sort: params[:sort] || "count", dir: params[:dir] || "desc", q: params[:q].to_s }
-    end
-
-    private
-
-    def render_row(v)
-      { id: v.id, identifier: v.identifier, kind: v.kind, layout: v.layout, duration: v.duration_ms.round(3),
-        occurred_at: v.occurred_at, execution_id: v.execution_id, execution_source: v.execution_source,
-        execution_preview: v.execution_preview, group_hash: v.group_hash }
-    end
-    end
-end