rails_pulse 0.3.3 → 0.4.0.pre.2

data/lib/rails_pulse/job_run_collector.rb

@@ -17,32 +17,59 @@ module RailsPulse
         job = nil
         job_run = nil
 
-        with_recording_suppressed do
-          job = find_or_create_job(active_job)
-          job_run = create_job_run(job, active_job, adapter, occurred_at)
+        # Pulse DB writes before yield must not prevent the job from running.
+        begin
+          with_recording_suppressed do
+            job = find_or_create_job(active_job)
+            job_run = create_job_run(job, active_job, adapter, occurred_at)
+          end
+        rescue => e
+          RailsPulse.logger.error "Failed to initialize job tracking: #{e.class} - #{e.message}"
+          job_run = nil
         end
 
         RequestStore.store[:rails_pulse_request_id] = nil
-        RequestStore.store[:rails_pulse_job_run_id] = job_run.id
+        RequestStore.store[:rails_pulse_job_run_id] = job_run&.id
         RequestStore.store[:rails_pulse_operations] = []
 
         yield
 
-        duration = elapsed_time_ms(start_time)
-        with_recording_suppressed do
-          job_run.update!(status: "success", duration: duration)
+        # Record success — must not re-raise if the job already completed.
+        begin
+          if job_run
+            duration = elapsed_time_ms(start_time)
+            with_recording_suppressed do
+              job_run.update!(status: "success", duration: duration)
+            end
+          end
+        rescue => e
+          RailsPulse.logger.error "Failed to record job success: #{e.class} - #{e.message}"
         end
       rescue => error
-        duration = elapsed_time_ms(start_time)
-        with_recording_suppressed do
-          job_run.update!(
-            status: failure_status_for(error),
-            duration: duration,
-            error_class: error.class.name,
-            error_message: error.message
-          ) if job_run
+        # Record failure — must always re-raise the ORIGINAL error.
+        begin
+          if job_run
+            duration = elapsed_time_ms(start_time)
+            with_recording_suppressed do
+              job_run.update!(
+                status: failure_status_for(error),
+                duration: duration,
+                error_class: error.class.name,
+                # Same redaction as exception occurrences — a job failure
+                # message can carry the same literal PII a request one can.
+                error_message: RailsPulse::ExceptionMessageSanitizer.for_exception(error)
+              )
+            end
+          end
+          # Capture outside with_recording_suppressed — the capture service
+          # checks skip_recording_rails_pulse_activity and would bail out.
+          # The service's own SQL is already filtered by the rails_pulse_ prefix.
+          RailsPulse::ExceptionCaptureService.capture(error, environment: Rails.env.to_s)
+          RequestStore.store[:rails_pulse_captured_exception] = error
+        rescue => e
+          RailsPulse.logger.error "Failed to record job failure: #{e.class} - #{e.message}"
         end
-        raise
+        raise error
       ensure
         begin
           save_operations(job_run)

data/lib/rails_pulse/middleware/asset_server.rb

@@ -11,6 +11,10 @@ module RailsPulse
         ".svg" => "image/svg+xml"
       }.freeze
 
+      # "/rails-pulse-assets/0.3.3/rails-pulse.css" → lookup at
+      # public/rails-pulse-assets/rails-pulse.css. Unversioned paths still work.
+      VERSIONED_ASSET_PATH = %r{\A(/rails-pulse-assets/)(?:\d+\.\d+[\w.\-]*/)}.freeze
+
       def initialize(app, root, options = {})
         # Rack::Static expects (app, options) where options[:root] is the root path
         options = options.merge(root: root) if root.is_a?(String) || root.is_a?(Pathname)
@@ -23,6 +27,9 @@ module RailsPulse
           return @app.call(env)
         end
 
+        env = env.dup
+        env["PATH_INFO"] = strip_asset_version(env["PATH_INFO"])
+
         # Log asset requests for debugging
         RailsPulse.logger.debug "Asset request: #{env['PATH_INFO']}"
 
@@ -51,6 +58,10 @@ module RailsPulse
         env["PATH_INFO"]&.start_with?("/rails-pulse-assets/")
       end
 
+      def strip_asset_version(path)
+        path.to_s.sub(VERSIONED_ASSET_PATH, '\1')
+      end
+
       def cache_headers
         if defined?(Rails) && Rails.env.development?
           { "Cache-Control" => "no-cache, no-store, must-revalidate", "Pragma" => "no-cache" }

data/lib/rails_pulse/middleware/request_collector.rb

@@ -40,10 +40,11 @@ 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)
+        path_params = env["action_dispatch.request.path_parameters"] || {}
+        controller_action = [ path_params[:controller], path_params[:action] ].compact.join("#").presence
         tracking_data = {
           method: req.request_method,
-          path: req.path,
+          path: RailsPulse::RoutePathNormalizer.normalize(req.path, path_params),
           duration: duration,
           status: status,
           is_error: status.to_i >= 500,
@@ -54,8 +55,12 @@ module RailsPulse
           operations: operations.map(&:dup)
         }
 
-        # Send to tracker (non-blocking if async mode enabled)
-        RailsPulse::Tracker.track_request(tracking_data)
+        # Send to tracker — rescue ensures Pulse never 500s a host request.
+        begin
+          RailsPulse::Tracker.track_request(tracking_data)
+        rescue => e
+          RailsPulse.logger.error("RailsPulse tracking failed: #{e.class} - #{e.message}")
+        end
 
         [ status, headers, response ]
       ensure

data/lib/rails_pulse/packaged_assets.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+
+module RailsPulse
+  # Copies gem-built dashboard files into the host's public/assets with a
+  # content digest, then records them in a small manifest. This is hooked to
+  # assets:precompile so CDNs (asset_sync, CloudFront on /assets) and
+  # CDN-only CSP policies see the same URLs as the rest of the host app —
+  # without running the host js_compressor over the already-minified bundle.
+  class PackagedAssets
+    LOGICAL_NAMES = %w[
+      rails-pulse.css
+      rails-pulse.js
+      rails-pulse-icons.js
+      rails-pulse-logo.png
+      search.svg
+    ].freeze
+
+    MANIFEST_FILENAME = ".rails-pulse-manifest.json"
+
+    class << self
+      def install!(destination: default_destination)
+        FileUtils.mkdir_p(destination)
+        entries = {}
+
+        LOGICAL_NAMES.each do |logical_name|
+          source = source_path(logical_name)
+          next unless source.exist?
+
+          digested_name = digested_filename(logical_name, source)
+          FileUtils.cp(source, destination.join(digested_name))
+          copy_adjacent_source_map(source, destination)
+          entries[logical_name] = digested_name
+        end
+
+        File.write(destination.join(MANIFEST_FILENAME), JSON.pretty_generate(entries))
+        patch_host_manifests(destination, entries)
+        reset!
+        entries
+      end
+
+      def url_path(logical_name)
+        digested = manifest[logical_name.to_s]
+        return if digested.blank?
+
+        "/assets/#{digested}"
+      end
+
+      def manifest
+        @manifest ||= load_manifest
+      end
+
+      def reset!
+        @manifest = nil
+      end
+
+      def uninstall!(destination: default_destination)
+        path = destination.join(MANIFEST_FILENAME)
+        if path.exist?
+          JSON.parse(path.read).each_value do |filename|
+            FileUtils.rm_f(destination.join(filename))
+          end
+          FileUtils.rm_f(path)
+        end
+        %w[rails-pulse.js.map rails-pulse.css.map rails-pulse-icons.js.map].each do |map|
+          FileUtils.rm_f(destination.join(map))
+        end
+        reset!
+      end
+
+      private
+
+      def default_destination
+        Rails.public_path.join("assets")
+      end
+
+      def source_path(logical_name)
+        Engine.root.join("public", "rails-pulse-assets", logical_name)
+      end
+
+      def digested_filename(logical_name, source)
+        ext = File.extname(logical_name)
+        base = File.basename(logical_name, ext)
+        digest = Digest::SHA256.file(source).hexdigest
+        "#{base}-#{digest}#{ext}"
+      end
+
+      def copy_adjacent_source_map(source, destination)
+        map = Pathname.new("#{source}.map")
+        FileUtils.cp(map, destination.join(map.basename)) if map.exist?
+      end
+
+      def load_manifest
+        path = Rails.public_path.join("assets", MANIFEST_FILENAME)
+        return {} unless path.exist?
+
+        JSON.parse(path.read)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def patch_host_manifests(destination, entries)
+        patch_propshaft_manifest(destination, entries)
+        patch_sprockets_manifests(destination, entries)
+      end
+
+      def patch_propshaft_manifest(destination, entries)
+        path = destination.join(".manifest.json")
+        return unless path.exist?
+
+        data = JSON.parse(path.read)
+        File.write(path, JSON.pretty_generate(data.merge(entries)))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def patch_sprockets_manifests(destination, entries)
+        Dir.glob(destination.join(".sprockets-manifest-*.json")).each do |path|
+          data = JSON.parse(File.read(path))
+          data["assets"] ||= {}
+          data["files"] ||= {}
+          entries.each do |logical_name, digested_name|
+            data["assets"][logical_name] = digested_name
+            file = destination.join(digested_name)
+            data["files"][digested_name] = {
+              "logical_path" => logical_name,
+              "mtime" => file.mtime.iso8601,
+              "size" => file.size,
+              "digest" => digested_name[/-([a-f0-9]{32,})\./, 1],
+              "integrity" => integrity_for(file)
+            }
+          end
+          File.write(path, JSON.pretty_generate(data))
+        rescue JSON::ParserError
+          next
+        end
+      end
+
+      def integrity_for(file)
+        "sha256-#{Digest::SHA256.base64digest(file.binread)}"
+      end
+    end
+  end
+end

data/lib/rails_pulse/route_indexes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RailsPulse
+  # Adapter-specific unique index that groups unrecognized routes (404s, middleware
+  # short-circuits) by path. PostgreSQL and SQLite use a partial unique index;
+  # MySQL uses a functional unique index because it has no partial indexes.
+  #
+  # Must not be added while upgrade rows still have a null controller_action on
+  # different-verb REST siblings (GET /users vs POST /users). Call this after
+  # RouteControllerActionBackfiller has assigned actions.
+  #
+  # PostgreSQL and SQLite go through `add_index(..., where:)` so `schema.rb`
+  # round-trips the predicate. Raw multiline `CREATE UNIQUE INDEX ... WHERE`
+  # is stored with a trailing newline that SQLite's schema dumper does not
+  # parse, so `db:schema:load` (and parallel test workers) recreate a unique
+  # index on every path. MySQL still uses SQL: `add_index(..., where:)` is
+  # silently ignored and would unique-index every path.
+  module RouteIndexes
+    NULL_ACTION_INDEX = "index_rails_pulse_routes_on_path_without_action"
+
+    def self.ensure_null_action_uniqueness!(connection)
+      return if exists?(connection)
+
+      adapter = connection.adapter_name.downcase
+
+      if adapter.include?("mysql")
+        version_string = connection.select_value("SELECT VERSION()")
+        if version_string.to_s.include?("MariaDB")
+          raise "Rails Pulse requires MySQL >= 8.0.13 for functional indexes. " \
+                "MariaDB is not supported — it does not implement the required " \
+                "CREATE INDEX ... ((expression)) syntax."
+        end
+
+        mysql_version = version_string.to_s.scan(/\A(\d+\.\d+\.\d+)/).flatten.first
+        if mysql_version && Gem::Version.new(mysql_version) < Gem::Version.new("8.0.13")
+          raise "Rails Pulse requires MySQL >= 8.0.13 for functional indexes " \
+                "(found #{mysql_version}). Upgrade MySQL or use PostgreSQL/SQLite."
+        end
+
+        table = connection.quote_table_name(:rails_pulse_routes)
+        connection.execute(<<~SQL.strip)
+          CREATE UNIQUE INDEX #{NULL_ACTION_INDEX}
+          ON #{table} ((CASE WHEN controller_action IS NULL THEN path ELSE NULL END))
+        SQL
+      else
+        connection.add_index(
+          :rails_pulse_routes,
+          :path,
+          unique: true,
+          where: "controller_action IS NULL",
+          name: NULL_ACTION_INDEX
+        )
+      end
+    end
+
+    def self.remove_null_action_uniqueness!(connection)
+      return unless exists?(connection)
+
+      connection.remove_index(:rails_pulse_routes, name: NULL_ACTION_INDEX)
+    end
+
+    def self.exists?(connection)
+      connection.indexes(:rails_pulse_routes).any? { |idx| idx.name == NULL_ACTION_INDEX }
+    end
+  end
+end

data/lib/rails_pulse/subscribers/exception_subscriber.rb

@@ -0,0 +1,36 @@
+module RailsPulse
+  module Subscribers
+    class ExceptionSubscriber
+      def self.subscribe!
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new(event).process
+        end
+      end
+
+      def initialize(event)
+        @event = event
+      end
+
+      def process
+        return unless RailsPulse.configuration.enabled
+        return unless RailsPulse.configuration.track_exceptions
+        return if RequestStore.store[:skip_recording_rails_pulse_activity]
+
+        exception = @event.payload[:exception_object]
+        return unless exception
+        return if RequestStore.store[:rails_pulse_captured_exception].equal?(exception)
+
+        RailsPulse::ExceptionCaptureService.capture(
+          exception,
+          request_url:     @event.payload[:path],
+          request_method:  @event.payload[:method],
+          request_params:  @event.payload[:params],
+          environment:     Rails.env.to_s
+        )
+      rescue => e
+        Rails.logger.error("[RailsPulse] ExceptionSubscriber error: #{e.message}")
+      end
+    end
+  end
+end

data/lib/rails_pulse/tracker.rb

@@ -1,5 +1,3 @@
-require "async"
-
 module RailsPulse
   module Tracker
     # PG::Connection::PQTRANS_INERROR (libpq enum value 3) — the connection's transaction
@@ -13,8 +11,12 @@ module RailsPulse
       def track_request(data)
         return if RequestStore.store[:skip_recording_rails_pulse_activity]
 
-        if RailsPulse.configuration.async
-          Async { perform_tracking(data) }
+        if RailsPulse.configuration.async && !connection_shared_across_threads?
+          Thread.new do
+            perform_tracking(data)
+          rescue => e
+            log_error(e)
+          end
         else
           perform_tracking(data)
         end
@@ -34,10 +36,11 @@ module RailsPulse
           clear_aborted_transaction(conn)
           RequestStore.store[:skip_recording_rails_pulse_activity] = true
 
-          route = RailsPulse::Route.by_method_and_path(data[:method], data[:path])
+          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],
@@ -51,12 +54,28 @@ module RailsPulse
           RailsPulse::Operation.persist_bulk(ops, request_id: request.id)
 
           request
-        rescue => e
-          log_error(e)
-          nil
-        ensure
-          RequestStore.store[:skip_recording_rails_pulse_activity] = false
         end
+      rescue => e
+        log_error(e)
+        nil
+      ensure
+        RequestStore.store[:skip_recording_rails_pulse_activity] = false
+      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
+      # 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".
+      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
+      rescue StandardError
+        false
       end
 
       def clear_aborted_transaction(conn)

data/lib/rails_pulse/version.rb

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

data/lib/rails_pulse.rb

@@ -1,5 +1,6 @@
 require "rails_pulse/version"
 require "rails_pulse/engine"
+require "rails_pulse/packaged_assets"
 require "rails_pulse/configuration"
 require "rails_pulse/paginator"
 require "rails_pulse/cleanup_service"

data/lib/rails_pulse_server.ru

@@ -1,58 +1,22 @@
-# Load Rails environment - try multiple locations
+# Load the host Rails environment. The dashboard is a mounted engine and needs
+# the host's models, routes and initializer (authentication, database), so run
+# this from the Rails application's root — or from the gem root, which loads
+# the dummy app for development.
 if File.exist?("test/dummy/config/environment.rb")
-  # Running from Rails Pulse gem root (for development/testing)
   require_relative "../test/dummy/config/environment"
 elsif File.exist?("config/environment.rb")
-  # Running from a Rails app that has Rails Pulse installed
   require File.expand_path("config/environment", Dir.pwd)
 else
-  # Standalone mode - load minimal dependencies
-  puts "=" * 80
-  puts "RailsPulse Dashboard (Standalone Mode)"
-  puts "=" * 80
+  abort <<~MESSAGE
+    RailsPulse standalone dashboard: config/environment.rb not found in #{Dir.pwd}.
 
-  require "bundler/setup"
-  require "active_support/all"
-  require "active_record"
+    Run from your Rails application's root directory:
 
-  $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-  require "rails_pulse"
+      cd /path/to/your/app
+      RAILS_ENV=production bundle exec rackup $(bundle show rails_pulse)/lib/rails_pulse_server.ru -p 3001
 
-  # Load database configuration from environment
-  db_config = if ENV["DATABASE_URL"]
-    { url: ENV["DATABASE_URL"] }
-  elsif File.exist?("config/database.yml")
-    require "yaml"
-    db_yml = YAML.load_file("config/database.yml", aliases: true)
-    rails_env = ENV.fetch("RAILS_ENV", "production")
-
-    rails_pulse_config = db_yml.dig(rails_env, "rails_pulse")
-    if rails_pulse_config
-      rails_pulse_config
-    else
-      puts "WARNING: No 'rails_pulse' database found in config/database.yml, using primary connection"
-      db_yml[rails_env]
-    end
-  else
-    raise "Database configuration not found. Set DATABASE_URL or provide config/database.yml"
-  end
-
-  puts "Connecting to database: #{db_config[:database] || db_config[:url]&.split('@')&.last}"
-
-  # Configure RailsPulse for dashboard-only mode
-  RailsPulse.configure do |config|
-    # CRITICAL: Disable tracking in dashboard process
-    config.enabled = false
-
-    # Configure database connection
-    config.connects_to = { database: db_config }
-  end
-
-  # Establish database connection
-  RailsPulse::ApplicationRecord.establish_connection(db_config)
-
-  puts "Dashboard ready on port #{ENV.fetch('PORT', 3001)}"
-  puts "=" * 80
+    RAILS_ENV selects the database and enables dashboard authentication.
+  MESSAGE
 end
 
 # Disable output buffering so logs appear immediately
@@ -99,10 +63,15 @@ secret_key = ENV.fetch("SECRET_KEY_BASE") do
   raise "SECRET_KEY_BASE environment variable must be set for standalone dashboard"
 end
 
+# `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,
   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
 
 run DashboardApp.new

data/lib/tasks/rails_pulse.rake

@@ -9,6 +9,10 @@ namespace :db do
         if schema_file.exist?
           load schema_file
           puts "Rails Pulse schema loaded successfully"
+          # 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.
+          record_rails_pulse_migrations_applied
         else
           puts "Rails Pulse schema file not found. Run: rails generate rails_pulse:install --database=separate"
         end
@@ -28,12 +32,87 @@ namespace :db do
   end
 end
 
+# Hook into test database preparation so the separate Rails Pulse DB is populated
+# for test runs, not just for development/production db:prepare.
+# The task may be namespaced as "app:db:schema:load_rails_pulse" in engine context
+# vs "db:schema:load_rails_pulse" in a host app — try both.
+Rake::Task["db:test:prepare"].enhance do
+  if separate_database_setup?
+    task_name = %w[db:schema:load_rails_pulse app:db:schema:load_rails_pulse]
+      .find { |name| Rake::Task.task_defined?(name) }
+    if task_name
+      Rake::Task[task_name].reenable
+      Rake::Task[task_name].invoke
+    end
+  end
+end if Rake::Task.task_defined?("db:test:prepare")
+
 # Helper function to detect database setup type
 def separate_database_setup?
-  # Check if there's a rails_pulse_migrate directory (indicates separate database)
-  Rails.root.join("db/rails_pulse_migrate").exist? ||
-  # Check if database.yml has rails_pulse configuration
-  (Rails.application.config.database_configuration.dig(Rails.env, "rails_pulse").present?)
+  # A .keep file alone (created by install_generator for all modes) does not
+  # indicate separate-DB. Require actual migration files or a database.yml entry.
+  migrate_dir = Rails.root.join("db/rails_pulse_migrate")
+  has_migration_files = migrate_dir.exist? && Dir.glob("#{migrate_dir}/*.rb").any?
+  has_db_config = Rails.application.config.database_configuration.dig(Rails.env, "rails_pulse").present?
+  has_migration_files || has_db_config
+end
+
+# After a schema load, insert version numbers for any migration files already in
+# db/rails_pulse_migrate/ into schema_migrations so Rails does not report them as
+# pending. The schema already includes every column those migrations would add, so
+# running them would be a no-op — but Rails still needs the version recorded.
+def record_rails_pulse_migrations_applied
+  return unless defined?(RailsPulse::ApplicationRecord)
+
+  migrations_path = Rails.root.join("db/rails_pulse_migrate")
+  return unless migrations_path.exist?
+
+  connection = RailsPulse::ApplicationRecord.connection
+
+  # Only record versions if the schema load actually created/updated tables.
+  # On an existing database, the schema file is a no-op, so marking migrations
+  # as applied would hide genuinely pending migrations.
+  unless connection.table_exists?(:rails_pulse_routes)
+    puts "[RailsPulse] Schema load did not create tables — skipping migration recording"
+    return
+  end
+
+  # Create schema_migrations if this is a brand-new database that has not yet
+  # had any migrations run against it (e.g. just after db:create).
+  unless connection.table_exists?(:schema_migrations)
+    connection.create_table :schema_migrations, id: false do |t|
+      t.string :version, null: false
+    end
+    connection.add_index :schema_migrations, :version,
+      unique: true, name: "unique_schema_migrations"
+  end
+
+  Dir.glob("#{migrations_path}/*.rb").sort.each do |file|
+    version = File.basename(file, ".rb").split("_").first
+    migration_name = File.basename(file, ".rb").sub(/\A\d+_/, "")
+
+    # For the 0.4.0 route-identity migrations, only record them as applied if
+    # the schema actually has the columns they would add. This prevents marking
+    # them applied on an existing DB where the schema load was a no-op.
+    if migration_name.include?("change_rails_pulse_routes") || migration_name.include?("null_action_unique_index")
+      unless connection.column_exists?(:rails_pulse_routes, :controller_action) &&
+             connection.column_exists?(:rails_pulse_routes, :http_methods)
+        puts "[RailsPulse] Skipping #{version} — route columns not present yet"
+        next
+      end
+    end
+
+    next if connection.select_values(
+      "SELECT version FROM schema_migrations WHERE version = #{connection.quote(version)}"
+    ).any?
+
+    connection.execute(
+      "INSERT INTO schema_migrations (version) VALUES (#{connection.quote(version)})"
+    )
+    puts "[RailsPulse] Marked migration #{version} as applied (schema already up to date)"
+  end
+rescue => e
+  warn "[RailsPulse] Could not mark migrations as applied: #{e.message}"
 end
 
 namespace :rails_pulse do

data/lib/tasks/rails_pulse_assets.rake

@@ -0,0 +1,15 @@
+namespace :rails_pulse do
+  desc "Copy pre-built dashboard assets into public/assets without running the host JS compressor"
+  task install_assets: :environment do
+    entries = RailsPulse::PackagedAssets.install!
+    puts "[RailsPulse] Installed #{entries.size} dashboard assets into public/assets"
+  end
+end
+
+# Copy after the host pipeline finishes so asset_sync / CDN uploads include
+# the files, but never register them for Sprockets compression (#190).
+if Rake::Task.task_defined?("assets:precompile")
+  Rake::Task["assets:precompile"].enhance do
+    Rake::Task["rails_pulse:install_assets"].invoke
+  end
+end