rails_pulse 0.2.4 → 0.2.5.pre.pre.2

data/lib/generators/rails_pulse/templates/db/rails_pulse_schema.rb

@@ -3,128 +3,211 @@
 # Load with: rails db:schema:load:rails_pulse or db:prepare
 
 RailsPulse::Schema = lambda do |connection|
+  adapter = connection.adapter_name.downcase
   # Skip if all tables already exist to prevent conflicts
-  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_summaries ]
+  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_jobs, :rails_pulse_job_runs, :rails_pulse_summaries ]
 
-  if ENV["CI"] == "true"
-    existing_tables = required_tables.select { |table| connection.table_exists?(table) }
-    missing_tables = required_tables - existing_tables
-    puts "[RailsPulse::Schema] Existing tables: #{existing_tables.join(', ')}" if existing_tables.any?
-    puts "[RailsPulse::Schema] Missing tables: #{missing_tables.join(', ')}" if missing_tables.any?
+  # Check which tables already exist
+  existing_tables = required_tables.select { |table| connection.table_exists?(table) }
+  missing_tables = required_tables - existing_tables
+
+  # Always log for transparency (not just in CI)
+  if existing_tables.any?
+    puts "[RailsPulse::Schema] Existing tables detected: #{existing_tables.join(', ')}"
+  end
+
+  if missing_tables.any?
+    puts "[RailsPulse::Schema] Creating missing tables: #{missing_tables.join(', ')}"
   end
 
-  return if required_tables.all? { |table| connection.table_exists?(table) }
+  # If all tables exist, skip creation entirely
+  if missing_tables.empty?
+    puts "[RailsPulse::Schema] All Rails Pulse tables already exist. Skipping schema load."
+    return
+  end
+
+  unless connection.table_exists?(:rails_pulse_routes)
+    connection.create_table :rails_pulse_routes do |t|
+      t.string :method, null: false, comment: "HTTP method (e.g., GET, POST)"
+      t.string :path, null: false, comment: "Request path (e.g., /posts/index)"
+      t.text :tags, comment: "JSON array of tags for filtering and categorization"
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_routes, [ :method, :path ], unique: true, name: "index_rails_pulse_routes_on_method_and_path"
+  end
 
-  connection.create_table :rails_pulse_routes do |t|
-    t.string :method, null: false, comment: "HTTP method (e.g., GET, POST)"
-    t.string :path, null: false, comment: "Request path (e.g., /posts/index)"
-    t.text :tags, comment: "JSON array of tags for filtering and categorization"
-    t.timestamps
+  unless connection.table_exists?(:rails_pulse_queries)
+    connection.create_table :rails_pulse_queries do |t|
+      t.string :hashed_sql, limit: 32, null: false, comment: "MD5 hash of normalized SQL for indexing"
+      t.text :normalized_sql, null: false, comment: "Normalized SQL query string (e.g., SELECT * FROM users WHERE id = ?)"
+      t.datetime :analyzed_at, comment: "When query analysis was last performed"
+      t.text :explain_plan, comment: "EXPLAIN output from actual SQL execution"
+      t.text :issues, comment: "JSON array of detected performance issues"
+      t.text :metadata, comment: "JSON object containing query complexity metrics"
+      t.text :query_stats, comment: "JSON object with query characteristics analysis"
+      t.text :backtrace_analysis, comment: "JSON object with call chain and N+1 detection"
+      t.text :index_recommendations, comment: "JSON array of database index recommendations"
+      t.text :n_plus_one_analysis, comment: "JSON object with enhanced N+1 query detection results"
+      t.text :suggestions, comment: "JSON array of optimization recommendations"
+      t.text :tags, comment: "JSON array of tags for filtering and categorization"
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_queries, :hashed_sql, unique: true, name: "index_rails_pulse_queries_on_hashed_sql"
   end
 
-  connection.add_index :rails_pulse_routes, [ :method, :path ], unique: true, name: "index_rails_pulse_routes_on_method_and_path"
-
-  connection.create_table :rails_pulse_queries do |t|
-    t.string :normalized_sql, limit: 1000, null: false, comment: "Normalized SQL query string (e.g., SELECT * FROM users WHERE id = ?)"
-    t.datetime :analyzed_at, comment: "When query analysis was last performed"
-    t.text :explain_plan, comment: "EXPLAIN output from actual SQL execution"
-    t.text :issues, comment: "JSON array of detected performance issues"
-    t.text :metadata, comment: "JSON object containing query complexity metrics"
-    t.text :query_stats, comment: "JSON object with query characteristics analysis"
-    t.text :backtrace_analysis, comment: "JSON object with call chain and N+1 detection"
-    t.text :index_recommendations, comment: "JSON array of database index recommendations"
-    t.text :n_plus_one_analysis, comment: "JSON object with enhanced N+1 query detection results"
-    t.text :suggestions, comment: "JSON array of optimization recommendations"
-    t.text :tags, comment: "JSON array of tags for filtering and categorization"
-    t.timestamps
+  unless connection.table_exists?(:rails_pulse_requests)
+    connection.create_table :rails_pulse_requests do |t|
+      t.references :route, null: false, foreign_key: { to_table: :rails_pulse_routes }, comment: "Link to the route"
+      t.decimal :duration, precision: 15, scale: 6, null: false, comment: "Total request duration in milliseconds"
+      t.integer :status, null: false, comment: "HTTP status code (e.g., 200, 500)"
+      t.boolean :is_error, null: false, default: false, comment: "True if status >= 500"
+      t.string :request_uuid, null: false, comment: "Unique identifier for the request (e.g., UUID)"
+      t.string :controller_action, comment: "Controller and action handling the request (e.g., PostsController#show)"
+      t.timestamp :occurred_at, null: false, comment: "When the request started"
+      t.text :tags, comment: "JSON array of tags for filtering and categorization"
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_requests, :occurred_at, name: "index_rails_pulse_requests_on_occurred_at"
+    connection.add_index :rails_pulse_requests, :request_uuid, unique: true, name: "index_rails_pulse_requests_on_request_uuid"
+    connection.add_index :rails_pulse_requests, [ :route_id, :occurred_at ], name: "index_rails_pulse_requests_on_route_id_and_occurred_at"
   end
 
-  connection.add_index :rails_pulse_queries, :normalized_sql, unique: true, name: "index_rails_pulse_queries_on_normalized_sql", length: 191
-
-  connection.create_table :rails_pulse_requests do |t|
-    t.references :route, null: false, foreign_key: { to_table: :rails_pulse_routes }, comment: "Link to the route"
-    t.decimal :duration, precision: 15, scale: 6, null: false, comment: "Total request duration in milliseconds"
-    t.integer :status, null: false, comment: "HTTP status code (e.g., 200, 500)"
-    t.boolean :is_error, null: false, default: false, comment: "True if status >= 500"
-    t.string :request_uuid, null: false, comment: "Unique identifier for the request (e.g., UUID)"
-    t.string :controller_action, comment: "Controller and action handling the request (e.g., PostsController#show)"
-    t.timestamp :occurred_at, null: false, comment: "When the request started"
-    t.text :tags, comment: "JSON array of tags for filtering and categorization"
-    t.timestamps
+  unless connection.table_exists?(:rails_pulse_jobs)
+    connection.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
+
+    connection.add_index :rails_pulse_jobs, :name, unique: true, name: "index_rails_pulse_jobs_on_name"
+    connection.add_index :rails_pulse_jobs, :queue_name, name: "index_rails_pulse_jobs_on_queue"
+    connection.add_index :rails_pulse_jobs, :runs_count, name: "index_rails_pulse_jobs_on_runs_count"
   end
 
-  connection.add_index :rails_pulse_requests, :occurred_at, name: "index_rails_pulse_requests_on_occurred_at"
-  connection.add_index :rails_pulse_requests, :request_uuid, unique: true, name: "index_rails_pulse_requests_on_request_uuid"
-  connection.add_index :rails_pulse_requests, [ :route_id, :occurred_at ], name: "index_rails_pulse_requests_on_route_id_and_occurred_at"
-
-  connection.create_table :rails_pulse_operations do |t|
-    t.references :request, null: false, foreign_key: { to_table: :rails_pulse_requests }, comment: "Link to the request"
-    t.references :query, foreign_key: { to_table: :rails_pulse_queries }, index: true, comment: "Link to the normalized SQL query"
-    t.string :operation_type, null: false, comment: "Type of operation (e.g., database, view, gem_call)"
-    t.string :label, null: false, comment: "Descriptive name (e.g., SELECT FROM users WHERE id = 1, render layout)"
-    t.decimal :duration, precision: 15, scale: 6, null: false, comment: "Operation duration in milliseconds"
-    t.string :codebase_location, comment: "File and line number (e.g., app/models/user.rb:25)"
-    t.float :start_time, null: false, default: 0.0, comment: "Operation start time in milliseconds"
-    t.timestamp :occurred_at, null: false, comment: "When the request started"
-    t.timestamps
+  unless connection.table_exists?(:rails_pulse_job_runs)
+    connection.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
+
+    connection.add_index :rails_pulse_job_runs, :run_id, unique: true, name: "index_rails_pulse_job_runs_on_run_id"
+    connection.add_index :rails_pulse_job_runs, [ :job_id, :occurred_at ], name: "index_rails_pulse_job_runs_on_job_and_occurred"
+    connection.add_index :rails_pulse_job_runs, :occurred_at, name: "index_rails_pulse_job_runs_on_occurred_at"
+    connection.add_index :rails_pulse_job_runs, :status, name: "index_rails_pulse_job_runs_on_status"
+    connection.add_index :rails_pulse_job_runs, [ :job_id, :status ], name: "index_rails_pulse_job_runs_on_job_and_status"
   end
 
-  connection.add_index :rails_pulse_operations, :operation_type, name: "index_rails_pulse_operations_on_operation_type"
-  connection.add_index :rails_pulse_operations, :occurred_at, name: "index_rails_pulse_operations_on_occurred_at"
-  connection.add_index :rails_pulse_operations, [ :query_id, :occurred_at ], name: "index_rails_pulse_operations_on_query_and_time"
-  connection.add_index :rails_pulse_operations, [ :query_id, :duration, :occurred_at ], name: "index_rails_pulse_operations_query_performance"
-  connection.add_index :rails_pulse_operations, [ :occurred_at, :duration, :operation_type ], name: "index_rails_pulse_operations_on_time_duration_type"
-
-  connection.create_table :rails_pulse_summaries do |t|
-    # Time fields
-    t.datetime :period_start, null: false, comment: "Start of the aggregation period"
-    t.datetime :period_end, null: false, comment: "End of the aggregation period"
-    t.string :period_type, null: false, comment: "Aggregation period type: hour, day, week, month"
-
-    # Polymorphic association to handle both routes and queries
-    t.references :summarizable, polymorphic: true, null: false, index: true, comment: "Link to Route or Query"
-    # This creates summarizable_type (e.g., 'RailsPulse::Route', 'RailsPulse::Query')
-    # and summarizable_id (route_id or query_id)
-
-    # Universal metrics
-    t.integer :count, default: 0, null: false, comment: "Total number of requests/operations"
-    t.float :avg_duration, comment: "Average duration in milliseconds"
-    t.float :min_duration, comment: "Minimum duration in milliseconds"
-    t.float :max_duration, comment: "Maximum duration in milliseconds"
-    t.float :p50_duration, comment: "50th percentile duration"
-    t.float :p95_duration, comment: "95th percentile duration"
-    t.float :p99_duration, comment: "99th percentile duration"
-    t.float :total_duration, comment: "Total duration in milliseconds"
-    t.float :stddev_duration, comment: "Standard deviation of duration"
-
-    # Request/Route specific metrics
-    t.integer :error_count, default: 0, comment: "Number of error responses (5xx)"
-    t.integer :success_count, default: 0, comment: "Number of successful responses"
-    t.integer :status_2xx, default: 0, comment: "Number of 2xx responses"
-    t.integer :status_3xx, default: 0, comment: "Number of 3xx responses"
-    t.integer :status_4xx, default: 0, comment: "Number of 4xx responses"
-    t.integer :status_5xx, default: 0, comment: "Number of 5xx responses"
-
-    t.timestamps
+  unless connection.table_exists?(:rails_pulse_operations)
+    connection.create_table :rails_pulse_operations do |t|
+      t.references :request, null: true, foreign_key: { to_table: :rails_pulse_requests }, comment: "Link to the request"
+      t.references :job_run, null: true, foreign_key: { to_table: :rails_pulse_job_runs }, comment: "Link to a background job execution"
+      t.references :query, foreign_key: { to_table: :rails_pulse_queries }, index: true, comment: "Link to the normalized SQL query"
+      t.string :operation_type, null: false, comment: "Type of operation (e.g., database, view, gem_call)"
+      t.string :label, null: false, comment: "Descriptive name (e.g., SELECT FROM users WHERE id = 1, render layout)"
+      t.decimal :duration, precision: 15, scale: 6, null: false, comment: "Operation duration in milliseconds"
+      t.string :codebase_location, comment: "File and line number (e.g., app/models/user.rb:25)"
+      t.float :start_time, null: false, default: 0.0, comment: "Operation start time in milliseconds"
+      t.timestamp :occurred_at, null: false, comment: "When the request started"
+      t.timestamps
+    end
+
+    connection.add_index :rails_pulse_operations, :operation_type, name: "index_rails_pulse_operations_on_operation_type"
+    connection.add_index :rails_pulse_operations, :occurred_at, name: "index_rails_pulse_operations_on_occurred_at"
+    connection.add_index :rails_pulse_operations, [ :query_id, :occurred_at ], name: "index_rails_pulse_operations_on_query_and_time"
+    connection.add_index :rails_pulse_operations, [ :query_id, :duration, :occurred_at ], name: "index_rails_pulse_operations_query_performance"
+    connection.add_index :rails_pulse_operations, [ :occurred_at, :duration, :operation_type ], name: "index_rails_pulse_operations_on_time_duration_type"
+
+    if adapter.include?("postgres") || adapter.include?("mysql")
+      connection.add_check_constraint :rails_pulse_operations,
+        "(request_id IS NOT NULL OR job_run_id IS NOT NULL)",
+        name: "rails_pulse_operations_request_or_job_run"
+    end
   end
 
-  # Unique constraint and indexes for summaries
-  connection.add_index :rails_pulse_summaries, [ :summarizable_type, :summarizable_id, :period_type, :period_start ],
-          unique: true,
-          name: "idx_pulse_summaries_unique"
-  connection.add_index :rails_pulse_summaries, [ :period_type, :period_start ], name: "index_rails_pulse_summaries_on_period"
-  connection.add_index :rails_pulse_summaries, :created_at, name: "index_rails_pulse_summaries_on_created_at"
+  unless connection.table_exists?(:rails_pulse_summaries)
+    connection.create_table :rails_pulse_summaries do |t|
+      # Time fields
+      t.datetime :period_start, null: false, comment: "Start of the aggregation period"
+      t.datetime :period_end, null: false, comment: "End of the aggregation period"
+      t.string :period_type, null: false, comment: "Aggregation period type: hour, day, week, month"
+
+      # Polymorphic association to handle both routes and queries
+      t.references :summarizable, polymorphic: true, null: false, index: true, comment: "Link to Route or Query"
+      # This creates summarizable_type (e.g., 'RailsPulse::Route', 'RailsPulse::Query')
+      # and summarizable_id (route_id or query_id)
+
+      # Universal metrics
+      t.integer :count, default: 0, null: false, comment: "Total number of requests/operations"
+      t.float :avg_duration, comment: "Average duration in milliseconds"
+      t.float :min_duration, comment: "Minimum duration in milliseconds"
+      t.float :max_duration, comment: "Maximum duration in milliseconds"
+      t.float :p50_duration, comment: "50th percentile duration"
+      t.float :p95_duration, comment: "95th percentile duration"
+      t.float :p99_duration, comment: "99th percentile duration"
+      t.float :total_duration, comment: "Total duration in milliseconds"
+      t.float :stddev_duration, comment: "Standard deviation of duration"
+
+      # Request/Route specific metrics
+      t.integer :error_count, default: 0, comment: "Number of error responses (5xx)"
+      t.integer :success_count, default: 0, comment: "Number of successful responses"
+      t.integer :status_2xx, default: 0, comment: "Number of 2xx responses"
+      t.integer :status_3xx, default: 0, comment: "Number of 3xx responses"
+      t.integer :status_4xx, default: 0, comment: "Number of 4xx responses"
+      t.integer :status_5xx, default: 0, comment: "Number of 5xx responses"
+
+      t.timestamps
+    end
+
+    # Unique constraint and indexes for summaries
+    connection.add_index :rails_pulse_summaries, [ :summarizable_type, :summarizable_id, :period_type, :period_start ],
+            unique: true,
+            name: "idx_pulse_summaries_unique"
+    connection.add_index :rails_pulse_summaries, [ :period_type, :period_start ], name: "index_rails_pulse_summaries_on_period"
+    connection.add_index :rails_pulse_summaries, :created_at, name: "index_rails_pulse_summaries_on_created_at"
+  end
 
   # Add indexes to existing tables for efficient aggregation
-  connection.add_index :rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation"
-  connection.add_index :rails_pulse_requests, :created_at, name: "idx_requests_created_at"
+  unless connection.index_exists?(:rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation")
+    connection.add_index :rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation"
+  end
+
+  unless connection.index_exists?(:rails_pulse_requests, :created_at, name: "idx_requests_created_at")
+    connection.add_index :rails_pulse_requests, :created_at, name: "idx_requests_created_at"
+  end
 
-  connection.add_index :rails_pulse_operations, [ :created_at, :query_id ], name: "idx_operations_for_aggregation"
-  connection.add_index :rails_pulse_operations, :created_at, name: "idx_operations_created_at"
+  unless connection.index_exists?(:rails_pulse_operations, [ :created_at, :query_id ], name: "idx_operations_for_aggregation")
+    connection.add_index :rails_pulse_operations, [ :created_at, :query_id ], name: "idx_operations_for_aggregation"
+  end
+
+  unless connection.index_exists?(:rails_pulse_operations, :created_at, name: "idx_operations_created_at")
+    connection.add_index :rails_pulse_operations, :created_at, name: "idx_operations_created_at"
+  end
 
-  if ENV["CI"] == "true"
-    created_tables = required_tables.select { |table| connection.table_exists?(table) }
-    puts "[RailsPulse::Schema] Successfully created tables: #{created_tables.join(', ')}"
+  # Log successful creation
+  created_tables = required_tables.select { |table| connection.table_exists?(table) }
+  newly_created = created_tables - existing_tables
+  if newly_created.any?
+    puts "[RailsPulse::Schema] Successfully created tables: #{newly_created.join(', ')}"
   end
 end
 

data/lib/generators/rails_pulse/templates/migrations/install_rails_pulse_tables.rb

@@ -1,6 +1,12 @@
 # Generated from Rails Pulse schema - automatically loads current schema definition
 class InstallRailsPulseTables < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>.<%= Rails::VERSION::MINOR %>]
-  def change
+  def up
+    # Check if Rails Pulse is already installed
+    if rails_pulse_installed?
+      say "Rails Pulse tables already exist. Skipping installation.", :yellow
+      return
+    end
+
     # Load and execute the Rails Pulse schema directly
     # This ensures the migration is always in sync with the schema file
     schema_file = File.join(::Rails.root.to_s, "db/rails_pulse_schema.rb")
@@ -20,4 +26,27 @@ class InstallRailsPulseTables < ActiveRecord::Migration[<%= Rails::VERSION::MAJO
       raise "Rails Pulse schema file not found at db/rails_pulse_schema.rb"
     end
   end
+
+  def down
+    # Rollback: drop all Rails Pulse tables in reverse dependency order
+    say "Dropping Rails Pulse tables..."
+
+    drop_table :rails_pulse_operations if table_exists?(:rails_pulse_operations)
+    drop_table :rails_pulse_job_runs if table_exists?(:rails_pulse_job_runs)
+    drop_table :rails_pulse_jobs if table_exists?(:rails_pulse_jobs)
+    drop_table :rails_pulse_summaries if table_exists?(:rails_pulse_summaries)
+    drop_table :rails_pulse_requests if table_exists?(:rails_pulse_requests)
+    drop_table :rails_pulse_routes if table_exists?(:rails_pulse_routes)
+    drop_table :rails_pulse_queries if table_exists?(:rails_pulse_queries)
+
+    say "Rails Pulse tables dropped successfully"
+  end
+
+  private
+
+  def rails_pulse_installed?
+    # Check if core Rails Pulse tables exist
+    # We check for routes and requests as they are foundational tables
+    table_exists?(:rails_pulse_routes) && table_exists?(:rails_pulse_requests)
+  end
 end

data/lib/generators/rails_pulse/templates/rails_pulse.rb

@@ -92,6 +92,37 @@ RailsPulse.configure do |config|
 
   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/lib/rails_pulse/active_job_extensions.rb

@@ -0,0 +1,13 @@
+module RailsPulse
+  module ActiveJobExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      around_perform do |job, block|
+        RailsPulse::JobRunCollector.track(job) do
+          block.call
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/adapters/delayed_job_plugin.rb

@@ -0,0 +1,25 @@
+module RailsPulse
+  module Adapters
+    class DelayedJobPlugin < Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:perform) do |worker, job_data, &block|
+          next block.call(worker, job_data) unless RailsPulse.configuration.enabled
+          next block.call(worker, job_data) unless RailsPulse.configuration.track_jobs
+
+          job_wrapper = JobWrapper.new(
+            job_id: job_data.id.to_s,
+            class_name: job_data.payload_object.class.name,
+            queue_name: job_data.queue,
+            arguments: job_data.payload_object.args,
+            enqueued_at: job_data.created_at,
+            executions: job_data.attempts
+          )
+
+          RailsPulse::JobRunCollector.track(job_wrapper, adapter: "delayed_job") do
+            block.call(worker, job_data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/adapters/sidekiq_middleware.rb

@@ -0,0 +1,41 @@
+module RailsPulse
+  module Adapters
+    class SidekiqMiddleware
+      def call(worker, job_data, queue)
+        return yield unless RailsPulse.configuration.enabled
+        return yield unless RailsPulse.configuration.track_jobs
+
+        # Create ActiveJob-like wrapper for tracking
+        job_wrapper = JobWrapper.new(
+          job_id: job_data["jid"],
+          class_name: worker.class.name,
+          queue_name: queue,
+          arguments: job_data["args"],
+          enqueued_at: Time.at(job_data["enqueued_at"] || Time.current.to_f),
+          executions: job_data["retry_count"] || 0
+        )
+
+        RailsPulse::JobRunCollector.track(job_wrapper, adapter: "sidekiq") do
+          yield
+        end
+      end
+    end
+
+    class JobWrapper
+      attr_reader :job_id, :queue_name, :arguments, :enqueued_at, :executions
+
+      def initialize(job_id:, class_name:, queue_name:, arguments:, enqueued_at:, executions:)
+        @job_id = job_id
+        @class_name = class_name
+        @queue_name = queue_name
+        @arguments = arguments
+        @enqueued_at = enqueued_at
+        @executions = executions
+      end
+
+      def class
+        OpenStruct.new(name: @class_name)
+      end
+    end
+  end
+end

data/lib/rails_pulse/cleanup_service.rb

@@ -39,9 +39,11 @@ module RailsPulse
 
       # Clean up in order that respects foreign key constraints
       @stats[:time_based][:operations] = cleanup_operations_by_time(cutoff_time)
+      @stats[:time_based][:job_runs] = cleanup_job_runs_by_time(cutoff_time)
       @stats[:time_based][:requests] = cleanup_requests_by_time(cutoff_time)
       @stats[:time_based][:queries] = cleanup_queries_by_time(cutoff_time)
       @stats[:time_based][:routes] = cleanup_routes_by_time(cutoff_time)
+      @stats[:time_based][:jobs] = cleanup_jobs_by_time(cutoff_time)
     end
 
     def perform_count_based_cleanup
@@ -51,9 +53,11 @@ module RailsPulse
 
       # Clean up in order that respects foreign key constraints
       @stats[:count_based][:operations] = cleanup_operations_by_count
+      @stats[:count_based][:job_runs] = cleanup_job_runs_by_count
       @stats[:count_based][:requests] = cleanup_requests_by_count
       @stats[:count_based][:queries] = cleanup_queries_by_count
       @stats[:count_based][:routes] = cleanup_routes_by_count
+      @stats[:count_based][:jobs] = cleanup_jobs_by_count
     end
 
     # Time-based cleanup methods
@@ -110,6 +114,27 @@ module RailsPulse
       count
     end
 
+    def cleanup_job_runs_by_time(cutoff_time)
+      return 0 unless defined?(RailsPulse::JobRun)
+
+      job_runs = RailsPulse::JobRun.where("occurred_at < ?", cutoff_time)
+      count = job_runs.count
+      job_runs.delete_all
+      count
+    end
+
+    def cleanup_jobs_by_time(cutoff_time)
+      return 0 unless defined?(RailsPulse::Job)
+
+      job_ids_with_runs = RailsPulse::JobRun.distinct.pluck(:job_id).compact
+      jobs = RailsPulse::Job
+        .where("created_at < ?", cutoff_time)
+        .where.not(id: job_ids_with_runs)
+      count = jobs.count
+      jobs.delete_all
+      count
+    end
+
     # Count-based cleanup methods
     def cleanup_operations_by_count
       return 0 unless defined?(RailsPulse::Operation)
@@ -196,6 +221,46 @@ module RailsPulse
       records_to_delete
     end
 
+    def cleanup_job_runs_by_count
+      return 0 unless defined?(RailsPulse::JobRun)
+
+      max_records = @config.max_table_records[:rails_pulse_job_runs]
+      return 0 unless max_records
+
+      current_count = RailsPulse::JobRun.count
+      return 0 if current_count <= max_records
+
+      records_to_delete = current_count - max_records
+      ids_to_delete = RailsPulse::JobRun
+        .order(:occurred_at)
+        .limit(records_to_delete)
+        .pluck(:id)
+
+      RailsPulse::JobRun.where(id: ids_to_delete).delete_all
+      records_to_delete
+    end
+
+    def cleanup_jobs_by_count
+      return 0 unless defined?(RailsPulse::Job)
+
+      max_records = @config.max_table_records[:rails_pulse_jobs]
+      return 0 unless max_records
+
+      job_ids_with_runs = RailsPulse::JobRun.distinct.pluck(:job_id).compact
+      available_jobs = RailsPulse::Job.where.not(id: job_ids_with_runs)
+      current_count = available_jobs.count
+      return 0 if current_count <= max_records
+
+      records_to_delete = current_count - max_records
+      ids_to_delete = available_jobs
+        .order(:created_at)
+        .limit(records_to_delete)
+        .pluck(:id)
+
+      RailsPulse::Job.where(id: ids_to_delete).delete_all
+      records_to_delete
+    end
+
     def log_cleanup_summary
       total_time_based = @stats[:time_based].values.sum
       total_count_based = @stats[:count_based].values.sum