rails-informant 0.6.2 → 0.7.0

data/app/models/rails_informant/occurrence.rb

@@ -10,9 +10,11 @@ module RailsInformant
       environment_context
       error_group_id
       exception_chain
+      failing_request_id
       git_sha
       id
       request_context
+      request_id
       updated_at
       user_context
     ].freeze

data/config/routes.rb

@@ -1,4 +1,8 @@
 RailsInformant::Engine.routes.draw do
+  # Checked per request: the host enables capture in an initializer, which
+  # runs after the engine's routes are loaded.
+  resources :browser_reports, only: :create, constraints: ->(_) { RailsInformant.capture_browser_errors }
+
   namespace :api do
     scope "v1" do
       resources :errors, only: [ :index, :show, :update, :destroy ] do

data/db/migrate/20260227000000_create_informant_tables.rb

@@ -9,6 +9,7 @@ class CreateInformantTables < ActiveRecord::Migration[8.1]
       t.string :first_backtrace_line
       t.string :controller_action
       t.string :job_class
+      t.string :source, null: false, default: "server"
       t.integer :total_occurrences, default: 0, null: false
       t.references :duplicate_of, foreign_key: { to_table: :informant_error_groups }
       t.string :fix_sha
@@ -23,6 +24,7 @@ class CreateInformantTables < ActiveRecord::Migration[8.1]
       t.datetime :last_occurrence_stored_at
       t.timestamps
 
+      t.index [ :source, :status ]
       t.index [ :status, :last_seen_at ]
       t.index [ :status, :original_sha ]
       t.index [ :status, :resolved_at ]
@@ -55,7 +57,9 @@ class CreateInformantTables < ActiveRecord::Migration[8.1]
       t.jsonb :custom_context
       t.jsonb :environment_context
       t.jsonb :breadcrumbs
+      t.string :failing_request_id, index: true
       t.string :git_sha
+      t.string :request_id, index: true
       t.timestamps
 
       t.index [ :error_group_id, :created_at ]

data/lib/generators/rails_informant/browser_generator.rb

@@ -0,0 +1,103 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module RailsInformant
+  class BrowserGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+
+    HEAD_CLOSE_LINE = /^([ \t]*)<\/head>/
+    IMPORTMAP = "config/importmap.rb"
+    IMPORTMAP_TAGS_LINE = /^([ \t]*)<%=\s*javascript_importmap_tags/
+    INITIALIZER = "config/initializers/rails_informant.rb"
+    LAYOUT = "app/views/layouts/application.html.erb"
+    TAG = "<%= informant_browser_tag %>"
+
+    source_root File.expand_path("templates", __dir__)
+
+    def create_migration_file
+      if browser_columns_present?
+        say "Database already has the browser capture columns, skipping the migration.", :yellow
+        return
+      end
+
+      migration_template "add_browser_capture_to_informant_tables.rb.erb",
+        "db/migrate/add_browser_capture_to_informant_tables.rb"
+    end
+
+    def pin_module
+      return say_missing(IMPORTMAP, %(add `pin "rails_informant"` to your import map)) unless exist?(IMPORTMAP)
+      return if read(IMPORTMAP).match?(/^\s*pin\s+["']rails_informant["']/)
+
+      separator = read(IMPORTMAP).end_with?("\n") ? "" : "\n"
+      append_to_file IMPORTMAP, %(#{separator}pin "rails_informant"\n)
+    end
+
+    def add_layout_tag
+      return say_missing(LAYOUT, "add #{TAG} to your layout's <head>, before javascript_importmap_tags") unless exist?(LAYOUT)
+
+      layout = read(LAYOUT)
+      return if layout.include?("informant_browser_tag")
+
+      if (indent = layout[IMPORTMAP_TAGS_LINE, 1])
+        inject_into_file LAYOUT, "#{indent}#{TAG}\n", before: IMPORTMAP_TAGS_LINE
+      elsif (indent = layout[HEAD_CLOSE_LINE, 1])
+        inject_into_file LAYOUT, "#{indent}  #{TAG}\n", before: HEAD_CLOSE_LINE
+      else
+        say "No javascript_importmap_tags or </head> in #{LAYOUT}. Add #{TAG} to your layout's <head> manually.", :red
+      end
+    end
+
+    def enable_capture
+      return say_missing(INITIALIZER, "set `config.capture_browser_errors = true` in your RailsInformant.configure block") unless exist?(INITIALIZER)
+
+      initializer = read(INITIALIZER)
+      commented = /^([ \t]*)#\s*(config\.capture_browser_errors = true)$/
+
+      if initializer.match?(commented)
+        gsub_file INITIALIZER, commented, '\1\2'
+      elsif initializer.include?("capture_browser_errors")
+        nil
+      elsif (block = initializer.match(/^RailsInformant\.configure do \|(\w+)\|\n.*?(?=^end\b)/m))
+        inject_into_file INITIALIZER, "  #{block[1]}.capture_browser_errors = true\n", after: block[0]
+      else
+        say "No RailsInformant.configure block in #{INITIALIZER}. Set config.capture_browser_errors = true manually.", :red
+      end
+    end
+
+    def print_next_steps
+      say ""
+      say "Browser error capture set up!", :green
+      say ""
+      say "Next steps:", :yellow
+      say "  1. Run migrations:"
+      say "       bin/rails db:migrate"
+      say ""
+      say "  2. Restart the app server."
+      say ""
+      say "  3. Load a page and check the browser console and network panel"
+      say "     for the rails_informant module."
+      say ""
+    end
+
+    private
+
+    # No connection or no informant tables yet (install migration not run) both
+    # count as "absent": the migration's own guards make writing it harmless.
+    def browser_columns_present?
+      connection = ActiveRecord::Base.connection
+      connection.column_exists?(:informant_error_groups, :source) &&
+        connection.column_exists?(:informant_occurrences, :request_id) &&
+        connection.column_exists?(:informant_occurrences, :failing_request_id)
+    rescue ActiveRecord::ActiveRecordError
+      false
+    end
+
+    def exist?(relative_path) = File.exist?(File.join(destination_root, relative_path))
+
+    def read(relative_path) = File.read(File.join(destination_root, relative_path))
+
+    def say_missing(relative_path, instruction)
+      say "#{relative_path} not found, skipping. #{instruction.upcase_first}.", :red
+    end
+  end
+end

data/lib/generators/rails_informant/install_generator.rb

@@ -37,6 +37,9 @@ module RailsInformant
       say "  3. Install Claude Code integration:"
       say "       bin/rails generate rails_informant:skill"
       say ""
+      say "  4. Optional: capture browser JavaScript errors (importmap apps):"
+      say "       bin/rails generate rails_informant:browser"
+      say ""
     end
 
     private

data/lib/generators/rails_informant/templates/add_browser_capture_to_informant_tables.rb.erb

@@ -0,0 +1,33 @@
+class AddBrowserCaptureToInformantTables < ActiveRecord::Migration[8.1]
+  # up/down rather than change: a reversed `change` re-evaluates the guards
+  # against the migrated schema, skips every step and leaves the columns behind.
+  def up
+    unless column_exists?(:informant_error_groups, :source)
+      add_column :informant_error_groups, :source, :string, null: false, default: "server"
+    end
+    unless index_exists?(:informant_error_groups, [ :source, :status ])
+      add_index :informant_error_groups, [ :source, :status ]
+    end
+
+    unless column_exists?(:informant_occurrences, :failing_request_id)
+      add_column :informant_occurrences, :failing_request_id, :string
+    end
+    unless index_exists?(:informant_occurrences, :failing_request_id)
+      add_index :informant_occurrences, :failing_request_id
+    end
+
+    unless column_exists?(:informant_occurrences, :request_id)
+      add_column :informant_occurrences, :request_id, :string
+    end
+    unless index_exists?(:informant_occurrences, :request_id)
+      add_index :informant_occurrences, :request_id
+    end
+  end
+
+  def down
+    remove_column :informant_occurrences, :request_id, if_exists: true
+    remove_column :informant_occurrences, :failing_request_id, if_exists: true
+    remove_index :informant_error_groups, [ :source, :status ], if_exists: true
+    remove_column :informant_error_groups, :source, if_exists: true
+  end
+end

data/lib/generators/rails_informant/templates/create_informant_tables.rb.erb

@@ -9,6 +9,7 @@ class CreateInformantTables < ActiveRecord::Migration[8.1]
       t.string :first_backtrace_line
       t.string :controller_action
       t.string :job_class
+      t.string :source, null: false, default: "server"
       t.integer :total_occurrences, default: 0, null: false
       t.references :duplicate_of, foreign_key: { to_table: :informant_error_groups }
       t.string :fix_sha
@@ -23,6 +24,7 @@ class CreateInformantTables < ActiveRecord::Migration[8.1]
       t.datetime :last_occurrence_stored_at
       t.timestamps
 
+      t.index [ :source, :status ]
       t.index [ :status, :last_seen_at ]
       t.index [ :status, :original_sha ]
       t.index [ :status, :resolved_at ]
@@ -45,7 +47,9 @@ class CreateInformantTables < ActiveRecord::Migration[8.1]
       t.<%= json_column_type %> :custom_context
       t.<%= json_column_type %> :environment_context
       t.<%= json_column_type %> :breadcrumbs
+      t.string :failing_request_id, index: true
       t.string :git_sha
+      t.string :request_id, index: true
       t.timestamps
 
       t.index [ :error_group_id, :created_at ]

data/lib/generators/rails_informant/templates/initializer.rb.erb

@@ -26,4 +26,10 @@ RailsInformant.configure do |config|
 
   # Auto-purge resolved errors after N days (nil = keep forever)
   # config.retention_days = 30
+
+  # Browser error capture (off by default; `rails g rails_informant:browser` enables it)
+  # config.capture_browser_errors = true
+
+  # Most new browser error groups created per hour (default 50)
+  # config.browser_new_group_limit = 50
 end

data/lib/rails_informant/browser_context.rb

@@ -0,0 +1,48 @@
+module RailsInformant
+  # The render-time context a page echoes back in its reports. Encrypted, not
+  # just signed, so user details stay unreadable in page HTML that third-party
+  # scripts or cached copies can see.
+  module BrowserContext
+    IDENTITY_TTL = 24.hours
+    PURPOSE = :browser_report
+
+    class << self
+      def generate(request)
+        encryptor.encrypt_and_sign({
+          "rendered_at" => Time.current.iso8601(6),
+          "request_id" => request.request_id,
+          "revision" => RailsInformant.current_git_sha,
+          "user_context" => ContextBuilder.build_user_context(request.env)
+        }, purpose: PURPOSE)
+      end
+
+      # The message has no expiry so a long-open tab still supplies its render
+      # time and revision, which keep a stale page from reopening a fixed
+      # group; only the identity parts age out.
+      def verify(blob)
+        return unless blob.is_a?(String)
+
+        payload = encryptor.decrypt_and_verify(blob, purpose: PURPOSE) or return
+        rendered_at = Time.iso8601(payload["rendered_at"])
+        fresh = rendered_at > IDENTITY_TTL.ago
+
+        BrowserReport::Context.new(
+          rendered_at:,
+          request_id: (payload["request_id"] if fresh),
+          revision: payload["revision"],
+          user_context: (payload["user_context"] if fresh)
+        )
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        nil
+      end
+
+      private
+
+      # The serializer is explicit so the host's message_serializer default
+      # cannot change the payload's shape or key types.
+      def encryptor
+        ActiveSupport::MessageEncryptor.new Rails.application.key_generator.generate_key("informant_browser", 32), serializer: :json
+      end
+    end
+  end
+end

data/lib/rails_informant/browser_error.rb

@@ -0,0 +1,14 @@
+module RailsInformant
+  # Stands in for a JavaScript error so before_record callbacks can read
+  # message and backtrace as they do for Ruby errors. The JS name lives in
+  # the group's error_class string; no constant is ever made from it.
+  class BrowserError < StandardError
+    attr_reader :name
+
+    def initialize(message, backtrace:, name:)
+      super(message)
+      @name = name
+      set_backtrace backtrace
+    end
+  end
+end

data/lib/rails_informant/browser_fingerprint.rb

@@ -0,0 +1,21 @@
+require "digest"
+
+module RailsInformant
+  class BrowserFingerprint
+    HEX = /\b(?:0x)?(?=[0-9a-f]*\d)[0-9a-f]{8,}\b/i
+    URL = %r{\b[a-z][a-z0-9+.-]*://\S+}i
+    UUID = /\b\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\b/
+
+    # The message is left out when an app frame exists because browsers word
+    # the same failure differently, which would split one bug into a group
+    # per engine.
+    def self.generate(error_class:, message:, stack:)
+      key = stack.first_app_frame&.fingerprint_key || normalize_message(message)
+      Digest::SHA256.hexdigest "browser:#{error_class}:#{key}"
+    end
+
+    def self.normalize_message(message)
+      message.to_s.gsub(URL, "<url>").gsub(UUID, "<uuid>").gsub(HEX, "<hex>").gsub(/\d+/, "<n>")
+    end
+  end
+end

data/lib/rails_informant/browser_report.rb

@@ -0,0 +1,102 @@
+module RailsInformant
+  # One browser report, normalized at the boundary: every field comes from
+  # the page and is attacker-controlled, so only allowlisted keys and types
+  # are read, strings are capped and filtered, and identity comes only from
+  # the verified render-time context.
+  class BrowserReport
+    # What the server vouched for when it rendered the page. Any field may be
+    # nil, and the whole context is nil when the page sent none or it failed
+    # verification.
+    Context = Data.define(:rendered_at, :request_id, :revision, :user_context)
+
+    BREADCRUMB_KEYS = %w[category duration message metadata timestamp].freeze
+    URL_BREADCRUMB_CATEGORIES = %w[fetch.error turbo.visit].freeze
+    MAX_BACKTRACE_LINE_LENGTH = 255
+    MAX_BREADCRUMBS = 20
+    MAX_MESSAGE_LENGTH = 1_000
+    MAX_REQUEST_ID_LENGTH = 255
+    MAX_STACK_LENGTH = 20_000
+    NAME_PATTERN = /\A[A-Z][A-Za-z0-9_]{0,63}\z/
+
+    attr_reader :context, :error, :error_class, :message, :page_path, :stack
+
+    def initialize(report, context:, base_url:, remote_ip:, user_agent:)
+      @report = report
+      @context = context
+      @remote_ip = remote_ip
+      @user_agent = user_agent
+
+      @name = string(report["name"])
+      @error_class = "JS::#{NAME_PATTERN.match?(@name) ? @name : "Error"}"
+      @message = string(report["message"]).truncate(MAX_MESSAGE_LENGTH)
+      @stack = JavascriptStack.parse(string(report["stack"]).first(MAX_STACK_LENGTH), origin: base_url)
+      @page_url = string(report["url"]).split("#").first.presence
+      @page_path = ContextBuilder.page_path(@page_url)
+      @error = BrowserError.new(message, backtrace:, name: @name)
+    end
+
+    def group_attributes(now:)
+      {
+        controller_action: nil,
+        created_at: now,
+        error_class:,
+        first_backtrace_line:,
+        first_seen_at: now,
+        job_class: nil,
+        last_seen_at: now,
+        message:,
+        severity: "error",
+        source: "browser",
+        total_occurrences: 1,
+        updated_at: now
+      }
+    end
+
+    def occurrence_attributes
+      {
+        backtrace: error.backtrace,
+        breadcrumbs:,
+        environment_context: ContextBuilder.build_environment_context,
+        failing_request_id: string(report["failing_request_id"]).first(MAX_REQUEST_ID_LENGTH).presence,
+        git_sha: context&.revision,
+        request_context: ContextFilter.filter(ip: remote_ip, url: page_url && ContextBuilder.filtered_url(page_url), user_agent:),
+        request_id: context&.request_id,
+        user_context: ContextFilter.filter(context&.user_context)
+      }
+    end
+
+    private
+
+    attr_reader :name, :page_url, :remote_ip, :report, :user_agent
+
+    # V8 starts error.stack with the error's own "Name: message" line, which
+    # is not a frame and would otherwise show up as the top of the backtrace.
+    def backtrace
+      lines = stack.backtrace
+      lines = lines.drop(1) if v8_header?(lines.first)
+      ContextFilter.filter_backtrace(lines.map { it.first(MAX_BACKTRACE_LINE_LENGTH) })
+    end
+
+    def v8_header?(line)
+      name.present? && (line == name || line&.start_with?("#{name}:"))
+    end
+
+    def breadcrumbs
+      Array(report["breadcrumbs"]).grep(Hash).first(MAX_BREADCRUMBS).map do |crumb|
+        crumb = ContextFilter.filter(crumb.slice(*BREADCRUMB_KEYS))
+        if URL_BREADCRUMB_CATEGORIES.include?(crumb["category"]) && crumb["message"].is_a?(String)
+          crumb["message"] = ContextBuilder.filtered_url(crumb["message"])
+        end
+        crumb
+      end
+    end
+
+    def first_backtrace_line
+      (stack.first_app_frame || stack.frames.first)&.to_s&.first(MAX_BACKTRACE_LINE_LENGTH)
+    end
+
+    def string(value)
+      value.is_a?(String) ? value : ""
+    end
+  end
+end

data/lib/rails_informant/configuration.rb

@@ -1,6 +1,8 @@
 module RailsInformant
   class Configuration
-    attr_accessor :capture_errors,
+    attr_accessor :browser_new_group_limit,
+                  :capture_browser_errors,
+                  :capture_errors,
                   :capture_runner_errors,
                   :capture_user_email,
                   :api_token,
@@ -17,6 +19,8 @@ module RailsInformant
       @before_record_callbacks = []
       @api_token = ENV["INFORMANT_API_TOKEN"]
       @app_name = ENV["INFORMANT_APP_NAME"]
+      @browser_new_group_limit = ENV.fetch("INFORMANT_BROWSER_NEW_GROUP_LIMIT", "50").to_i
+      @capture_browser_errors = ENV["INFORMANT_CAPTURE_BROWSER_ERRORS"] == "true"
       @capture_errors = ENV.fetch("INFORMANT_CAPTURE_ERRORS", "true") != "false"
       @capture_runner_errors = ENV.fetch("INFORMANT_CAPTURE_RUNNER_ERRORS", "true") != "false"
       @capture_user_email = false

data/lib/rails_informant/context_builder.rb

@@ -68,7 +68,7 @@ module RailsInformant
       end
 
       def group_attributes(error, severity:, context:, env:, now:)
-        {
+        attrs = {
           error_class: error.class.name, severity:,
           message: ContextFilter.filter_message(error.message),
           first_backtrace_line: Fingerprint.first_app_frame(error),
@@ -77,10 +77,12 @@ module RailsInformant
           first_seen_at: now, last_seen_at: now,
           total_occurrences: 1, created_at: now, updated_at: now
         }
+        attrs[:source] = "server" if RailsInformant.browser_schema_ready?
+        attrs
       end
 
       def occurrence_attributes(error, env:, context:)
-        {
+        attrs = {
           backtrace: ContextFilter.filter_backtrace(error.backtrace),
           exception_chain: build_exception_chain(error),
           request_context: build_request_context(env),
@@ -90,6 +92,8 @@ module RailsInformant
           breadcrumbs: BreadcrumbBuffer.current.flush,
           git_sha: RailsInformant.current_git_sha
         }
+        attrs[:request_id] = extract_request_id(env, context) if RailsInformant.browser_schema_ready?
+        attrs
       end
 
       def build_custom_context(error)
@@ -112,6 +116,19 @@ module RailsInformant
         end
       end
 
+      # Rails assigns the ID in ActionDispatch::RequestId, so it exists even
+      # when no proxy sent an X-Request-Id header.
+      def extract_request_id(env, context)
+        if env
+          env["action_dispatch.request_id"]
+        else
+          case context
+          in { controller: ActionController::Metal => controller } then controller.request.request_id
+          else nil
+          end
+        end
+      end
+
       def extract_job_class(context)
         case context[:job]
         in ActiveJob::Base => job then job.class.name
@@ -120,6 +137,12 @@ module RailsInformant
         end
       end
 
+      def page_path(url)
+        URI.parse(url).path.presence if url
+      rescue URI::InvalidURIError
+        nil
+      end
+
       def filtered_url(url)
         uri = URI.parse(url)
         if uri.query.present?

data/lib/rails_informant/current.rb

@@ -1,5 +1,5 @@
 module RailsInformant
   class Current < ActiveSupport::CurrentAttributes
-    attribute :breadcrumbs, :custom_context, :delivering_notification, :silenced, :user_context
+    attribute :breadcrumbs, :browser_group_limit_logged, :custom_context, :delivering_notification, :ingesting_browser_report, :silenced, :user_context
   end
 end

data/lib/rails_informant/engine.rb

@@ -2,6 +2,12 @@ module RailsInformant
   class Engine < ::Rails::Engine
     isolate_namespace RailsInformant
 
+    # Always included: the generator writes the tag into the host layout for
+    # good, and the helper itself returns nil while browser capture is off.
+    initializer "rails_informant.browser_helper" do
+      ActiveSupport.on_load(:action_view) { include RailsInformant::BrowserHelper }
+    end
+
     initializer "rails_informant.error_subscriber" do
       next unless RailsInformant.capture_errors
 

data/lib/rails_informant/error_recorder.rb

@@ -29,24 +29,86 @@ module RailsInformant
         event = run_before_record_callbacks(error, attrs, env:, fingerprint:)
         return if event.halted?
 
-        fingerprint = event.fingerprint
         attrs[:severity] = event.severity if %w[error warning info].include?(event.severity)
 
-        group = ErrorGroup.find_or_create_for(fingerprint, attrs)
-        group.detect_regression!
+        record_group(event.fingerprint, attrs) { ContextBuilder.occurrence_attributes(error, env:, context:) }
+      rescue StandardError => e
+        log_capture_failure e
+      end
 
-        return if spike_limit_exceeded?(group)
+      # Called by the browser ingest endpoint once per report. The ingest
+      # request's own env, params and breadcrumbs describe the endpoint, not
+      # the page, so none of them reach the stored group or occurrence.
+      def record_browser(report, context:, base_url:, remote_ip:, user_agent:)
+        return unless RailsInformant.initialized?
+
+        browser_report = BrowserReport.new(report, context:, base_url:, remote_ip:, user_agent:)
+        return if RailsInformant.ignored_request_path?(browser_report.page_path)
+        return if RailsInformant.ignored_error_class?(browser_report.error_class)
+
+        attrs = browser_report.group_attributes(now: Time.current)
+        fingerprint = BrowserFingerprint.generate(error_class: attrs[:error_class], message: attrs[:message], stack: browser_report.stack)
 
-        store_occurrence(group, error, env:, context:) if should_store_occurrence?(group)
-        notify(group)
+        event = run_before_record_callbacks(browser_report.error, attrs, fingerprint:, request_path: browser_report.page_path, source: "browser")
+        return if event.halted?
+
+        attrs[:severity] = event.severity if %w[error warning info].include?(event.severity)
+        return if browser_group_limit_reached?(event.fingerprint)
+
+        record_group(event.fingerprint, attrs, page_rendered_at: context&.rendered_at, browser: true) { browser_report.occurrence_attributes }
       rescue StandardError => e
-        Rails.logger.error "[RailsInformant] Capture failed: #{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}"
+        log_capture_failure e
+      ensure
+        BreadcrumbBuffer.current.flush
       end
 
       private
 
-      def run_before_record_callbacks(error, attrs, env:, fingerprint:)
-        event = Event.new(error, attrs, env:, fingerprint:)
+      def record_group(fingerprint, attrs, browser: false, page_rendered_at: nil, &occurrence_attributes)
+        group = ErrorGroup.find_or_create_for(fingerprint, attrs)
+        stale_page = browser && group.rendered_before_resolution?(page_rendered_at)
+        group.detect_regression! unless stale_page
+
+        return if spike_limit_exceeded?(group)
+
+        store_occurrence(group, occurrence_attributes) if should_store_occurrence?(group)
+        # The group stays resolved, so the notification policy would
+        # otherwise alert on an error the fix already addressed.
+        notify(group) unless stale_page
+      end
+
+      # A DB count rather than a process counter, so the cap holds across
+      # workers and under a null cache store.
+      def browser_group_limit_reached?(fingerprint)
+        return false if ErrorGroup.exists?(fingerprint:)
+
+        limit = RailsInformant.config.browser_new_group_limit
+        return false if ErrorGroup.browser_created_this_hour.count < limit
+
+        unless Current.browser_group_limit_logged
+          Current.browser_group_limit_logged = true
+          Rails.logger.warn "[RailsInformant] Dropped browser report: browser_new_group_limit (#{limit}) new groups already created this hour"
+          record_browser_group_limit limit
+        end
+        true
+      end
+
+      # Recorded as an ordinary server group so a full cap alerts like any
+      # error instead of only reaching the log. It skips record's
+      # self-caused check, which the ingest request would otherwise trip.
+      def record_browser_group_limit(limit)
+        raise BrowserGroupLimitReached, "browser_new_group_limit (#{limit}) reached: new browser error groups are dropped for the rest of the hour"
+      rescue BrowserGroupLimitReached => e
+        attrs = ContextBuilder.group_attributes(e, severity: "warning", context: {}, env: nil, now: Time.current)
+        record_group(Fingerprint.generate(e), attrs) { ContextBuilder.occurrence_attributes(e, env: nil, context: {}) }
+      end
+
+      def log_capture_failure(error)
+        Rails.logger.error "[RailsInformant] Capture failed: #{error.class}: #{error.message}\n#{error.backtrace&.first(5)&.join("\n")}"
+      end
+
+      def run_before_record_callbacks(error, attrs, fingerprint:, **)
+        event = Event.new(error, attrs, fingerprint:, **)
         callbacks = RailsInformant.config.before_record_callbacks
 
         callbacks.each do |callback|
@@ -89,10 +151,12 @@ module RailsInformant
       end
 
       # Detect errors caused by RailsInformant itself to prevent feedback loops.
-      # Primary: CurrentAttributes flag set during notification delivery.
+      # Primary: CurrentAttributes flags set during notification delivery and
+      # browser report ingest, where a recorded failure could amplify a flood.
       # Fallback: backtrace heuristic for cross-execution scenarios (e.g. queue retries).
       def self_caused_error?(error)
-        Current.delivering_notification || error.backtrace&.any? { it.include?("rails_informant/notifiers") }
+        Current.delivering_notification || Current.ingesting_browser_report ||
+          error.backtrace&.any? { it.include?("rails_informant/notifiers") }
       end
 
       def should_store_occurrence?(group)
@@ -101,10 +165,10 @@ module RailsInformant
         group.last_occurrence_stored_at.before?(OCCURRENCE_COOLDOWN.seconds.ago)
       end
 
-      def store_occurrence(group, error, env:, context:)
+      def store_occurrence(group, occurrence_attributes)
         now = Time.current
         ErrorGroup.transaction do
-          group.occurrences.create! ContextBuilder.occurrence_attributes(error, env:, context:)
+          group.occurrences.create! occurrence_attributes.call
           ErrorGroup.where(id: group.id).update_all last_occurrence_stored_at: now, updated_at: now
           group.last_occurrence_stored_at = now
         end