rails_pulse 0.2.3 → 0.2.5.pre.pre.2

data/config/brakeman.ignore

@@ -0,0 +1,213 @@
+{
+  "ignored_warnings": [
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "3d4cff0f317df7445891a1fc467912f3ad09e869da9b3e8433d5897354f5d849",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/rails_pulse/request.rb",
+      "line": 40,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "Arel.sql(\"FLOOR(#{parent.table[:status].name} / 100)\")",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "Request",
+        "method": null
+      },
+      "user_input": "parent.table[:status].name",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: Using Arel.sql with column name from ActiveRecord table definition - safe, not user input"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "dc13170579f824326ffcaf309858f90fc807c7bdc4bfe41df3bb5d2b8f719a12",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/rails_pulse/request.rb",
+      "line": 54,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "Arel.sql with configuration thresholds",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "Request",
+        "method": null
+      },
+      "user_input": "((RailsPulse.configuration rescue nil).request_thresholds or { :slow => 500, :very_slow => 1000, :critical => 2000 })[:slow]",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: Using Arel.sql with configuration values from RailsPulse.configuration - safe, not user input"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "f3a63d26866552b7e487f0de0f73af1c6575a62a0bbea859a52fd24912b06f3d",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/rails_pulse/jobs/cards/average_duration.rb",
+      "line": 21,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "quote(current_window_start)",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Jobs::Cards::AverageDuration",
+        "method": "to_metric_card"
+      },
+      "user_input": "quote(current_window_start)",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: Uses connection.quote() method with calculated timestamp - safe, properly escaped by ActiveRecord"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "e9c51f9fff0ace6daba404a62decb15efdbc72129cdf0818ee802dcfb3419c11",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/rails_pulse/jobs/cards/failure_rate.rb",
+      "line": 21,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "quote(current_window_start)",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Jobs::Cards::FailureRate",
+        "method": "to_metric_card"
+      },
+      "user_input": "quote(current_window_start)",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: Uses connection.quote() method with calculated timestamp - safe, properly escaped by ActiveRecord"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "808fdc102a0d41199ed96c40058b819ea5a28dc4a8eeabca5c444d528006cb40",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/rails_pulse/jobs/cards/total_jobs.rb",
+      "line": 22,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "quote(current_window_start)",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Jobs::Cards::TotalJobs",
+        "method": "to_metric_card"
+      },
+      "user_input": "quote(current_window_start)",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: Uses connection.quote() method with calculated timestamp - safe, properly escaped by ActiveRecord"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "f92a184f3bc0b0374b67cf49510f2c7dd5fb010fe86a9ae210daf920b9523214",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/rails_pulse/jobs/cards/total_runs.rb",
+      "line": 20,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "quote(current_window_start)",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Jobs::Cards::TotalRuns",
+        "method": "to_metric_card"
+      },
+      "user_input": "quote(current_window_start)",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: Uses connection.quote() method with calculated timestamp - safe, properly escaped by ActiveRecord"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "3c816cd9f565d6592595f5566cbd9d9a19ecb51ad704477f01a9bf2b4c1f29fb",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/services/rails_pulse/analysis/explain_plan_analyzer.rb",
+      "line": 191,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "RailsPulse::ApplicationRecord.connection.execute(\"EXPLAIN (ANALYZE, BUFFERS) #{sql}\")",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Analysis::ExplainPlanAnalyzer",
+        "method": "execute_postgres_explain"
+      },
+      "user_input": "sql",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: SQL comes from Rails' ActiveRecord instrumentation (payload[:sql]), not user input. This is internally-generated SQL that Rails has already executed safely. EXPLAIN is read-only."
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "a57a1c949d21de15d6b48e52bfc3077e3177a13ba1d703ddf48e241fb4e81c6e",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/services/rails_pulse/analysis/explain_plan_analyzer.rb",
+      "line": 196,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "RailsPulse::ApplicationRecord.connection.execute(\"EXPLAIN #{sql}\")",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Analysis::ExplainPlanAnalyzer",
+        "method": "execute_mysql_explain"
+      },
+      "user_input": "sql",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: SQL comes from Rails' ActiveRecord instrumentation (payload[:sql]), not user input. This is internally-generated SQL that Rails has already executed safely. EXPLAIN is read-only."
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "85c09ca9672d132fb206d0371e20087deaf381d89733f73d647129878b89f374",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/services/rails_pulse/analysis/explain_plan_analyzer.rb",
+      "line": 201,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "RailsPulse::ApplicationRecord.connection.execute(\"EXPLAIN QUERY PLAN #{sql}\")",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "RailsPulse::Analysis::ExplainPlanAnalyzer",
+        "method": "execute_sqlite_explain"
+      },
+      "user_input": "sql",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Reviewed: SQL comes from Rails' ActiveRecord instrumentation (payload[:sql]), not user input. This is internally-generated SQL that Rails has already executed safely. EXPLAIN is read-only."
+    }
+  ],
+  "updated": "2025-11-30 15:10:00 +0700",
+  "brakeman_version": "7.1.1"
+}

data/config/brakeman.yml

@@ -0,0 +1,68 @@
+---
+# Brakeman configuration file for Rails Pulse Engine
+# https://brakemanscanner.org/docs/options/
+
+# Application path - scan the engine files
+:app_path: "."
+
+# This is a Rails engine, not a standalone app
+:engine_paths:
+  - app
+  - lib
+
+# Rails version - let Brakeman detect automatically from gemspec
+:rails7: true
+
+# Output format for reports (can be: text, json, html, csv, tabs, markdown)
+:output_format: :text
+
+# Paths to skip - don't scan dummy app or test files
+:skip_files:
+  - test/dummy/**/*
+  - node_modules/**/*
+  - vendor/**/*
+  - gemfiles/**/*
+
+# Paths to ignore - additional paths to skip
+:ignore_paths:
+  - test/**/*
+  - tmp/**/*
+  - log/**/*
+  - vendor/**/*
+  - node_modules/**/*
+  - public/**/*
+  - gemfiles/**/*
+
+# Confidence levels: 0 = high only, 1 = high and medium, 2 = all
+:min_confidence: 1  # Report high and medium confidence warnings only
+
+# Exit code configuration
+:exit_on_warn: true  # Exit with error code if warnings found
+:exit_on_error: true  # Exit with error code if errors found
+
+# Interactive mode
+:interactive: false
+
+# Parallelization
+:parallel_checks: true
+
+# Report additional information
+:report_progress: true
+:highlight_user_input: true
+:message_limit: 100  # Maximum number of warnings to report per type
+
+# Ignore file for specific false positives
+:ignore_file: config/brakeman.ignore
+
+# Additional options
+:absolute_paths: false  # Use relative paths in reports
+:summary_only: false    # Show full details, not just summary
+
+# Engine-specific: Skip checks that don't apply to mountable engines
+# These checks are more relevant for standalone apps
+:skip_checks:
+  # Skip checks that are handled by the host application
+  - CheckForgerySetting  # CSRF protection is handled by host app
+
+# Note: We're NOT skipping SQL injection checks - those should be reviewed
+# Note: We're NOT skipping file access checks - those should be reviewed

data/config/importmap.rb

@@ -1,6 +1,6 @@
 pin "application", to: "rails_pulse/application.js"
 
-# echarts is a dependency of the rails_charts gem
+# echarts is used for chart rendering
 pin "echarts", to: "echarts.min.js"
 # pin "echarts/theme/inspired", to: "echarts/theme/inspired.js"
 pin "rails_pulse/theme", to: "rails_pulse/theme.js"

data/config/initializers/rails_pulse.rb

@@ -71,6 +71,58 @@ RailsPulse.configure do |config|
   config.ignored_requests = []
   config.ignored_queries  = []
 
+  # ====================================================================================================
+  #                                                 TAGGING
+  # ====================================================================================================
+  # Define custom tags for categorizing routes, requests, and queries.
+  # You can add any custom tags you want for filtering and organization.
+  #
+  # Tag names should be in present tense and describe the current state or category.
+  # Examples of good tag names:
+  #   - "critical" (for high-priority endpoints)
+  #   - "experimental" (for routes under development)
+  #   - "deprecated" (for routes being phased out)
+  #   - "external" (for third-party API calls)
+  #   - "background" (for async job-related operations)
+  #   - "admin" (for administrative routes)
+  #   - "public" (for public-facing routes)
+  #
+  # Example configuration:
+  #   config.tags = ["ignored", "critical", "experimental", "deprecated", "external", "admin"]
+
+  config.tags = [ "ignored", "critical", "experimental" ]
+
+  # ====================================================================================================
+  #                                            BACKGROUND JOBS
+  # ====================================================================================================
+  # Configure background job monitoring and tracking.
+  # When enabled, Rails Pulse will track job executions, durations, failures, and retries.
+  # Supports ActiveJob, Sidekiq, and Delayed Job.
+
+  # Enable or disable background job tracking
+  config.track_jobs = false
+
+  # Thresholds for job execution times (in milliseconds)
+  config.job_thresholds = {
+    slow:      5_000,   # 5 seconds
+    very_slow: 30_000,  # 30 seconds
+    critical:  60_000   # 1 minute
+  }
+
+  # Job classes to ignore from tracking (by class name)
+  # Examples:
+  #   config.ignored_jobs = ["ActionMailer::MailDeliveryJob", "MyApp::HealthCheckJob"]
+  config.ignored_jobs = []
+
+  # Queue names to ignore from tracking
+  # Examples:
+  #   config.ignored_queues = ["low_priority", "mailers"]
+  config.ignored_queues = []
+
+  # Capture job arguments for debugging (may contain sensitive data)
+  # Set to false in production to avoid storing potentially sensitive information
+  config.capture_job_arguments = true
+
   # ====================================================================================================
   #                                            DATABASE CONFIGURATION
   # ====================================================================================================

data/config/routes.rb

@@ -10,6 +10,12 @@ RailsPulse::Engine.routes.draw do
   end
   resources :operations, only: %i[show]
   resources :caches, only: %i[show], as: :cache
+
+  if RailsPulse.configuration.track_jobs
+    resources :jobs, only: %i[index show], param: :id do
+      resources :runs, only: %i[index show], controller: "job_runs"
+    end
+  end
   patch "pagination/limit", to: "application#set_pagination_limit"
   patch "settings/global_filters", to: "application#set_global_filters"
 

data/db/rails_pulse_migrate/20250113000000_add_jobs_to_rails_pulse.rb

@@ -0,0 +1,95 @@
+# Add background job tracking to Rails Pulse
+class AddJobsToRailsPulse < ActiveRecord::Migration[7.0]
+  def up
+    # Create jobs table for storing job definitions
+    unless table_exists?(:rails_pulse_jobs)
+      create_table :rails_pulse_jobs do |t|
+        t.string :name, null: false, comment: "Job class name"
+        t.string :queue_name, comment: "Default queue"
+        t.text :description, comment: "Optional description"
+        t.integer :runs_count, null: false, default: 0, comment: "Cache of total runs"
+        t.integer :failures_count, null: false, default: 0, comment: "Cache of failed runs"
+        t.integer :retries_count, null: false, default: 0, comment: "Cache of retried runs"
+        t.decimal :avg_duration, precision: 15, scale: 6, comment: "Average duration in milliseconds"
+        t.text :tags, comment: "JSON array of tags"
+        t.timestamps
+      end
+
+      add_index :rails_pulse_jobs, :name, unique: true, name: "index_rails_pulse_jobs_on_name"
+      add_index :rails_pulse_jobs, :queue_name, name: "index_rails_pulse_jobs_on_queue"
+      add_index :rails_pulse_jobs, :runs_count, name: "index_rails_pulse_jobs_on_runs_count"
+    end
+
+    # Create job_runs table for individual job executions
+    unless table_exists?(:rails_pulse_job_runs)
+      create_table :rails_pulse_job_runs do |t|
+        t.references :job, null: false, foreign_key: { to_table: :rails_pulse_jobs }, comment: "Link to job definition"
+        t.string :run_id, null: false, comment: "Adapter specific run id"
+        t.decimal :duration, precision: 15, scale: 6, comment: "Execution duration in milliseconds"
+        t.string :status, null: false, comment: "Execution status"
+        t.string :error_class, comment: "Error class name"
+        t.text :error_message, comment: "Error message"
+        t.integer :attempts, null: false, default: 0, comment: "Retry attempts"
+        t.timestamp :occurred_at, null: false, comment: "When the job started"
+        t.timestamp :enqueued_at, comment: "When the job was enqueued"
+        t.text :arguments, comment: "Serialized arguments"
+        t.string :adapter, comment: "Queue adapter"
+        t.text :tags, comment: "Execution tags"
+        t.timestamps
+      end
+
+      add_index :rails_pulse_job_runs, :run_id, unique: true, name: "index_rails_pulse_job_runs_on_run_id"
+      add_index :rails_pulse_job_runs, [ :job_id, :occurred_at ], name: "index_rails_pulse_job_runs_on_job_and_occurred"
+      add_index :rails_pulse_job_runs, :occurred_at, name: "index_rails_pulse_job_runs_on_occurred_at"
+      add_index :rails_pulse_job_runs, :status, name: "index_rails_pulse_job_runs_on_status"
+      add_index :rails_pulse_job_runs, [ :job_id, :status ], name: "index_rails_pulse_job_runs_on_job_and_status"
+    end
+
+    # Add job_run_id to operations table if it doesn't exist
+    if table_exists?(:rails_pulse_operations) && !column_exists?(:rails_pulse_operations, :job_run_id)
+      # Make request_id nullable to allow job operations
+      change_column_null :rails_pulse_operations, :request_id, true
+
+      # Add job_run_id reference
+      add_reference :rails_pulse_operations, :job_run,
+        null: true,
+        foreign_key: { to_table: :rails_pulse_job_runs },
+        comment: "Link to a background job execution"
+
+      # Add check constraint for PostgreSQL and MySQL to ensure either request_id or job_run_id is present
+      adapter = connection.adapter_name.downcase
+      if adapter.include?("postgres") || adapter.include?("mysql")
+        execute <<-SQL
+          ALTER TABLE rails_pulse_operations
+          ADD CONSTRAINT rails_pulse_operations_request_or_job_run
+          CHECK (request_id IS NOT NULL OR job_run_id IS NOT NULL)
+        SQL
+      end
+    end
+  end
+
+  def down
+    # Remove check constraint first
+    adapter = connection.adapter_name.downcase
+    if adapter.include?("postgres") || adapter.include?("mysql")
+      execute <<-SQL
+        ALTER TABLE rails_pulse_operations
+        DROP CONSTRAINT IF EXISTS rails_pulse_operations_request_or_job_run
+      SQL
+    end
+
+    # Remove job_run_id from operations
+    if column_exists?(:rails_pulse_operations, :job_run_id)
+      remove_reference :rails_pulse_operations, :job_run, foreign_key: { to_table: :rails_pulse_job_runs }
+    end
+
+    # Make request_id non-nullable again
+    if column_exists?(:rails_pulse_operations, :request_id)
+      change_column_null :rails_pulse_operations, :request_id, false
+    end
+
+    # Drop job tables
+    drop_table :rails_pulse_job_runs if table_exists?(:rails_pulse_job_runs)
+    drop_table :rails_pulse_jobs if table_exists?(:rails_pulse_jobs)
+  end
+end

data/db/rails_pulse_migrate/20250122000000_add_query_fingerprinting.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+# Add query fingerprinting to handle long SQL queries
+# Uses MD5 hash of normalized SQL as unique identifier
+class AddQueryFingerprinting < ActiveRecord::Migration[7.0]
+  def up
+    return unless table_exists?(:rails_pulse_queries)
+
+    # Add hashed_sql column if it doesn't exist
+    unless column_exists?(:rails_pulse_queries, :hashed_sql)
+      say "Adding hashed_sql column to rails_pulse_queries..."
+      add_column :rails_pulse_queries, :hashed_sql, :string, limit: 32
+
+      # Backfill existing records with MD5 hash
+      say "Backfilling query hashes for existing records..."
+      backfill_query_hashes
+
+      # Make it required and unique
+      say "Adding constraints and indexes..."
+      change_column_null :rails_pulse_queries, :hashed_sql, false
+      add_index :rails_pulse_queries, :hashed_sql, unique: true,
+                name: "index_rails_pulse_queries_on_hashed_sql"
+
+      # Remove old index
+      say "Removing old normalized_sql index..."
+      if index_exists?(:rails_pulse_queries, :normalized_sql, name: "index_rails_pulse_queries_on_normalized_sql")
+        remove_index :rails_pulse_queries, :normalized_sql, name: "index_rails_pulse_queries_on_normalized_sql"
+      end
+
+      # Change normalized_sql to text (remove 1000 char limit)
+      say "Changing normalized_sql to text type (removing length limit)..."
+      change_column :rails_pulse_queries, :normalized_sql, :text
+
+      say "Query fingerprinting migration completed successfully!", :green
+    else
+      say "Query fingerprinting already applied. Skipping.", :yellow
+    end
+  end
+
+  def down
+    # Prevent rollback if there are queries longer than 1000 characters
+    if has_long_queries?
+      raise ActiveRecord::IrreversibleMigration,
+            "Cannot rollback: normalized_sql contains queries longer than 1000 characters. " \
+            "Rolling back would truncate data."
+    end
+
+    return unless column_exists?(:rails_pulse_queries, :hashed_sql)
+
+    say "Rolling back query fingerprinting changes..."
+
+    # Restore varchar limit (safe because we checked for long queries)
+    change_column :rails_pulse_queries, :normalized_sql, :string, limit: 1000
+
+    # Restore old index
+    add_index :rails_pulse_queries, :normalized_sql, unique: true,
+              name: "index_rails_pulse_queries_on_normalized_sql", length: 191
+
+    # Remove new index
+    if index_exists?(:rails_pulse_queries, :hashed_sql, name: "index_rails_pulse_queries_on_hashed_sql")
+      remove_index :rails_pulse_queries, :hashed_sql, name: "index_rails_pulse_queries_on_hashed_sql"
+    end
+
+    # Remove hashed_sql column
+    remove_column :rails_pulse_queries, :hashed_sql
+
+    say "Rollback completed.", :green
+  end
+
+  private
+
+  def backfill_query_hashes
+    adapter = connection.adapter_name.downcase
+
+    if adapter.include?("postgres") || adapter.include?("mysql")
+      # Use database MD5 function for better performance
+      execute <<-SQL
+        UPDATE rails_pulse_queries
+        SET hashed_sql = MD5(normalized_sql)
+        WHERE hashed_sql IS NULL
+      SQL
+    else
+      # SQLite - use Ruby MD5 (slower but works)
+      require "digest"
+      RailsPulse::Query.where(hashed_sql: nil).find_each do |query|
+        query.update_column(:hashed_sql, Digest::MD5.hexdigest(query.normalized_sql))
+      end
+    end
+
+    # Handle potential duplicates (queries with same normalized SQL)
+    handle_duplicate_hashes
+  end
+
+  def handle_duplicate_hashes
+    # Group queries by hash and find duplicates
+    query_groups = RailsPulse::Query
+      .select(:hashed_sql)
+      .group(:hashed_sql)
+      .having("COUNT(*) > 1")
+      .pluck(:hashed_sql)
+
+    return if query_groups.empty?
+
+    say "Found #{query_groups.size} duplicate query groups. Merging...", :yellow
+
+    query_groups.each do |hash|
+      # Get all queries with this hash, ordered by creation time
+      queries = RailsPulse::Query.where(hashed_sql: hash).order(:created_at).to_a
+      keep_query = queries.first
+      duplicate_queries = queries[1..]
+
+      duplicate_queries.each do |dup_query|
+        # Count operations before merge
+        operations_count = RailsPulse::Operation.where(query_id: dup_query.id).count
+
+        if operations_count > 0
+          say "  Merging #{operations_count} operations from query ##{dup_query.id} into ##{keep_query.id}"
+
+          # Reassign operations to the kept query
+          RailsPulse::Operation.where(query_id: dup_query.id).update_all(query_id: keep_query.id)
+        end
+
+        # Delete the duplicate query
+        dup_query.delete
+      end
+    end
+
+    say "Merged #{query_groups.size} duplicate query groups successfully.", :green
+  end
+
+  def has_long_queries?
+    # Check if any queries exceed 1000 characters
+    adapter = connection.adapter_name.downcase
+
+    if adapter.include?("postgres")
+      result = execute("SELECT EXISTS(SELECT 1 FROM rails_pulse_queries WHERE LENGTH(normalized_sql) > 1000)")
+      # Handle both Rails 7.2 and 8.0 result formats
+      result.first.is_a?(Hash) ? result.first["exists"] == "t" : result.first[0] == "t"
+    elsif adapter.include?("mysql")
+      result = execute("SELECT EXISTS(SELECT 1 FROM rails_pulse_queries WHERE LENGTH(normalized_sql) > 1000) as result")
+      # Handle both result formats
+      result.first.is_a?(Hash) ? result.first["result"] == 1 : result.first[0] == 1
+    else
+      # SQLite
+      result = execute("SELECT COUNT(*) as count FROM rails_pulse_queries WHERE LENGTH(normalized_sql) > 1000")
+      count = result.first.is_a?(Hash) ? result.first["count"] : result.first[0]
+      count.to_i > 0
+    end
+  end
+end

data/db/rails_pulse_migrate/20250202000000_add_index_to_request_uuid.rb

@@ -0,0 +1,14 @@
+# Add index to rails_pulse_requests.request_uuid for efficient lookups
+class AddIndexToRequestUuid < ActiveRecord::Migration[7.0]
+  def up
+    unless index_exists?(:rails_pulse_requests, :request_uuid)
+      add_index :rails_pulse_requests, :request_uuid, unique: true, name: "index_rails_pulse_requests_on_request_uuid"
+    end
+  end
+
+  def down
+    if index_exists?(:rails_pulse_requests, :request_uuid)
+      remove_index :rails_pulse_requests, name: "index_rails_pulse_requests_on_request_uuid"
+    end
+  end
+end