rails_pulse 0.3.3 → 0.4.0.pre.2

data/app/javascript/rails_pulse/application.js

@@ -1,24 +1,48 @@
-import * as echarts from "echarts";
-import "./theme";
+// Only the chart types and components Rails Pulse actually renders are pulled in.
+// Importing the "echarts" barrel instead would bundle every chart type (sankey,
+// gauge, map, ...) and roughly quintuple the bundle.
+import * as echarts from "echarts/core";
+import { BarChart, LineChart } from "echarts/charts";
+import {
+  DataZoomComponent,
+  GridComponent,
+  LegendComponent,
+  MarkAreaComponent,
+  MarkLineComponent,
+  TooltipComponent
+} from "echarts/components";
+import { CanvasRenderer } from "echarts/renderers";
 import { Application } from "@hotwired/stimulus";
 
+// TooltipComponent installs AxisPointer itself, so `axisPointer` options work.
+echarts.use([
+  BarChart,
+  LineChart,
+  DataZoomComponent,
+  GridComponent,
+  LegendComponent,
+  MarkAreaComponent,
+  MarkLineComponent,
+  TooltipComponent,
+  CanvasRenderer
+]);
+
 // CSS Zero Controllers
 import ContextMenuController from "./controllers/context_menu_controller";
 import DatePickerController from "./controllers/datepicker_controller";
 import DialogController from "./controllers/dialog_controller";
 import MenuController from "./controllers/menu_controller";
 import PopoverController from "./controllers/popover_controller";
-import FormController from "./controllers/form_controller";
 
 // Rails Pulse Controllers
 import ChartController from "./controllers/chart_controller";
 import IndexController from "./controllers/index_controller";
 import ColorSchemeController from "./controllers/color_scheme_controller";
 import PaginationController from "./controllers/pagination_controller";
-import TimezoneController from "./controllers/timezone_controller";
 import IconController from "./controllers/icon_controller";
 import ExpandableRowsController from "./controllers/expandable_rows_controller";
 import CollapsibleController from "./controllers/collapsible_controller";
+import ClipboardController from "./controllers/clipboard_controller";
 import TableSortController from "./controllers/table_sort_controller";
 import GlobalFiltersController from "./controllers/global_filters_controller";
 import CustomRangeController from "./controllers/custom_range_controller"
@@ -26,7 +50,6 @@ import SeriesToggleController from "./controllers/series_toggle_controller";
 import DeploymentMarkersToggleController from "./controllers/deployment_markers_toggle_controller";
 import FlameGraphController from "./controllers/flame_graph_controller";
 import ChartSwitcherController from "./controllers/chart_switcher_controller";
-import PeriodSelectorController from "./controllers/period_selector_controller";
 import TimeRangeController from "./controllers/time_range_controller";
 const application = Application.start();
 
@@ -42,16 +65,15 @@ application.register("rails-pulse--datepicker", DatePickerController);
 application.register("rails-pulse--dialog", DialogController);
 application.register("rails-pulse--menu", MenuController);
 application.register("rails-pulse--popover", PopoverController);
-application.register("rails-pulse--form", FormController);
 
 application.register("rails-pulse--chart", ChartController);
 application.register("rails-pulse--index", IndexController);
 application.register("rails-pulse--color-scheme", ColorSchemeController);
 application.register("rails-pulse--pagination", PaginationController);
-application.register("rails-pulse--timezone", TimezoneController);
 application.register("rails-pulse--icon", IconController);
 application.register("rails-pulse--expandable-rows", ExpandableRowsController);
 application.register("rails-pulse--collapsible", CollapsibleController);
+application.register("rails-pulse--clipboard", ClipboardController);
 application.register("rails-pulse--table-sort", TableSortController);
 application.register("rails-pulse--global-filters", GlobalFiltersController);
 application.register("rails-pulse--custom-range", CustomRangeController);
@@ -59,7 +81,6 @@ application.register("rails-pulse--series-toggle", SeriesToggleController);
 application.register("rails-pulse--deployment-markers-toggle", DeploymentMarkersToggleController);
 application.register("rails-pulse--flame-graph", FlameGraphController);
 application.register("rails-pulse--chart-switcher", ChartSwitcherController);
-application.register("rails-pulse--period-selector", PeriodSelectorController);
 application.register("rails-pulse--time-range", TimeRangeController);
 
 // Register ECharts theme for Rails Pulse

data/app/javascript/rails_pulse/controllers/clipboard_controller.js

@@ -0,0 +1,58 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["source"]
+  static values = {
+    label: { type: String, default: "copy" },
+    copiedLabel: { type: String, default: "copied!" },
+    errorLabel: { type: String, default: "copy failed" },
+    resetDelay: { type: Number, default: 1500 }
+  }
+
+  disconnect() {
+    if (this.resetTimeout) clearTimeout(this.resetTimeout)
+  }
+
+  async copy(event) {
+    const button = event.currentTarget
+    const text = this.hasSourceTarget ? this.sourceTarget.textContent : ""
+
+    try {
+      await this.write(text)
+      this.flash(button, this.copiedLabelValue)
+    } catch {
+      this.flash(button, this.errorLabelValue)
+    }
+  }
+
+  // navigator.clipboard is undefined on insecure origins, which is where a
+  // mounted dashboard often lives (http://staging.internal). Fall back to the
+  // legacy execCommand path there rather than silently doing nothing.
+  async write(text) {
+    if (navigator.clipboard && window.isSecureContext) {
+      return navigator.clipboard.writeText(text)
+    }
+
+    const textarea = document.createElement("textarea")
+    textarea.value = text
+    textarea.setAttribute("readonly", "")
+    textarea.style.position = "fixed"
+    textarea.style.opacity = "0"
+    document.body.appendChild(textarea)
+    textarea.select()
+
+    try {
+      if (!document.execCommand("copy")) throw new Error("execCommand copy failed")
+    } finally {
+      document.body.removeChild(textarea)
+    }
+  }
+
+  flash(button, message) {
+    button.textContent = message
+    if (this.resetTimeout) clearTimeout(this.resetTimeout)
+    this.resetTimeout = setTimeout(() => {
+      button.textContent = this.labelValue
+    }, this.resetDelayValue)
+  }
+}

data/app/javascript/rails_pulse/controllers/index_controller.js

@@ -40,6 +40,16 @@ export default class extends Controller {
     this.handleChartInitialized = this.onChartInitialized.bind(this);
 
     document.addEventListener('stimulus:echarts:rendered', this.handleChartInitialized);
+
+    // Releasing the mouse outside the chart still ends a drag-zoom. This is not
+    // chart-specific, so it is bound once per controller rather than in
+    // setupChartEventListeners — that runs again on every chart switch and used
+    // to stack a new document listener each time.
+    this.handleDocumentMouseUp = () => {
+      if (!this.chart || !this.visibleData) return;
+      this.handleZoomChange();
+    };
+    document.addEventListener('mouseup', this.handleDocumentMouseUp);
   }
 
   disconnect() {
@@ -226,12 +236,6 @@ export default class extends Controller {
       this.handleZoomChange();
     });
 
-    // When releasing the mouse button outside the chart, we want to check if the visible data has changed
-    this.handleDocumentMouseUp = () => {
-      this.handleZoomChange();
-    };
-    document.addEventListener('mouseup', this.handleDocumentMouseUp);
-
     // Use ZRender (the underlying canvas renderer) to catch clicks anywhere in the
     // chart grid — not just on data point markers — then map the pixel position back
     // to the nearest x-axis bucket so any click in a column triggers filtering.
@@ -398,8 +402,8 @@ export default class extends Controller {
       }
 
       if (this.getAxisType(currentOption) === 'time') {
-        const startValue = dataZoom.startValue || xAxisData[0];
-        const endValue = dataZoom.endValue || xAxisData[xAxisData.length - 1];
+        const startValue = dataZoom.startValue ?? xAxisData[0];
+        const endValue = dataZoom.endValue ?? xAxisData[xAxisData.length - 1];
 
         return {
           xAxis: xAxisData.filter(value => value >= startValue && value <= endValue),
@@ -410,8 +414,10 @@ export default class extends Controller {
         };
       }
 
-      const startValue = dataZoom.startValue || 0;
-      const endValue = dataZoom.endValue || xAxisData.length - 1;
+      // ?? not ||: index 0 is a valid category position, and `0 || fallback`
+      // silently widens the range back to the full axis.
+      const startValue = dataZoom.startValue ?? 0;
+      const endValue = dataZoom.endValue ?? xAxisData.length - 1;
 
       return {
         xAxis: xAxisData.slice(startValue, endValue + 1),

data/app/javascript/rails_pulse/controllers/pagination_controller.js

@@ -28,11 +28,15 @@ export default class extends Controller {
 
   // Restore the pagination limit from URL or session storage on page load
   restorePaginationLimit() {
+    // hasLimitTarget, not truthiness: accessing a missing Stimulus target throws
+    // rather than returning undefined, which would break connect() outright.
+    if (!this.hasLimitTarget) return
+
     // URL params take precedence over session storage
     const urlParams = new URLSearchParams(window.location.search)
     const urlLimit = urlParams.get('limit')
 
-    if (urlLimit && this.limitTarget) {
+    if (urlLimit) {
       // Sync sessionStorage with URL param
       sessionStorage.setItem(this.storageKeyValue, urlLimit)
       if (this.limitTarget.value !== urlLimit) {
@@ -41,7 +45,7 @@ export default class extends Controller {
     } else {
       // Fall back to sessionStorage if no URL param
       const savedLimit = sessionStorage.getItem(this.storageKeyValue)
-      if (savedLimit && this.limitTarget && this.limitTarget.value !== savedLimit) {
+      if (savedLimit && this.limitTarget.value !== savedLimit) {
         this.limitTarget.value = savedLimit
       }
     }

data/app/javascript/rails_pulse/controllers/popover_controller.js

@@ -42,6 +42,10 @@ export default class extends Controller {
   }
 
   disconnect() {
+    // A pending debouncedShow would otherwise fire showPopover() on an element
+    // that has already been removed (e.g. the table was replaced by a fetch).
+    clearTimeout(this.#showTimer)
+    clearTimeout(this.#hideTimer)
     this.cleanup()
   }
 

data/app/models/concerns/rails_pulse/taggable.rb

@@ -5,20 +5,25 @@ module RailsPulse
     # Tag validation constants
     TAG_NAME_REGEX = /\A[a-z0-9_-]+\z/i
     MAX_TAG_LENGTH = 50
+    # Escape character for LIKE patterns over the serialized tags column.
+    # Never appears in a valid tag name, and needs no quoting on any adapter.
+    LIKE_ESCAPE = "!".freeze
 
     included do
       # Callbacks
       before_save :ensure_tags_is_array
 
-      # Scopes with table name qualification to avoid ambiguity
-      # Note: LIKE patterns are sanitized to prevent SQL injection via wildcards
+      # Scopes with table name qualification to avoid ambiguity.
+      # LIKE patterns are sanitized so `_`/`%` in a tag are matched literally.
+      # The ESCAPE clause is explicit because SQLite has no default escape
+      # character — without it `my\_tag` matches a literal backslash there
+      # and the filter silently matches nothing. `!` is used rather than `\`
+      # because MySQL and PostgreSQL disagree on how to quote a backslash.
       scope :with_tag, ->(tag) {
-        sanitized_tag = sanitize_sql_like(tag.to_s, "\\")
-        where("#{table_name}.tags LIKE ?", "%\"#{sanitized_tag}\"%")
+        where("#{table_name}.tags LIKE ? ESCAPE '!'", "%\"#{sanitize_sql_like(tag.to_s, LIKE_ESCAPE)}\"%")
       }
       scope :without_tag, ->(tag) {
-        sanitized_tag = sanitize_sql_like(tag.to_s, "\\")
-        where.not("#{table_name}.tags LIKE ?", "%\"#{sanitized_tag}\"%")
+        where.not("#{table_name}.tags LIKE ? ESCAPE '!'", "%\"#{sanitize_sql_like(tag.to_s, LIKE_ESCAPE)}\"%")
       }
       scope :with_tags, -> { where("#{table_name}.tags IS NOT NULL AND #{table_name}.tags != '[]'") }
     end

data/app/models/rails_pulse/cards/base.rb

@@ -173,6 +173,59 @@ module RailsPulse
         [ icon, format_percentage(percentage.abs, precision) ]
       end
 
+      # Compares a subject against its own history rather than against the
+      # immediately preceding window.
+      #
+      # The period-over-period arrow above answers "is this week worse than last
+      # week?", which is noisy — last week may itself have been unusual. This
+      # answers "is this worse than how this normally behaves?", which is the
+      # question the number is actually being read for.
+      #
+      # Only available where there is a single subject to have a history. Index
+      # pages aggregate across every route or query, so they keep the
+      # period-over-period arrow.
+      #
+      # @return [Array(String, String, String), nil] icon, amount, caption
+      def baseline_trend_for(subject, metric:)
+        return nil if subject.nil?
+
+        comparison = RailsPulse::Operations::Compare.call(subject, metric: metric)
+        return nil unless comparison.sufficient_data?
+
+        percentage = comparison.percent_change
+
+        icon = if percentage.abs < 0.1
+          "move-right"
+        elsif percentage.positive?
+          "trending-up"
+        else
+          "trending-down"
+        end
+
+        [ icon, format_percentage(percentage.abs, 1), baseline_caption(comparison) ]
+      end
+
+      # Names the change point only when there is a regression to explain. On a
+      # healthy metric "since Aug 26" would be noise, and locating it costs a
+      # second query that is not worth spending to say nothing.
+      def baseline_caption(comparison)
+        caption = "Compared to its #{baseline_window_text} normal"
+        return caption unless comparison.regression?
+
+        change_point = RailsPulse::Operations::ChangePoint.call(
+          comparison.subject, metric: comparison.metric
+        )
+        return caption if change_point.nil?
+
+        stamp = change_point.hourly? ? change_point.at.strftime("%b %-d %H:%M") : change_point.at.strftime("%b %-d")
+        "#{caption} · since #{stamp}"
+      end
+
+      def baseline_window_text
+        days = (RailsPulse.configuration.baseline_window / 1.day).round
+        "#{days}-day"
+      end
+
       # Existing format helpers (keep as-is)
       def format_percentage(value, precision = 1)
         "#{value.round(precision)}%"

data/app/models/rails_pulse/dashboard/health_summary.rb

@@ -11,6 +11,7 @@ module RailsPulse
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds
+        @exception_thresholds = RailsPulse.configuration.exception_thresholds
       end
 
       def to_health_data
@@ -18,6 +19,7 @@ module RailsPulse
           routes:   route_counts,
           queries:  query_counts,
           jobs:     job_counts,
+          exceptions: exception_counts,
           storage:  storage_counts
         }
       end
@@ -108,6 +110,56 @@ module RailsPulse
 
         { healthy: healthy, slow: slow, critical: critical }
       end
+
+      # Exception groups classified by how often they fired over the dashboard
+      # period, read from summaries rather than from ExceptionGroup's lifetime
+      # occurrence_count — a group that fired ten thousand times last year and
+      # is now silent is not a critical problem today.
+      #
+      # A group with occurrences in the period but below the warning threshold
+      # counts as "slow" rather than "healthy": an exception happening at all is
+      # not healthy, it is just not yet urgent.
+      def exception_counts
+        return nil unless RailsPulse.configuration.track_exceptions
+        return nil unless exception_summaries_available?
+
+        start, finish = period_range
+
+        counts = RailsPulse::Summary
+          .for_exceptions
+          .where.not(summarizable_id: 0)
+          .where(period_start: start..finish)
+          .group(:summarizable_id)
+          .sum(:count)
+
+        healthy = slow = critical = 0
+
+        open_group_ids.each do |group_id|
+          occurrences = counts[group_id].to_i
+
+          if occurrences >= @exception_thresholds[:critical]
+            critical += 1
+          elsif occurrences >= @exception_thresholds[:warning]
+            slow += 1
+          elsif occurrences.positive?
+            slow += 1
+          else
+            healthy += 1
+          end
+        end
+
+        { healthy: healthy, slow: slow, critical: critical }
+      end
+
+      def open_group_ids
+        RailsPulse::ExceptionGroup.where(status: "open").pluck(:id)
+      end
+
+      def exception_summaries_available?
+        RailsPulse::ExceptionGroup.table_exists?
+      rescue ActiveRecord::ActiveRecordError
+        false
+      end
     end
   end
 end

data/app/models/rails_pulse/dashboard/needs_attention.rb

@@ -11,12 +11,13 @@ module RailsPulse
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds
+        @exception_thresholds = RailsPulse.configuration.exception_thresholds
       end
 
       MAX_ITEMS = 10
 
       def to_attention_data
-        items    = route_items + query_items + job_items
+        items    = route_items + query_items + job_items + exception_items
         critical = items.select { |i| i[:severity] == :critical }.sort_by { |i| -i[:sort_score] }
         warning  = items.select { |i| i[:severity] == :warning  }.sort_by { |i| -i[:sort_score] }
 
@@ -247,6 +248,77 @@ module RailsPulse
         end
       end
 
+      # Exception groups that fired often enough over the period to be worth
+      # looking at. Read from summaries, not from ExceptionGroup#occurrence_count
+      # — that is a lifetime counter, so a group that was noisy last year and is
+      # silent now would otherwise be reported forever.
+      #
+      # Ignored groups are excluded by design: a user marking something ignored
+      # is saying "stop telling me about this", and the attention list is
+      # exactly where that must be honoured.
+      def exception_items
+        return [] unless RailsPulse.configuration.track_exceptions
+        return [] unless exception_tables_available?
+
+        start, finish = period_range
+
+        counts = RailsPulse::Summary
+          .for_exceptions
+          .where.not(summarizable_id: 0)
+          .where(period_start: start..finish)
+          .group(:summarizable_id)
+          .sum(:count)
+
+        return [] if counts.empty?
+
+        groups = RailsPulse::ExceptionGroup
+          .where(id: counts.keys, status: "open")
+          .index_by(&:id)
+
+        counts.filter_map do |group_id, occurrences|
+          group = groups[group_id]
+          next if group.nil?
+
+          severity = exception_severity(occurrences)
+          next if severity.nil?
+
+          {
+            type:       "EXCEPTION",
+            name:       group.exception_class,
+            reason:     "#{occurrences} occurrence#{occurrences == 1 ? "" : "s"}#{group.location.present? ? " · #{group.location}" : ""}",
+            metric:     "#{occurrences} this period",
+            metric_sub: group.last_seen_at ? "last seen #{time_ago_phrase(group.last_seen_at)}" : "open",
+            link:       url_helpers.exception_path(group.id),
+            severity:   severity,
+            sort_score: occurrences.to_f
+          }
+        end
+      end
+
+      def exception_severity(occurrences)
+        return :critical if occurrences >= @exception_thresholds[:critical]
+        return :warning  if occurrences >= @exception_thresholds[:warning]
+
+        nil
+      end
+
+      def time_ago_phrase(time)
+        seconds = (Time.current - time).to_i
+        return "just now" if seconds < 60
+        return "#{seconds / 60}m ago" if seconds < 3600
+        return "#{seconds / 3600}h ago" if seconds < 86_400
+
+        "#{seconds / 86_400}d ago"
+      end
+
+      # The exception tables arrive in a migration, so a host that has upgraded
+      # the gem but not yet run migrations must still get a working dashboard.
+      def exception_tables_available?
+        RailsPulse::ExceptionGroup.table_exists?
+      rescue ActiveRecord::ActiveRecordError
+        false
+      end
+
       def truncate_sql(sql)
         return "" if sql.blank?
         cleaned = sql.gsub(/\s+/, " ").strip