rails_pulse 0.2.5.pre.4 → 0.2.5.pre.5

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails_pulse
 version: !ruby/object:Gem::Version
-  version: 0.2.5.pre.4
+  version: 0.2.5.pre.5
 platform: ruby
 authors:
 - Rails Pulse
 bindir: bin
 cert_chain: []
-date: 2025-12-18 00:00:00.000000000 Z
+date: 2026-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -139,6 +139,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby on Rails performance monitoring tool that provides insights into
   your application's performance, helping you identify bottlenecks and optimize your
   code for better efficiency.
@@ -333,9 +361,7 @@ files:
 - config/importmap.rb
 - config/initializers/rails_pulse.rb
 - config/routes.rb
-- db/rails_pulse_migrate/20250113000000_add_jobs_to_rails_pulse.rb
-- db/rails_pulse_migrate/20250122000000_add_query_fingerprinting.rb
-- db/rails_pulse_migrate/20250202000000_add_index_to_request_uuid.rb
+- db/rails_pulse_migrate/20260117000000_optimize_rails_pulse_indexes.rb
 - db/rails_pulse_schema.rb
 - lib/generators/rails_pulse/convert_to_migrations_generator.rb
 - lib/generators/rails_pulse/install_generator.rb

data/db/rails_pulse_migrate/20250113000000_add_jobs_to_rails_pulse.rb

@@ -1,95 +0,0 @@
-# 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

@@ -1,150 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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