rails_pulse 0.3.3 → 0.4.0.pre.2

data/app/models/rails_pulse/route.rb

@@ -9,25 +9,77 @@ module RailsPulse
     has_many :summaries, as: :summarizable, class_name: "RailsPulse::Summary", dependent: :destroy
 
     # Validations
-    validates :method, presence: true
     validates :path, presence: true
+    validates :http_methods, presence: true
+
+    # Find an existing route by controller_action + path, or create one.
+    # When a route already exists, the incoming http_method is appended to its
+    # http_methods array if not already present (self-healing for PATCH/PUT etc.).
+    # For requests without a controller_action (404s, middleware short-circuits),
+    # falls back to grouping by path alone.
+    def self.find_or_create_for_request(http_method, path, controller_action: nil)
+      route = if controller_action.present?
+        find_or_insert_by_action(http_method, path, controller_action)
+      else
+        find_or_insert_by_path(http_method, path)
+      end
+
+      # Always append — concurrent first inserts of different verbs can skip the
+      # INSERT via ON CONFLICT DO NOTHING and would otherwise drop the losing verb.
+      route.add_http_method(http_method)
+      route
+    end
 
-    def self.by_method_and_path(method, path)
-      # Fast path: route already exists (the common case for recurring requests).
-      route = find_by(method: method, path: path)
-      return route if route
-
-      # Use INSERT ... ON CONFLICT DO NOTHING rather than create_or_find_by so that
-      # concurrent inserts for the same route are silently skipped at the database level.
-      # create_or_find_by rescues RecordNotUnique at the Ruby level, but PostgreSQL still
-      # logs a constraint violation ERROR before raising — causing noisy logs.
-      # unique_by is omitted for cross-database compatibility (MySQL rejects it); there is
-      # only one unique constraint on this table so DO NOTHING resolves unambiguously.
-      # Tags must be set explicitly here because insert bypasses before_save callbacks.
-      insert(
-        { method: method, path: path, tags: "[]", created_at: Time.current, updated_at: Time.current }
-      )
-      find_by!(method: method, path: path)
+    def self.find_or_insert_by_action(http_method, path, controller_action)
+      find_by(controller_action: controller_action, path: path) || begin
+        # INSERT ... ON CONFLICT DO NOTHING so concurrent inserts are skipped at the DB.
+        insert(
+          { http_methods: [ http_method ].to_json, path: path, controller_action: controller_action,
+            tags: "[]", created_at: Time.current, updated_at: Time.current }
+        )
+        find_by!(controller_action: controller_action, path: path)
+      end
+    end
+    private_class_method :find_or_insert_by_action
+
+    def self.find_or_insert_by_path(http_method, path)
+      find_by(controller_action: nil, path: path) || begin
+        insert(
+          { http_methods: [ http_method ].to_json, path: path, controller_action: nil,
+            tags: "[]", created_at: Time.current, updated_at: Time.current }
+        )
+        where(controller_action: nil, path: path).order(:id).first!
+      end
+    end
+    private_class_method :find_or_insert_by_path
+
+    def http_methods_list
+      return [] if http_methods.blank?
+      JSON.parse(http_methods)
+    rescue JSON::ParserError
+      []
+    end
+
+    def add_http_method(http_method)
+      return if http_method.blank?
+      current = http_methods_list
+      return if current.include?(http_method)
+      update_column(:http_methods, (current + [ http_method ]).sort.to_json)
+    end
+
+    # True when at least one stored route still has no action but the live
+    # host router would assign one — the usual sign that schema migrated
+    # without `rails rails_pulse:migrate_routes`.
+    def self.needs_action_backfill?
+      return false unless column_names.include?("controller_action")
+      return false unless column_names.include?("http_methods")
+
+      where(controller_action: [ nil, "" ]).limit(25).any? do |route|
+        method = route.http_methods_list.first
+        next false if method.blank?
+
+        RailsPulse::RouteRecognizer.call(route.path, method: method).present?
+      end
     end
 
     def self.ransackable_attributes(auth_object = nil)
@@ -69,13 +121,11 @@ module RailsPulse
     end
 
     ransacker :requests_per_minute do
-      # Use a simpler database-agnostic approach - this is mainly used for sorting/filtering
-      # so exact precision isn't as critical as avoiding database-specific functions
       Arel.sql("COUNT(rails_pulse_requests.id)")
     end
 
     def to_breadcrumb
-      "#{method.upcase} #{path}".truncate(60)
+      "#{http_methods_list.sort.join('|')} #{path}".truncate(60)
     end
 
     def self.average_response_time
@@ -83,7 +133,7 @@ module RailsPulse
     end
 
     def path_and_method
-      "#{path} #{method}"
+      "#{path} #{http_methods_list.join('|')}"
     end
   end
 end

data/app/models/rails_pulse/routes/cards/error_rates.rb

@@ -33,8 +33,11 @@ module RailsPulse
           server_rate = has_data ? (total_errors.to_f / total_requests * 100).round(2) : 0
           client_rate = has_data ? (total_4xx.to_f / total_requests * 100).round(2) : 0
 
-          # Use base class trend calculation
-          if show_trend?
+          baseline = baseline_trend_for(@route, metric: :error_rate)
+
+          if baseline
+            trend_icon, trend_amount, trend_caption = baseline
+          elsif show_trend?
             trend_icon, trend_amount = has_data ? trend_for(current_total, previous_total) : [ "move-right", "—" ]
           end
 
@@ -58,7 +61,7 @@ module RailsPulse
             sparkline_options: { tooltip: { formatter: "sparkline_percentage_tooltip" } },
             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: has_data ? "#{format_number(total_errors + total_4xx)} errors" : period_date_range,
             help_heading: "Error Rates",
             help_text: "Combined 5xx and 4xx error rate over the last 2 weeks. 5xx server errors indicate bugs or infrastructure issues. 4xx client errors may indicate broken API consumers or deprecated endpoints."

data/app/models/rails_pulse/routes/cards/percentile_response_times.rb

@@ -28,8 +28,13 @@ module RailsPulse
 
           has_data = metrics.total_count.to_i > 0
 
-          # Use base class trend calculation
-          if show_trend?
+          # Prefer a comparison against this route's own history; fall back to
+          # period-over-period on the index, where there is no single subject.
+          baseline = baseline_trend_for(@route, metric: :p95)
+
+          if baseline
+            trend_icon, trend_amount, trend_caption = baseline
+          elsif show_trend?
             trend_icon, trend_amount = has_data ? trend_for(current_period_p95, previous_period_p95) : [ "move-right", "—" ]
           end
 
@@ -56,7 +61,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: has_data ? "Across #{format_number(metrics.total_count.to_i)} requests" : period_date_range,
             help_heading: "P95 Response Time",
             help_text: "The 95th percentile response time — 95% of requests are faster than this. Weighted by request volume across all routes. A rising P95 indicates increasing slowness affecting your users."

data/app/models/rails_pulse/routes/tables/index.rb

@@ -13,23 +13,21 @@ module RailsPulse
 
         def group_columns
           %w[
-            rails_pulse_summaries.summarizable_id
-            rails_pulse_summaries.summarizable_type
             rails_pulse_routes.id
             rails_pulse_routes.path
-            rails_pulse_routes.method
+            rails_pulse_routes.controller_action
             rails_pulse_routes.tags
+            rails_pulse_routes.http_methods
           ]
         end
 
         def select_columns
           [
-            "rails_pulse_summaries.summarizable_id",
-            "rails_pulse_summaries.summarizable_type",
             "rails_pulse_routes.id as route_id",
             "rails_pulse_routes.path",
-            "rails_pulse_routes.method as route_method",
+            "rails_pulse_routes.controller_action",
             "rails_pulse_routes.tags",
+            "rails_pulse_routes.http_methods as route_methods",
             "AVG(rails_pulse_summaries.avg_duration) as avg_duration",
             "MAX(rails_pulse_summaries.max_duration) as max_duration",
             "#{WEIGHTED_P95} as p95_duration",
@@ -58,6 +56,10 @@ module RailsPulse
             grouped_query.order(Arel.sql("(SUM(rails_pulse_summaries.error_count) * 100.0) / SUM(rails_pulse_summaries.count)").send(direction))
           when "route_path"
             grouped_query.order(Arel.sql("rails_pulse_routes.path").send(direction))
+          when "route_controller_action"
+            grouped_query.order(Arel.sql("rails_pulse_routes.controller_action").send(direction))
+          when "route_methods_sort"
+            grouped_query.order(Arel.sql("rails_pulse_routes.http_methods").send(direction))
           end
         end
 

data/app/models/rails_pulse/summary.rb

@@ -30,6 +30,14 @@ module RailsPulse
     scope :for_routes, -> { where(summarizable_type: "RailsPulse::Route") }
     scope :for_queries, -> { where(summarizable_type: "RailsPulse::Query") }
     scope :for_jobs, -> { where(summarizable_type: "RailsPulse::Job") }
+    scope :for_exceptions, -> { where(summarizable_type: "RailsPulse::ExceptionGroup") }
+
+    # Frequency across every exception group, written alongside the per-group
+    # rows so a chart of total exception volume is one query rather than one
+    # per group.
+    scope :overall_exceptions, -> {
+      where(summarizable_type: "RailsPulse::ExceptionGroup", summarizable_id: 0)
+    }
     scope :by_job_name, ->(job_name) { for_jobs.joins(:job).where(rails_pulse_jobs: { name: job_name }) }
     scope :recent, -> { order(period_start: :desc) }
 
@@ -61,7 +69,8 @@ module RailsPulse
         "  (summarizable_type = 'RailsPulse::Route' AND summarizable_id IN (?)) OR " \
         "  (summarizable_type = 'RailsPulse::Query' AND summarizable_id IN (?)) OR " \
         "  (summarizable_type = 'RailsPulse::Job' AND summarizable_id IN (?)) OR " \
-        "  (summarizable_type = 'RailsPulse::Request')" \
+        "  (summarizable_type = 'RailsPulse::Request') OR " \
+        "  (summarizable_type = 'RailsPulse::ExceptionGroup')" \
         ")",
         route_ids,
         query_ids,
@@ -73,7 +82,8 @@ module RailsPulse
     def self.ransackable_attributes(auth_object = nil)
       %w[
         period_start period_end avg_duration min_duration max_duration p95_duration p99_duration
-        count error_count requests_per_minute error_rate_percentage route_path_cont
+        count error_count requests_per_minute error_rate_percentage
+        route_path route_controller_action route_methods_sort
         execution_count total_time_consumed normalized_sql
         summarizable_id summarizable_type
       ]
@@ -101,14 +111,15 @@ module RailsPulse
       Arel.sql("rails_pulse_routes.path")
     end
 
-    # Ransacker for route path filtering using subquery (works without JOIN)
-    ransacker :route_path_cont do |parent|
-      Arel.sql(<<-SQL)
-        rails_pulse_summaries.summarizable_id IN (
-          SELECT id FROM rails_pulse_routes
-          WHERE rails_pulse_routes.path LIKE '%' || ? || '%'
-        )
-      SQL
+    # Ransacker for controller_action sorting (when joined with routes table)
+    ransacker :route_controller_action do
+      Arel.sql("rails_pulse_routes.controller_action")
+    end
+
+    # Placeholder ransacker for method aggregation sorting; actual ORDER BY is
+    # applied by Routes::Tables::Index#named_sort using http_methods.
+    ransacker :route_methods_sort do
+      Arel.sql("rails_pulse_routes.http_methods")
     end
 
     # Sorting-specific ransackers for GROUP BY compatibility (used only in ORDER BY)

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

@@ -41,9 +41,11 @@ module RailsPulse
       def apply_tag_filters(query)
         actual_disabled_tags = @disabled_tags.reject { |tag| tag == "non_tagged" }
 
+        # Explicit ESCAPE: SQLite has no default escape character, so without
+        # it an underscore in a tag is never matched literally there.
         actual_disabled_tags.each do |tag|
-          sanitized_tag = ActiveRecord::Base.sanitize_sql_like(tag.to_s, "\\")
-          query = query.where.not("#{model_table}.tags LIKE ?", "%#{sanitized_tag}%")
+          sanitized_tag = ActiveRecord::Base.sanitize_sql_like(tag.to_s, RailsPulse::Taggable::LIKE_ESCAPE)
+          query = query.where.not("#{model_table}.tags LIKE ? ESCAPE '!'", "%#{sanitized_tag}%")
         end
 
         unless @show_non_tagged

data/app/services/rails_pulse/analysis/explain_plan_analyzer.rb

@@ -3,7 +3,21 @@
 module RailsPulse
   module Analysis
     class ExplainPlanAnalyzer < BaseAnalyzer
-      EXPLAIN_TIMEOUT = 5.seconds
+      # PostgreSQL statement_timeout for the EXPLAIN itself. Planner-only
+      # work is fast; this only guards against a pathological plan.
+      STATEMENT_TIMEOUT = "5s".freeze
+
+      # Only EXPLAIN SELECT/WITH statements — executing EXPLAIN on a
+      # DELETE/UPDATE/INSERT would re-run the statement on PostgreSQL
+      # when ANALYZE is used, and is never useful for the dashboard.
+      SAFE_VERB = /\A\s*(SELECT|WITH)\b/i
+
+      # The verb check only sees the first statement. PostgreSQL's execute
+      # (async_exec) runs every statement in the string, so a captured
+      # "SELECT …; UPDATE …" would re-run the UPDATE on every page view.
+      # Comments are refused too: nothing legitimate needs them explained,
+      # and they are the other place a second statement can hide.
+      UNSAFE_SQL = %r{;|--|/\*}
 
       def analyze
         return { explain_plan: nil, issues: [] } if recent_operations.empty?
@@ -21,25 +35,34 @@ module RailsPulse
 
       def generate_explain_plan(sql)
         return nil unless sql.present?
+        return nil unless sql.match?(SAFE_VERB)
 
-        # Skip EXPLAIN queries in test environment to avoid transaction issues
-        return nil if Rails.env.test?
+        sanitized_sql = sanitize_sql_for_explain(sql)
+        return nil unless sanitized_sql
 
         begin
-          sanitized_sql = sanitize_sql_for_explain(sql)
-
-          Timeout.timeout(EXPLAIN_TIMEOUT) do
-            case database_adapter
+          conn = RailsPulse::ApplicationRecord.connection
+          plan = nil
+
+          # A savepoint keeps a failed EXPLAIN from aborting the host's
+          # surrounding transaction, and it is always rolled back: EXPLAIN
+          # writes nothing, so rolling back costs nothing, and it undoes the
+          # SET LOCALs below (and anything a statement that slipped past the
+          # guards might have done) instead of leaking them into the caller's
+          # transaction.
+          conn.transaction(requires_new: true) do
+            plan = case database_adapter
             when "postgresql"
               execute_postgres_explain(sanitized_sql)
             when "mysql", "mysql2"
               execute_mysql_explain(sanitized_sql)
             when "sqlite"
               execute_sqlite_explain(sanitized_sql)
-            else
-              nil
             end
+            raise ActiveRecord::Rollback
           end
+
+          plan
         rescue => e
           RailsPulse.logger.warn("[ExplainPlanAnalyzer] EXPLAIN failed for query #{query.id}: #{e.message}")
           nil
@@ -182,13 +205,25 @@ module RailsPulse
         issues
       end
 
+      # Strips a trailing terminator, then refuses anything that could still
+      # carry a second statement or a comment. Returns nil for refused SQL.
       def sanitize_sql_for_explain(sql)
-        # Basic sanitization for EXPLAIN
-        sql.strip.gsub(/;+\s*$/, "")
+        cleaned = sql.strip.gsub(/;+\s*$/, "")
+        return nil if cleaned.match?(UNSAFE_SQL)
+
+        cleaned
       end
 
+      # SET LOCAL is scoped to the enclosing transaction/savepoint and is
+      # undone by the rollback in generate_explain_plan. Read-only means
+      # even a statement that got past the guards cannot write, and the
+      # timeout replaces Timeout.timeout, which could interrupt the driver
+      # mid-protocol and leave the connection in an undefined state.
       def execute_postgres_explain(sql)
-        result = RailsPulse::ApplicationRecord.connection.execute("EXPLAIN (ANALYZE, BUFFERS) #{sql}")
+        conn = RailsPulse::ApplicationRecord.connection
+        conn.execute("SET LOCAL transaction_read_only = on")
+        conn.execute("SET LOCAL statement_timeout = '#{STATEMENT_TIMEOUT}'")
+        result = conn.execute("EXPLAIN #{sql}")
         result.values.flatten.join("\n")
       end
 

data/app/services/rails_pulse/exception_capture_service.rb

@@ -0,0 +1,228 @@
+module RailsPulse
+  class ExceptionCaptureService
+    APP_FRAME_PATTERN = %r{/app/|/lib/|/config/}
+    # /lib/ruby/ matches interpreter stdlib (…/lib/ruby/3.3.0/…) without
+    # treating project paths that happen to contain "ruby" as gem code.
+    GEM_FRAME_PATTERN = %r{/gems/|/rubygems/|/bundler/|/lib/ruby/}
+
+    PARAMS_SIZE_LIMIT = 10_240 # 10KB
+    DEPLOY_SHA_TTL    = 60     # seconds
+    # Cap stored frames so a pathological backtrace cannot balloon the row.
+    BACKTRACE_FRAME_LIMIT = 50
+
+    # Cached on the class so every request in this process shares one value instead
+    # of each hitting the DB. Because multiple threads can call capture concurrently,
+    # the cache variables need a mutex to prevent torn reads/writes.
+    @_deploy_sha_mutex     = Mutex.new # guards @_deploy_sha_value and @_deploy_sha_cached_at
+    @_deploy_sha_value     = nil
+    @_deploy_sha_cached_at = nil
+
+    class << self
+      def capture(exception, request_url: nil, request_method: nil, request_params: nil, environment: nil, deploy_sha: nil)
+        new(exception, request_url: request_url, request_method: request_method, request_params: request_params, environment: environment, deploy_sha: deploy_sha).capture
+      end
+
+      def fetch_deploy_sha
+        @_deploy_sha_mutex.synchronize do
+          # Check expiry inside the lock so only one thread does the DB query when
+          # the cache is cold — other threads block here and then see the fresh value.
+          if @_deploy_sha_cached_at.nil? || (Time.current.to_f - @_deploy_sha_cached_at) >= DEPLOY_SHA_TTL
+            @_deploy_sha_value     = RailsPulse::Deployment.order(started_at: :desc).first&.revision
+            @_deploy_sha_cached_at = Time.current.to_f
+          end
+          @_deploy_sha_value
+        end
+      end
+
+      def reset_deploy_sha_cache!
+        @_deploy_sha_mutex.synchronize do
+          @_deploy_sha_value     = nil
+          @_deploy_sha_cached_at = nil
+        end
+      end
+    end
+
+    def initialize(exception, request_url: nil, request_method: nil, request_params: nil, environment: nil, deploy_sha: nil)
+      @exception = exception
+      @request_url = request_url
+      @request_method = request_method
+      @request_params = request_params
+      @environment = environment || Rails.env.to_s
+      @deploy_sha = deploy_sha
+    end
+
+    def capture
+      return unless RailsPulse.configuration.track_exceptions
+      return if RequestStore.store[:skip_recording_rails_pulse_activity]
+
+      frames      = parse_backtrace(@exception.backtrace || [])
+      location    = fingerprint_location(frames)
+      fingerprint = Digest::SHA256.hexdigest("#{@exception.class.name}:#{location}")
+      now         = Time.current
+
+      group = upsert_group(fingerprint, location, now)
+      create_occurrence(group, frames, now) unless group.status == "ignored"
+    rescue => e
+      Rails.logger.error("[RailsPulse] ExceptionCaptureService error: #{e.message}")
+      nil
+    end
+
+
+    private
+
+    # Memoized: both upsert_group and create_occurrence need the sanitized
+    # message, and this runs on the host's error path.
+    def sanitize_exception_message(exception)
+      @sanitize_exception_message ||= ExceptionMessageSanitizer.for_exception(exception)
+    end
+
+    # Reusable aborted-transaction recovery shared with Tracker.
+    def clear_aborted_transaction(conn)
+      raw = conn.raw_connection
+      return unless raw.respond_to?(:transaction_status) && raw.transaction_status == 3 # PG_TRANSACTION_INERROR
+      conn.rollback_db_transaction
+    rescue ActiveRecord::StatementInvalid
+      nil
+    end
+
+    def parse_backtrace(raw_backtrace)
+      raw_backtrace.first(BACKTRACE_FRAME_LIMIT).filter_map do |line|
+        match = line.match(/\A(.+):(\d+):in ['`](.+?)'\z/)
+        next unless match
+        { file: match[1], line: match[2].to_i, method: match[3] }
+      end
+    end
+
+    def first_app_frame(frames)
+      frames.find { |f| f[:file].match?(APP_FRAME_PATTERN) && !f[:file].match?(GEM_FRAME_PATTERN) }
+    end
+
+    # Relative path used in the fingerprint and stored on the group so
+    # Capistrano-style release prefixes do not split groups across deploys.
+    def fingerprint_location(frames)
+      frame = first_app_frame(frames)
+      return "unknown" unless frame
+
+      path = normalize_app_path(frame[:file])
+      anonymous = frame[:method].include?("block") || frame[:method].start_with?("<")
+      anonymous ? "#{path}:#{frame[:line]}" : "#{path}##{frame[:method]}"
+    end
+
+    def normalize_app_path(file)
+      path = file.to_s
+      root = Rails.root.to_s.chomp("/")
+      if root.present? && path.start_with?("#{root}/")
+        return path.delete_prefix("#{root}/")
+      end
+
+      # Rightmost /app/, /lib/, or /config/ so Capistrano paths like
+      # /var/www/app/releases/TIMESTAMP/app/models/user.rb keep only app/models/user.rb.
+      if (idx = path.rindex(/\/(?:app|lib|config)\//))
+        path[(idx + 1)..]
+      else
+        path
+      end
+    end
+
+    # Single SQL upsert: inserts a new group or updates the existing one.
+    # occurrence_count is incremented atomically in the same statement, so no
+    # separate update_counters call is needed and no race window exists.
+    def upsert_group(fingerprint, location, now)
+      message = sanitize_exception_message(@exception)
+      conn    = ExceptionGroup.connection
+      clear_aborted_transaction(conn)
+
+      # Explicitly set status/preserve: SQLite schema dumps omit boolean DEFAULT false,
+      # so omitting those columns makes INSERT fail with NOT NULL on preserve.
+      if conn.adapter_name.downcase.include?("mysql")
+        conn.execute(<<~SQL)
+          INSERT INTO rails_pulse_exception_groups
+            (fingerprint, exception_class, location, message, first_seen_at, last_seen_at, occurrence_count, status, preserve, created_at, updated_at)
+          VALUES (
+            #{conn.quote(fingerprint)},
+            #{conn.quote(@exception.class.name)},
+            #{conn.quote(location)},
+            #{conn.quote(message)},
+            #{conn.quote(now)},
+            #{conn.quote(now)},
+            1,
+            #{conn.quote("open")},
+            #{conn.quote(false)},
+            #{conn.quote(now)},
+            #{conn.quote(now)}
+          )
+          ON DUPLICATE KEY UPDATE
+            exception_class  = VALUES(exception_class),
+            location         = VALUES(location),
+            message          = VALUES(message),
+            last_seen_at     = VALUES(last_seen_at),
+            occurrence_count = occurrence_count + 1,
+            updated_at       = VALUES(updated_at)
+        SQL
+      else
+        conn.execute(<<~SQL)
+          INSERT INTO rails_pulse_exception_groups
+            (fingerprint, exception_class, location, message, first_seen_at, last_seen_at, occurrence_count, status, preserve, created_at, updated_at)
+          VALUES (
+            #{conn.quote(fingerprint)},
+            #{conn.quote(@exception.class.name)},
+            #{conn.quote(location)},
+            #{conn.quote(message)},
+            #{conn.quote(now)},
+            #{conn.quote(now)},
+            1,
+            #{conn.quote("open")},
+            #{conn.quote(false)},
+            #{conn.quote(now)},
+            #{conn.quote(now)}
+          )
+          ON CONFLICT (fingerprint) DO UPDATE SET
+            exception_class  = EXCLUDED.exception_class,
+            location         = EXCLUDED.location,
+            message          = EXCLUDED.message,
+            last_seen_at     = EXCLUDED.last_seen_at,
+            occurrence_count = rails_pulse_exception_groups.occurrence_count + 1,
+            updated_at       = EXCLUDED.updated_at
+        SQL
+      end
+
+      group = ExceptionGroup.find_by!(fingerprint: fingerprint)
+
+      ExceptionGroup.where(id: group.id, status: "resolved")
+                    .update_all(status: "open", resolved_at: nil, updated_at: Time.current)
+
+      group
+    end
+
+    def current_deploy_sha
+      self.class.fetch_deploy_sha
+    end
+
+    def filtered_params
+      return nil unless RailsPulse.configuration.capture_exception_params
+      return nil if @request_params.blank?
+
+      params_hash = @request_params.respond_to?(:to_unsafe_h) ? @request_params.to_unsafe_h : @request_params.to_h
+      filter      = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+      filtered    = filter.filter(params_hash)
+
+      serialized = filtered.to_json
+      serialized.bytesize <= PARAMS_SIZE_LIMIT ? filtered : nil
+    end
+
+    def create_occurrence(group, frames, now)
+      ExceptionOccurrence.create!(
+        exception_group: group,
+        exception_class: @exception.class.name,
+        message:         sanitize_exception_message(@exception),
+        backtrace:       frames,
+        request_url:     @request_url,
+        request_method:  @request_method,
+        request_params:  filtered_params,
+        environment:     @environment,
+        deploy_sha:      @deploy_sha || current_deploy_sha,
+        occurred_at:     now
+      )
+    end
+  end
+end