rails_pulse 0.4.2 → 0.5.0.pre.2

data/lib/rails_pulse/scoped_inflector.rb

@@ -0,0 +1,35 @@
+module RailsPulse
+  # Zeitwerk inflector that pins the engine's own file names and defers
+  # everything else to the host's inflector.
+  #
+  # Rails' autoloader inflector is one map for the whole application, keyed
+  # only on a file's basename. Registering "api" => "Api" there would also
+  # rename a host's app/controllers/api/ directory, and a host that declares
+  # `inflect.acronym "API"` would then fail to find API::V1::... Checking the
+  # absolute path keeps the overrides inside the engine.
+  class ScopedInflector
+    # @param fallback [#camelize] the inflector the autoloader had before
+    # @param root [String] absolute path whose files the overrides apply to
+    # @param overrides [Hash{String => String}] basename => constant name
+    def initialize(fallback, root:, overrides:)
+      @fallback = fallback
+      @root = File.join(root.to_s, "")
+      @overrides = overrides
+    end
+
+    def camelize(basename, abspath)
+      if abspath.to_s.start_with?(@root) && @overrides.key?(basename)
+        @overrides[basename]
+      else
+        @fallback.camelize(basename, abspath)
+      end
+    end
+
+    # Hosts register their own overrides with
+    # `Rails.autoloaders.main.inflector.inflect(...)`; those still reach the
+    # inflector they were written for.
+    def inflect(overrides)
+      @fallback.inflect(overrides)
+    end
+  end
+end

data/lib/rails_pulse/statistics.rb

@@ -42,5 +42,32 @@ module RailsPulse
       sum_of_squares = values.sum { |v| (v - mean) ** 2 }
       Math.sqrt(sum_of_squares / (values.size - 1))
     end
+
+    # Sample standard deviation of the union of several groups, from three
+    # sums over the groups that a database can compute in one GROUP BY, so
+    # the groups never have to be loaded. Exact: equal to calculate_stddev
+    # over all the groups' values together. For groups i with count n_i,
+    # mean m_i and sample standard deviation s_i (nil for a group of one):
+    #
+    #   within_sum          = sum of (n_i - 1) * s_i^2
+    #   weighted_mean_sum   = sum of n_i * m_i
+    #   weighted_square_sum = sum of n_i * m_i^2
+    #
+    # @param count [Integer] Total number of values across the groups
+    # @return [Float, nil] The standard deviation or nil if fewer than two values
+    #
+    # @example Groups [10, 20, 30] (n 3, mean 20, s 10) and [100, 400] (n 2, mean 250, s 212.13)
+    #   Statistics.pooled_stddev(count: 5, within_sum: 45_200, weighted_mean_sum: 560, weighted_square_sum: 126_200)
+    #   # => 164.83 (approximately; calculate_stddev of [10, 20, 30, 100, 400])
+    def self.pooled_stddev(count:, within_sum:, weighted_mean_sum:, weighted_square_sum:)
+      return nil if count < 2
+
+      mean = weighted_mean_sum.to_f / count
+      # The between-group term, sum of n_i * (m_i - mean)^2, expanded so it
+      # needs only the two sums. Clamped because that expansion can come out
+      # a hair below zero in floating point when every value is equal.
+      sum_of_squares = within_sum.to_f + [ weighted_square_sum.to_f - (count * mean * mean), 0 ].max
+      Math.sqrt(sum_of_squares / (count - 1))
+    end
   end
 end

data/lib/rails_pulse/subscribers/exception_subscriber.rb

@@ -15,11 +15,11 @@ module RailsPulse
       def process
         return unless RailsPulse.configuration.enabled
         return unless RailsPulse.configuration.track_exceptions
-        return if RequestStore.store[:skip_recording_rails_pulse_activity]
+        return if RailsPulse::Current.skip_recording_rails_pulse_activity
 
         exception = @event.payload[:exception_object]
         return unless exception
-        return if RequestStore.store[:rails_pulse_captured_exception].equal?(exception)
+        return if RailsPulse::Current.rails_pulse_captured_exception.equal?(exception)
 
         RailsPulse::ExceptionCaptureService.capture(
           exception,

data/lib/rails_pulse/subscribers/operation_subscriber.rb

@@ -1,8 +1,6 @@
 module RailsPulse
   module Subscribers
     class OperationSubscriber
-      FRAME_SLICE = 40
-
       class << self
         def subscribe!
           subscribe_sql_queries!
@@ -48,24 +46,12 @@ module RailsPulse
         # not materialise the whole stack: a bare caller_locations on a
         # typical 150-frame controller action costs ~30 µs per call, which is
         # ~15 ms on a 500-query request before the response goes out.
-        # Thread.each_caller_location (Ruby 3.2+) yields frames lazily and
-        # stops at the first match; older Rubies walk the stack in slices.
+        # Thread.each_caller_location yields frames lazily and stops at the
+        # first match.
         def find_app_frame
-          if Thread.respond_to?(:each_caller_location)
-            Thread.each_caller_location do |loc|
-              path = loc.path
-              return path if path&.start_with?(app_path)
-            end
-            return nil
-          end
-
-          offset = 2
-          while (frames = caller_locations(offset, FRAME_SLICE)) && !frames.empty?
-            frames.each do |loc|
-              path = loc.path
-              return path if path&.start_with?(app_path)
-            end
-            offset += FRAME_SLICE
+          Thread.each_caller_location do |loc|
+            path = loc.path
+            return path if path&.start_with?(app_path)
           end
           nil
         end
@@ -100,10 +86,10 @@ module RailsPulse
 
         def capture_operation(event_name, start, finish, payload, operation_type, label_key = nil, extra: {})
           return unless RailsPulse.configuration.enabled
-          return if RequestStore.store[:skip_recording_rails_pulse_activity]
+          return if RailsPulse::Current.skip_recording_rails_pulse_activity
 
-          request_id = RequestStore.store[:rails_pulse_request_id]
-          job_run_id = RequestStore.store[:rails_pulse_job_run_id]
+          request_id = RailsPulse::Current.rails_pulse_request_id
+          job_run_id = RailsPulse::Current.rails_pulse_job_run_id
           return unless request_id || job_run_id
 
           # Skip RailsPulse-related operations to prevent recursion
@@ -149,16 +135,16 @@ module RailsPulse
             occurred_at: Time.zone.at(start)
           }.merge(extra)
 
-          RequestStore.store[:rails_pulse_operations] ||= []
-          RequestStore.store[:rails_pulse_operations] << operation_data
+          RailsPulse::Current.rails_pulse_operations ||= []
+          RailsPulse::Current.rails_pulse_operations << operation_data
         end
 
         def store_operation(label:, operation_type:, start:, finish:, codebase_location:)
           return unless RailsPulse.configuration.enabled
-          return if RequestStore.store[:skip_recording_rails_pulse_activity]
+          return if RailsPulse::Current.skip_recording_rails_pulse_activity
 
-          request_id = RequestStore.store[:rails_pulse_request_id]
-          job_run_id = RequestStore.store[:rails_pulse_job_run_id]
+          request_id = RailsPulse::Current.rails_pulse_request_id
+          job_run_id = RailsPulse::Current.rails_pulse_job_run_id
           return unless request_id || job_run_id
 
           operation_data = {
@@ -172,8 +158,8 @@ module RailsPulse
             occurred_at: Time.zone.at(start)
           }
 
-          RequestStore.store[:rails_pulse_operations] ||= []
-          RequestStore.store[:rails_pulse_operations] << operation_data
+          RailsPulse::Current.rails_pulse_operations ||= []
+          RailsPulse::Current.rails_pulse_operations << operation_data
         end
 
         def subscribe_sql_queries!

data/lib/rails_pulse/tasks/status_reporter.rb

@@ -11,7 +11,20 @@ module RailsPulse
     # Anything that needs action is repeated in a closing "Action needed"
     # list, and `report` returns false in that case so release scripts can
     # stop on it.
+    #
+    # Below that, "Suggestions" covers how the install is run rather than
+    # whether it is current: SummaryJob or CleanupJob not running, hourly
+    # summaries kept too briefly, jobs not tracked. Development and test
+    # environments rarely schedule either job, so these never change the
+    # exit status.
     class StatusReporter
+      # Hourly summaries back deployment comparisons and hour-precise change
+      # points; below a week, last week's deploys can no longer be compared.
+      RECOMMENDED_HOURLY_RETENTION = 7.days
+
+      # CleanupJob is meant to run daily.
+      CLEANUP_STALE_AFTER = 2.days
+
       attr_reader :output, :config
 
       def self.report(output: $stdout)
@@ -22,6 +35,7 @@ module RailsPulse
         @output = output
         @config = RailsPulse.configuration
         @actions = []
+        @suggestions = []
       end
 
       # Returns true when nothing needs attention.
@@ -35,8 +49,14 @@ module RailsPulse
         print_route_backfill
         print_initializer
         print_tracking
+        print_writer
         print_summaries
+        print_retention
+        print_cleanup
+        print_jobs
+        print_cloud
         print_actions
+        print_suggestions
 
         @actions.empty?
       end
@@ -47,6 +67,10 @@ module RailsPulse
         @actions << text
       end
 
+      def suggest(text)
+        @suggestions << text
+      end
+
       # -- sections -----------------------------------------------------------
 
       def print_database
@@ -149,21 +173,185 @@ module RailsPulse
         output.puts "Tracking:   enabled=#{config.enabled} requests=#{config.enabled} jobs=#{config.track_jobs} " \
                     "exceptions=#{config.track_exceptions} async=#{config.async}"
         output.puts "Dashboard:  mount_dashboard=#{config.mount_dashboard} authentication=#{auth}"
+        output.puts "API:        api_token #{config.api_token.to_s.empty? ? 'NOT set (rails-pulse CLI and MCP server refuse every request)' : 'set'}, " \
+                    "deployment_token #{config.deployment_token.to_s.empty? ? 'NOT set (POST deployments refuses every request; the rake tasks still work)' : 'set'}"
+      end
+
+      # This process has no writer of its own; read every process's heartbeats
+      def print_writer
+        unless RailsPulse::Event.table_available?
+          output.puts "Writer:     (skipped — events table missing, schema is behind)"
+          return
+        end
+
+        summary = RailsPulse::WriterHeartbeat.summary
+        if summary[:last_sampled_at].nil?
+          output.puts "Writer:     no heartbeats yet (they start when a process with config.async tracks its first request)"
+          return
+        end
+
+        dropped = summary[:dropped].to_i
+        output.puts "Writer:     #{summary[:processes]} live process(es), queue depth #{summary[:queue_depth]}/#{summary[:queue_size]}, " \
+                    "#{dropped} request(s) dropped in the last hour, last heartbeat #{time_ago(summary[:last_sampled_at])}"
+        return if dropped.zero?
+
+        action "The writer dropped #{dropped} request(s) in the last hour. Raise config.async_queue_size or check database latency."
+      rescue StandardError => e
+        output.puts "Writer:     could not check (#{e.class}: #{e.message})"
       end
 
       def print_summaries
         last = RailsPulse::Summary.maximum(:updated_at)
         if last.nil?
           output.puts "Summaries:  none generated yet (schedule RailsPulse::SummaryJob hourly; backfill with rails rails_pulse:backfill_summaries)"
+          suggest "Schedule RailsPulse::SummaryJob hourly (see the README); the dashboard, the API and cleanup all read its summaries."
         elsif last < 2.hours.ago
           output.puts "Summaries:  last generated #{time_ago(last)} — stale (is RailsPulse::SummaryJob scheduled?)"
+          suggest "RailsPulse::SummaryJob last ran #{time_ago(last)}; check it is scheduled hourly and the worker is running."
         else
           output.puts "Summaries:  last generated #{time_ago(last)}"
         end
+        print_hourly_coverage
       rescue StandardError => e
         output.puts "Summaries:  could not check (#{e.class}: #{e.message})"
       end
 
+      # Hours SummaryJob skipped inside the hourly retention window. It writes
+      # the overall request row for every hour, even an empty one, so a gap
+      # between the oldest and newest row is an hour it did not run.
+      def print_hourly_coverage
+        hours = RailsPulse::Summary.overall_requests
+          .where(period_type: "hour")
+          .where(period_start: config.hourly_summary_retention.ago..)
+          .distinct
+          .pluck(:period_start)
+        return if hours.empty?
+
+        span = ((hours.max - hours.min) / 1.hour).round + 1
+        missing = span - hours.size
+        if missing.zero?
+          output.puts "            hourly: #{hours.size} consecutive hour(s) summarized"
+        else
+          output.puts "            hourly: #{hours.size} of the last #{span} hours summarized, #{missing} missing"
+          suggest "RailsPulse::SummaryJob skipped #{missing} hour(s) in the last #{span}. Check its schedule; " \
+                  "rails rails_pulse:backfill_summaries fills the gaps."
+        end
+      end
+
+      def print_retention
+        hourly = config.hourly_summary_retention
+        raw = config.full_retention_period ? days(config.full_retention_period) : "no age limit"
+        output.puts "Retention:  raw data #{raw}, hourly summaries #{days(hourly)}"
+        return if hourly >= RECOMMENDED_HOURLY_RETENTION
+
+        suggest "Keep hourly summaries for #{days(RECOMMENDED_HOURLY_RETENTION)}: deployment comparisons and hour-precise " \
+                "change points read them, and at #{days(hourly)} a deploy from last week can no longer be compared. " \
+                "Add config.hourly_summary_retention = #{RECOMMENDED_HOURLY_RETENTION.in_days.to_i}.days to config/initializers/rails_pulse.rb."
+      end
+
+      def print_cleanup
+        unless config.archiving_enabled
+          output.puts "Cleanup:    off (config.archiving_enabled = false); nothing is pruned"
+          return
+        end
+        unless RailsPulse::Event.table_available?
+          output.puts "Cleanup:    (skipped — events table missing, schema is behind)"
+          return
+        end
+
+        run = RailsPulse::CleanupRun.latest
+        if run.nil?
+          print_cleanup_never_run
+        elsif run.outcome == "failed"
+          stages = run.metadata_hash["failed_stages"].to_a.join(", ")
+          output.puts "Cleanup:    last ran #{time_ago(run.occurred_at)} and failed (#{stages})"
+          suggest "The last cleanup failed in #{stages}; the log has the error. Run rails rails_pulse:cleanup to retry."
+        elsif run.occurred_at < CLEANUP_STALE_AFTER.ago
+          output.puts "Cleanup:    last ran #{time_ago(run.occurred_at)} — stale (is RailsPulse::CleanupJob scheduled?)"
+          suggest "Cleanup last ran #{time_ago(run.occurred_at)}; schedule RailsPulse::CleanupJob daily so retention is enforced."
+        else
+          output.puts "Cleanup:    last ran #{time_ago(run.occurred_at)}, #{run.value.to_i} row(s) deleted"
+        end
+      rescue StandardError => e
+        output.puts "Cleanup:    could not check (#{e.class}: #{e.message})"
+      end
+
+      # No run recorded is only a problem once there is something to prune.
+      def print_cleanup_never_run
+        overdue = config.full_retention_period &&
+          RailsPulse::Request.where(occurred_at: ...(config.full_retention_period + 1.day).ago).exists?
+
+        if overdue
+          output.puts "Cleanup:    no run recorded, and requests older than #{days(config.full_retention_period)} are still held"
+          suggest "Schedule RailsPulse::CleanupJob daily (see the README); data past retention is not being pruned."
+        else
+          output.puts "Cleanup:    no run recorded yet (schedule RailsPulse::CleanupJob daily)"
+        end
+      end
+
+      def print_jobs
+        unless config.track_jobs
+          output.puts "Jobs:       not tracked"
+          suggest "Track background jobs to see failures and slow jobs alongside requests: " \
+                  "config.track_jobs = true in config/initializers/rails_pulse.rb."
+          return
+        end
+
+        unless RailsPulse::SchemaCheck.current?
+          output.puts "Jobs:       tracked (count skipped — schema is behind)"
+          return
+        end
+
+        count = RailsPulse::Job.count
+        output.puts(count.zero? ? "Jobs:       tracked, none recorded yet" : "Jobs:       tracked, #{count} job class(es) recorded")
+      rescue StandardError => e
+        output.puts "Jobs:       could not check (#{e.class}: #{e.message})"
+      end
+
+      # Reported, never an action: a Cloud outage or a refused key must not
+      # fail a deploy that runs this task.
+      def print_cloud
+        cloud = config.cloud
+        unless cloud.enabled?
+          output.puts "Cloud:      off (set config.cloud.api_key and config.cloud.application to send to Rails Pulse Cloud)"
+          return
+        end
+
+        unless RailsPulse::Cloud::Installation.table_exists? && RailsPulse::Cloud::BufferedBatch.table_exists?
+          output.puts "Cloud:      configured, but its tables are not installed, so nothing is sent"
+          suggest "Install the Rails Pulse Cloud tables: rails generate rails_pulse:install_cloud, then #{migrate_command}."
+          return
+        end
+
+        installation = RailsPulse::Cloud::Installation.existing
+        buffered = RailsPulse::Cloud::BufferedBatch.count
+        buffer = "#{buffered} batch(es) buffered (#{(RailsPulse::Cloud::BufferedBatch.sum(:byte_size) / 1024.0).round(1)} KB)"
+        output.puts "Cloud:      #{cloud.application} (#{cloud.environment}) to #{cloud.url}: #{cloud_state(installation)}; #{buffer}"
+        return suggest_cloud_health_job if installation.nil?
+
+        output.puts "            last error #{time_ago(installation.last_error_at)}: #{installation.last_error}" if installation.last_error.present?
+        suggest installation.pause_reason if installation.paused?
+        if installation.contract_deprecated_on.present?
+          suggest "Rails Pulse Cloud stops accepting this gem's sync contract on #{installation.contract_deprecated_on}; upgrade rails_pulse before then."
+        end
+        suggest_cloud_health_job if installation.last_health_at.nil? || installation.last_health_at < 5.minutes.ago
+      rescue StandardError => e
+        output.puts "Cloud:      could not check (#{e.class}: #{e.message})"
+      end
+
+      def cloud_state(installation)
+        return "not synced yet" if installation.nil?
+        return "paused until #{installation.paused_until.utc.iso8601}" if installation.paused?
+        return "connected, last accepted #{time_ago(installation.last_success_at)}" if installation.last_success_at
+
+        "nothing accepted yet"
+      end
+
+      def suggest_cloud_health_job
+        suggest "Schedule RailsPulse::CloudHealthJob every minute (see config/initializers/rails_pulse.rb). It sends health " \
+                "updates and retries buffered batches; the hourly sync follows RailsPulse::SummaryJob on its own."
+      end
+
       def print_actions
         output.puts
         if @actions.empty?
@@ -174,6 +362,14 @@ module RailsPulse
         end
       end
 
+      def print_suggestions
+        return if @suggestions.empty?
+
+        output.puts
+        output.puts "Suggestions:"
+        @suggestions.each { |text| output.puts "  - #{text}" }
+      end
+
       # -- helpers ------------------------------------------------------------
 
       def gem_migrations_not_in_host
@@ -204,6 +400,11 @@ module RailsPulse
         config.connects_to.present? ? "rails db:migrate:rails_pulse" : "rails db:migrate"
       end
 
+      def days(duration)
+        value = (duration / 1.day.to_f).round(1)
+        "#{value == value.to_i ? value.to_i : value} day#{'s' unless value == 1}"
+      end
+
       def time_ago(time)
         seconds = (Time.current - time).to_i
         return "#{seconds}s ago" if seconds < 60

data/lib/rails_pulse/tracker.rb

@@ -1,3 +1,5 @@
+require "socket"
+
 module RailsPulse
   # Persists the data RequestCollector gathers for one request: the route,
   # the request row and its operations.
@@ -12,6 +14,10 @@ module RailsPulse
   #
   # With `config.async = false`, or whenever the pool's connection is pinned
   # to the current thread (transactional tests), writes happen inline.
+  #
+  # Once a minute the writer also records a WriterHeartbeat event (queue
+  # depth, drops since the last sample) so the dashboard and rails_pulse:status
+  # can see every process's writer, not just the one serving the page.
   module Tracker
     # PG::Connection::PQTRANS_INERROR (libpq enum value 3) — the connection's transaction
     # was aborted by a DB-level error and no ROLLBACK has been issued yet. Defined as a
@@ -20,11 +26,16 @@ module RailsPulse
     PG_TRANSACTION_INERROR = 3
     private_constant :PG_TRANSACTION_INERROR
 
+    # How often record_heartbeat prunes stale rows, rather than every heartbeat
+    PRUNE_INTERVAL = 1.hour
+    private_constant :PRUNE_INTERVAL
+
     # The background writer: one thread, one bounded queue, one connection.
     class Writer
       BATCH_SIZE = 50
       DROP_LOG_INTERVAL = 60 # seconds between "queue full" log lines
       SHUTDOWN_TIMEOUT = 5   # seconds to wait for the queue to drain at exit
+      HEARTBEAT_INTERVAL = 60 # seconds between WriterHeartbeat samples
 
       attr_reader :queue_size, :dropped
 
@@ -38,6 +49,8 @@ module RailsPulse
         @dropped = 0
         @drop_window_count = 0
         @drop_window_started = nil
+        @dropped_at_last_heartbeat = 0
+        @last_heartbeat_at = nil
         @exit_hook_installed = false
       end
 
@@ -59,6 +72,15 @@ module RailsPulse
         @thread&.alive? || false
       end
 
+      # Taking a sample resets the drop count for the next window
+      def take_heartbeat_sample
+        @mutex.synchronize do
+          since_last = @dropped - @dropped_at_last_heartbeat
+          @dropped_at_last_heartbeat = @dropped
+          { queue_size: @queue_size, queue_depth: @queue.size, dropped: since_last, dropped_total: @dropped }
+        end
+      end
+
       # Persist everything queued so far on the calling thread. Used by
       # shutdown when the writer thread is gone, and by tests.
       def drain
@@ -110,11 +132,17 @@ module RailsPulse
       end
 
       def run
-        # pop returns nil once the queue is closed and empty.
-        while (first = @queue.pop)
-          batch = [ first ]
-          batch << @queue.pop(true) while batch.size < BATCH_SIZE && !@queue.empty?
-          Tracker.perform_tracking_batch(batch)
+        # pop returns nil both on timeout and once the queue is closed and empty
+        loop do
+          first = @queue.pop(timeout: HEARTBEAT_INTERVAL)
+          if first.nil?
+            break if @queue.closed?
+          else
+            batch = [ first ]
+            batch << @queue.pop(true) while batch.size < BATCH_SIZE && !@queue.empty?
+            Tracker.perform_tracking_batch(batch)
+          end
+          heartbeat_if_due
         end
       rescue => e
         # perform_tracking_batch rescues its own errors, so this is a bug in the
@@ -122,6 +150,14 @@ module RailsPulse
         RailsPulse.logger.error("Rails Pulse writer thread stopped: #{e.class} - #{e.message}")
       end
 
+      def heartbeat_if_due
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return if @last_heartbeat_at && now - @last_heartbeat_at < HEARTBEAT_INTERVAL
+
+        @last_heartbeat_at = now
+        Tracker.record_heartbeat(take_heartbeat_sample)
+      end
+
       def install_exit_hook
         return if @exit_hook_installed
 
@@ -148,7 +184,7 @@ module RailsPulse
 
     class << self
       def track_request(data)
-        return if RequestStore.store[:skip_recording_rails_pulse_activity]
+        return if RailsPulse::Current.skip_recording_rails_pulse_activity
         return unless RailsPulse::SchemaCheck.tracking_allowed?
 
         if RailsPulse.configuration.async && !connection_shared_across_threads?
@@ -175,6 +211,27 @@ module RailsPulse
       # Discard the writer, queue contents included. For tests.
       def reset_writer!
         @writer_mutex.synchronize { @writer = nil }
+        @last_heartbeat_prune_at = nil
+      end
+
+      # table_exists? has to run inside with_writer_connection too, or the bare
+      # call pins a connection on this thread that nothing would ever release
+      def record_heartbeat(sample)
+        with_writer_connection do
+          next false unless RailsPulse::Event.table_available?
+
+          RailsPulse::WriterHeartbeat.record!(hostname: hostname, pid: Process.pid,
+                                              host_label: RailsPulse.configuration.cloud.host_label, **sample)
+          prune_heartbeats_if_due
+          true
+        end
+      rescue => e
+        RailsPulse.logger.debug("Rails Pulse writer heartbeat failed: #{e.class} - #{e.message}")
+        false
+      end
+
+      def hostname
+        @hostname ||= Socket.gethostname
       end
 
       def healthy?
@@ -230,6 +287,14 @@ module RailsPulse
         end
       end
 
+      def prune_heartbeats_if_due
+        now = Time.current
+        return if @last_heartbeat_prune_at && now - @last_heartbeat_prune_at < PRUNE_INTERVAL
+
+        @last_heartbeat_prune_at = now
+        RailsPulse::WriterHeartbeat.prune!
+      end
+
       def perform_tracking(data)
         with_writer_connection do
           request = persist_request(data)
@@ -245,11 +310,11 @@ module RailsPulse
       def with_writer_connection
         RailsPulse::ApplicationRecord.connection_pool.with_connection do |conn|
           clear_aborted_transaction(conn)
-          RequestStore.store[:skip_recording_rails_pulse_activity] = true
+          RailsPulse::Current.skip_recording_rails_pulse_activity = true
           yield
         end
       ensure
-        RequestStore.store[:skip_recording_rails_pulse_activity] = false
+        RailsPulse::Current.skip_recording_rails_pulse_activity = false
       end
 
       def persist_request(data)
@@ -280,14 +345,11 @@ module RailsPulse
       # connection to every thread that asks for one. A background writer would
       # then interleave its statements with the test's on a single socket, which
       # PostgreSQL reports as "message type 0x5a arrived from server while idle".
-      # Rails 7.2+ records the pin in the pool's @pinned_connection; 7.1 sets a
-      # @lock_thread on the pool instead. Neither is public API, so read both
-      # defensively and treat any failure as "not shared".
+      # Rails records the pin in the pool's @pinned_connection. That is not
+      # public API, so read it defensively and treat any failure as "not shared".
       def connection_shared_across_threads?
         pool = RailsPulse::ApplicationRecord.connection_pool
-        return true if pool.instance_variable_get(:@pinned_connection)
-
-        pool.instance_variable_get(:@lock_thread) ? true : false
+        pool.instance_variable_get(:@pinned_connection) ? true : false
       rescue StandardError
         false
       end

data/lib/rails_pulse/version.rb

@@ -1,3 +1,3 @@
 module RailsPulse
-  VERSION = "0.4.2"
+  VERSION = "0.5.0.pre.2"
 end

data/lib/rails_pulse.rb

@@ -22,10 +22,6 @@ module RailsPulse
       @nav_items || []
     end
 
-    def pro?
-      defined?(RailsPulse::Pro) == "constant"
-    end
-
     def configure
       self.configuration ||= Configuration.new
       yield(configuration)

data/lib/tasks/rails_pulse.rake

@@ -11,6 +11,12 @@ namespace :db do
         if schema_file.exist?
           load schema_file
           puts "Rails Pulse schema loaded successfully"
+          # Present only when the app ran rails_pulse:install_cloud.
+          cloud_schema_file = Rails.root.join("db/rails_pulse_cloud_schema.rb")
+          if cloud_schema_file.exist?
+            load cloud_schema_file
+            puts "Rails Pulse Cloud schema loaded successfully"
+          end
           # Record any copied migrations as already applied so they don't show as
           # pending after a fresh schema load. The schema file creates all tables and
           # columns directly, so the incremental migrations are logically already done.

data/lib/tasks/rails_pulse_tasks.rake

@@ -28,6 +28,13 @@ namespace :rails_pulse do
     exit 1 unless RailsPulse::Tasks::StatusReporter.report
   end
 
+  namespace :cloud do
+    desc "Prints exactly what the next Rails Pulse Cloud sync would send, without sending anything."
+    task preview: :environment do
+      print RailsPulse::Cloud::Preview.new.render
+    end
+  end
+
   desc "Migrate existing routes: backfill controller actions, normalize paths, consolidate multi-verb routes."
   task migrate_routes: :environment do
     ca_results = RailsPulse::RouteControllerActionBackfiller.call