rails_pulse 0.3.2 → 0.3.3.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4ae84f35fe7c694c6a41c2b7baf710bfbbbbcaa651c63fda713a7c2321ea6a2
-  data.tar.gz: 1159b79cb75887806cbb655fe515198262810c882a87bcc3bec802ac0346eb7e
+  metadata.gz: b3163ab148ab6f7c2f3d94f39212eec0ddcd56d04701b5320a570725433c04ac
+  data.tar.gz: 3c1780d7779c03cf2176ae680c4ffcd8168fb2c91bf3da55f41b63a38d1044cd
 SHA512:
-  metadata.gz: f8cb7c6c3e70a936552c10bb6b03067de2733287432bbb4a7464227e70ca33c4a597cb7d485bcaf5ff67c3127ce30f896e17207b765335aa92916d40239963fe
-  data.tar.gz: 361a77be31e5e47294577d1629717f48b9a9fe55f80f023799c6caafd989eadeeabeb2f2cf4500a7d87403596ba5dcff54e461a02ba801a362e3dcd1697bc502
+  metadata.gz: 5ab05d4a32b9d9efc69b4a4f2683888815c6f213a1fee3e5f8a351492959d12318c345c589179455fab4c8db2ffbe496e2fcdf168badbf6557819b6479551171
+  data.tar.gz: 4697d128fdb52cc22a5a345652c48fbcd324e8482911325f3859a2dd46febbb8be309da2988c281a3adcf2efc22eaca06a03f1e02c4a3e393392e21e1b54b829

data/app/models/rails_pulse/operation.rb

@@ -37,6 +37,60 @@ module RailsPulse
     before_validation :associate_query
     before_validation :truncate_label
 
+    # Bulk-insert a batch of operation hashes captured during a request or job run.
+    # `context` is merged into every row to bind it to its parent — either
+    # `{ request_id: id }` or `{ job_run_id: id, request_id: nil }`.
+    #
+    # SQL operations are handled in two phases to minimise DB round-trips:
+    #   1. Normalise each unique SQL source once and collect hashed→normalised pairs.
+    #   2. Resolve (or create) the corresponding Query records in bulk rather than
+    #      one create_or_find_by per operation, which matters for N+1-heavy requests.
+    #
+    # insert_all! is used instead of individual creates to bypass ActiveRecord
+    # callbacks and validations — normalisation and truncation are done inline above.
+    # All rows must have the same key set, so keys are union-normalised before insert.
+    def self.persist_bulk(ops, context)
+      return if ops.empty?
+
+      # Phase 1: normalise each unique SQL source once.
+      # norm_cache avoids re-normalising repeated SQL (e.g. N+1 queries).
+      # norm_map feeds the bulk Query resolver: { hashed_sql => normalized_sql }.
+      norm_cache = {}
+      norm_map = {}
+      ops.each do |op|
+        next unless op[:operation_type] == "sql"
+        sql_source = op[:actual_sql].presence || op[:label].presence
+        next unless sql_source
+        unless norm_cache.key?(sql_source)
+          normalized = RailsPulse::SqlQueryNormalizer.normalize(sql_source)
+          hashed = Digest::MD5.hexdigest(normalized)
+          norm_cache[sql_source] = [ hashed, normalized ]
+          norm_map[hashed] ||= normalized
+        end
+      end
+
+      # Phase 2: resolve Query IDs in bulk (1 SELECT in steady state).
+      query_id_map = RailsPulse::Query.bulk_find_or_create(norm_map)
+
+      now = Time.current
+      rows = ops.map do |op|
+        op = op.merge(context).merge(created_at: now, updated_at: now)
+        if op[:operation_type] == "sql"
+          sql_source = op[:actual_sql].presence || op[:label].presence
+          if sql_source && (meta = norm_cache[sql_source])
+            hashed, normalized = meta
+            op = op.merge(label: normalized.truncate(255), query_id: query_id_map[hashed])
+          end
+        end
+        op[:label] = op[:label]&.truncate(255)
+        op
+      end
+      # insert_all! requires every row to have identical keys.
+      all_keys = rows.flat_map(&:keys).uniq
+      rows = rows.map { |r| all_keys.each_with_object({}) { |k, h| h[k] = r[k] } }
+      insert_all!(rows)
+    end
+
     def self.ransackable_attributes(auth_object = nil)
       %w[id occurred_at label duration start_time average_query_time_ms query_count operation_type query_id]
     end

data/app/models/rails_pulse/query.rb

@@ -24,6 +24,21 @@ module RailsPulse
     serialize :index_recommendations, type: Array, coder: JSON
     serialize :suggestions, type: Array, coder: JSON
 
+    def self.bulk_find_or_create(norm_map)
+      return {} if norm_map.empty?
+
+      id_map = where(hashed_sql: norm_map.keys).pluck(:hashed_sql, :id).to_h
+
+      missing = norm_map.reject { |h, _| id_map.key?(h) }
+      unless missing.empty?
+        now = Time.current
+        insert_all(missing.map { |h, n| { hashed_sql: h, normalized_sql: n, created_at: now, updated_at: now } })
+        id_map.merge!(where(hashed_sql: missing.keys).pluck(:hashed_sql, :id).to_h)
+      end
+
+      id_map
+    end
+
     def self.ransackable_attributes(auth_object = nil)
       %w[id normalized_sql average_query_time_ms execution_count total_time_consumed performance_status occurred_at]
     end

data/app/models/rails_pulse/request.rb

@@ -16,7 +16,7 @@ module RailsPulse
     validates :duration, presence: true, numericality: { greater_than_or_equal_to: 0 }
     validates :status, presence: true
     validates :is_error, inclusion: { in: [ true, false ] }
-    validates :request_uuid, presence: true, uniqueness: true
+    validates :request_uuid, presence: true
 
     before_validation :set_request_uuid, on: :create
 

data/app/services/rails_pulse/sql_query_normalizer.rb

@@ -92,21 +92,49 @@ module RailsPulse
     end
 
     def handle_special_constructs(query)
-      normalized = query.dup
+      normalized = normalize_in_clauses(query)
+      normalized.gsub(/\bBETWEEN\s+\?\s+AND\s+\?/i, "BETWEEN ? AND ?")
+    end
 
-      # Handle IN clauses with multiple values - replace content but preserve structure
-      normalized = normalized.gsub(/\bIN\s*\(\s*([^)]+)\)/i) do |match|
-        content = $1
-        # Count commas to determine number of values
-        value_count = content.split(",").length
-        placeholders = Array.new(value_count, "?").join(", ")
-        "IN (#{placeholders})"
+    # Replaces IN clause contents with placeholders using paren-depth tracking
+    # so that subqueries containing nested parens (e.g. HAVING (COUNT(*) > N))
+    # are handled correctly. A flat [^)]+ regex stops at the first ) it finds,
+    # which breaks when the subquery contains function calls or nested clauses.
+    def normalize_in_clauses(query)
+      result = +""
+      i = 0
+      while i < query.length
+        at_word_boundary = i == 0 || !query[i - 1].match?(/[a-zA-Z_0-9]/i)
+        m = at_word_boundary && query[i..].match(/\AIN\s*\(\s*/i)
+
+        if m
+          content_start = i + m[0].length
+          depth = 1
+          j = content_start
+
+          while j < query.length && depth > 0
+            case query[j]
+            when "(" then depth += 1
+            when ")" then depth -= 1
+            end
+            j += 1 if depth > 0
+          end
+
+          content = query[content_start...j]
+
+          if content.strip.match?(/\ASELECT\s/i)
+            result << "IN (?)"
+          else
+            value_count = [ content.split(",").length, 1 ].max
+            result << "IN (#{Array.new(value_count, "?").join(", ")})"
+          end
+          i = j + 1
+        else
+          result << query[i]
+          i += 1
+        end
       end
-
-      # Handle BETWEEN clauses
-      normalized = normalized.gsub(/\bBETWEEN\s+\?\s+AND\s+\?/i, "BETWEEN ? AND ?")
-
-      normalized
+      result
     end
 
     def restore_identifiers(query, identifier_mapping)

data/app/services/rails_pulse/summary_service.rb

@@ -71,34 +71,17 @@ module RailsPulse
     private
 
     def aggregate_routes
-      # Use ActiveRecord for cross-database compatibility
-      route_groups = Request
+      all_rows = Request
         .where(occurred_at: start_time...end_time)
         .where.not(route_id: nil)
-        .joins(:route)
-        .group(:route_id)
-
-      # Calculate basic aggregates
-      basic_stats = route_groups.pluck(
-        :route_id,
-        Arel.sql("COUNT(*) as request_count"),
-        Arel.sql("AVG(duration) as avg_duration"),
-        Arel.sql("MIN(duration) as min_duration"),
-        Arel.sql("MAX(duration) as max_duration"),
-        Arel.sql("SUM(duration) as total_duration")
-      )
-
-      basic_stats.each do |stats|
-        route_id = stats[0]
+        .pluck(:route_id, :duration, :status)
 
-        # Calculate percentiles and status counts separately for cross-DB compatibility
-        durations = Request
-          .where(occurred_at: start_time...end_time)
-          .where(route_id: route_id)
-          .pluck(:duration, :status)
+      return if all_rows.empty?
 
-        sorted_durations = durations.map(&:first).compact.sort
-        statuses = durations.map(&:last)
+      all_rows.group_by(&:first).each do |route_id, rows|
+        durations = rows.map { |_, d, _| d }.compact.sort
+        statuses = rows.map { |_, _, s| s }
+        avg = durations.sum.to_f / durations.size
 
         summary = Summary.find_or_initialize_by(
           summarizable_type: "RailsPulse::Route",
@@ -109,15 +92,15 @@ module RailsPulse
 
         summary.assign_attributes(
           period_end: end_time,
-          count: stats[1],
-          avg_duration: stats[2],
-          min_duration: stats[3],
-          max_duration: stats[4],
-          total_duration: stats[5],
-          p50_duration: RailsPulse::Statistics.calculate_percentile(sorted_durations, 0.5),
-          p95_duration: RailsPulse::Statistics.calculate_percentile(sorted_durations, 0.95),
-          p99_duration: RailsPulse::Statistics.calculate_percentile(sorted_durations, 0.99),
-          stddev_duration: RailsPulse::Statistics.calculate_stddev(sorted_durations, stats[2]),
+          count: rows.size,
+          avg_duration: avg,
+          min_duration: durations.first,
+          max_duration: durations.last,
+          total_duration: durations.sum,
+          p50_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.5),
+          p95_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.95),
+          p99_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.99),
+          stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, avg),
           error_count: statuses.count { |s| s >= 500 },
           success_count: statuses.count { |s| s < 500 },
           status_2xx: statuses.count { |s| s.between?(200, 299) },
@@ -131,31 +114,18 @@ module RailsPulse
     end
 
     def aggregate_queries
-      query_groups = Operation
+      all_rows = Operation
         .where(occurred_at: start_time...end_time)
         .where.not(query_id: nil)
-        .joins(:query)
-        .group(:query_id)
-
-      basic_stats = query_groups.pluck(
-        :query_id,
-        Arel.sql("COUNT(*) as execution_count"),
-        Arel.sql("AVG(duration) as avg_duration"),
-        Arel.sql("MIN(duration) as min_duration"),
-        Arel.sql("MAX(duration) as max_duration"),
-        Arel.sql("SUM(duration) as total_duration")
-      )
+        .pluck(:query_id, :duration)
+
+      return if all_rows.empty?
 
-      basic_stats.each do |stats|
-        query_id = stats[0]
+      all_rows.group_by(&:first).each do |query_id, rows|
+        durations = rows.map(&:last).compact.sort
+        next if durations.empty?
 
-        # Calculate percentiles separately
-        durations = Operation
-          .where(occurred_at: start_time...end_time)
-          .where(query_id: query_id)
-          .pluck(:duration)
-          .compact
-          .sort
+        avg = durations.sum.to_f / durations.size
 
         summary = Summary.find_or_initialize_by(
           summarizable_type: "RailsPulse::Query",
@@ -166,15 +136,15 @@ module RailsPulse
 
         summary.assign_attributes(
           period_end: end_time,
-          count: stats[1],
-          avg_duration: stats[2],
-          min_duration: stats[3],
-          max_duration: stats[4],
-          total_duration: stats[5],
+          count: durations.size,
+          avg_duration: avg,
+          min_duration: durations.first,
+          max_duration: durations.last,
+          total_duration: durations.sum,
           p50_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.5),
           p95_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.95),
           p99_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.99),
-          stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, stats[2])
+          stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, avg)
         )
 
         summary.save!

data/lib/rails_pulse/cleanup_service.rb

@@ -57,7 +57,7 @@ module RailsPulse
       # Only delete records from periods that have already been summarized.
       # This prevents count-based cleanup from removing data before the summary
       # job has had a chance to aggregate it.
-      cutoff = latest_summarized_cutoff
+      cutoff = summarized_cutoff
 
       # Operations: only delete those before the summarization cutoff
       ops_scope = cutoff ? RailsPulse::Operation.where("occurred_at < ?", cutoff) : RailsPulse::Operation.none
@@ -93,39 +93,35 @@ module RailsPulse
     end
 
     def cleanup_requests_by_time(cutoff_time)
-      request_ids = RailsPulse::Request.where("occurred_at < ?", cutoff_time).pluck(:id)
-      RailsPulse::Operation.where(request_id: request_ids).delete_all
-      RailsPulse::Request.where(id: request_ids).delete_all
-      request_ids.size
+      request_subquery = RailsPulse::Request.where("occurred_at < ?", cutoff_time).select(:id)
+      RailsPulse::Operation.where(request_id: request_subquery).delete_all
+      RailsPulse::Request.where("occurred_at < ?", cutoff_time).delete_all
     end
 
     def cleanup_queries_by_time(cutoff_time)
       RailsPulse::Query
         .where("created_at < ?", cutoff_time)
-        .where("id NOT IN (SELECT DISTINCT query_id FROM rails_pulse_operations WHERE query_id IS NOT NULL)")
+        .where("id NOT IN (SELECT query_id FROM rails_pulse_operations WHERE query_id IS NOT NULL)")
         .delete_all
     end
 
     def cleanup_routes_by_time(cutoff_time)
       RailsPulse::Route
         .where("created_at < ?", cutoff_time)
-        .where("id NOT IN (SELECT DISTINCT route_id FROM rails_pulse_requests WHERE route_id IS NOT NULL)")
+        .where("id NOT IN (SELECT route_id FROM rails_pulse_requests WHERE route_id IS NOT NULL)")
         .delete_all
     end
 
     def cleanup_job_runs_by_time(cutoff_time)
-      job_run_ids = RailsPulse::JobRun.where("occurred_at < ?", cutoff_time).pluck(:id)
-      return 0 if job_run_ids.empty?
-
-      RailsPulse::Operation.where(job_run_id: job_run_ids).delete_all
-      RailsPulse::JobRun.where(id: job_run_ids).delete_all
-      job_run_ids.size
+      job_run_subquery = RailsPulse::JobRun.where("occurred_at < ?", cutoff_time).select(:id)
+      RailsPulse::Operation.where(job_run_id: job_run_subquery).delete_all
+      RailsPulse::JobRun.where("occurred_at < ?", cutoff_time).delete_all
     end
 
     def cleanup_jobs_by_time(cutoff_time)
       RailsPulse::Job
         .where("created_at < ?", cutoff_time)
-        .where("id NOT IN (SELECT DISTINCT job_id FROM rails_pulse_job_runs WHERE job_id IS NOT NULL)")
+        .where("id NOT IN (SELECT job_id FROM rails_pulse_job_runs WHERE job_id IS NOT NULL)")
         .delete_all
     end
 
@@ -136,7 +132,7 @@ module RailsPulse
       return 0 unless max_records
 
       # Only delete requests from periods that have already been summarized
-      cutoff = latest_summarized_cutoff
+      cutoff = summarized_cutoff
       return 0 unless cutoff
 
       current_count = RailsPulse::Request.count
@@ -173,21 +169,21 @@ module RailsPulse
 
     def cleanup_queries_by_count
       scope = RailsPulse::Query.where(
-        "id NOT IN (SELECT DISTINCT query_id FROM rails_pulse_operations WHERE query_id IS NOT NULL)"
+        "id NOT IN (SELECT query_id FROM rails_pulse_operations WHERE query_id IS NOT NULL)"
       )
       cleanup_by_count(RailsPulse::Query, :rails_pulse_queries, order_column: :created_at, scope: scope)
     end
 
     def cleanup_routes_by_count
       scope = RailsPulse::Route.where(
-        "id NOT IN (SELECT DISTINCT route_id FROM rails_pulse_requests WHERE route_id IS NOT NULL)"
+        "id NOT IN (SELECT route_id FROM rails_pulse_requests WHERE route_id IS NOT NULL)"
       )
       cleanup_by_count(RailsPulse::Route, :rails_pulse_routes, order_column: :created_at, scope: scope)
     end
 
     def cleanup_jobs_by_count
       scope = RailsPulse::Job.where(
-        "id NOT IN (SELECT DISTINCT job_id FROM rails_pulse_job_runs WHERE job_id IS NOT NULL)"
+        "id NOT IN (SELECT job_id FROM rails_pulse_job_runs WHERE job_id IS NOT NULL)"
       )
       cleanup_by_count(RailsPulse::Job, :rails_pulse_jobs, order_column: :created_at, scope: scope)
     end
@@ -203,8 +199,8 @@ module RailsPulse
     # Returns the period_end of the most recent completed hourly overall-request
     # summary, or nil if the summary job has never run. Records with occurred_at
     # before this timestamp have been fully aggregated and are safe to delete.
-    def latest_summarized_cutoff
-      RailsPulse::Summary
+    def summarized_cutoff
+      @summarized_cutoff ||= RailsPulse::Summary
         .where(summarizable_type: "RailsPulse::Request", summarizable_id: 0, period_type: "hour")
         .maximum(:period_end)
     end

data/lib/rails_pulse/job_run_collector.rb

@@ -128,17 +128,12 @@ module RailsPulse
       def save_operations(job_run)
         return unless job_run
 
-        operations_data = RequestStore.store[:rails_pulse_operations] || []
-        operations_data.each do |operation_data|
-          operation_data[:job_run_id] = job_run.id
-          operation_data[:request_id] = nil
-
-          with_recording_suppressed do
-            RailsPulse::Operation.create!(operation_data)
-          end
-        rescue => e
-          RailsPulse.logger.error "Failed to save job operation: #{e.class} - #{e.message}"
+        ops = RequestStore.store[:rails_pulse_operations] || []
+        with_recording_suppressed do
+          RailsPulse::Operation.persist_bulk(ops, job_run_id: job_run.id, request_id: nil)
         end
+      rescue => e
+        RailsPulse.logger.error "Failed to save job operations: #{e.class} - #{e.message}"
       ensure
         RequestStore.store[:rails_pulse_operations] = nil
       end

data/lib/rails_pulse/middleware/request_collector.rb

@@ -30,7 +30,6 @@ module RailsPulse
         RequestStore.store[:rails_pulse_operations] = []
 
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        controller_action = "#{env['action_dispatch.request.parameters']&.[]('controller')&.classify}##{env['action_dispatch.request.parameters']&.[]('action')}"
         occurred_at = Time.current
 
         # Process request
@@ -41,6 +40,7 @@ module RailsPulse
         # Deep copy operations array to prevent race condition in async mode
         operations = RequestStore.store[:rails_pulse_operations] || []
         detect_n_plus_one(operations)
+        controller_action = operations.find { |op| op[:operation_type] == "controller" }&.[](:label)
         tracking_data = {
           method: req.request_method,
           path: req.path,
@@ -85,7 +85,7 @@ module RailsPulse
         sql_ops = operations.select { |op| op[:operation_type] == "sql" }
         return if sql_ops.size < 2
 
-        groups = sql_ops.group_by { |op| RailsPulse::SqlQueryNormalizer.normalize(op[:label].to_s) }
+        groups = sql_ops.group_by { |op| RailsPulse::SqlQueryNormalizer.normalize(op[:actual_sql].to_s) }
         groups.each do |normalized_sql, ops|
           next if ops.size < 2
           ops.each do |op|

data/lib/rails_pulse/subscribers/operation_subscriber.rb

@@ -21,7 +21,7 @@ module RailsPulse
 
         def clean_sql_label(sql)
           return sql unless sql
-          # Remove Rails SQL comments like /*action='search',application='Dummy',controller='home'*/
+          return sql unless sql.include?("/*")
           sql.gsub(/\/\*[^*]*\*\//, "").strip
         end
 
@@ -36,8 +36,11 @@ module RailsPulse
           end
         end
 
+        def app_path
+          @app_path ||= Rails.root.join("app").to_s
+        end
+
         def find_app_frame
-          app_path = Rails.root.join("app").to_s
           caller_locations.each do |loc|
             path = loc.absolute_path || loc.path
             return path if path && path.start_with?(app_path)
@@ -47,23 +50,30 @@ module RailsPulse
 
         def controller_action_source_location(payload)
           return nil unless payload[:controller] && payload[:action]
+
+          cache_key = "#{payload[:controller]}##{payload[:action]}"
+          @source_location_cache ||= {}
+          return @source_location_cache[cache_key] if @source_location_cache.key?(cache_key)
+
+          result = nil
           begin
             controller_klass = payload[:controller].constantize
             if controller_klass.instance_methods(false).include?(payload[:action].to_sym)
               file, line = controller_klass.instance_method(payload[:action]).source_location
-              return "#{relative_path(file)}:#{line}" if file && line
+              result = "#{relative_path(file)}:#{line}" if file && line
             end
             # fallback: try superclass (for ApplicationController actions)
-            if controller_klass.superclass.respond_to?(:instance_method)
+            if result.nil? && controller_klass.superclass.respond_to?(:instance_method)
               if controller_klass.superclass.instance_methods(false).include?(payload[:action].to_sym)
                 file, line = controller_klass.superclass.instance_method(payload[:action]).source_location
-                return "#{relative_path(file)}:#{line}" if file && line
+                result = "#{relative_path(file)}:#{line}" if file && line
               end
             end
           rescue => e
             RailsPulse.logger.debug "Could not resolve controller source location: #{e.class} - #{e.message}"
           end
-          nil
+
+          @source_location_cache[cache_key] = result
         end
 
         def capture_operation(event_name, start, finish, payload, operation_type, label_key = nil, extra: {})

data/lib/rails_pulse/tracker.rb

@@ -29,11 +29,8 @@ module RailsPulse
 
           begin
             # Find or create route
-            route = RailsPulse::Route.create_or_find_by(
-              method: data[:method],
-              path: data[:path]
-            )
-            route = RailsPulse::Route.find_by!(method: data[:method], path: data[:path]) unless route
+            route = RailsPulse::Route.find_by(method: data[:method], path: data[:path]) ||
+                    RailsPulse::Route.create_or_find_by(method: data[:method], path: data[:path])
 
 
             # Create request record
@@ -49,9 +46,8 @@ module RailsPulse
             )
 
             # Create operation records
-            (data[:operations] || []).each do |op_data|
-              RailsPulse::Operation.create!(op_data.merge(request_id: request.id))
-            end
+            ops = data[:operations] || []
+            RailsPulse::Operation.persist_bulk(ops, request_id: request.id)
 
             request
           rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::StatementInvalid => e

data/lib/rails_pulse/version.rb

@@ -1,3 +1,3 @@
 module RailsPulse
-  VERSION = "0.3.2"
+  VERSION = "0.3.3.pre.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_pulse
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3.pre.1
 platform: ruby
 authors:
 - Scott Harvey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -515,7 +515,9 @@ metadata:
   source_code_uri: https://github.com/railspulse/rails_pulse
   changelog_uri: https://github.com/railspulse/rails_pulse/blob/main/CHANGELOG.md
   documentation_uri: https://railspulse.com/documentation/installation
-post_install_message:
+post_install_message: |
+  Rails Pulse 0.3.3.pre.1 installed. If upgrading, run:
+    rails generate rails_pulse:upgrade && rails db:migrate
 rdoc_options: []
 require_paths:
 - lib