rails_pulse 0.3.3 → 0.4.0.pre.2

data/app/models/rails_pulse/exceptions/cards/exception_rate.rb

@@ -0,0 +1,116 @@
+module RailsPulse
+  module Exceptions
+    module Cards
+      # Exceptions raised per 1,000 requests.
+      #
+      # Raw occurrence counts rise with traffic, so a busy week and a broken
+      # week look the same on the Occurrences card. Dividing by request volume
+      # separates the two: this is the only exception figure that can fall while
+      # occurrences climb, which is what "we shipped a fix but got busier" looks
+      # like.
+      #
+      # Both sides come from rails_pulse_summaries — the all-groups exception
+      # rollup over the overall request summary — so the ratio stays accurate
+      # after cleanup has pruned the underlying records.
+      class ExceptionRate < RailsPulse::Cards::Base
+        PER = 1_000
+
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
+          @disabled_tags   = disabled_tags
+          @show_non_tagged = show_non_tagged
+          @period          = period
+          @period_type     = period_type
+        end
+
+        def to_metric_card
+          exceptions = window_totals(RailsPulse::Summary.overall_exceptions)
+          requests   = window_totals(RailsPulse::Summary.overall_requests)
+
+          rate = rate_for(exceptions[:total], requests[:total])
+
+          # More exceptions per request is worse, so the arrow reads the
+          # opposite way round from a throughput card — the strip already
+          # colours trending-up as negative.
+          if show_trend?
+            trend_icon, trend_amount = trend_for(
+              rate_for(exceptions[:current],  requests[:current]),
+              rate_for(exceptions[:previous], requests[:previous])
+            )
+          end
+
+          {
+            id: "exceptions_rate",
+            chart_color: RailsPulse::ChartColors::DEFAULT,
+            context: "exceptions",
+            title: "Exception Rate",
+            summary: "#{rate} per #{format_number(PER)}",
+            chart_data: sparkline_data,
+            trend_icon: trend_icon,
+            trend_amount: trend_amount,
+            trend_text: (show_trend? ? comparison_period_text : nil),
+            period_stat: period_stat(exceptions[:total], requests[:total]),
+            help_heading: "Exception Rate",
+            help_text: "Exceptions raised per 1,000 requests over the period. Occurrence counts on their own rise and fall with traffic; this figure does not, so it is the one to watch when you want to know whether the application itself got worse. Reads the all-groups exception rollup against the overall request summary. Exceptions raised inside background jobs are counted in the numerator but have no request to divide by, so a job-heavy application will read high."
+          }
+        end
+
+        private
+
+        # Total, current-window and previous-window counts in one pass, so the
+        # rate can be compared across windows without four separate queries.
+        def window_totals(scope)
+          row = scope
+            .where(period_type: @period_type, period_start: range_start..now)
+            .select(
+              "SUM(rails_pulse_summaries.count) AS total_count",
+              "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_count",
+              "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count"
+            )
+            .take
+
+          {
+            total:    row&.total_count.to_i,
+            current:  row&.current_count.to_i,
+            previous: row&.previous_count.to_i
+          }
+        end
+
+        # No requests in a period is "nothing to divide by", not "a rate of
+        # zero" — but zero is the honest reading for a card that answers "how
+        # often did this happen", and it keeps the sparkline continuous.
+        def rate_for(exceptions, requests)
+          return 0.0 if requests.to_i.zero?
+
+          (exceptions.to_f / requests * PER).round(1)
+        end
+
+        def sparkline_data
+          exceptions = grouped_counts(RailsPulse::Summary.overall_exceptions)
+          requests   = grouped_counts(RailsPulse::Summary.overall_requests)
+
+          sparkline_from(
+            requests.keys.union(exceptions.keys).index_with do |bucket|
+              rate_for(exceptions[bucket], requests[bucket])
+            end
+          )
+        end
+
+        def grouped_counts(scope)
+          scoped = scope.where(period_type: @period_type, period_start: current_window_start..now)
+
+          if period_type_hours?
+            scoped.group_by_hour(:period_start).sum("rails_pulse_summaries.count")
+          else
+            scoped.group_by_date(:period_start).sum("rails_pulse_summaries.count")
+          end
+        end
+
+        def period_stat(exceptions, requests)
+          return period_date_range if requests.zero?
+
+          "#{format_number(exceptions)} raised · #{format_number(requests)} requests"
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/exceptions/cards/open_groups.rb

@@ -0,0 +1,49 @@
+module RailsPulse
+  module Exceptions
+    module Cards
+      # How many distinct exception sites are currently open.
+      #
+      # Occurrence volume and open-group count answer different questions: one
+      # loud exception firing ten thousand times and a hundred different sites
+      # each firing once are both worth knowing about, and neither number tells
+      # you about the other.
+      class OpenGroups < RailsPulse::Cards::Base
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
+          @disabled_tags   = disabled_tags
+          @show_non_tagged = show_non_tagged
+          @period          = period
+          @period_type     = period_type
+        end
+
+        def to_metric_card
+          open_count = RailsPulse::ExceptionGroup.where(status: "open").count
+
+          # New groups are the ones that did not exist before this window — a
+          # site that has just started failing, rather than a known one.
+          new_in_window = RailsPulse::ExceptionGroup
+            .where(status: "open")
+            .where(first_seen_at: current_window_start..now)
+            .count
+
+          grouped = RailsPulse::ExceptionGroup
+            .where(first_seen_at: current_window_start..now)
+            .group_by_date(:first_seen_at)
+            .count
+
+          {
+            id: "exceptions_open_groups",
+            chart_color: RailsPulse::ChartColors::DEFAULT,
+            context: "exceptions",
+            title: "Open Groups",
+            summary: "#{format_number(open_count)} open",
+            chart_data: sparkline_from(grouped),
+            trend_text: nil,
+            period_stat: "#{format_number(new_in_window)} new this period",
+            help_heading: "Open Exception Groups",
+            help_text: "Distinct exception sites currently marked open — one per exception class and code location, not one per raise. Resolved and ignored groups are excluded. The period figure counts sites seen for the first time in this window, which is usually where a new bug shows up."
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/exceptions/cards/total_occurrences.rb

@@ -0,0 +1,62 @@
+module RailsPulse
+  module Exceptions
+    module Cards
+      # How often exceptions fired, and whether that is going up.
+      #
+      # This is the card that makes "which exceptions are increasing?" a
+      # question the product can answer at a glance. It reads the all-groups
+      # rollup summary rather than ExceptionGroup#occurrence_count, which is a
+      # lifetime counter and never goes down.
+      class TotalOccurrences < RailsPulse::Cards::Base
+        SUMMARIZABLE_TYPE = "RailsPulse::ExceptionGroup".freeze
+
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
+          @disabled_tags   = disabled_tags
+          @show_non_tagged = show_non_tagged
+          @period          = period
+          @period_type     = period_type
+        end
+
+        def to_metric_card
+          base_query = RailsPulse::Summary
+            .overall_exceptions
+            .where(period_type: @period_type, period_start: range_start..now)
+
+          metrics = base_query.select(
+            "SUM(rails_pulse_summaries.count) AS total_count",
+            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_count",
+            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count"
+          ).take
+
+          total    = metrics&.total_count.to_i
+          current  = metrics&.current_count.to_i
+          previous = metrics&.previous_count.to_i
+
+          # More exceptions is worse, so the trend arrow means the opposite of
+          # what it means on a throughput card.
+          trend_icon, trend_amount = trend_for(current, previous) if show_trend?
+
+          grouped = base_query
+            .where(period_start: current_window_start..now)
+            .group_by_date(:period_start)
+            .sum("rails_pulse_summaries.count")
+
+          {
+            id: "exceptions_total_occurrences",
+            chart_color: RailsPulse::ChartColors::DEFAULT,
+            context: "exceptions",
+            title: "Occurrences",
+            summary: "#{format_number(total)} raised",
+            chart_data: sparkline_from(grouped),
+            trend_icon: trend_icon,
+            trend_amount: trend_amount,
+            trend_text: (show_trend? ? comparison_period_text : nil),
+            period_stat: period_date_range,
+            help_heading: "Exception Occurrences",
+            help_text: "How many exceptions your application raised over the period, across every group. Read from retained summaries, so the history stays accurate even after individual occurrence records have been cleaned up. A rising trend is the signal to look at which groups are growing."
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/exceptions/charts/occurrence_volume.rb

@@ -0,0 +1,56 @@
+module RailsPulse
+  module Exceptions
+    module Charts
+      # Exception frequency over time, read from the all-groups rollup summary.
+      #
+      # Reads summaries rather than counting occurrence rows directly: occurrence
+      # rows are pruned by retention, so counting them would show a chart that
+      # silently flattens toward zero the further back you look. Summaries are
+      # retained at day granularity indefinitely.
+      class OccurrenceVolume
+        def initialize(start_time:, end_time:, period_type: "day")
+          @start_time  = start_time
+          @end_time    = end_time
+          @period_type = period_type
+        end
+
+        def to_chart_data
+          totals = RailsPulse::Summary
+            .overall_exceptions
+            .where(period_type: @period_type, period_start: @start_time..@end_time)
+            .group(:period_start)
+            .sum(:count)
+
+          return nil if totals.empty?
+
+          raw = totals.transform_keys { |period_start| period_start.to_i }
+          padded = pad_with_zeros(raw)
+
+          {
+            series: [ {
+              name: "Occurrences",
+              data: padded.map { |timestamp, value| [ timestamp * 1000, value ] },
+              type: "bar",
+              color: RailsPulse::ChartColors::DEFAULT
+            } ]
+          }
+        end
+
+        private
+
+        # A period with no exceptions produces no summary row, which is the
+        # answer "zero" rather than "no data" — leaving the gap unfilled would
+        # draw a chart that skips quiet days and misrepresents the trend.
+        def pad_with_zeros(raw)
+          step = @period_type.to_s == "hour" ? 3600 : 86_400
+
+          {}.tap do |padded|
+            (@start_time.to_i..@end_time.to_i).step(step) do |timestamp|
+              padded[timestamp] = raw[timestamp] || 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/exceptions/raw_data.rb

@@ -0,0 +1,216 @@
+module RailsPulse
+  module Exceptions
+    # Builds the plain-text "Raw Data" block shown on the exception pages and
+    # copied to the clipboard for pasting into an LLM.
+    #
+    # Markdown rather than JSON (as the query page uses) because the payload is
+    # mostly backtrace and source snippets, which JSON string-escapes into
+    # something neither a human nor a model reads well.
+    #
+    # Runs its own aggregate queries off the group's occurrences association so
+    # the views and controllers stay thin and this stays independently testable.
+    class RawData
+      include RailsPulse::BacktraceHelper
+
+      # Caps keep the payload pasteable.
+      MAX_EXPANDED_FRAMES = 10
+      MAX_ENDPOINTS = 10
+      MAX_FRAMES = 50
+      SOURCE_RADIUS = 3
+      RECENT_WINDOW = 24.hours
+      PRIOR_WINDOW = 7.days
+
+      def initialize(group, occurrence: nil, aggregates: true)
+        @group = group
+        @occurrence = occurrence
+        @aggregates = aggregates
+      end
+
+      def to_s
+        sections.compact_blank.join("\n\n") << "\n"
+      end
+
+      private
+
+      attr_reader :group, :occurrence
+
+      def sections
+        [
+          heading,
+          summary_section,
+          frequency_section,
+          deploy_section,
+          request_section,
+          params_section,
+          backtrace_section,
+          source_section
+        ]
+      end
+
+      def aggregates?
+        @aggregates
+      end
+
+      def heading
+        "# Exception: #{group.exception_class}"
+      end
+
+      def summary_section
+        list = [
+          [ "Class", group.exception_class ],
+          [ "Message", message ],
+          [ "Location", group.location.presence || "unknown" ],
+          [ "Status", group.status ],
+          [ "Preserved from cleanup", group.preserve? ? "yes" : "no" ],
+          [ "Fingerprint", group.fingerprint ]
+        ]
+
+        section("Summary", bullets(list))
+      end
+
+      # The group message is sanitized at capture; occurrence messages are too
+      # (see ExceptionMessageSanitizer), but fall back to the group's if blank.
+      def message
+        (occurrence&.message.presence || group.message.presence || "—")
+      end
+
+      def frequency_section
+        list = [
+          [ "First seen", timestamp(group.first_seen_at) ],
+          [ "Last seen", timestamp(group.last_seen_at) ],
+          [ "Total occurrences (lifetime)", group.occurrence_count ]
+        ]
+
+        if aggregates?
+          list << [ "Stored occurrences", "#{stored_count} (older rows may have been pruned by retention)" ]
+          list << [ "Last 24 hours", recent_count ]
+          list << [ "Preceding 7 days", prior_count ]
+        end
+
+        section("Frequency", bullets(list))
+      end
+
+      def deploy_section
+        return unless aggregates?
+
+        shas = occurrences.where.not(deploy_sha: nil).distinct.pluck(:deploy_sha)
+        return if shas.empty?
+
+        first_sha = occurrences.order(:occurred_at).pick(:deploy_sha)
+
+        list = [ [ "Deploy SHAs seen", shas.join(", ") ] ]
+        list << [ "Earliest stored occurrence deployed at", first_sha ] if first_sha.present?
+
+        section("Deploys", bullets(list))
+      end
+
+      def request_section
+        lines = []
+
+        if aggregates?
+          environments = occurrences.where.not(environment: nil).distinct.pluck(:environment)
+          lines << "- Environments: #{environments.join(', ')}" if environments.any?
+
+          endpoints = occurrences.where.not(request_url: nil)
+                                 .distinct.limit(MAX_ENDPOINTS)
+                                 .pluck(:request_method, :request_url)
+          if endpoints.any?
+            lines << "- Endpoints:"
+            endpoints.each { |method, url| lines << "  - #{method.presence || '?'} #{url}" }
+          end
+        elsif occurrence
+          lines << "- Environment: #{occurrence.environment}" if occurrence.environment.present?
+          if occurrence.request_url.present?
+            lines << "- Endpoint: #{occurrence.request_method.presence || '?'} #{occurrence.request_url}"
+          end
+          lines << "- Deploy SHA: #{occurrence.deploy_sha}" if occurrence.deploy_sha.present?
+          lines << "- Occurred at: #{timestamp(occurrence.occurred_at)}"
+        end
+
+        section("Request context", lines.join("\n")) if lines.any?
+      end
+
+      # Already run through ActiveSupport::ParameterFilter at capture time.
+      def params_section
+        params = occurrence&.request_params
+        return if params.blank?
+
+        section("Request params (filtered)", fenced(JSON.pretty_generate(params), "json"))
+      end
+
+      def backtrace_section
+        return if frames.empty?
+
+        lines = frames.each_with_index.map do |frame, index|
+          origin = app_frame?(frame) ? "app" : "gem"
+          "#{(index + 1).to_s.rjust(2)}. [#{origin}] #{frame_display_path(frame)}:#{frame['line']}:in `#{frame['method']}'"
+        end
+
+        title = "Backtrace"
+        title += " (occurrence at #{timestamp(occurrence.occurred_at)})" if occurrence&.occurred_at
+
+        section(title, fenced(lines.join("\n")))
+      end
+
+      # Source is read from disk for app frames only, and BacktraceHelper
+      # sandboxes reads to Rails.root.
+      def source_section
+        expanded = frames.select { |frame| app_frame?(frame) }
+                         .first(MAX_EXPANDED_FRAMES)
+                         .filter_map do |frame|
+          lines = frame_source_lines(frame, radius: SOURCE_RADIUS)
+          next if lines.blank?
+
+          body = lines.map do |lineno, content|
+            marker = lineno == frame["line"].to_i ? ">" : " "
+            "#{marker} #{lineno.to_s.rjust(4)} | #{content}"
+          end.join("\n")
+
+          "### #{frame_display_path(frame)}:#{frame['line']} — `#{frame['method']}`\n\n#{fenced(body, 'ruby')}"
+        end
+
+        return if expanded.empty?
+
+        section("Source", expanded.join("\n\n"))
+      end
+
+      def frames
+        @frames ||= Array(occurrence&.backtrace).first(MAX_FRAMES).select { |frame| frame.is_a?(Hash) }
+      end
+
+      def occurrences
+        group.occurrences
+      end
+
+      def stored_count
+        @stored_count ||= occurrences.count
+      end
+
+      def recent_count
+        @recent_count ||= occurrences.where(occurred_at: RECENT_WINDOW.ago..).count
+      end
+
+      def prior_count
+        @prior_count ||= occurrences.where(occurred_at: (RECENT_WINDOW + PRIOR_WINDOW).ago...RECENT_WINDOW.ago).count
+      end
+
+      def timestamp(time)
+        return "—" if time.blank?
+        time.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+      end
+
+      def bullets(pairs)
+        pairs.map { |label, value| "- #{label}: #{value}" }.join("\n")
+      end
+
+      def fenced(body, language = "")
+        "```#{language}\n#{body}\n```"
+      end
+
+      def section(title, body)
+        return if body.blank?
+        "## #{title}\n\n#{body}"
+      end
+    end
+  end
+end

data/app/models/rails_pulse/jobs/cards/p95_duration.rb

@@ -40,7 +40,13 @@ module RailsPulse
           current_p95 = weighted_average(current_weighted_p95, current_runs)
           previous_p95 = weighted_average(previous_weighted_p95, previous_runs)
 
-          trend_icon, trend_amount = trend_for(current_p95, previous_p95) if show_trend?
+          baseline = baseline_trend_for(@job, metric: :p95)
+
+          if baseline
+            trend_icon, trend_amount, trend_caption = baseline
+          elsif show_trend?
+            trend_icon, trend_amount = trend_for(current_p95, previous_p95)
+          end
 
           grouped_weighted = base_query
             .group_by_date(:period_start)
@@ -61,7 +67,7 @@ module RailsPulse
             chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
-            trend_text: (show_trend? ? comparison_period_text : nil),
+            trend_text: trend_caption || (show_trend? ? comparison_period_text : nil),
             period_stat: total_runs > 0 ? "Across #{format_number(total_runs)} runs" : period_date_range,
             help_heading: "P95 Duration",
             help_text: "The 95th percentile execution time — 95% of jobs complete faster than this. Weighted by job volume across all classes. A rising P95 indicates jobs are becoming slower, which may cause queue backlog."

data/app/models/rails_pulse/operation.rb

@@ -83,6 +83,9 @@ module RailsPulse
           end
         end
         op[:label] = op[:label]&.truncate(255)
+        # actual_sql is used for normalization above but should not be persisted
+        # unless the user has opted in — it may contain unparameterized PII.
+        op[:actual_sql] = nil unless RailsPulse.configuration.capture_actual_sql
         op
       end
       # insert_all! requires every row to have identical keys.
@@ -109,20 +112,26 @@ module RailsPulse
       Arel.sql("COUNT(rails_pulse_operations.id)")
     end
 
-    ransacker :occurred_at, formatter: ->(val) {
-      # Handle different time formats for database compatibility
+    # Handle different time formats for database compatibility. An
+    # unparseable value becomes nil, which Ransack treats as "no filter",
+    # rather than a 500 from a hand-edited query string.
+    OCCURRED_AT_FORMATTER = lambda do |val|
       case val
       when Time, DateTime, ActiveSupport::TimeWithZone
         val.utc.iso8601
       when String
-        Time.zone.parse(val).utc.iso8601
+        Time.zone.parse(val)&.utc&.iso8601
       when Integer
         Time.at(val).utc.iso8601
       else
         # Fallback: try to parse as integer timestamp
         Time.at(val.to_i).utc.iso8601
       end
-    } do |parent|
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    ransacker :occurred_at, formatter: OCCURRED_AT_FORMATTER do |parent|
       parent.table[:occurred_at]
     end
 

data/app/models/rails_pulse/queries/cards/percentile_query_times.rb

@@ -26,8 +26,13 @@ module RailsPulse
           current_period_p95 = metrics.current_p95 || 0
           previous_period_p95 = metrics.previous_p95 || 0
 
-          # Use base class trend calculation
-          trend_icon, trend_amount = trend_for(current_period_p95, previous_period_p95) if show_trend?
+          baseline = baseline_trend_for(@query, metric: :p95)
+
+          if baseline
+            trend_icon, trend_amount, trend_caption = baseline
+          elsif show_trend?
+            trend_icon, trend_amount = trend_for(current_period_p95, previous_period_p95)
+          end
 
           # Create a query for sparkline data using only the current period
           sparkline_query = RailsPulse::Summary
@@ -65,7 +70,7 @@ module RailsPulse
             chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
-            trend_text: (show_trend? ? comparison_period_text : nil),
+            trend_text: trend_caption || (show_trend? ? comparison_period_text : nil),
             period_stat: metrics.total_count.to_i > 0 ? "Across #{format_number(metrics.total_count.to_i)} queries" : period_date_range,
             help_heading: "P95 Query Time",
             help_text: "The 95th percentile database query duration — 95% of queries complete faster than this. Weighted by execution frequency across all queries. Slow queries are often caused by missing indexes or N+1 patterns."

data/app/models/rails_pulse/request.rb

@@ -21,7 +21,7 @@ module RailsPulse
     before_validation :set_request_uuid, on: :create
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id route_id occurred_at duration status status_category status_indicator route_path response_size_bytes]
+      %w[id route_id occurred_at duration status status_category status_indicator route_path http_method controller_action response_size_bytes]
     end
 
     def self.ransackable_associations(auth_object = nil)
@@ -36,6 +36,10 @@ module RailsPulse
       Arel.sql("rails_pulse_routes.path")
     end
 
+    ransacker :http_method do |parent|
+      parent.table[:method]
+    end
+
     ransacker :status_category do |parent|
       # Returns the first digit of the status code (2, 3, 4, or 5)
       # Use FLOOR instead of CAST for cross-database compatibility