rails_pulse 0.3.3 → 0.4.0.pre.2

data/app/services/rails_pulse/operations/subject.rb

@@ -0,0 +1,77 @@
+module RailsPulse
+  module Operations
+    # Normalizes the different things a caller can ask about — a Route, Query or
+    # Job record, or the symbol :requests for the overall application rollup —
+    # into the (summarizable_type, summarizable_id) pair the summaries table is
+    # keyed by.
+    #
+    # This exists so callers of the Operations API never have to know how
+    # summaries are stored. It is the one place that knows about the
+    # summarizable_id = 0 convention used for the overall request rollup.
+    class Subject
+      SUPPORTED_TYPES = %w[RailsPulse::Route RailsPulse::Query RailsPulse::Job RailsPulse::Request].freeze
+
+      # The overall-request rollup is stored with a sentinel id rather than a
+      # real record, so it needs its own constant.
+      OVERALL_REQUESTS_ID = 0
+
+      attr_reader :type, :id, :record
+
+      # @param subject [RailsPulse::Route, RailsPulse::Query, RailsPulse::Job, Symbol]
+      #   a record, or :requests for the overall application rollup
+      # @return [Subject]
+      # @raise [ArgumentError] if the subject is not something summaries are kept for
+      def self.wrap(subject)
+        return subject if subject.is_a?(self)
+
+        if subject == :requests
+          return new(type: "RailsPulse::Request", id: OVERALL_REQUESTS_ID, record: nil)
+        end
+
+        type = subject.class.name
+
+        unless SUPPORTED_TYPES.include?(type)
+          raise ArgumentError,
+            "unsupported subject #{type.inspect} — expected a Route, Query, Job, or :requests"
+        end
+
+        new(type: type, id: subject.id, record: subject)
+      end
+
+      def initialize(type:, id:, record:)
+        @type   = type
+        @id     = id
+        @record = record
+      end
+
+      # Summaries for this subject, unscoped by period.
+      def summaries
+        RailsPulse::Summary.where(summarizable_type: type, summarizable_id: id)
+      end
+
+      def overall_requests?
+        type == "RailsPulse::Request" && id == OVERALL_REQUESTS_ID
+      end
+
+      # Short human label, used in finding messages and API output.
+      def label
+        return "All requests" if overall_requests?
+
+        case type
+        when "RailsPulse::Route" then record&.path
+        when "RailsPulse::Query" then record&.normalized_sql
+        when "RailsPulse::Job"   then record&.name
+        end.presence || "#{type.demodulize} ##{id}"
+      end
+
+      def ==(other)
+        other.is_a?(Subject) && other.type == type && other.id == id
+      end
+      alias eql? ==
+
+      def hash
+        [ type, id ].hash
+      end
+    end
+  end
+end

data/app/services/rails_pulse/route_controller_action_backfiller.rb

@@ -0,0 +1,110 @@
+module RailsPulse
+  class RouteControllerActionBackfiller
+    def self.call
+      new.call
+    end
+
+    def call
+      results = { updated: 0, skipped: 0, already_set: 0, merged: 0 }
+      total = RailsPulse::Route.count
+      processed = 0
+      RailsPulse::Route.find_each do |route|
+        process_route(route, results)
+        processed += 1
+      end
+      puts "" if total > 0
+      consolidate_unrecognized_duplicates(results)
+      results
+    end
+
+    private
+
+    def process_route(route, results)
+      # Skip rows already destroyed by an earlier merge in this run.
+      return unless RailsPulse::Route.exists?(id: route.id)
+
+      if route.controller_action.present?
+        results[:already_set] += 1
+        return
+      end
+
+      ca = recognized_controller_action(route) || controller_action_from_requests(route)
+
+      if ca
+        apply_controller_action(route, ca, results)
+      else
+        results[:skipped] += 1
+      end
+    end
+
+    def recognized_controller_action(route)
+      primary_method = route.http_methods_list.first
+      return nil unless primary_method
+
+      params = RailsPulse::RouteRecognizer.call(route.path, method: primary_method)
+      params && [ params[:controller], params[:action] ].compact.join("#").presence
+    end
+
+    # Historical requests stored PascalCase class names (HomeController#index).
+    # Normalize to the capture-time format (home#index).
+    def controller_action_from_requests(route)
+      raw = RailsPulse::Request.where(route_id: route.id)
+        .where.not(controller_action: [ nil, "" ])
+        .group(:controller_action)
+        .order(Arel.sql("COUNT(*) DESC"))
+        .limit(1)
+        .pluck(:controller_action)
+        .first
+
+      normalize_controller_action(raw)
+    end
+
+    def normalize_controller_action(value)
+      return nil if value.blank?
+
+      controller, action = value.to_s.split("#", 2)
+      return nil if controller.blank? || action.blank?
+
+      "#{controller.delete_suffix("Controller").underscore}##{action}"
+    end
+
+    def apply_controller_action(route, ca, results)
+      existing = RailsPulse::Route.find_by(controller_action: ca, path: route.path)
+      if existing && existing.id != route.id
+        RailsPulse::RouteMerger.call(target: existing, source: route)
+        results[:merged] += 1
+        return
+      end
+
+      route.update_column(:controller_action, ca)
+      results[:updated] += 1
+    rescue ActiveRecord::RecordNotUnique
+      # Concurrent insert/update raced us; merge into the surviving row.
+      existing = RailsPulse::Route.find_by!(controller_action: ca, path: route.path)
+      RailsPulse::RouteMerger.call(target: existing, source: route) unless existing.id == route.id
+      results[:merged] += 1
+    end
+
+    # Remaining null-action rows are unrecognized (404s). Group them by path so
+    # GET+POST /unknown become one route before the null-action unique index is added.
+    def consolidate_unrecognized_duplicates(results)
+      paths = RailsPulse::Route.where(controller_action: nil)
+        .group(:path)
+        .having("COUNT(*) > 1")
+        .pluck(:path)
+
+      paths.each do |path|
+        routes = RailsPulse::Route.where(controller_action: nil, path: path).order(:id).to_a
+        winner = routes.shift
+        next unless winner
+
+        routes.each do |loser|
+          next unless RailsPulse::Route.exists?(id: loser.id)
+
+          RailsPulse::RouteMerger.call(target: winner, source: loser)
+          results[:merged] += 1
+        end
+      end
+    end
+  end
+end

data/app/services/rails_pulse/route_merger.rb

@@ -0,0 +1,99 @@
+module RailsPulse
+  # Merges source into target: combine http_methods, reassign requests and summaries, destroy source.
+  # Used when two routes would collide on the unique [controller_action, path] index.
+  class RouteMerger
+    METRIC_SUM_COLUMNS = %w[
+      count error_count success_count total_duration
+      status_2xx status_3xx status_4xx status_5xx
+    ].freeze
+
+    WEIGHTED_AVG_COLUMNS = %w[
+      avg_duration p50_duration p95_duration p99_duration
+    ].freeze
+
+    def self.call(target:, source:)
+      new(target, source).call
+    end
+
+    def initialize(target, source)
+      @target = target
+      @source = source
+    end
+
+    def call
+      return if @target.id == @source.id
+
+      @source.http_methods_list.each { |m| @target.add_http_method(m) }
+      RailsPulse::Route.transaction do
+        @source.requests.update_all(route_id: @target.id)
+        reassign_or_merge_summaries!
+        @source.destroy!
+      end
+    end
+
+    private
+
+    def reassign_or_merge_summaries!
+      source_summaries = RailsPulse::Summary.where(
+        summarizable_type: "RailsPulse::Route",
+        summarizable_id: @source.id
+      )
+
+      source_summaries.find_each do |source_summary|
+        target_summary = RailsPulse::Summary.find_by(
+          summarizable_type: "RailsPulse::Route",
+          summarizable_id: @target.id,
+          period_type: source_summary.period_type,
+          period_start: source_summary.period_start
+        )
+
+        if target_summary
+          merge_summary_metrics!(target_summary, source_summary)
+          source_summary.destroy!
+        else
+          source_summary.update_column(:summarizable_id, @target.id)
+        end
+      end
+    end
+
+    def merge_summary_metrics!(target_summary, source_summary)
+      target_count = target_summary.count.to_i
+      source_count = source_summary.count.to_i
+      combined_count = target_count + source_count
+
+      attrs = {}
+
+      METRIC_SUM_COLUMNS.each do |column|
+        next unless target_summary.has_attribute?(column)
+
+        attrs[column] = target_summary.public_send(column).to_f + source_summary.public_send(column).to_f
+      end
+
+      if combined_count.positive?
+        WEIGHTED_AVG_COLUMNS.each do |column|
+          next unless target_summary.has_attribute?(column)
+
+          target_value = target_summary.public_send(column)
+          source_value = source_summary.public_send(column)
+          next if target_value.nil? && source_value.nil?
+
+          attrs[column] = (
+            (target_value.to_f * target_count) + (source_value.to_f * source_count)
+          ) / combined_count
+        end
+      end
+
+      if target_summary.has_attribute?(:min_duration)
+        mins = [ target_summary.min_duration, source_summary.min_duration ].compact
+        attrs[:min_duration] = mins.min if mins.any?
+      end
+
+      if target_summary.has_attribute?(:max_duration)
+        maxes = [ target_summary.max_duration, source_summary.max_duration ].compact
+        attrs[:max_duration] = maxes.max if maxes.any?
+      end
+
+      target_summary.update_columns(attrs.merge(updated_at: Time.current))
+    end
+  end
+end

data/app/services/rails_pulse/route_migrator.rb

@@ -0,0 +1,139 @@
+module RailsPulse
+  class RouteMigrator
+    def self.call
+      new.call
+    end
+
+    def call
+      sync_id_sequence!
+      results = { merged: 0, skipped: 0, unchanged: 0 }
+      RailsPulse::Route.find_each { |route| process_route(route, results) }
+      results
+    end
+
+    private
+
+    def process_route(route, results)
+      # Skip rows already destroyed by an earlier merge in this run.
+      return unless RailsPulse::Route.exists?(id: route.id)
+
+      primary_method = route.http_methods_list.first
+      return results[:skipped] += 1 unless primary_method
+
+      params = RailsPulse::RouteRecognizer.call(route.path, method: primary_method)
+      return results[:skipped] += 1 unless params
+
+      normalized = RailsPulse::RoutePathNormalizer.normalize(route.path, params)
+
+      # Derive controller_action from the recognized route params if not already stored.
+      recognized_ca = [ params[:controller], params[:action] ].compact.join("#").presence
+
+      if normalized == route.path
+        assign_or_merge_controller_action(route, recognized_ca, results)
+        return
+      end
+
+      ca_for_target = recognized_ca || route.controller_action
+      target = find_or_create_normalized_route(route, ca_for_target, normalized)
+      RailsPulse::RouteMerger.call(target: target, source: route) unless target.id == route.id
+
+      results[:merged] += 1
+    end
+
+    def assign_or_merge_controller_action(route, recognized_ca, results)
+      if route.controller_action.nil? && recognized_ca.present?
+        existing = RailsPulse::Route.find_by(controller_action: recognized_ca, path: route.path)
+        if existing && existing.id != route.id
+          RailsPulse::RouteMerger.call(target: existing, source: route)
+          results[:merged] += 1
+          return
+        end
+
+        begin
+          route.update_column(:controller_action, recognized_ca)
+        rescue ActiveRecord::RecordNotUnique
+          existing = RailsPulse::Route.find_by(controller_action: recognized_ca, path: route.path)
+          if existing && existing.id != route.id
+            RailsPulse::RouteMerger.call(target: existing, source: route)
+            results[:merged] += 1
+            return
+          end
+          raise
+        end
+      end
+
+      results[:unchanged] += 1
+    end
+
+    # Find an existing normalized route, or create one. Handles two RecordNotUnique cases:
+    # 1. Concurrent create on [controller_action, path] — find and return the winner
+    # 2. Stale PK sequence (id already taken) — resync sequence and retry create
+    def find_or_create_normalized_route(route, controller_action, path)
+      existing = RailsPulse::Route.find_by(controller_action: controller_action, path: path)
+      return existing if existing
+
+      attrs = {
+        http_methods: route.http_methods,
+        path: path,
+        controller_action: controller_action,
+        tags: route.tags || "[]"
+      }
+
+      RailsPulse::Route.create!(attrs)
+    rescue ActiveRecord::RecordNotUnique => e
+      existing = RailsPulse::Route.find_by(controller_action: controller_action, path: path)
+      return existing if existing
+
+      raise unless primary_key_conflict?(e)
+
+      sync_id_sequence!
+      RailsPulse::Route.create!(attrs)
+    end
+
+    def primary_key_conflict?(error)
+      message = error.message.to_s
+      message.include?("rails_pulse_routes_pkey") ||
+        message.include?("PRIMARY KEY") ||
+        message.match?(/unique constraint.*\bids?\b/i)
+    end
+
+    def sync_id_sequence!
+      connection = RailsPulse::Route.connection
+      table = RailsPulse::Route.table_name
+      max_id = RailsPulse::Route.maximum(:id).to_i
+      return if max_id.zero?
+
+      case connection.adapter_name.downcase
+      when /postgres/
+        sequence = connection.select_value(
+          "SELECT pg_get_serial_sequence(#{connection.quote(table)}, 'id')"
+        )
+        return unless sequence
+
+        connection.execute(
+          "SELECT setval(#{connection.quote(sequence)}, #{max_id}, true)"
+        )
+      when /mysql/
+        # ALTER TABLE implicitly commits on MySQL and destroys SAVEPOINTs used by
+        # transactional tests / nested transactions. Skip while nested.
+        return if connection.open_transactions.positive?
+
+        connection.execute(
+          "ALTER TABLE #{connection.quote_table_name(table)} AUTO_INCREMENT = #{max_id + 1}"
+        )
+      when /sqlite/
+        quoted_table = connection.quote(table)
+        exists = connection.select_value(
+          "SELECT 1 FROM sqlite_sequence WHERE name = #{quoted_table}"
+        )
+        if exists
+          connection.execute(
+            "UPDATE sqlite_sequence SET seq = #{max_id} WHERE name = #{quoted_table}"
+          )
+        end
+      end
+    rescue ActiveRecord::StatementInvalid
+      # Best-effort; create will raise a clearer error if the sequence is still wrong.
+    end
+  end
+end

data/app/services/rails_pulse/route_path_normalizer.rb

@@ -0,0 +1,79 @@
+module RailsPulse
+  class RoutePathNormalizer
+    SKIP_PARAMS = %i[controller action format].freeze
+
+    def self.normalize(path, path_params)
+      new(path, path_params).normalize
+    end
+
+    def initialize(path, path_params)
+      @path = path
+      @path_params = path_params || {}
+    end
+
+    def normalize
+      return @path if @path.nil? || @path.empty?
+
+      if route_params.empty?
+        # No path params means the request missed the Rails router (404,
+        # middleware short-circuit, mounted Rack app). Bucket dynamic segments
+        # to prevent unbounded route cardinality from scanners and bots.
+        return bucket_unrecognized_path(@path)
+      end
+
+      value_to_keys = build_value_map
+      segments = @path.split("/", -1)
+      segments.map { |seg| substitute_segment(seg, value_to_keys) }.join("/")
+    end
+
+    private
+
+    def route_params
+      @route_params ||= @path_params.reject { |k, _| SKIP_PARAMS.include?(k) }
+    end
+
+    def build_value_map
+      route_params.each_with_object({}) do |(key, value), map|
+        str = value.to_s
+        map[str] ||= []
+        map[str] << key
+      end
+    end
+
+    def substitute_segment(segment, value_to_keys)
+      # Exact match — only substitute if unambiguous (one key for this value)
+      if (keys = value_to_keys[segment]) && keys.length == 1
+        return ":#{keys.first}"
+      end
+
+      # Format extension match: e.g. "42.json" when id="42"
+      if segment.include?(".")
+        base, ext = segment.split(".", 2)
+        if (keys = value_to_keys[base]) && keys.length == 1
+          return ":#{keys.first}.#{ext}"
+        end
+      end
+
+      segment
+    end
+
+    # Replace dynamic-looking segments so scanner paths, bot probes, and
+    # arbitrary IDs don't create one route row per distinct URL.
+    UUID_RE  = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+    SHA_RE   = /\A[0-9a-f]{40}\z/i
+    DIGIT_RE = /\A\d+\z/
+
+    def bucket_unrecognized_path(path)
+      segments = path.split("/", -1)
+      segments.map! do |seg|
+        case seg
+        when UUID_RE  then ":uuid"
+        when SHA_RE   then ":sha"
+        when DIGIT_RE then ":id"
+        else seg
+        end
+      end
+      segments.join("/")
+    end
+  end
+end

data/app/services/rails_pulse/route_recognizer.rb

@@ -0,0 +1,47 @@
+module RailsPulse
+  # Recognizes a path/method against the host app's router outside a real request.
+  # Host apps often constrain routes with Devise/Warden (`r.env["warden"].authenticated?`);
+  # those constraints raise when warden is missing, so we stub it and try both
+  # authenticated and unauthenticated.
+  class RouteRecognizer
+    WardenStub = Struct.new(:authenticated) do
+      def authenticated?(*)
+        authenticated
+      end
+
+      def authenticate?(*)
+        authenticated
+      end
+    end
+
+    def self.call(path, method:)
+      new(path, method).call
+    end
+
+    def initialize(path, method)
+      @path = path
+      @method = method.to_s.upcase
+    end
+
+    def call
+      return nil if @path.blank? || @method.blank?
+
+      recognize(authenticated: true) || recognize(authenticated: false)
+    end
+
+    private
+
+    def recognize(authenticated:)
+      env = Rack::MockRequest.env_for(@path, method: @method)
+      env["warden"] = WardenStub.new(authenticated)
+      request = ActionDispatch::Request.new(env)
+
+      Rails.application.routes.recognize_path_with_request(request, @path, {})
+    rescue ActionController::RoutingError, ActionController::UnknownHttpMethod
+      nil
+    rescue NoMethodError, ArgumentError
+      # Other request-env constraints that still can't run outside a real request.
+      nil
+    end
+  end
+end

data/app/services/rails_pulse/summary_service.rb

@@ -17,6 +17,7 @@ module RailsPulse
         aggregate_routes    # Per-route metrics
         aggregate_queries   # Per-query metrics
         aggregate_jobs      # Per-job metrics
+        aggregate_exceptions # Per-exception-group frequency
       end
 
       RailsPulse.logger.info "Completed #{period_type} summary"
@@ -113,6 +114,50 @@ module RailsPulse
       end
     end
 
+    # Exception frequency, per group and overall.
+    #
+    # ExceptionGroup#occurrence_count is a lifetime counter and occurrence rows
+    # are pruned by retention, so without this there is no way to ask how often
+    # something happened last week — the history is gone as soon as cleanup
+    # runs. Only `count` is meaningful here; the duration columns stay null
+    # because an exception has no duration.
+    def aggregate_exceptions
+      return unless RailsPulse.configuration.track_exceptions
+      return unless ExceptionOccurrence.table_exists?
+
+      counts = ExceptionOccurrence
+        .where(occurred_at: start_time...end_time)
+        .group(:exception_group_id)
+        .count
+
+      return if counts.empty?
+
+      counts.each do |group_id, occurrences|
+        upsert_exception_summary(group_id, occurrences)
+      end
+
+      # A rollup across every group, so the dashboard can chart total exception
+      # volume without loading one series per group.
+      upsert_exception_summary(0, counts.values.sum)
+    rescue ActiveRecord::ActiveRecordError => e
+      # Exceptions are the newest summarizable and the only optional one. A
+      # failure here must not lose the route, query and job summaries that were
+      # written in the same transaction.
+      RailsPulse.logger.error "Exception summary skipped: #{e.message}"
+    end
+
+    def upsert_exception_summary(group_id, occurrences)
+      summary = Summary.find_or_initialize_by(
+        summarizable_type: "RailsPulse::ExceptionGroup",
+        summarizable_id: group_id,
+        period_type: period_type,
+        period_start: start_time
+      )
+
+      summary.assign_attributes(period_end: end_time, count: occurrences)
+      summary.save!
+    end
+
     def aggregate_queries
       all_rows = Operation
         .where(occurred_at: start_time...end_time)

data/app/services/rails_pulse/tag_filter_service.rb

@@ -8,10 +8,12 @@ module RailsPulse
     def self.filter_ids(model_class, disabled_tags, show_non_tagged)
       relation = model_class.all
 
-      # Exclude items with disabled tags
+      # Exclude items with disabled tags. Explicit ESCAPE: SQLite has no
+      # default escape character, so without it an underscore in a tag is
+      # never matched literally there and the exclusion matches nothing.
       disabled_tags.each do |tag|
-        sanitized_tag = ActiveRecord::Base.sanitize_sql_like(tag.to_s, "\\")
-        relation = relation.where.not("tags LIKE ?", "%#{sanitized_tag}%")
+        sanitized_tag = ActiveRecord::Base.sanitize_sql_like(tag.to_s, RailsPulse::Taggable::LIKE_ESCAPE)
+        relation = relation.where.not("tags LIKE ? ESCAPE '!'", "%#{sanitized_tag}%")
       end
 
       # Exclude non-tagged items if show_non_tagged is false

data/app/views/layouts/rails_pulse/_menu_items.html.erb

@@ -13,6 +13,13 @@
   <span class="overflow-ellipsis">Queries</span>
 <% end %>
 
+<% if RailsPulse.configuration.track_exceptions %>
+  <%= link_to exceptions_path, class: 'btn sidebar-menu__button' do %>
+    <%= rails_pulse_icon "alert-circle", width: "16" %>
+    <span class="overflow-ellipsis">Exceptions</span>
+  <% end %>
+<% end %>
+
 <% if RailsPulse.configuration.track_jobs %>
   <%= link_to jobs_path, class: 'btn sidebar-menu__button' do %>
     <%= rails_pulse_icon "zap", width: "16" %>

data/app/views/layouts/rails_pulse/_onboarding_banner.html.erb

@@ -1,3 +1,11 @@
+<% if @route_backfill_pending %>
+  <div class="setup-banner setup-banner--negative">
+    <p class="setup-banner__title">Route actions have not been backfilled</p>
+    <p class="setup-banner__body">Schema migrate adds the Action column but leaves it empty. Run this once to fill controller actions, normalize historical paths, and merge routes that share the same action:</p>
+    <code class="setup-banner__command"><span class="setup-banner__command-prefix">$</span> bin/rails rails_pulse:migrate_routes</code>
+  </div>
+<% end %>
+
 <% if @summaries_stale %>
   <div class="setup-banner setup-banner--negative">
     <p class="setup-banner__title">Summary jobs don't appear to be running</p>

data/app/views/layouts/rails_pulse/_setup_screen.html.erb

@@ -1,10 +1,10 @@
 <div class="setup-screen">
   <div class="setup-screen__brand">
-    <%= image_tag rails_pulse.asset_path("rails-pulse-logo.png"),
-    width: 72,
-    height: 72,
-    alt: "Rails Pulse",
-    class: "setup-screen__logo" %>
+    <%= tag.img src: rails_pulse.asset_path("rails-pulse-logo.png"),
+      width: 72,
+      height: 72,
+      alt: "Rails Pulse",
+      class: "setup-screen__logo" %>
     <p class="setup-screen__brand-name">Rails Pulse</p>
   </div>
 

data/app/views/layouts/rails_pulse/application.html.erb

@@ -33,10 +33,10 @@
       })();
     </script>
 
-    <!-- Rails Pulse Pre-compiled Assets (CSP-safe) -->
-    <%= stylesheet_link_tag rails_pulse.asset_path('rails-pulse.css') %>
-    <%= javascript_include_tag rails_pulse.asset_path('rails-pulse-icons.js'), defer: true, nonce: rails_pulse_csp_nonce %>
-    <%= javascript_include_tag rails_pulse.asset_path('rails-pulse.js'), defer: true, nonce: rails_pulse_csp_nonce %>
+    <%# tag.link/script (not stylesheet_link_tag): middleware fallback paths must stay off asset_host. %>
+    <%= tag.link rel: "stylesheet", href: rails_pulse.asset_path("rails-pulse.css") %>
+    <%= tag.script "", src: rails_pulse.asset_path("rails-pulse-icons.js"), defer: true, nonce: rails_pulse_csp_nonce %>
+    <%= tag.script "", src: rails_pulse.asset_path("rails-pulse.js"), defer: true, nonce: rails_pulse_csp_nonce %>
   </head>
 
   <body class="header-layout">