railwatch 0.9.4 → 1.0.0

data/app/frontend/types/globals.d.ts

@@ -1,9 +0,0 @@
-import type { FlashData, SharedProps } from "@/types"
-
-declare module "@inertiajs/core" {
-  export interface InertiaConfig {
-    sharedPageProps: SharedProps
-    flashDataType: FlashData
-    errorValueType: string[]
-  }
-}

data/app/frontend/types/index.ts

@@ -1,288 +0,0 @@
-import type { LucideIcon } from "lucide-react"
-
-export interface Auth {
-  user: User
-  session: Pick<Session, "id" | "recently_authenticated">
-}
-
-export interface BreadcrumbItem {
-  title: string
-  href: string
-}
-
-export interface NavItem {
-  title: string
-  href: string
-  icon?: LucideIcon | null
-  isActive?: boolean
-}
-
-export interface FlashData {
-  alert?: string
-  warning?: string
-  notice?: string
-}
-
-export interface AccountSummary {
-  id: number
-  name: string
-  slug: string
-  plan: string
-}
-
-export interface EnvironmentSummary {
-  id: number
-  name: string
-  slug: string
-  last_seen_at: string | null
-  paused: boolean
-}
-
-export interface ApplicationSummary {
-  id: number
-  name: string
-  slug: string
-  issue_prefix: string
-  environments: EnvironmentSummary[]
-}
-
-export interface EnvironmentContext {
-  id: number
-  name: string
-  slug: string
-  application_id: number
-  application_name: string
-  issue_prefix: string
-  last_seen_at: string | null
-  paused: boolean
-  token_prefix: string
-  repository_url: string | null
-  default_branch: string
-}
-
-export type Window = "1h" | "6h" | "24h" | "7d" | "30d" | "custom"
-
-// Chart bucket width; the server offers the subset that fits the window.
-export type Step = "1m" | "5m" | "15m" | "1h" | "6h" | "1d"
-
-export interface WindowRange {
-  from: string
-  to: string
-}
-
-export type TelemetryTimeParams =
-  | { window: Exclude<Window, "custom">; from?: never; to?: never }
-  | { window?: never; from: string; to: string }
-
-export interface CursorMeta {
-  limit: number
-  next_cursor: string | null
-  has_more: boolean
-}
-
-export interface SharedProps {
-  auth: Auth
-  account: AccountSummary | null
-  accounts: { id: number; name: string }[]
-  applications: ApplicationSummary[]
-  environment?: EnvironmentContext
-  telemetry_freshness?: {
-    received_at: string | null
-    aggregated_at?: string | null
-    processing_lag_seconds: number | null
-  }
-  window?: Window
-  range?: WindowRange
-  step?: Step
-  steps?: Step[]
-  flash: FlashData
-  google_oauth: boolean
-  embedded?: boolean
-  saved_views?: SavedView[]
-  [key: string]: unknown
-}
-
-export interface User {
-  id: number
-  name: string
-  email: string
-  provider: string | null
-  avatar?: string
-  verified: boolean
-  editor: string
-  editor_root: string | null
-  created_at: string
-  updated_at: string
-  [key: string]: unknown
-}
-
-export interface Session {
-  id: string
-  user_agent: string
-  ip_address: string
-  created_at: string
-  recently_authenticated: boolean
-}
-
-// Telemetry shapes shared by pages
-
-export type Percentile = "p50" | "p95" | "p99"
-
-// One chart bucket. Durations are null where nothing ran, so a latency
-// line breaks over a quiet bucket instead of dropping to zero.
-export interface SeriesPoint {
-  t: string
-  count: number
-  errors: number
-  client_errors: number
-  avg: number | null
-  p50: number | null
-  p95: number | null
-  p99: number | null
-}
-
-export interface GroupRow {
-  group_hash: string
-  name: string
-  count: number
-  errors: number
-  client_errors: number
-  avg: number
-  p50: number
-  p95: number
-  p99: number
-  max: number
-  sparkline: number[]
-}
-
-export interface Summary {
-  count: number
-  errors: number
-  client_errors: number
-  avg: number
-  p50: number
-  p95: number
-  p99: number
-  max: number
-}
-
-export interface SummaryWithDelta {
-  current: Summary
-  previous: Summary
-}
-
-// Release health: crash-free rates are null, not 0, when there were no
-// sessions (or no users) to divide by.
-export interface ReleaseHealthSummary {
-  sessions: number
-  users: number
-  crash_free_sessions: number | null
-  crash_free_users: number | null
-  errored: number | null
-  avg_duration_ms: number | null
-}
-
-export interface SessionStatusPoint {
-  t: string
-  sessions: number
-  ok: number
-  errored: number
-  crashed: number
-}
-
-export interface DeployMarker {
-  deploy: string
-  ref: string
-  at: string
-}
-
-export interface IssueRow {
-  id: number
-  key: string
-  title: string
-  kind: "exception" | "performance"
-  status: "open" | "resolved" | "ignored" | "merged"
-  priority: "low" | "normal" | "high" | "urgent"
-  culprit?: string | null
-  occurrences: number
-  affected_users: number
-  first_seen_at?: string
-  last_seen_at: string
-  assignee?: { id: number; name: string } | null
-  fingerprint_source?: string | null
-  source?: string | null
-  application?: { id: number; name: string }
-  environment?: { id: number; name: string }
-}
-
-export interface ExecutionRow {
-  execution_id: string
-  name: string
-  kind?: string
-  status?: number | null
-  outcome?: string | null
-  duration: number
-  occurred_at: string
-  user_ref?: string | null
-  tenant?: string | null
-  exception_preview?: string | null
-  inertia_component?: string | null
-  queries?: number
-  deploy?: string | null
-}
-
-export interface Frame {
-  file: string
-  line: number
-  function: string
-  in_app: boolean
-  code?: Record<string, string>
-}
-
-export interface ExceptionDetail {
-  id: number
-  class_name: string
-  message: string
-  handled: boolean
-  severity?: string
-  source?: string
-  file?: string | null
-  line?: number | null
-  frames: Frame[]
-  cause?: { class: string; message: string } | null
-  locals?: Record<string, string> | null
-  context?: string | null
-  occurred_at?: string
-  execution_id?: string | null
-  execution_source?: string | null
-  execution_preview?: string | null
-  deploy?: string | null
-  group_hash?: string
-}
-
-export interface TimelineEntry {
-  type: string
-  id: number
-  offset: number
-  duration: number | null
-  label: string
-  stage: string | null
-  sql?: string | null
-  source?: string | null
-  detail?: Record<string, string | number | boolean | null>
-}
-
-// A named filter on one environment page, shared through every env page's
-// props. `url` is built server-side from the page's route helper.
-export interface SavedView {
-  id: number
-  name: string
-  page: string
-  query: string | null
-  window: string | null
-  params: Record<string, string>
-  pinned: boolean
-  shared: boolean
-  mine: boolean
-  url: string
-}

data/app/frontend/types/vite-env.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="vite/client" />
-
-interface ImportMetaEnv {
-  readonly VITE_APP_NAME: string
-}
-
-interface ImportMeta {
-  readonly env: ImportMetaEnv
-}

data/app/helpers/railwatch/assets_helper.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Emits the dashboard's script and stylesheet tags from the manifest Vite
-  # wrote at gem build time. The gem ships the built bundle under
-  # public/railwatch, so a host app needs no Node toolchain and no asset
-  # pipeline integration: the engine serves those files itself and this
-  # helper does the little that rails_vite's vite_tags would have done.
-  module AssetsHelper
-    MANIFEST = Railwatch::Engine.root.join("public/railwatch/manifest.json")
-    ASSET_PREFIX = "/railwatch/assets"
-
-    def railwatch_asset_tags(nonce: nil)
-      manifest = railwatch_manifest
-      tags = []
-      preloaded = Set.new
-      %w[app/frontend/entrypoints/application.css app/frontend/entrypoints/inertia.tsx].each do |entry|
-        info = manifest.fetch(entry)
-        Array(info["imports"]).each do |key|
-          file = manifest.fetch(key)["file"]
-          next unless preloaded.add?(file)
-          tags << tag.link(rel: "modulepreload", href: "#{ASSET_PREFIX}/#{file}", nonce: nonce)
-        end
-        tags << if info["file"].end_with?(".css")
-          tag.link(rel: "stylesheet", href: "#{ASSET_PREFIX}/#{info['file']}", nonce: nonce)
-        else
-          tag.script(src: "#{ASSET_PREFIX}/#{info['file']}", type: "module", nonce: nonce)
-        end
-        Array(info["css"]).each { |css| tags << tag.link(rel: "stylesheet", href: "#{ASSET_PREFIX}/#{css}", nonce: nonce) }
-      end
-      safe_join(tags, "\n")
-    end
-
-    def railwatch_font_preloads
-      safe_join(railwatch_manifest.select { |k, _| k.end_with?(".woff2") && k.include?("Roboto") }.map { |_, v|
-        tag.link(rel: "preload", href: "#{ASSET_PREFIX}/#{v['file']}", as: "font", type: "font/woff2", crossorigin: "anonymous")
-      }, "\n")
-    end
-
-    # The bundle digest doubles as the Inertia asset version: a gem upgrade
-    # changes it and every open tab does a full reload on its next visit.
-    def self.digest
-      @digest ||= Digest::SHA256.file(MANIFEST).hexdigest[0, 16]
-    end
-
-    private
-
-    def railwatch_manifest
-      @railwatch_manifest ||= JSON.parse(File.read(MANIFEST))
-    end
-  end
-end

data/app/jobs/railwatch/anomaly_scan_job.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  class AnomalyScanJob < ApplicationJob
-    queue_as :default
-
-    def perform
-      DetectAnomaliesJob.perform_later(Environment.current) if AnomalyRule.where(enabled: true).exists?
-    end
-  end
-end

data/app/jobs/railwatch/application_job.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # The engine's jobs run on whatever Active Job adapter the host configured.
-  class ApplicationJob < ActiveJob::Base
-  end
-end

data/app/jobs/railwatch/auto_resolve_issues_job.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Auto-resolves open issues that have gone quiet for a configured number of
-  # days (nil = off). Resolved with no deploy attached, so any recurrence is
-  # treated as a regression rather than a duplicate. Runs daily (recurring.yml).
-  class AutoResolveIssuesJob < ApplicationJob
-    queue_as :default
-
-    def perform
-      days = Railwatch::Embedded::Account.auto_resolve_after_days
-      return unless days
-
-      Issue.open.where("last_seen_at < ?", days.days.ago).find_each do |issue|
-        issue.resolve!(deploy: nil)
-      end
-    end
-  end
-end

data/app/jobs/railwatch/check_scheduled_tasks_job.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Flags scheduled tasks that have not run when expected. Uses the schedule
-  # string the gem sends (Solid Queue's cron / natural language) parsed with
-  # fugit, which Solid Queue already depends on.
-  class CheckScheduledTasksJob < ApplicationJob
-    include DetectionSnapshotting
-
-    queue_as :default
-
-    GRACE = 5.minutes
-    # A deploy restarts the worker, and Solid Queue skips (does not replay) the
-    # recurring ticks that fell inside the restart window. A tick missed within
-    # this long after a deploy is the deploy, not the scheduler.
-    DEPLOY_GRACE = 15.minutes
-
-    def perform(environment)
-      require "fugit"
-      tasks = environment.with_telemetry do
-        last_runs = Telemetry::Execution.scheduled.where("occurred_at > ?", 30.days.ago).group(:task_key).maximum(:occurred_at)
-        schedules = Telemetry::Execution.latest_schedules(last_runs.keys)
-        last_runs.map { |key, last| [ key, last, schedules[key] ] }
-      end
-      last_deploy_at = environment.deploys.maximum(:deployed_at)
-      configured = environment.with_telemetry { Telemetry::HealthSample.recurring_task_keys }
-      open_missed = environment.issues.open.where("group_hash LIKE 'missed:%'").index_by(&:group_hash)
-      tasks.each do |key, last_run, schedule|
-        next if schedule.blank?
-        # A task taken out of config/recurring.yml stops running on purpose.
-        # Its history would otherwise read as a miss every window for 30 days
-        # (reconcile_ingest_batches was live for four minutes and flagged 62
-        # times). The gem ships the schedule Solid Queue is actually running
-        # on every health sample; a key absent from the newest manifest is
-        # removed, not missed. No manifest yet means an older gem: judge from
-        # history alone, as before.
-        if configured && !configured.include?(key)
-          resolve_missed!(open_missed["missed:#{key}"], "Auto-resolved: #{key} is no longer a configured recurring task.")
-          next
-        end
-        cron = Fugit.parse(schedule) or next
-        expected = cron.next_time(last_run).to_t
-        if expected > Time.current - GRACE
-          # The task is back on schedule; a missed-run issue for it heals on its own.
-          resolve_missed!(open_missed["missed:#{key}"], "Auto-resolved: #{key} ran again on schedule.")
-          next
-        end
-        next if last_deploy_at && expected.between?(last_deploy_at - DEPLOY_GRACE, last_deploy_at + DEPLOY_GRACE)
-        diagnosis = diagnose(key, expected)
-        issue, outcome = Issue.record_occurrence!(
-          environment: environment, group_hash: "missed:#{key}", kind: "performance",
-          title: "Scheduled task #{key} missed its run (expected #{expected.utc.iso8601})#{diagnosis[:title_suffix]}",
-          culprit: key, occurred_at: Time.current, deploy: nil, user_ref: nil,
-          sample: { task_key: key, schedule: schedule, last_run: last_run.iso8601, expected: expected.iso8601 }.merge(diagnosis[:sample]))
-        next unless outcome == :new || outcome == :regressed
-
-        # Only on a new or regressed issue: the detectors re-run every few minutes
-        # and capturing a snapshot on every breached window would query telemetry
-        # for an issue nobody is newly looking at.
-        latest = environment.with_telemetry { Telemetry::Execution.scheduled.where(task_key: key).recent.first }
-        issue.update!(sample: issue.sample.merge("detection" => IssueDetectionSnapshot.capture(
-          environment: environment, kind: "performance", telemetry_type: "scheduled_task",
-          telemetry_group_hash: latest.group_hash, target: key, metric: "missed", from: expected, to: Time.current,
-          representative_from: last_run,
-          rule: { type: "schedule", task_key: key, schedule: schedule,
-                 last_run: last_run.iso8601, expected: expected.iso8601 }
-        )))
-        payload = { issue_key: issue.key, title: issue.title, environment: environment.name }
-        environment.application.alert_rules.where(event: "threshold").find_each do |rule|
-          next unless rule.matches?(issue: issue, payload: payload)
-          rule.fire!(event: "threshold", issue: issue, payload: payload)
-        end
-      end
-    end
-
-    private
-
-    # Where the run went, from Solid Queue's own ledger when it is in this
-    # process. A RecurringExecution row is written by the scheduler the moment
-    # it enqueues a run, so its presence without a scheduled_task execution
-    # means "enqueued, never performed" (no worker, or a wedged one); its
-    # absence means the scheduler itself never fired. The hosted platform, and
-    # any adapter other than Solid Queue, only ever sees the absence of the
-    # run and reports it as before.
-    def diagnose(key, expected)
-      return NO_DIAGNOSIS unless defined?(::SolidQueue::RecurringExecution)
-
-      enqueued_at = Railwatch.ignore { ::SolidQueue::RecurringExecution.where(task_key: key).where("run_at >= ?", expected - 1.minute).maximum(:run_at) }
-      workers = Railwatch.ignore { ::SolidQueue::Process.where(kind: "Worker").count }
-      if enqueued_at
-        { title_suffix: workers.zero? ? ": enqueued, but no Solid Queue worker is running" : ": enqueued, not yet performed",
-          sample: { enqueued_at: enqueued_at.iso8601, workers: workers, cause: workers.zero? ? "no_worker" : "backlog" } }
-      else
-        { title_suffix: ": the scheduler never enqueued it",
-          sample: { enqueued_at: nil, workers: workers, cause: "scheduler" } }
-      end
-    rescue StandardError
-      NO_DIAGNOSIS
-    end
-
-    NO_DIAGNOSIS = { title_suffix: "", sample: {} }.freeze
-
-    # Sentry Crons marked a monitor OK again on the next successful check-in;
-    # the same here: once the task has run inside its window again, the open
-    # missed-run issue resolves with an activity row, so it does not sit open
-    # until someone notices it is stale.
-    def resolve_missed!(issue, body)
-      return unless issue
-      issue.resolve!
-      issue.activities.create!(kind: "comment", data: { body: body })
-    end
-  end
-end

data/app/jobs/railwatch/detect_anomalies_job.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module Railwatch
-  # Compares each enabled anomaly rule's current window against the same clock
-  # window on each of the previous `baseline_days` days and opens an anomaly
-  # issue when the current value sits above the baseline's mean plus
-  # `deviation` standard deviations. Runs on a schedule via AnomalyScanJob.
-  class DetectAnomaliesJob < ApplicationJob
-    include DetectionSnapshotting
-
-    queue_as :default
-
-    TYPE_FOR = DetectPerformanceIssuesJob::TYPE_FOR
-    # Fewer baseline days than this and the standard deviation is noise.
-    MIN_BASELINE_DAYS = AnomalyRule::MIN_BASELINE_DAYS
-    # Volume metrics on a handful of events swing wildly; ignore them.
-    MIN_EVENTS = 20
-    COOL_DOWN = 60.minutes
-    MAX_GROUPS_PER_RULE = 50
-    MAX_CURRENT_ROWS_PER_RULE = MAX_GROUPS_PER_RULE * 25
-    MAX_BASELINE_ROWS_PER_RULE = 50_000
-
-    def perform(environment)
-      now = Time.current
-      environment.anomaly_rules.enabled.find_each do |rule|
-        detect(environment, rule, now).each { |detection| open_issue(environment, rule, now, detection) }
-      end
-    end
-
-    private
-
-    def detect(environment, rule, now)
-      from = now - rule.window_minutes.minutes
-      type = TYPE_FOR.fetch(rule.target_kind)
-      environment.with_telemetry do
-        groups = current_groups(rule, type, from, now)
-        baseline = baseline_rows(rule, type, groups.keys, from, now)
-        return [] unless baseline
-
-        groups.filter_map do |group_hash, (name, summary)|
-          anomaly_for(rule, group_hash, name, summary, baseline.fetch(group_hash, []), from, now)
-        end
-      end
-    end
-
-    # Rollups are hourly, so a window shorter than an hour reads the whole
-    # enclosing hour bucket (Rollup.between rounds `from` down); the baseline
-    # windows are shifted by whole days and land on the same hour, so the
-    # comparison stays like-for-like.
-    def current_groups(rule, type, from, to)
-      scope = Telemetry::Rollup.for_type(type).between(from, to)
-      scope = scope.where(name: rule.target) unless rule.target == "*"
-      group_hashes = scope.reorder(nil).group(:group_hash).order(Arel.sql("SUM(count) DESC"), :group_hash)
-                          .limit(MAX_GROUPS_PER_RULE + 1).pluck(:group_hash)
-      if group_hashes.length > MAX_GROUPS_PER_RULE
-        Rails.logger.warn("anomaly detector evaluated only the #{MAX_GROUPS_PER_RULE} busiest groups rule_id=#{rule.id}")
-        group_hashes.pop
-      end
-      rows = scope.where(group_hash: group_hashes).order(:bucket, :group_hash).limit(MAX_CURRENT_ROWS_PER_RULE + 1).to_a
-      if rows.length > MAX_CURRENT_ROWS_PER_RULE
-        Rails.logger.error("anomaly detector skipped rule_id=#{rule.id}: more than #{MAX_CURRENT_ROWS_PER_RULE} current rollups")
-        return {}
-      end
-
-      rows.group_by(&:group_hash)
-          .transform_values { |group_rows| [ group_rows.first.name, Telemetry::Rollup.summarize(group_rows) ] }
-    end
-
-    def anomaly_for(rule, group_hash, name, summary, baseline_rows, from, to)
-      return if cooling_down?(rule, group_hash)
-      current = value_for(rule.metric, summary, rule.window_minutes)
-      return if current.nil?
-      return if %w[count error_rate].include?(rule.metric) && summary[:count] < MIN_EVENTS
-
-      baseline = baseline_values(rule, baseline_rows, from, to)
-      return if baseline.size < MIN_BASELINE_DAYS
-      mean = baseline.sum / baseline.size
-      stddev = Math.sqrt(baseline.sum { |v| (v - mean)**2 } / baseline.size)
-      return unless current > mean + (rule.deviation * stddev) && current > mean * 1.25
-
-      # A perfectly flat baseline has no σ to measure against, so report the
-      # rule's own threshold rather than an infinite one.
-      sigmas = stddev.positive? ? (current - mean) / stddev : rule.deviation
-      { group_hash: group_hash, name: name, current: current.round(2), mean: mean.round(2),
-        stddev: stddev.round(2), sigmas: sigmas.round(2) }
-    end
-
-    # The same clock window on each of the previous `baseline_days` days. Days
-    # with no rollups at all are left out rather than counted as zero.
-    def baseline_values(rule, rows, from, to)
-      (1..rule.baseline_days).filter_map do |days|
-        day_rows = rows.select { |row| row.bucket.between?((from - days.days).beginning_of_hour, to - days.days) }
-        next if day_rows.empty?
-        value_for(rule.metric, Telemetry::Rollup.summarize(day_rows), rule.window_minutes)
-      end
-    end
-
-    # One query for every group's baseline, reading only the hour buckets the
-    # baseline windows actually cover rather than the whole `baseline_days` span.
-    def baseline_rows(rule, type, group_hashes, from, to)
-      return {} if group_hashes.empty?
-
-      rows = Telemetry::Rollup.for_type(type)
-               .where(group_hash: group_hashes, bucket: baseline_buckets(rule, from, to))
-               .order(:bucket, :group_hash).limit(MAX_BASELINE_ROWS_PER_RULE + 1).to_a
-      if rows.length > MAX_BASELINE_ROWS_PER_RULE
-        Rails.logger.error("anomaly detector skipped rule_id=#{rule.id}: more than #{MAX_BASELINE_ROWS_PER_RULE} baseline rollups")
-        return nil
-      end
-      rows.group_by(&:group_hash)
-    end
-
-    # The hour buckets covered by the same clock window on each of the previous
-    # `baseline_days` days.
-    def baseline_buckets(rule, from, to)
-      (1..rule.baseline_days).flat_map do |days|
-        bucket = (from - days.days).beginning_of_hour
-        last = to - days.days
-        buckets = []
-        while bucket <= last
-          buckets << bucket
-          bucket += 1.hour
-        end
-        buckets
-      end
-    end
-
-    def value_for(metric, summary, window_minutes)
-      case metric
-      when "p95" then summary[:p95] / 1000.0
-      when "avg" then summary[:avg] / 1000.0
-      when "count" then summary[:count] / window_minutes.to_f
-      when "error_rate" then summary[:count].zero? ? nil : (summary[:errors] * 100.0 / summary[:count])
-      end
-    end
-
-    # Reads the primary database: one open anomaly issue per (rule, group) is
-    # enough for an hour, however often the scan runs.
-    def cooling_down?(rule, group_hash)
-      Issue.where(environment_id: rule.environment_id, group_hash: issue_group_hash(rule, group_hash))
-           .where(last_seen_at: COOL_DOWN.ago..).exists?
-    end
-
-    def issue_group_hash(rule, group_hash)
-      "anomaly:#{rule.id}:#{group_hash}"
-    end
-
-    def open_issue(environment, rule, now, detection)
-      issue, outcome = Issue.record_occurrence!(
-        environment: environment, group_hash: issue_group_hash(rule, detection[:group_hash]), kind: "anomaly",
-        title: "#{rule.metric} of #{detection[:name]} is #{detection[:sigmas].round(1)}σ above its #{rule.baseline_days}-day baseline (#{detection[:current]} vs #{detection[:mean]})",
-        culprit: detection[:name], occurred_at: now, deploy: nil, user_ref: nil,
-        sample: { rule_id: rule.id, metric: rule.metric, current: detection[:current], mean: detection[:mean],
-                  stddev: detection[:stddev], sigmas: detection[:sigmas], window_minutes: rule.window_minutes })
-      carry_detection(issue, outcome) do
-        IssueDetectionSnapshot.capture(
-          environment: environment, kind: "anomaly", telemetry_type: TYPE_FOR.fetch(rule.target_kind),
-          telemetry_group_hash: detection[:group_hash], target: detection[:name], metric: rule.metric,
-          from: now - rule.window_minutes.minutes, to: now, value: detection[:current],
-          baseline: detection.slice(:mean, :stddev, :sigmas).merge(days: rule.baseline_days, deviation: rule.deviation),
-          rule: { type: "anomaly", id: rule.id, target_kind: rule.target_kind, target: rule.target }
-        )
-      end
-      if outcome == :new || outcome == :regressed
-        issue.fire_alerts!("anomaly", rule_id: rule.id, metric: rule.metric, current: detection[:current],
-          mean: detection[:mean], sigmas: detection[:sigmas])
-      end
-      rule.update_columns(last_fired_at: now)
-    end
-  end
-end