rails_pulse 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11728d425611e7ab3a9edb171f05638a783d1c8d3ded8dff112bb615e8a18d11
-  data.tar.gz: 3e16c2d59f4f4bd8d2df49625d9f6005edc98dec701212a6052f4abfd1cac6f3
+  metadata.gz: 4d5eb9055acbfc951ef6874c484b10f0c4c9a02f4886148fd917ec1f83cdc386
+  data.tar.gz: fe1db6e87b0788868ab99a4c5ee2c818fb2720b8aaa88a59d86023a8a4bc0f92
 SHA512:
-  metadata.gz: 443645ed917ef9beea2d642ff8c4a7d2e57cc87559a09e74dfd75d20d18fb0ff11040eac6e825f3ff0af35637ea23757c88b24e78f35e32f64a7660168aa940a
-  data.tar.gz: d11227a7a11c24bff167104e712f9d075a394130a196938ed71b360e6cbc82a8f930672187b92d0009ed5c14fee882ff23d3d88a3df25b1ddeff3a8839452b5b
+  metadata.gz: 17141eaefe36c4ee6e857fe36ae3ee7c9e500cb6b3dc07ba79b2ba20248cb1a01920d5f0441c09279af0ab04efa020ffe144aeef1f4fb00036094378c1e2fc65
+  data.tar.gz: 8bf37d00fc3b161eb84587eef5562cebe493adb6a0729897f00aed9d38a69b1847ba82781473a8d2b3deb4ad1acea764b014460a758bc12ef686028096974355

data/README.md

@@ -87,15 +87,22 @@ bundle install
 Generate the installation files:
 
 ```bash
+# Install with single database setup (default - recommended)
 rails generate rails_pulse:install
-```
 
-Load the database schema:
+# Or install with separate database setup
+rails generate rails_pulse:install --database=separate
+```
 
+**For single database setup (default):**
 ```bash
-rails db:prepare
+rails db:migrate    # Creates Rails Pulse tables in your main database
 ```
 
+**For separate database setup:**
+1. Configure `config/database.yml` with your Rails Pulse database settings
+2. Run: `rails db:prepare` to create and load the schema
+
 Add the Rails Pulse route to your application:
 
 ```ruby
@@ -122,6 +129,10 @@ Rails Pulse automatically starts collecting performance data once installed. Acc
 http://localhost:3000/rails_pulse
 ```
 
+**Database Setup:**
+- **Single Database (default)**: Rails Pulse tables are created in your main database - no additional configuration needed
+- **Separate Database**: See the [Separate Database Support](#separate-database-support) section for setup instructions
+
 ### Basic Configuration
 
 Customize Rails Pulse in `config/initializers/rails_pulse.rb`:
@@ -287,20 +298,36 @@ RailsPulse::CleanupJob.perform_later
 
 ## Separate Database Support
 
-Rails Pulse supports storing performance monitoring data in a **separate database**. By default, Rails Pulse stores data in your main application database alongside your existing tables.
+Rails Pulse offers two database setup options to fit your application's needs:
+
+### Option 1: Single Database (Default - Recommended)
+
+Stores Rails Pulse data in your main application database alongside your existing tables. This is the simplest setup and works great for most applications.
+
+**Advantages:**
+- Zero additional configuration required
+- Simpler backup and deployment strategies
+- Works with any database (SQLite, PostgreSQL, MySQL)
+
+**Installation:**
+```bash
+rails generate rails_pulse:install
+rails db:migrate
+```
+
+### Option 2: Separate Database
 
-Use a separate database when you want:
+Stores Rails Pulse data in a dedicated database, completely isolated from your main application.
 
+**Use a separate database when you want:**
 - **Isolating monitoring data** from your main application database
 - **Using different database engines** optimized for time-series data
 - **Scaling monitoring independently** from your application
 - **Simplified backup strategies** with separate retention policies
 
-**For shared database setup (default)**, no database configuration is needed - simply run `rails db:prepare` after installation.
-
 ### Configuration
 
-To use a separate database, configure the `connects_to` option in your Rails Pulse initializer:
+To use a separate database, install with the `--database=separate` flag, then configure the `connects_to` option in your Rails Pulse initializer:
 
 ```ruby
 RailsPulse.configure do |config|
@@ -356,17 +383,30 @@ production:
     pool: 5
 ```
 
-### Schema Loading
+### Installation Steps
 
-After installation, load the Rails Pulse database schema:
+**For separate database setup:**
 
-```bash
-rails db:prepare
-```
+1. **Generate installation files:**
+   ```bash
+   rails generate rails_pulse:install --database=separate
+   ```
+
+2. **Configure `config/database.yml`** (see examples above)
+
+3. **Create and load the schema:**
+   ```bash
+   rails db:prepare
+   ```
+   This automatically creates the database and loads the Rails Pulse schema.
+
+**Schema Management:**
 
-This command works for both:
-- Shared database setup (default): Loads tables into your main application database
-- Separate database setup: Automatically loads tables into your configured Rails Pulse database
+The schema file `db/rails_pulse_schema.rb` serves as your single source of truth for the database structure. It:
+- Defines all Rails Pulse tables in one place
+- Is loaded by the installation migration
+- Should not be deleted or modified
+- Future updates will provide migrations in `db/rails_pulse_migrate/`
 
 ## Testing
 

data/Rakefile

@@ -1,109 +1,192 @@
 require "bundler/setup"
+require "bundler/gem_tasks"
 
 # Load environment variables from .env file
 require "dotenv/load" if File.exist?(".env")
 
 APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
 load "rails/tasks/engine.rake"
-load "rails/tasks/statistics.rake"
 
-require "bundler/gem_tasks"
+desc "Setup database for testing"
+task :test_setup do
+  database = ENV['DB'] || 'sqlite3'
+
+  puts "\n" + "=" * 50
+  puts "🛠️  Rails Pulse Test Setup"
+  puts "=" * 50
+  puts "Database: #{database.upcase}"
+  puts "=" * 50
+  puts
+
+  begin
+    # Remove schema.rb to ensure clean migration
+    schema_file = "test/dummy/db/schema.rb"
+    if File.exist?(schema_file)
+      puts "🧹 Removing existing schema.rb file..."
+      File.delete(schema_file)
+    end
 
-# Test tasks
-namespace :test do
-  desc "Run unit tests (models, helpers, services, instrumentation)"
-  task :unit do
-    sh "rails test test/models test/helpers test/services test/support test/instrumentation"
-  end
+    case database.downcase
+    when 'sqlite3', 'sqlite'
+      puts "📦 Setting up SQLite database..."
+      sh "RAILS_ENV=test bin/rails db:drop db:create db:migrate"
+
+    when 'mysql2', 'mysql'
+      puts "🐬 Setting up MySQL database..."
+      sh "DB=mysql2 RAILS_ENV=test rails db:drop db:create db:migrate"
+
+    when 'postgresql', 'postgres'
+      puts "🐘 Setting up PostgreSQL database..."
+      sh "DB=postgresql RAILS_ENV=test rails db:drop db:create db:migrate"
+
+    else
+      puts "⚠️  Unknown database: #{database}"
+      puts "Supported databases: sqlite3, mysql2, postgresql"
+      exit 1
+    end
 
-  desc "Run functional tests (controllers)"
-  task :functional do
-    sh "rails test test/controllers"
+    puts "\n✅ Database setup complete!"
+    puts "Ready to run: rake test"
+
+  rescue => e
+    puts "\n❌ Database setup failed!"
+    puts "Error: #{e.message}"
+    puts "\nTroubleshooting:"
+    puts "• Ensure #{database} is installed and running"
+    puts "• Check database credentials in test/dummy/config/database.yml"
+    puts "• Verify RAILS_ENV=test environment is configured"
+    exit 1
   end
+end
 
-  desc "Run integration tests"
-  task :integration do
-    sh "rails test test/integration test/system"
+desc "Run test suite"
+task :test do
+  database = ENV['DB'] || 'sqlite3'
+
+  # Get Rails version from Gemfile.lock or fallback
+  rails_version = begin
+    require 'rails'
+    Rails.version
+  rescue LoadError
+    # Try to get from Gemfile.lock
+    gemfile_lock = File.read('Gemfile.lock') rescue nil
+    if gemfile_lock && gemfile_lock.match(/rails \(([^)]+)\)/)
+      $1
+    else
+      'unknown'
+    end
   end
 
-  desc "Run all tests"
-  task :all do
-    sh "rails test"
+  puts "\n" + "=" * 50
+  puts "💛 Rails Pulse Test Suite"
+  puts "=" * 50
+  puts "Database: #{database.upcase}"
+  puts "Rails: #{rails_version}"
+  puts "=" * 50
+  puts
+
+  sh "rails test test/controllers test/helpers test/instrumentation test/jobs test/models test/services test/system"
+end
+
+desc "Setup database for specific Rails version and database"
+task :test_setup_for_version, [ :database, :rails_version ] do |t, args|
+  database = args[:database] || ENV['DB'] || 'sqlite3'
+  rails_version = args[:rails_version] || 'rails-8-0'
+
+  puts "\n" + "=" * 50
+  puts "🛠️  Rails Pulse Test Setup"
+  puts "=" * 50
+  puts "Database: #{database.upcase}"
+  puts "Rails: #{rails_version.upcase.gsub('-', ' ')}"
+  puts "=" * 50
+  puts
+
+  begin
+    # Remove schema.rb to ensure clean migration
+    schema_file = "test/dummy/db/schema.rb"
+    if File.exist?(schema_file)
+      puts "🧹 Removing existing schema.rb file..."
+      File.delete(schema_file)
+    end
+
+    if rails_version == "rails-8-0" && database == "sqlite3"
+      # Use current default setup
+      puts "📦 Setting up #{database.upcase} database with Rails 8.0..."
+      sh "RAILS_ENV=test bin/rails db:drop db:create db:migrate"
+    else
+      # Use appraisal with specific database and Rails version
+      puts "📦 Setting up #{database.upcase} database with #{rails_version.upcase.gsub('-', ' ')}..."
+      sh "DB=#{database} bundle exec appraisal #{rails_version} rails db:drop db:create db:migrate RAILS_ENV=test"
+    end
+
+    puts "\n✅ Database setup complete for #{database.upcase} + #{rails_version.upcase.gsub('-', ' ')}!"
+
+  rescue => e
+    puts "\n❌ Database setup failed!"
+    puts "Error: #{e.message}"
+    exit 1
   end
+end
 
-  desc "Run tests across all database and Rails version combinations (local only - CI uses sqlite3 + postgresql)"
-  task :matrix do
-    databases = [ "sqlite3", "postgresql", "mysql2" ]
-    rails_versions = [ "rails-7-2", "rails-8-0" ]
-
-    failed_combinations = []
-
-    databases.each do |database|
-      rails_versions.each do |rails_version|
-        puts "\n" + "=" * 80
-        puts "🧪 Local Testing: #{database.upcase} + #{rails_version.upcase}"
-        puts "(CI only tests SQLite3 + PostgreSQL for reliability)"
-        puts "=" * 80
-
-        begin
-          gemfile = "gemfiles/#{rails_version.gsub('-', '_')}.gemfile"
-
-          # Set environment variables
-          env_vars = {
-            "DB" => database,
-            "BUNDLE_GEMFILE" => gemfile,
-            "FORCE_DB_CONFIG" => "true"
-          }
-
-          # Add database-specific environment variables
-          case database
-          when "postgresql"
-            env_vars.merge!({
-              "POSTGRES_USERNAME" => ENV.fetch("POSTGRES_USERNAME", "postgres"),
-              "POSTGRES_PASSWORD" => ENV.fetch("POSTGRES_PASSWORD", ""),
-              "POSTGRES_HOST" => ENV.fetch("POSTGRES_HOST", "localhost"),
-              "POSTGRES_PORT" => ENV.fetch("POSTGRES_PORT", "5432")
-            })
-          when "mysql2"
-            env_vars.merge!({
-              "MYSQL_USERNAME" => ENV.fetch("MYSQL_USERNAME", "root"),
-              "MYSQL_PASSWORD" => ENV.fetch("MYSQL_PASSWORD", "password"),
-              "MYSQL_HOST" => ENV.fetch("MYSQL_HOST", "localhost"),
-              "MYSQL_PORT" => ENV.fetch("MYSQL_PORT", "3306")
-            })
-          end
-
-          # Build environment string
-          env_string = env_vars.map { |k, v| "#{k}=#{v}" }.join(" ")
-
-          # Run the test command
-          sh "#{env_string} bundle exec rails test:all"
-
-          puts "✅ PASSED: #{database} + #{rails_version}"
-
-        rescue => e
-          puts "❌ FAILED: #{database} + #{rails_version}"
-          puts "Error: #{e.message}"
-          failed_combinations << "#{database} + #{rails_version}"
+desc "Test all database and Rails version combinations"
+task :test_matrix do
+  databases = %w[sqlite3 postgresql mysql2]
+  rails_versions = %w[rails-7-2 rails-8-0]
+
+  failed_combinations = []
+  total_combinations = databases.size * rails_versions.size
+  current = 0
+
+  puts "\n" + "=" * 60
+  puts "🚀 Rails Pulse Full Test Matrix"
+  puts "=" * 60
+  puts "Testing #{total_combinations} combinations..."
+  puts "=" * 60
+
+  databases.each do |database|
+    rails_versions.each do |rails_version|
+      current += 1
+
+      puts "\n[#{current}/#{total_combinations}] Testing: #{database.upcase} + #{rails_version.upcase.gsub('-', ' ')}"
+      puts "-" * 50
+
+      begin
+        # First setup the database for this specific combination
+        Rake::Task[:test_setup_for_version].reenable
+        Rake::Task[:test_setup_for_version].invoke(database, rails_version)
+
+        # Then run the tests
+        if rails_version == "rails-8-0" && database == "sqlite3"
+          # Current default setup
+          sh "bundle exec rake test"
+        else
+          # Use appraisal with specific database
+          sh "DB=#{database} bundle exec appraisal #{rails_version} rake test"
         end
-      end
-    end
 
-    puts "\n" + "=" * 80
-    puts "🏁 Local Test Matrix Results"
-    puts "(CI automatically tests SQLite3 + PostgreSQL only)"
-    puts "=" * 80
+        puts "✅ PASSED: #{database} + #{rails_version}"
 
-    if failed_combinations.empty?
-      puts "✅ All combinations passed!"
-    else
-      puts "❌ Failed combinations:"
-      failed_combinations.each { |combo| puts "  - #{combo}" }
-      exit 1
+      rescue => e
+        puts "❌ FAILED: #{database} + #{rails_version}"
+        puts "   Error: #{e.message}"
+        failed_combinations << "#{database} + #{rails_version}"
+      end
     end
   end
+
+  puts "\n" + "=" * 60
+  puts "🏁 Test Matrix Results"
+  puts "=" * 60
+
+  if failed_combinations.empty?
+    puts "🎉 All #{total_combinations} combinations passed!"
+  else
+    puts "✅ Passed: #{total_combinations - failed_combinations.size}/#{total_combinations}"
+    puts "❌ Failed combinations:"
+    failed_combinations.each { |combo| puts "   • #{combo}" }
+    exit 1
+  end
 end
 
-# Override default test task
-desc "Run all tests"
-task test: "test:all"
+
+task default: :test

data/app/controllers/rails_pulse/queries_controller.rb

@@ -55,7 +55,7 @@ module RailsPulse
     end
 
     def table_model
-      show_action? ? Operation : Summary
+      Summary
     end
 
     def chart_class
@@ -76,7 +76,10 @@ module RailsPulse
       base_params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
 
       if show_action?
-        base_params.merge(summarizable_id_eq: @query.id)
+        base_params.merge(
+          summarizable_id_eq: @query.id,
+          summarizable_type_eq: "RailsPulse::Query"
+        )
       else
         base_params
       end
@@ -84,13 +87,14 @@ module RailsPulse
 
     def build_table_ransack_params(ransack_params)
       if show_action?
-        # For Operation model on show page
+        # For Summary model on show page
         params = ransack_params.merge(
-          occurred_at_gteq: Time.at(@table_start_time),
-          occurred_at_lt: Time.at(@table_end_time),
-          query_id_eq: @query.id
+          period_start_gteq: Time.at(@table_start_time),
+          period_start_lt: Time.at(@table_end_time),
+          summarizable_id_eq: @query.id,
+          summarizable_type_eq: "RailsPulse::Query"
         )
-        params[:duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
         params
       else
         # For Summary model on index page
@@ -104,23 +108,13 @@ module RailsPulse
     end
 
     def default_table_sort
-      show_action? ? "occurred_at desc" : "period_start desc"
+      "period_start desc"
     end
 
     def build_table_results
       if show_action?
-        # Only show operations that belong to time periods where we have query summaries
-        # This ensures the table data is consistent with the chart data
-        @ransack_query.result
-          .joins(<<~SQL)
-            INNER JOIN rails_pulse_summaries ON
-              rails_pulse_summaries.summarizable_id = rails_pulse_operations.query_id AND
-              rails_pulse_summaries.summarizable_type = 'RailsPulse::Query' AND
-              rails_pulse_summaries.period_type = '#{period_type}' AND
-              rails_pulse_operations.occurred_at >= rails_pulse_summaries.period_start AND
-              rails_pulse_operations.occurred_at < rails_pulse_summaries.period_end
-          SQL
-          .distinct
+        # For Summary model on show page - ransack params already include query ID and type filters
+        @ransack_query.result.where(period_type: period_type)
       else
         Queries::Tables::Index.new(
           ransack_query: @ransack_query,

data/app/controllers/rails_pulse/requests_controller.rb

@@ -5,13 +5,7 @@ module RailsPulse
     before_action :set_request, only: :show
 
     def index
-      unless turbo_frame_request?
-        @average_response_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil).to_metric_card
-        @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil).to_metric_card
-        @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil).to_metric_card
-        @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil).to_metric_card
-      end
-
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
@@ -21,12 +15,22 @@ module RailsPulse
 
     private
 
+    def setup_metric_cards
+      return if  turbo_frame_request?
+
+      @average_response_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil).to_metric_card
+      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil).to_metric_card
+    end
+
+
     def chart_model
-      Summary
+      RailsPulse::Summary
     end
 
     def table_model
-      Request
+      RailsPulse::Request
     end
 
     def chart_class
@@ -64,27 +68,36 @@ module RailsPulse
     end
 
     def build_table_results
-      # Only show requests that belong to time periods where we have overall request summaries
-      # This ensures the table data is consistent with the chart data
-      @ransack_query.result
-        .joins(:route)
-        .joins(<<~SQL)
-          INNER JOIN rails_pulse_summaries ON
-            rails_pulse_summaries.summarizable_id = 0 AND
-            rails_pulse_summaries.summarizable_type = 'RailsPulse::Request' AND
-            rails_pulse_summaries.period_type = '#{period_type}' AND
-            rails_pulse_requests.occurred_at >= rails_pulse_summaries.period_start AND
-            rails_pulse_requests.occurred_at < rails_pulse_summaries.period_end
-        SQL
-        .select(
-          "rails_pulse_requests.id",
-          "rails_pulse_requests.occurred_at",
-          "rails_pulse_requests.duration",
-          "rails_pulse_requests.status",
-          "rails_pulse_requests.route_id",
-          "rails_pulse_routes.path"
-        )
-        .distinct
+      base_query = @ransack_query.result.includes(:route)
+
+      # If sorting by route_path, we need to join the routes table
+      if @ransack_query.sorts.any? { |sort| sort.name == "route_path" }
+        base_query = base_query.joins(:route)
+      end
+
+      base_query
+    end
+
+
+    def setup_table_data(ransack_params)
+      table_ransack_params = build_table_ransack_params(ransack_params)
+      @ransack_query = table_model.ransack(table_ransack_params)
+
+      # Only apply default sort if not using Requests::Tables::Index (which handles its own sorting)
+      # For requests, we always use the Tables::Index on the index action
+      unless action_name == "index"
+        @ransack_query.sorts = default_table_sort if @ransack_query.sorts.empty?
+      end
+
+      table_results = build_table_results
+      handle_pagination
+
+      @pagy, @table_data = pagy(table_results, limit: session_pagination_limit)
+    end
+
+    def handle_pagination
+      method = pagination_method
+      send(method, params[:limit]) if params[:limit].present?
     end
 
     def set_request

data/app/helpers/rails_pulse/breadcrumbs_helper.rb

@@ -25,7 +25,7 @@ module RailsPulse
 
       return crumbs if path_segments.empty?
 
-      current_path = "/rails_pulse"
+      current_path = main_app.rails_pulse_path.chomp("/")
 
       path_segments.each_with_index do |segment, index|
         current_path += "/#{segment}"

data/app/helpers/rails_pulse/chart_helper.rb

@@ -27,7 +27,7 @@ module RailsPulse
           top: "10%",
           containLabel: true
         },
-        animation: false
+        animation: true
       }
     end
 

data/app/helpers/rails_pulse/formatting_helper.rb

@@ -3,7 +3,8 @@ module RailsPulse
     def human_readable_occurred_at(occurred_at)
       return "" unless occurred_at.present?
       time = occurred_at.is_a?(String) ? Time.parse(occurred_at) : occurred_at
-      time.strftime("%b %d, %Y %l:%M %p")
+      # Convert to local system timezone (same as charts use)
+      time.getlocal.strftime("%b %d, %Y %l:%M %p")
     end
 
     def time_ago_in_words(time)
@@ -11,8 +12,10 @@ module RailsPulse
 
       # Convert to Time object if it's a string
       time = Time.parse(time.to_s) if time.is_a?(String)
+      # Convert to local system timezone for consistent calculation
+      time = time.getlocal
 
-      seconds_ago = Time.current - time
+      seconds_ago = Time.now - time
 
       case seconds_ago
       when 0..59
@@ -25,5 +28,21 @@ module RailsPulse
         "#{(seconds_ago / 86400).to_i}d ago"
       end
     end
+
+    def human_readable_summary_period(summary)
+      return "" unless summary&.period_start&.present? && summary&.period_end&.present?
+
+      # Convert UTC times to local system timezone to match chart display
+      start_time = summary.period_start.getlocal
+      end_time = summary.period_end.getlocal
+
+
+      case summary.period_type
+      when "hour"
+        start_time.strftime("%b %e %Y, %l:%M %p") + " - " + end_time.strftime("%l:%M %p")
+      when "day"
+        start_time.strftime("%b %e, %Y")
+      end
+    end
   end
 end