railwatch 0.9.4 → 1.0.0

data/app/controllers/railwatch/anomaly_rules_controller.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class AnomalyRulesController < DashboardController
-    def create
-      rule = environment.anomaly_rules.new(anomaly_rule_params)
-      if rule.save
-        redirect_to application_environment_thresholds_path(application, environment), notice: "Anomaly rule added"
-      else
-        redirect_to application_environment_thresholds_path(application, environment), inertia: { errors: rule.errors }
-      end
-    end
-
-    def update
-      rule = environment.anomaly_rules.find(params[:id])
-      rule.update(anomaly_rule_params)
-      redirect_to application_environment_thresholds_path(application, environment), notice: "Anomaly rule updated"
-    end
-
-    def destroy
-      environment.anomaly_rules.find(params[:id]).destroy
-      redirect_to application_environment_thresholds_path(application, environment), notice: "Anomaly rule removed"
-    end
-
-    private
-
-    def anomaly_rule_params
-      params.permit(:target_kind, :target, :metric, :deviation, :window_minutes, :baseline_days, :enabled)
-    end
-    end
-end

data/app/controllers/railwatch/attachments_controller.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# Serves the bytes an app attached to an execution or exception. The row
-# only exists in its own environment's telemetry database, so an id from
-# another environment 404s here.
-module Railwatch
-    class AttachmentsController < DashboardController
-    def show
-      attachment = telemetry { Telemetry::Attachment.find(params[:id]) }
-      # Rendered as text/plain even for text/html or SVG: these bytes came
-      # from a monitored app and must never execute on our origin.
-      if params[:view] == "1" && attachment.viewable?
-        send_data attachment.body, type: "text/plain; charset=utf-8", disposition: "inline"
-      else
-        send_data attachment.body, type: attachment.content_type.presence || "application/octet-stream",
-          filename: attachment.name, disposition: "attachment"
-      end
-    rescue Telemetry::BoundedGzip::Error
-      head :unprocessable_content
-    end
-    end
-end

data/app/controllers/railwatch/broadcasts_controller.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class BroadcastsController < DashboardController
-    def index
-      from, to = window_range
-      streams = telemetry do
-        Telemetry::Broadcast.between(from, to).group(:group_hash, :kind).pluck(:group_hash, :kind, Arel.sql("MAX(COALESCE(stream, channel))"), Arel.sql("COUNT(*)"), Arel.sql("SUM(bytes)"), Arel.sql("AVG(duration)"))
-          .map { |g, k, name, c, b, d| { group_hash: g, kind: k, name: name, count: c, bytes: b.to_i, avg: (d.to_f / 1000.0).round(3) } }.sort_by { |r| -r[:count] }.first(200)
-      end
-      recent = telemetry { Telemetry::Broadcast.between(from, to).recent.limit(100).map { |b| { id: b.id, kind: b.kind, stream: b.stream, channel: b.channel, action: b.action, bytes: b.bytes, failed: b.failed, duration: b.duration_ms.round(3), occurred_at: b.occurred_at, execution_id: b.execution_id, execution_preview: b.execution_preview } } }
-      render inertia: { streams: streams, recent: recent }
-    end
-    end
-end

data/app/controllers/railwatch/cache_events_controller.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class CacheEventsController < DashboardController
-    def index
-      from, to = window_range
-      fields = FilterQuery.parse(params[:q]).fetch(:fields)
-      keys = telemetry do
-        scope = Telemetry::Rollup.for_type("cache_event").between(from, to)
-        if fields["store"].present?
-          # Rollup rows have no store column; find the matching group_hashes
-          # from the raw cache_events for this window and filter by those.
-          hashes = Telemetry::CacheEvent.between(from, to).where(store: fields["store"]).distinct.pluck(:group_hash)
-          scope = scope.where(group_hash: hashes)
-        end
-        rows = scope.to_a
-        rows.group_by(&:group_hash).map do |group_hash, group_rows|
-          count = group_rows.sum(&:count)
-          hits = group_rows.sum { |r| r.extra["hits"].to_i }
-          misses = group_rows.sum { |r| r.extra["misses"].to_i }
-          duration_sum = group_rows.sum(&:duration_sum)
-          { group_hash: group_hash, key: group_rows.max_by(&:bucket).name, count: count, hits: hits, misses: misses,
-           hit_rate: (hits + misses).zero? ? nil : (hits * 100.0 / (hits + misses)).round(1),
-           avg: count.zero? ? 0 : (duration_sum / count / 1000.0).round(3), sparkline: Telemetry::Aggregations.sparkline(group_rows, from, to) }
-        end.sort_by { |r| -r[:count] }.first(200)
-      end
-      render inertia: { keys: keys, series: series("cache_event"), q: params[:q].to_s }
-    end
-    end
-end

data/app/controllers/railwatch/commands_controller.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class CommandsController < DashboardController
-    def index
-      rows = telemetry { Telemetry::Execution.commands.between(*window_range).recent.limit(200).to_a }
-      render inertia: { commands: grouped("command", limit: 100),
-                        runs: rows.map(&:as_row) }
-    end
-
-    def show
-      exe = telemetry { Telemetry::Execution.find_by!(execution_id: params[:id]) }
-      render inertia: "executions/show", props: ExecutionPresenter.new(exe, environment).props
-    end
-    end
-end

data/app/controllers/railwatch/comments_controller.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-    class CommentsController < DashboardController
-    def create
-      issue = Issue.all.find(params[:issue_id])
-      issue.comments.create!(user: Viewer.user, body: params.require(:body))
-      redirect_to issue_path(issue), notice: "Comment added"
-    end
-    end
-end

data/app/controllers/railwatch/dashboard_controller.rb

@@ -1,70 +0,0 @@
-# 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
-      return if config.http_basic_auth_waived?
-
-      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

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

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

@@ -1,81 +0,0 @@
-# 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
-
-    included do
-      before_action :set_environment
-      inertia_share environment: -> { environment_props }
-      inertia_share window: -> { window.key }
-      inertia_share range: -> { window.to_h }
-      inertia_share step: -> { step_key }
-      inertia_share steps: -> { Telemetry::Aggregations.steps_for(*window_range) }
-      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
-      @window ||= Window.parse(window: params[:window], from: params[:from], to: params[:to])
-    end
-
-    def window_range = window.range
-
-    # The chart bucket width: ?step= when it is one the window offers, else the
-    # window's default (a minute for an hour, an hour for a day, and so on).
-    def step_key
-      return @step_key if defined?(@step_key)
-      from, to = window_range
-      offered = Telemetry::Aggregations.steps_for(from, to)
-      @step_key = offered.include?(params[:step].to_s) ? params[:step].to_s : Telemetry::Aggregations.default_step(from, to)
-    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
-
-    # Time-bucketed series for charts, one point per step_key across the
-    # window: [{t, count, errors, client_errors, avg, p50, p95, p99}]
-    def series(record_type, group_hash: nil)
-      from, to = window_range
-      Telemetry::Aggregations.series(environment, record_type, from: from, to: to, group_hash: group_hash, step: step_key)
-    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 = window.previous.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

@@ -1,52 +0,0 @@
-# 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)
-      step = Telemetry::Aggregations::STEPS.fetch(step_key)
-      bucket = Telemetry::Aggregations.bucket_sql("occurred_at", step)
-      buckets = Hash.new { |h, k| h[k] = { count: 0, errors: 0 } }
-      Telemetry::Exception.between(from, to).group(bucket, :handled).count.each do |(b, handled), c|
-        buckets[b][:count] += c
-        buckets[b][:errors] += c unless handled
-      end
-      points = buckets.map { |b, c| { t: Time.at(b).utc, count: c[:count], errors: c[:errors], client_errors: 0, avg: nil, p50: nil, p95: nil, p99: nil } }
-      Telemetry::Aggregations.fill(points, from, to, step)
-    end
-    end
-end

data/app/controllers/railwatch/executions_controller.rb

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