rails_pulse 0.4.0.pre.4 → 0.4.0

data/lib/rails_pulse/engine.rb

@@ -7,50 +7,11 @@ require "rails_pulse/subscribers/operation_subscriber"
 require "rails_pulse/subscribers/exception_subscriber"
 require "rails_pulse/job_run_collector"
 require "rails_pulse/active_job_extensions"
-require "rails_pulse/extensions/active_record"
 require "request_store"
 require "rack/static"
 require "ransack"
 
 module RailsPulse
-  # Manually load services to avoid Zeitwerk autoload issues
-  autoload :SqlQueryNormalizer, File.expand_path("../../app/services/rails_pulse/sql_query_normalizer", __dir__)
-  autoload :SummaryService, File.expand_path("../../app/services/rails_pulse/summary_service", __dir__)
-  autoload :QueryAnalysisService, File.expand_path("../../app/services/rails_pulse/query_analysis_service", __dir__)
-  autoload :TagFilterService, File.expand_path("../../app/services/rails_pulse/tag_filter_service", __dir__)
-  autoload :ExceptionCaptureService, File.expand_path("../../app/services/rails_pulse/exception_capture_service", __dir__)
-  autoload :ExceptionMessageSanitizer, File.expand_path("../../app/services/rails_pulse/exception_message_sanitizer", __dir__)
-  autoload :OperationSuggestions, File.expand_path("../../app/services/rails_pulse/operation_suggestions", __dir__)
-  autoload :RoutePathNormalizer,             File.expand_path("../../app/services/rails_pulse/route_path_normalizer", __dir__)
-  autoload :RouteRecognizer,                 File.expand_path("../../app/services/rails_pulse/route_recognizer", __dir__)
-  autoload :RouteMerger,                     File.expand_path("../../app/services/rails_pulse/route_merger", __dir__)
-  autoload :RouteMigrator,                   File.expand_path("../../app/services/rails_pulse/route_migrator", __dir__)
-  autoload :RouteControllerActionBackfiller, File.expand_path("../../app/services/rails_pulse/route_controller_action_backfiller", __dir__)
-
-  # Historical comparison operations. This namespace is the read-only interface
-  # for "what changed?" — everything else in the codebase, and anything built on
-  # top of Rails Pulse later, should ask these rather than querying summaries
-  # directly.
-  module Operations
-    autoload :ChangePoint, File.expand_path("../../app/services/rails_pulse/operations/change_point", __dir__)
-    autoload :Compare,     File.expand_path("../../app/services/rails_pulse/operations/compare", __dir__)
-    autoload :Comparison,  File.expand_path("../../app/services/rails_pulse/operations/comparison", __dir__)
-    autoload :Metric,      File.expand_path("../../app/services/rails_pulse/operations/metric", __dir__)
-    autoload :Series,      File.expand_path("../../app/services/rails_pulse/operations/series", __dir__)
-    autoload :Subject,     File.expand_path("../../app/services/rails_pulse/operations/subject", __dir__)
-  end
-
-  # Analysis services
-  module Analysis
-    autoload :BacktraceAnalyzer, File.expand_path("../../app/services/rails_pulse/analysis/backtrace_analyzer", __dir__)
-    autoload :BaseAnalyzer, File.expand_path("../../app/services/rails_pulse/analysis/base_analyzer", __dir__)
-    autoload :ExplainPlanAnalyzer, File.expand_path("../../app/services/rails_pulse/analysis/explain_plan_analyzer", __dir__)
-    autoload :IndexRecommendationEngine, File.expand_path("../../app/services/rails_pulse/analysis/index_recommendation_engine", __dir__)
-    autoload :NPlusOneDetector, File.expand_path("../../app/services/rails_pulse/analysis/n_plus_one_detector", __dir__)
-    autoload :QueryCharacteristicsAnalyzer, File.expand_path("../../app/services/rails_pulse/analysis/query_characteristics_analyzer", __dir__)
-    autoload :SuggestionGenerator, File.expand_path("../../app/services/rails_pulse/analysis/suggestion_generator", __dir__)
-  end
-
   # Installer services
   module Installers
     autoload :MigrationInstaller, File.expand_path("installers/migration_installer", __dir__)
@@ -72,9 +33,20 @@ module RailsPulse
   class Engine < ::Rails::Engine
     isolate_namespace RailsPulse
 
-    # Tell Zeitwerk to ignore services directory since we manually autoload them
-    initializer "rails_pulse.ignore_services", before: :set_autoload_paths do
-      Rails.autoloaders.main.ignore(root.join("app/services")) if Rails.respond_to?(:autoloaders)
+    # Zeitwerk derives constant names from file names through the host's
+    # inflections. A host that declares `inflect.acronym "SQL"` (or "CSP")
+    # would expect sql_query_normalizer.rb to define SQLQueryNormalizer and
+    # fail to eager load in production. Pin the names of the files whose
+    # basenames contain a common acronym so the gem's constants do not depend
+    # on the host's inflections.
+    ACRONYM_SAFE_INFLECTIONS = {
+      "sql_query_normalizer" => "SqlQueryNormalizer",
+      "csp_helper" => "CspHelper",
+      "csp_test_controller" => "CspTestController"
+    }.freeze
+
+    initializer "rails_pulse.inflections", before: :set_autoload_paths do
+      Rails.autoloaders.main.inflector.inflect(ACRONYM_SAFE_INFLECTIONS) if Rails.respond_to?(:autoloaders)
     end
 
     # Load Rake tasks

data/lib/rails_pulse/middleware/request_collector.rb

@@ -36,10 +36,9 @@ module RailsPulse
         status, headers, response = @app.call(env)
         duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
 
-        # Collect all tracking data
-        # Deep copy operations array to prevent race condition in async mode
+        # Collect all tracking data. Operations are copied because the writer
+        # thread annotates them (N+1 detection) after this request has moved on.
         operations = RequestStore.store[:rails_pulse_operations] || []
-        detect_n_plus_one(operations)
         path_params = env["action_dispatch.request.path_parameters"] || {}
         controller_action = [ path_params[:controller], path_params[:action] ].compact.join("#").presence
         tracking_data = {
@@ -86,20 +85,6 @@ module RailsPulse
         nil
       end
 
-      def detect_n_plus_one(operations)
-        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[:actual_sql].to_s) }
-        groups.each do |normalized_sql, ops|
-          next if ops.size < 2
-          ops.each do |op|
-            op[:repeated_query_group] = normalized_sql
-            op[:repetition_count] = ops.size
-          end
-        end
-      end
-
       def should_ignore_route?(req)
         # Get ignored routes from configuration
         ignored_routes = RailsPulse.configuration.ignored_routes || []

data/lib/rails_pulse/standalone.rb

@@ -43,6 +43,18 @@ module RailsPulse
     # prepended override stays but defers to the mount prefix again.
     def exit_standalone!
       @standalone = false
+      @host_authentication_ignored_noted = false
+    end
+
+    # ApplicationController logs a one-line notice when the standalone
+    # dashboard ignores the host's authentication_method / authorize hooks.
+    # Returns true the first time it is called in this process (log now),
+    # false afterwards. Process-wide on purpose: a per-controller flag
+    # repeats the notice for every engine controller a visitor reaches.
+    def note_host_authentication_ignored!
+      return false if @host_authentication_ignored_noted
+
+      @host_authentication_ignored_noted = true
     end
   end
 

data/lib/rails_pulse/subscribers/operation_subscriber.rb

@@ -1,6 +1,8 @@
 module RailsPulse
   module Subscribers
     class OperationSubscriber
+      FRAME_SLICE = 40
+
       class << self
         def subscribe!
           subscribe_sql_queries!
@@ -40,10 +42,30 @@ module RailsPulse
           @app_path ||= Rails.root.join("app").to_s
         end
 
+        # The first frame under the host's app/ directory, or nil.
+        #
+        # This runs for every SQL, template, cache and HTTP event, so it must
+        # 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.
         def find_app_frame
-          caller_locations.each do |loc|
-            path = loc.absolute_path || loc.path
-            return path if path && path.start_with?(app_path)
+          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
           end
           nil
         end
@@ -133,6 +155,7 @@ module RailsPulse
 
         def store_operation(label:, operation_type:, start:, finish:, codebase_location:)
           return unless RailsPulse.configuration.enabled
+          return if RequestStore.store[:skip_recording_rails_pulse_activity]
 
           request_id = RequestStore.store[:rails_pulse_request_id]
           job_run_id = RequestStore.store[:rails_pulse_job_run_id]
@@ -157,6 +180,10 @@ module RailsPulse
           ActiveSupport::Notifications.subscribe "sql.active_record" do |name, start, finish, id, payload|
             begin
               next if payload[:name] == "SCHEMA"
+              # Cached reads never hit the database, so there's nothing to time or
+              # analyze for N+1s — skip before the stack walk in capture_operation.
+              next if payload[:cached]
+              next if query_ignored?(payload[:sql])
               capture_operation(name, start, finish, payload, "sql", :sql, extra: { row_count: payload[:row_count] })
             rescue => e
               RailsPulse.logger.error "Exception in SQL subscriber: #{e.class} - #{e.message}"
@@ -164,6 +191,21 @@ module RailsPulse
           end
         end
 
+        def query_ignored?(sql)
+          return false if sql.nil?
+
+          RailsPulse.configuration.ignored_queries.any? do |pattern|
+            case pattern
+            when String
+              pattern == sql
+            when Regexp
+              pattern.match?(sql)
+            else
+              false
+            end
+          end
+        end
+
         def subscribe_controller_actions!
           ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
             begin

data/lib/rails_pulse/tracker.rb

@@ -1,4 +1,17 @@
 module RailsPulse
+  # Persists the data RequestCollector gathers for one request: the route,
+  # the request row and its operations.
+  #
+  # With `config.async` (the default) the middleware hands the payload to a
+  # single per-process Writer thread through a bounded queue and returns
+  # immediately. The writer drains the queue in batches on one connection
+  # checked out of the Rails Pulse pool, so tracking never holds more than one
+  # of the host's connections and a traffic burst never fans out into a thread
+  # per request. When the queue is full the payload is dropped and counted;
+  # losing a sample is the intended trade for never slowing the host down.
+  #
+  # With `config.async = false`, or whenever the pool's connection is pinned
+  # to the current thread (transactional tests), writes happen inline.
   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
@@ -7,22 +20,163 @@ module RailsPulse
     PG_TRANSACTION_INERROR = 3
     private_constant :PG_TRANSACTION_INERROR
 
+    # 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
+
+      attr_reader :queue_size, :dropped
+
+      def initialize(queue_size:, auto_start: true)
+        @queue_size = queue_size
+        @auto_start = auto_start
+        @mutex = Mutex.new
+        @queue = SizedQueue.new(queue_size)
+        @thread = nil
+        @pid = Process.pid
+        @dropped = 0
+        @drop_window_count = 0
+        @drop_window_started = nil
+        @exit_hook_installed = false
+      end
+
+      # Never blocks. Returns false (and counts a drop) when the queue is full.
+      def enqueue(data)
+        ensure_thread!
+        @queue.push(data, true)
+        true
+      rescue ThreadError, ClosedQueueError
+        record_drop
+        false
+      end
+
+      def size
+        @queue.size
+      end
+
+      def running?
+        @thread&.alive? || false
+      end
+
+      # Persist everything queued so far on the calling thread. Used by
+      # shutdown when the writer thread is gone, and by tests.
+      def drain
+        batch = []
+        batch << @queue.pop(true) while !@queue.empty?
+        Tracker.perform_tracking_batch(batch) unless batch.empty?
+        batch.size
+      rescue ThreadError
+        batch.size
+      end
+
+      # Stop accepting work, let the thread finish what is queued (up to
+      # `timeout` seconds), then persist any remainder inline. Safe to call
+      # more than once; the next enqueue starts a fresh queue and thread.
+      def shutdown(timeout: SHUTDOWN_TIMEOUT)
+        thread = nil
+        @mutex.synchronize do
+          @queue.close
+          thread = @thread
+          @thread = nil
+        end
+        thread.join(timeout) if thread&.alive?
+        thread.kill if thread&.alive?
+        drain
+      end
+
+      private
+
+      def ensure_thread!
+        return unless @auto_start
+        return if @thread&.alive? && @pid == Process.pid
+
+        @mutex.synchronize do
+          # A forked child inherits the parent's queue contents and a thread
+          # that no longer exists. Start clean; the parent still owns its data.
+          if @pid != Process.pid
+            @pid = Process.pid
+            @queue = SizedQueue.new(@queue_size)
+          elsif @queue.closed?
+            @queue = SizedQueue.new(@queue_size)
+          end
+
+          next if @thread&.alive?
+
+          @thread = Thread.new { run }
+          @thread&.name = "rails_pulse_writer"
+          install_exit_hook
+        end
+      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)
+        end
+      rescue => e
+        # perform_tracking_batch rescues its own errors, so this is a bug in the
+        # loop itself. Report it; the next enqueue starts a fresh thread.
+        RailsPulse.logger.error("Rails Pulse writer thread stopped: #{e.class} - #{e.message}")
+      end
+
+      def install_exit_hook
+        return if @exit_hook_installed
+
+        @exit_hook_installed = true
+        at_exit { shutdown }
+      end
+
+      def record_drop
+        @mutex.synchronize do
+          @dropped += 1
+          @drop_window_count += 1
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          next if @drop_window_started && now - @drop_window_started < DROP_LOG_INTERVAL
+
+          RailsPulse.logger.warn(
+            "Rails Pulse writer queue is full (#{@queue_size}); dropped #{@drop_window_count} " \
+            "request(s) since the last notice. Raise config.async_queue_size or check database latency."
+          )
+          @drop_window_started = now
+          @drop_window_count = 0
+        end
+      end
+    end
+
     class << self
       def track_request(data)
         return if RequestStore.store[:skip_recording_rails_pulse_activity]
         return unless RailsPulse::SchemaCheck.tracking_allowed?
 
         if RailsPulse.configuration.async && !connection_shared_across_threads?
-          Thread.new do
-            perform_tracking(data)
-          rescue => e
-            log_error(e)
-          end
+          writer.enqueue(data)
+          nil
         else
           perform_tracking(data)
         end
       end
 
+      # Queue depth and lifetime drop count of the background writer, for
+      # health output. Zeros before the writer has been used.
+      def stats
+        current = @writer
+        { queue_size: current&.size || 0, dropped: current&.dropped || 0, running: current&.running? || false }
+      end
+
+      # Persist everything queued so far and stop the writer thread. The next
+      # tracked request starts it again.
+      def flush!
+        @writer&.shutdown
+      end
+
+      # Discard the writer, queue contents included. For tests.
+      def reset_writer!
+        @writer_mutex.synchronize { @writer = nil }
+      end
+
       def healthy?
         RailsPulse::ApplicationRecord.connection.execute("SELECT 1")
         true
@@ -30,39 +184,98 @@ module RailsPulse
         false
       end
 
-      private
+      # Marks SQL operations that repeat within one request with the
+      # normalized statement they share and how many times it ran. Runs on the
+      # writer so the normalisation cost stays off the request thread.
+      def detect_n_plus_one(operations)
+        sql_ops = operations.select { |op| op[:operation_type] == "sql" }
+        return if sql_ops.size < 2
 
-      def perform_tracking(data)
-        RailsPulse::ApplicationRecord.connection_pool.with_connection do |conn|
-          clear_aborted_transaction(conn)
-          RequestStore.store[:skip_recording_rails_pulse_activity] = true
+        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|
+            op[:repeated_query_group] = normalized_sql
+            op[:repetition_count] = ops.size
+          end
+        end
+      end
 
-          route = RailsPulse::Route.find_or_create_for_request(data[:method], data[:path], controller_action: data[:controller_action])
-
-          request = RailsPulse::Request.create!(
-            route: route,
-            method: data[:method],
-            duration: data[:duration],
-            status: data[:status],
-            is_error: data[:is_error],
-            request_uuid: data[:request_uuid],
-            controller_action: data[:controller_action],
-            occurred_at: data[:occurred_at],
-            response_size_bytes: data[:response_size_bytes]
-          )
+      # One connection checkout for the whole batch. A request that fails to
+      # persist is logged and skipped; the others in the batch still land, and
+      # their operations go in with a single insert.
+      def perform_tracking_batch(batch)
+        with_writer_connection do
+          persisted = batch.filter_map do |data|
+            request = persist_request(data)
+            [ request, data[:operations] ]
+          rescue => e
+            log_error(e)
+            nil
+          end
+
+          rows = persisted.flat_map { |request, operations| operation_rows(request, operations) }
+          RailsPulse::Operation.persist_bulk(rows, {}) unless rows.empty?
+        end
+      rescue => e
+        log_error(e)
+        nil
+      end
 
-          ops = data[:operations] || []
-          RailsPulse::Operation.persist_bulk(ops, request_id: request.id)
+      private
 
+      def writer
+        @writer_mutex.synchronize do
+          @writer ||= Writer.new(queue_size: RailsPulse.configuration.async_queue_size)
+        end
+      end
+
+      def perform_tracking(data)
+        with_writer_connection do
+          request = persist_request(data)
+          rows = operation_rows(request, data[:operations])
+          RailsPulse::Operation.persist_bulk(rows, {}) unless rows.empty?
           request
         end
       rescue => e
         log_error(e)
         nil
+      end
+
+      def with_writer_connection
+        RailsPulse::ApplicationRecord.connection_pool.with_connection do |conn|
+          clear_aborted_transaction(conn)
+          RequestStore.store[:skip_recording_rails_pulse_activity] = true
+          yield
+        end
       ensure
         RequestStore.store[:skip_recording_rails_pulse_activity] = false
       end
 
+      def persist_request(data)
+        route = RailsPulse::Route.find_or_create_for_request(data[:method], data[:path], controller_action: data[:controller_action])
+
+        RailsPulse::Request.create!(
+          route: route,
+          method: data[:method],
+          duration: data[:duration],
+          status: data[:status],
+          is_error: data[:is_error],
+          request_uuid: data[:request_uuid],
+          controller_action: data[:controller_action],
+          occurred_at: data[:occurred_at],
+          response_size_bytes: data[:response_size_bytes]
+        )
+      end
+
+      def operation_rows(request, operations)
+        operations = Array(operations)
+        return [] if operations.empty?
+
+        detect_n_plus_one(operations)
+        operations.map { |op| op.merge(request_id: request.id, job_run_id: nil) }
+      end
+
       # Transactional tests pin one connection per pool and hand that same
       # 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
@@ -93,5 +306,8 @@ module RailsPulse
         RailsPulse.logger.error(error.backtrace.join("\n")) if RailsPulse.logger.debug?
       end
     end
+
+    @writer = nil
+    @writer_mutex = Mutex.new
   end
 end

data/lib/rails_pulse/version.rb

@@ -1,3 +1,3 @@
 module RailsPulse
-  VERSION = "0.4.0.pre.4"
+  VERSION = "0.4.0"
 end

data/lib/rails_pulse.rb

@@ -33,6 +33,9 @@ module RailsPulse
     end
 
     def logger
+      configured = configuration&.logger
+      return configured if configured
+
       if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
         @logger ||= ActiveSupport::TaggedLogging.new(Rails.logger).tagged("RailsPulse")
       else
@@ -40,22 +43,6 @@ module RailsPulse
       end
     end
 
-    def clear_metric_cache!
-      Rails.cache.delete_matched("rails_pulse_metric*")
-    end
-
-    def warm_metric_cache!
-      # Pre-warm cache for common metrics
-      [ :average_response_times, :percentile_response_times, :request_count_totals, :error_rate_per_route ].each do |metric|
-        begin
-          logger.info "Warming cache for metric: #{metric}"
-          # This would trigger cache generation by making the request
-        rescue => e
-          logger.error "Failed to warm cache for #{metric}: #{e.message}"
-        end
-      end
-    end
-
     def connects_to
       configuration&.connects_to
     end

data/lib/rails_pulse_server.ru

@@ -26,10 +26,8 @@ RailsPulse.standalone!
 $stdout.sync = true
 $stderr.sync = true
 
-# Build the Rack app with session support
-require "rack/session/cookie"
 require "rack/static"
-require "securerandom"
+require "rack/method_override"
 require_relative "rails_pulse/rack_compat"
 require_relative "rails_pulse/middleware/asset_server"
 
@@ -62,6 +60,22 @@ class DashboardApp
   end
 end
 
+# Rails::Engine#call is entered directly here, skipping the action_dispatch.*
+# env defaults Rails::Application#call normally seeds before its middleware
+# stack runs. ActionDispatch::Cookies and Session::CookieStore below need
+# those (the encryption key generator, in particular) — without them,
+# ActionController::RequestForgeryProtection#commit_csrf_token never fires,
+# and every CSRF token silently fails to persist to the session.
+class SeedRailsEnv
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    @app.call(Rails.application.env_config.merge(env))
+  end
+end
+
 # Dashboard assets. RouteHelper#asset_path emits one of two URL shapes: the
 # gem-served fallback (/rails-pulse-assets/<version>/...) or, once
 # assets:precompile has run, the digested copies it installs under the host's
@@ -79,32 +93,32 @@ use Rack::Static,
   root: Rails.public_path.to_s,
   header_rules: [ [ :all, RailsPulse::Engine.asset_headers ] ]
 
-# Add session middleware for the dashboard. The cookie is signed with
-# SECRET_KEY_BASE when set, otherwise with the host app's own secret_key_base
-# (config/environment.rb is already loaded above) — hosts on encrypted
-# credentials have no SECRET_KEY_BASE environment variable.
-secret_key = ENV["SECRET_KEY_BASE"].to_s
-if secret_key.empty?
-  secret_key = begin
-    Rails.application.secret_key_base.to_s
-  rescue StandardError
-    ""
-  end
-end
-if secret_key.empty?
-  raise "SECRET_KEY_BASE environment variable must be set for standalone dashboard " \
-        "(no Rails secret_key_base was available to fall back to)"
-end
+# The mounted engine gets this from the host app's default stack; here it
+# must be added explicitly or the settings forms' PATCH routes 404.
+use Rack::MethodOverride
+
+# Fail fast on boot rather than on the first request. secret_key_base checks
+# SECRET_KEY_BASE, then the host's encrypted credentials.
+Rails.application.secret_key_base.presence || raise(
+  "No secret_key_base available for the standalone dashboard " \
+  "(set SECRET_KEY_BASE, or config/credentials)."
+)
+
+use SeedRailsEnv
+
+# ActionDispatch::Cookies and Session::CookieStore, not the plain rack-session
+# gem's Rack::Session::Cookie: only these know to call commit_csrf_token, so a
+# CSRF token generated for a form actually gets persisted to the session
+# instead of discarded at the end of the request.
+use ActionDispatch::Cookies
 
 # `secure` keeps the session cookie off plain HTTP in production. Set
 # RAILS_PULSE_INSECURE_SESSION=1 only for a deliberately non-TLS deployment
 # (a private network with no reverse proxy in front).
-use Rack::Session::Cookie,
+use ActionDispatch::Session::CookieStore,
   key: "rails_pulse_session",
-  secret: secret_key,
   same_site: :lax,
-  httponly: true,
   secure: Rails.env.production? && ENV["RAILS_PULSE_INSECURE_SESSION"].blank?,
-  max_age: 86400  # 1 day
+  expire_after: 86400  # 1 day
 
 run DashboardApp.new