rails_pulse 0.3.3 → 0.4.0.pre.2

data/db/rails_pulse_migrate/20260610000002_change_rails_pulse_routes_to_multi_verb_model.rb

@@ -0,0 +1,185 @@
+class ChangeRailsPulseRoutesToMultiVerbModel < ActiveRecord::Migration[7.0]
+  def up
+    # Step 1: Add http_methods JSON array column to routes
+    unless column_exists?(:rails_pulse_routes, :http_methods)
+      add_column :rails_pulse_routes, :http_methods, :text,
+        comment: "JSON array of HTTP methods accepted by this route (e.g., [\"GET\",\"POST\"])"
+    end
+
+    # Step 2: Backfill http_methods from the existing single method column
+    if column_exists?(:rails_pulse_routes, :method) && column_exists?(:rails_pulse_routes, :http_methods)
+      adapter = connection.adapter_name.downcase
+      if adapter.include?("mysql")
+        execute("UPDATE rails_pulse_routes SET http_methods = CONCAT('[\"', method, '\"]') WHERE http_methods IS NULL AND method IS NOT NULL")
+      else
+        execute("UPDATE rails_pulse_routes SET http_methods = '[\"' || method || '\"]' WHERE http_methods IS NULL AND method IS NOT NULL")
+      end
+      execute("UPDATE rails_pulse_routes SET http_methods = '[]' WHERE http_methods IS NULL")
+
+      connection.schema_cache.clear! if connection.respond_to?(:schema_cache)
+      http_methods_col = connection.columns(:rails_pulse_routes).find { |c| c.name == "http_methods" }
+      change_column_null :rails_pulse_routes, :http_methods, false if http_methods_col&.null
+    end
+
+    # Step 3: Add method column to requests so each request records the specific verb used
+    unless column_exists?(:rails_pulse_requests, :method)
+      add_column :rails_pulse_requests, :method, :string,
+        comment: "HTTP method used for this specific request (e.g., GET, POST)"
+    end
+
+    # Step 4: Backfill requests.method from routes.method before dropping that column
+    if column_exists?(:rails_pulse_routes, :method) && column_exists?(:rails_pulse_requests, :method)
+      execute(<<~SQL)
+        UPDATE rails_pulse_requests
+        SET method = (
+          SELECT method FROM rails_pulse_routes
+          WHERE rails_pulse_routes.id = rails_pulse_requests.route_id
+        )
+        WHERE method IS NULL
+      SQL
+    end
+
+    # Step 5: Merge rows that already share [controller_action, path]. Do not merge
+    # null-action rows by path — GET /users (users#index) and POST /users (users#create)
+    # must stay distinct until `rails_pulse:migrate_routes` backfills controller_action.
+    consolidate_non_null_controller_action_groups
+
+    # Step 6: Swap the unique index from [method, path] to [controller_action, path]
+    if index_exists?(:rails_pulse_routes, [ :method, :path ], name: "index_rails_pulse_routes_on_method_and_path")
+      remove_index :rails_pulse_routes, name: "index_rails_pulse_routes_on_method_and_path"
+    end
+
+    unless index_exists?(:rails_pulse_routes, [ :controller_action, :path ], name: "index_rails_pulse_routes_on_controller_action_and_path")
+      add_index :rails_pulse_routes, [ :controller_action, :path ], unique: true,
+        name: "index_rails_pulse_routes_on_controller_action_and_path"
+    end
+
+    # Step 7: Drop the now-redundant single-method column from routes
+    if column_exists?(:rails_pulse_routes, :method)
+      remove_column :rails_pulse_routes, :method
+    end
+
+    say "Action will stay empty until you run: rails rails_pulse:migrate_routes"
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration
+  end
+
+  private
+
+  def consolidate_non_null_controller_action_groups
+    groups = connection.select_all(<<~SQL).to_a
+      SELECT controller_action, path
+      FROM rails_pulse_routes
+      WHERE controller_action IS NOT NULL
+      GROUP BY controller_action, path
+      HAVING COUNT(*) > 1
+    SQL
+
+    groups.each do |group|
+      routes = connection.select_all(
+        "SELECT id, http_methods FROM rails_pulse_routes " \
+        "WHERE controller_action = #{connection.quote(group["controller_action"])} " \
+        "AND path = #{connection.quote(group["path"])} " \
+        "ORDER BY id"
+      ).to_a
+      merge_route_rows!(routes)
+    end
+  end
+
+  def merge_route_rows!(routes)
+    all_methods = routes.flat_map { |r|
+      begin
+        JSON.parse(r["http_methods"] || "[]")
+      rescue JSON::ParserError
+        []
+      end
+    }.uniq.sort
+
+    winner_id = routes.first["id"].to_i
+    loser_ids = routes.drop(1).map { |r| r["id"].to_i }
+    return if loser_ids.empty?
+
+    loser_list = loser_ids.join(",")
+
+    connection.execute("UPDATE rails_pulse_requests SET route_id = #{winner_id} WHERE route_id IN (#{loser_list})")
+    reassign_or_merge_summaries!(winner_id, loser_ids)
+    connection.execute("UPDATE rails_pulse_routes SET http_methods = #{connection.quote(all_methods.to_json)} WHERE id = #{winner_id}")
+    connection.execute("DELETE FROM rails_pulse_routes WHERE id IN (#{loser_list})")
+  end
+
+  # Reassign loser summaries to the winner. When the same period already exists on the
+  # winner, combine additive/weighted metrics then delete the loser row (unique index
+  # on [summarizable_type, summarizable_id, period_type, period_start]).
+  def reassign_or_merge_summaries!(winner_id, loser_ids)
+    loser_ids.each do |loser_id|
+      source_summaries = connection.select_all(<<~SQL).to_a
+        SELECT *
+        FROM rails_pulse_summaries
+        WHERE summarizable_type = 'RailsPulse::Route'
+          AND summarizable_id = #{loser_id.to_i}
+      SQL
+
+      source_summaries.each do |source|
+        existing = connection.select_one(<<~SQL)
+          SELECT *
+          FROM rails_pulse_summaries
+          WHERE summarizable_type = 'RailsPulse::Route'
+            AND summarizable_id = #{winner_id.to_i}
+            AND period_type = #{connection.quote(source["period_type"])}
+            AND period_start = #{connection.quote(source["period_start"])}
+        SQL
+
+        if existing
+          merge_summary_row!(existing, source)
+          connection.execute("DELETE FROM rails_pulse_summaries WHERE id = #{source["id"].to_i}")
+        else
+          connection.execute(
+            "UPDATE rails_pulse_summaries SET summarizable_id = #{winner_id.to_i} WHERE id = #{source["id"].to_i}"
+          )
+        end
+      end
+    end
+  end
+
+  def merge_summary_row!(target, source)
+    target_count = target["count"].to_i
+    source_count = source["count"].to_i
+    combined_count = target_count + source_count
+
+    sum_columns = %w[count error_count success_count total_duration status_2xx status_3xx status_4xx status_5xx]
+    weighted_columns = %w[avg_duration p50_duration p95_duration p99_duration]
+
+    sets = []
+
+    sum_columns.each do |column|
+      next unless target.key?(column)
+
+      sets << "#{column} = #{target[column].to_f + source[column].to_f}"
+    end
+
+    if combined_count.positive?
+      weighted_columns.each do |column|
+        next unless target.key?(column)
+        next if target[column].nil? && source[column].nil?
+
+        value = ((target[column].to_f * target_count) + (source[column].to_f * source_count)) / combined_count
+        sets << "#{column} = #{value}"
+      end
+    end
+
+    if target.key?("min_duration")
+      mins = [ target["min_duration"], source["min_duration"] ].compact
+      sets << "min_duration = #{mins.min}" if mins.any?
+    end
+
+    if target.key?("max_duration")
+      maxes = [ target["max_duration"], source["max_duration"] ].compact
+      sets << "max_duration = #{maxes.max}" if maxes.any?
+    end
+
+    sets << "updated_at = #{connection.quote(Time.current)}"
+    connection.execute("UPDATE rails_pulse_summaries SET #{sets.join(', ')} WHERE id = #{target["id"].to_i}")
+  end
+end

data/db/rails_pulse_migrate/20260610000003_add_null_action_unique_index_to_routes.rb

@@ -0,0 +1,32 @@
+require "rails_pulse/route_indexes"
+
+class AddNullActionUniqueIndexToRoutes < ActiveRecord::Migration[7.0]
+  def up
+    if duplicate_null_action_paths?
+      say "Deferring null-action unique index — duplicate paths exist."
+      say "Run `rails rails_pulse:migrate_routes` to consolidate duplicates, then"
+      say "the index will be created automatically."
+      return
+    end
+
+    RailsPulse::RouteIndexes.ensure_null_action_uniqueness!(connection)
+  end
+
+  def down
+    RailsPulse::RouteIndexes.remove_null_action_uniqueness!(connection)
+  end
+
+  private
+
+  def duplicate_null_action_paths?
+    connection.select_value(<<~SQL).to_i.positive?
+      SELECT COUNT(*) FROM (
+        SELECT 1
+        FROM rails_pulse_routes
+        WHERE controller_action IS NULL
+        GROUP BY path
+        HAVING COUNT(*) > 1
+      ) duplicates
+    SQL
+  end
+end

data/db/rails_pulse_migrate/20260823000001_add_location_to_exception_groups.rb

@@ -0,0 +1,12 @@
+class AddLocationToExceptionGroups < ActiveRecord::Migration[7.0]
+  def change
+    # Guard on table existence — users who deleted the exceptions migration
+    # per the upgrade generator's advice won't have the table yet.
+    return unless table_exists?(:rails_pulse_exception_groups)
+
+    unless column_exists?(:rails_pulse_exception_groups, :location)
+      add_column :rails_pulse_exception_groups, :location, :string,
+        comment: "Relative first app-code frame, e.g. app/models/user.rb#save"
+    end
+  end
+end

data/db/rails_pulse_schema.rb

@@ -2,10 +2,12 @@
 # This file contains the complete schema for Rails Pulse tables
 # Load with: rails db:schema:load_rails_pulse or db:prepare
 
-RailsPulse::Schema ||= lambda do |connection|
+require "rails_pulse/route_indexes" unless defined?(RailsPulse::RouteIndexes)
+
+RailsPulse::Schema = lambda do |connection|
   adapter = connection.adapter_name.downcase
   # Skip if all tables already exist to prevent conflicts
-  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_jobs, :rails_pulse_job_runs, :rails_pulse_summaries, :rails_pulse_deployments ]
+  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_jobs, :rails_pulse_job_runs, :rails_pulse_summaries, :rails_pulse_deployments, :rails_pulse_exception_groups, :rails_pulse_exception_occurrences ]
 
   # Check which tables already exist
   existing_tables = required_tables.select { |table| connection.table_exists?(table) }
@@ -28,14 +30,17 @@ RailsPulse::Schema ||= lambda do |connection|
 
   unless connection.table_exists?(:rails_pulse_routes)
     connection.create_table :rails_pulse_routes do |t|
-      t.string :method, null: false, comment: "HTTP method (e.g., GET, POST)"
-      t.string :path, null: false, comment: "Request path (e.g., /posts/index)"
+      t.text :http_methods, null: false, comment: "JSON array of HTTP methods accepted by this route (e.g., [\"GET\",\"POST\"])"
+      t.string :path, null: false, comment: "Normalized request path (e.g., /posts/:id)"
       t.text :tags, comment: "JSON array of tags for filtering and categorization"
+      t.string :controller_action, comment: "Rails controller and action handling this route (e.g., articles#show)"
       t.timestamps
     end
 
-    connection.add_index :rails_pulse_routes, [ :method, :path ], unique: true, name: "index_rails_pulse_routes_on_method_and_path"
+    connection.add_index :rails_pulse_routes, [ :controller_action, :path ], unique: true, name: "index_rails_pulse_routes_on_controller_action_and_path"
     connection.add_index :rails_pulse_routes, :path, name: "index_rails_pulse_routes_on_path"
+    # Groups 404s / unrecognized paths by path. Partial (PG/SQLite) or functional (MySQL).
+    RailsPulse::RouteIndexes.ensure_null_action_uniqueness!(connection)
   end
 
   unless connection.table_exists?(:rails_pulse_queries)
@@ -61,6 +66,7 @@ RailsPulse::Schema ||= lambda do |connection|
   unless connection.table_exists?(:rails_pulse_requests)
     connection.create_table :rails_pulse_requests do |t|
       t.references :route, null: false, foreign_key: { to_table: :rails_pulse_routes }, comment: "Link to the route"
+      t.string :method, comment: "HTTP method used for this request (e.g., GET, POST)"
       t.decimal :duration, precision: 15, scale: 6, null: false, comment: "Total request duration in milliseconds"
       t.integer :status, null: false, comment: "HTTP status code (e.g., 200, 500)"
       t.boolean :is_error, null: false, default: false, comment: "True if status >= 500"
@@ -211,6 +217,48 @@ RailsPulse::Schema ||= lambda do |connection|
       name: "index_rails_pulse_deployments_on_revision"
   end
 
+  unless connection.table_exists?(:rails_pulse_exception_groups)
+    connection.create_table :rails_pulse_exception_groups do |t|
+        t.string   :fingerprint,      null: false, comment: "SHA256 of exception_class + relative first app-code location"
+        t.string   :exception_class,  null: false, comment: "e.g. ActiveRecord::RecordNotFound"
+        t.string   :location,                      comment: "Relative first app-code frame, e.g. app/models/user.rb#save"
+        t.text     :message,                       comment: "Message from the most recent occurrence"
+        t.datetime :first_seen_at,    null: false
+        t.datetime :last_seen_at,     null: false
+        t.integer  :occurrence_count, null: false, default: 0
+        t.string   :status,           null: false, default: "open", comment: "open, resolved, ignored"
+        t.datetime :resolved_at,                   comment: "When the group was last resolved"
+        t.boolean  :preserve,         null: false, default: false, comment: "Exempt from all automatic cleanup including occurrence rows"
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_exception_groups, :fingerprint,     unique: true, name: "index_rp_exception_groups_on_fingerprint"
+    connection.add_index :rails_pulse_exception_groups, :last_seen_at,                  name: "index_rp_exception_groups_on_last_seen_at"
+    connection.add_index :rails_pulse_exception_groups, :exception_class,               name: "index_rp_exception_groups_on_class"
+    connection.add_index :rails_pulse_exception_groups, :status,                        name: "index_rp_exception_groups_on_status"
+  end
+
+  unless connection.table_exists?(:rails_pulse_exception_occurrences)
+    connection.create_table :rails_pulse_exception_occurrences do |t|
+      t.references :exception_group, null: false, index: false,
+                   foreign_key: { to_table: :rails_pulse_exception_groups },
+                   comment: "FK to the group this occurrence belongs to"
+      t.string   :exception_class, null: false
+      t.text     :message
+        t.text     :backtrace,       comment: "JSON array of {file, line, method} frames (first 50)"
+      t.string   :request_url,     comment: "Nullable — web requests only"
+      t.string   :request_method,  comment: "GET, POST, etc."
+      t.string   :environment,     comment: "production, staging, etc."
+      t.string   :deploy_sha,       comment: "Captured now even though Pro uses it — cannot backfill later"
+      t.text     :request_params,   comment: "JSON hash of filtered request params — web requests only"
+      t.datetime :occurred_at,      null: false
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_exception_occurrences, :occurred_at,        name: "index_rp_exception_occurrences_on_occurred_at"
+    connection.add_index :rails_pulse_exception_occurrences, :exception_group_id, name: "index_rp_exception_occurrences_on_group_id"
+  end
+
   # Add indexes to existing tables for efficient aggregation
   unless connection.index_exists?(:rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation")
     connection.add_index :rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation"
@@ -226,7 +274,7 @@ RailsPulse::Schema ||= lambda do |connection|
   if newly_created.any?
     puts "[RailsPulse::Schema] Successfully created tables: #{newly_created.join(', ')}"
   end
-end
+end unless defined?(RailsPulse::Schema)
 
 if defined?(RailsPulse::ApplicationRecord)
   RailsPulse::Schema.call(RailsPulse::ApplicationRecord.connection)

data/lib/generators/rails_pulse/base_methods.rb

@@ -13,6 +13,8 @@ module RailsPulse
         rails_pulse_job_runs
         rails_pulse_summaries
         rails_pulse_deployments
+        rails_pulse_exception_groups
+        rails_pulse_exception_occurrences
       ].freeze
 
       # Generate next migration number for timestamped migrations

data/lib/generators/rails_pulse/install_generator.rb

@@ -78,6 +78,11 @@ module RailsPulse
                  <<: *default
                  database: storage/#{Rails.env}_rails_pulse.sqlite3
                  migrations_paths: db/rails_pulse_migrate
+                 schema_dump: false
+
+          schema_dump: false is required so Rails does not dump or load
+          db/rails_pulse_structure.sql. Keep database_tasks enabled so
+          rails db:migrate:rails_pulse still runs upgrades.
 
           2. Run: rails db:prepare (creates database and loads schema)
           3. Restart your Rails server

data/lib/generators/rails_pulse/schema_parser.rb

@@ -48,6 +48,25 @@ module RailsPulse
 
       private
 
+      # Column definitions look like: t.text :column_name, comment: "..."
+      # The comment capture must tolerate escaped quotes — the http_methods
+      # comment embeds a JSON example, [\"GET\",\"POST\"] — so it matches a
+      # full Ruby string literal (quotes included) rather than stopping at the
+      # first quote character.
+      COLUMN_DEFINITION = /t\.(\w+)\s+:([a-zA-Z_][a-zA-Z0-9_]*)(?:.*?comment:\s*("(?:[^"\\]|\\.)*"))?/
+
+      # Turn the matched Ruby string literal back into the string it denotes, so
+      # callers hold the real comment text and re-escape it themselves (the
+      # upgrade migration template uses String#inspect). Falls back to stripping
+      # the quotes if the literal uses an escape String#undump rejects.
+      def decode_comment(literal)
+        return nil if literal.nil?
+
+        literal.undump
+      rescue RuntimeError
+        literal.delete_prefix('"').delete_suffix('"')
+      end
+
       # Parse column definitions from a table block
       # Returns hash of column_name => { type:, comment: }
       def parse_table_columns(table_block)
@@ -55,9 +74,10 @@ module RailsPulse
 
         table_block.split("\n").each do |line|
           # Match column definitions: t.text :column_name, comment: "..."
-          next unless match = line.match(/t\.(\w+)\s+:([a-zA-Z_][a-zA-Z0-9_]*)(?:.*?comment:\s*"([^"]*)")?/)
+          next unless match = line.match(COLUMN_DEFINITION)
 
-          column_type, column_name, comment = match.captures
+          column_type, column_name, comment_literal = match.captures
+          comment = decode_comment(comment_literal)
 
           # Skip timestamps and references (Rails handles these)
           next if %w[timestamps references].include?(column_type)

data/lib/generators/rails_pulse/templates/db/rails_pulse_schema.rb

@@ -2,10 +2,12 @@
 # This file contains the complete schema for Rails Pulse tables
 # Load with: rails db:schema:load_rails_pulse or db:prepare
 
-RailsPulse::Schema ||= lambda do |connection|
+require "rails_pulse/route_indexes" unless defined?(RailsPulse::RouteIndexes)
+
+RailsPulse::Schema = lambda do |connection|
   adapter = connection.adapter_name.downcase
   # Skip if all tables already exist to prevent conflicts
-  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_jobs, :rails_pulse_job_runs, :rails_pulse_summaries, :rails_pulse_deployments ]
+  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_jobs, :rails_pulse_job_runs, :rails_pulse_summaries, :rails_pulse_deployments, :rails_pulse_exception_groups, :rails_pulse_exception_occurrences ]
 
   # Check which tables already exist
   existing_tables = required_tables.select { |table| connection.table_exists?(table) }
@@ -28,14 +30,17 @@ RailsPulse::Schema ||= lambda do |connection|
 
   unless connection.table_exists?(:rails_pulse_routes)
     connection.create_table :rails_pulse_routes do |t|
-      t.string :method, null: false, comment: "HTTP method (e.g., GET, POST)"
-      t.string :path, null: false, comment: "Request path (e.g., /posts/index)"
+      t.text :http_methods, null: false, comment: "JSON array of HTTP methods accepted by this route (e.g., [\"GET\",\"POST\"])"
+      t.string :path, null: false, comment: "Normalized request path (e.g., /posts/:id)"
       t.text :tags, comment: "JSON array of tags for filtering and categorization"
+      t.string :controller_action, comment: "Rails controller and action handling this route (e.g., articles#show)"
       t.timestamps
     end
 
-    connection.add_index :rails_pulse_routes, [ :method, :path ], unique: true, name: "index_rails_pulse_routes_on_method_and_path"
+    connection.add_index :rails_pulse_routes, [ :controller_action, :path ], unique: true, name: "index_rails_pulse_routes_on_controller_action_and_path"
     connection.add_index :rails_pulse_routes, :path, name: "index_rails_pulse_routes_on_path"
+    # Groups 404s / unrecognized paths by path. Partial (PG/SQLite) or functional (MySQL).
+    RailsPulse::RouteIndexes.ensure_null_action_uniqueness!(connection)
   end
 
   unless connection.table_exists?(:rails_pulse_queries)
@@ -61,6 +66,7 @@ RailsPulse::Schema ||= lambda do |connection|
   unless connection.table_exists?(:rails_pulse_requests)
     connection.create_table :rails_pulse_requests do |t|
       t.references :route, null: false, foreign_key: { to_table: :rails_pulse_routes }, comment: "Link to the route"
+      t.string :method, comment: "HTTP method used for this request (e.g., GET, POST)"
       t.decimal :duration, precision: 15, scale: 6, null: false, comment: "Total request duration in milliseconds"
       t.integer :status, null: false, comment: "HTTP status code (e.g., 200, 500)"
       t.boolean :is_error, null: false, default: false, comment: "True if status >= 500"
@@ -211,6 +217,48 @@ RailsPulse::Schema ||= lambda do |connection|
       name: "index_rails_pulse_deployments_on_revision"
   end
 
+  unless connection.table_exists?(:rails_pulse_exception_groups)
+    connection.create_table :rails_pulse_exception_groups do |t|
+        t.string   :fingerprint,      null: false, comment: "SHA256 of exception_class + relative first app-code location"
+        t.string   :exception_class,  null: false, comment: "e.g. ActiveRecord::RecordNotFound"
+        t.string   :location,                      comment: "Relative first app-code frame, e.g. app/models/user.rb#save"
+        t.text     :message,                       comment: "Message from the most recent occurrence"
+        t.datetime :first_seen_at,    null: false
+        t.datetime :last_seen_at,     null: false
+        t.integer  :occurrence_count, null: false, default: 0
+        t.string   :status,           null: false, default: "open", comment: "open, resolved, ignored"
+        t.datetime :resolved_at,                   comment: "When the group was last resolved"
+        t.boolean  :preserve,         null: false, default: false, comment: "Exempt from all automatic cleanup including occurrence rows"
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_exception_groups, :fingerprint,     unique: true, name: "index_rp_exception_groups_on_fingerprint"
+    connection.add_index :rails_pulse_exception_groups, :last_seen_at,                  name: "index_rp_exception_groups_on_last_seen_at"
+    connection.add_index :rails_pulse_exception_groups, :exception_class,               name: "index_rp_exception_groups_on_class"
+    connection.add_index :rails_pulse_exception_groups, :status,                        name: "index_rp_exception_groups_on_status"
+  end
+
+  unless connection.table_exists?(:rails_pulse_exception_occurrences)
+    connection.create_table :rails_pulse_exception_occurrences do |t|
+      t.references :exception_group, null: false, index: false,
+                   foreign_key: { to_table: :rails_pulse_exception_groups },
+                   comment: "FK to the group this occurrence belongs to"
+      t.string   :exception_class, null: false
+      t.text     :message
+        t.text     :backtrace,       comment: "JSON array of {file, line, method} frames (first 50)"
+      t.string   :request_url,     comment: "Nullable — web requests only"
+      t.string   :request_method,  comment: "GET, POST, etc."
+      t.string   :environment,     comment: "production, staging, etc."
+      t.string   :deploy_sha,       comment: "Captured now even though Pro uses it — cannot backfill later"
+      t.text     :request_params,   comment: "JSON hash of filtered request params — web requests only"
+      t.datetime :occurred_at,      null: false
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_exception_occurrences, :occurred_at,        name: "index_rp_exception_occurrences_on_occurred_at"
+    connection.add_index :rails_pulse_exception_occurrences, :exception_group_id, name: "index_rp_exception_occurrences_on_group_id"
+  end
+
   # Add indexes to existing tables for efficient aggregation
   unless connection.index_exists?(:rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation")
     connection.add_index :rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation"
@@ -226,7 +274,7 @@ RailsPulse::Schema ||= lambda do |connection|
   if newly_created.any?
     puts "[RailsPulse::Schema] Successfully created tables: #{newly_created.join(', ')}"
   end
-end
+end unless defined?(RailsPulse::Schema)
 
 if defined?(RailsPulse::ApplicationRecord)
   RailsPulse::Schema.call(RailsPulse::ApplicationRecord.connection)

data/lib/generators/rails_pulse/templates/migrations/upgrade_rails_pulse_tables.rb

@@ -4,7 +4,7 @@ class UpgradeRailsPulseTables < ActiveRecord::Migration[<%= @migration_version %
     <% @missing_columns.each do |table_name, columns| %>
       <% columns.each do |column_name, definition| %>
     # Add <%= column_name %> column to <%= table_name %>
-    add_column :<%= table_name %>, :<%= column_name %>, :<%= definition[:type] %><% if definition[:comment] %>, comment: "<%= definition[:comment] %>"<% end %>
+    add_column :<%= table_name %>, :<%= column_name %>, :<%= definition[:type] %><% if definition[:comment] %>, comment: <%= definition[:comment].inspect %><% end %>
       <% end %>
     <% end %>
   end