rails_pulse 0.1.0 → 0.1.2

data/Rakefile

@@ -1,207 +1,109 @@
 require "bundler/setup"
 
+# 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"
 
 # Test tasks
 namespace :test do
-  desc "Run unit tests (fastest - uses in-memory database)"
+  desc "Run unit tests (models, helpers, services, instrumentation)"
   task :unit do
-    ENV["TEST_TYPE"] = "unit"
-    ENV["MEMORY_DATABASE"] = "true"
-    Rake::Task["test:run_unit"].invoke
+    sh "rails test test/models test/helpers test/services test/support test/instrumentation"
   end
 
-  desc "Run functional tests"
+  desc "Run functional tests (controllers)"
   task :functional do
-    ENV["TEST_TYPE"] = "functional"
-    ENV["MEMORY_DATABASE"] = "true"
-    Rake::Task["test:run_functional"].invoke
+    sh "rails test test/controllers"
   end
 
   desc "Run integration tests"
   task :integration do
-    ENV["TEST_TYPE"] = "integration"
-    ENV["MEMORY_DATABASE"] = "false"
-    Rake::Task["test:run_integration"].invoke
+    sh "rails test test/integration test/system"
   end
 
-  desc "Run all tests (unit, functional, integration)"
+  desc "Run all tests"
   task :all do
-    %w[unit functional integration].each do |test_type|
-      puts "\n=== Running #{test_type} tests ==="
-      Rake::Task["test:#{test_type}"].invoke
-    end
-  end
-
-  desc "Run unit tests (alias for test:unit)"
-  task units: :unit
-
-  desc "Run functional tests (alias for test:functional)"
-  task functionals: :functional
-
-  desc "Run integration tests (alias for test:integration)"
-  task integrations: :integration
-
-  desc "Run tests with speed optimizations"
-  task fast: :unit
-
-
-  # Internal tasks
-  task :run_unit do
-    sh "rails test test/models test/middleware test/lib test/support"
-  end
-
-  task :run_functional do
-    sh "rails test test/controllers test/helpers"
-  end
-
-  task :run_integration do
-    sh "rails test test/integration"
-  end
-end
-
-# Speed-optimized test task (unit tests only)
-desc "Run fast unit tests only"
-task test_fast: "test:unit"
-
-# Override default test task to run all tests
-desc "Run all tests"
-task test: "test:all"
-
-# Simplified database testing tasks
-namespace :test do
-  desc "Run tests with SQLite (default)"
-  task :sqlite do
-    puts "🗂️  Testing with SQLite..."
-    Rake::Task["test:all"].invoke
-  end
-
-  desc "Run tests with PostgreSQL"
-  task :postgresql do
-    puts "🐘 Testing with PostgreSQL..."
-    env = ENV.to_h.merge(
-      "DATABASE_ADAPTER" => "postgresql",
-      "FORCE_DB_CONFIG" => "true"
-    )
-    system(env, "rails test:all") || raise("PostgreSQL tests failed")
-  end
-
-  desc "Run tests with MySQL"
-  task :mysql do
-    puts "🐬 Testing with MySQL..."
-    env = ENV.to_h.merge(
-      "DATABASE_ADAPTER" => "mysql2",
-      "FORCE_DB_CONFIG" => "true",
-      "PARALLEL_WORKERS" => "1"
-    )
-    system(env, "rails test:all") || raise("MySQL tests failed")
+    sh "rails test"
   end
 
-  desc "Run test matrix (SQLite + PostgreSQL + MySQL)"
+  desc "Run tests across all database and Rails version combinations (local only - CI uses sqlite3 + postgresql)"
   task :matrix do
-    puts "\n🧪 Running test matrix...\n"
-
-    databases = [
-      { name: "SQLite", env: {}, emoji: "🗂️" },
-      { name: "PostgreSQL", env: { "DATABASE_ADAPTER" => "postgresql", "FORCE_DB_CONFIG" => "true" }, emoji: "🐘" },
-      { name: "MySQL", env: { "DATABASE_ADAPTER" => "mysql2", "FORCE_DB_CONFIG" => "true", "PARALLEL_WORKERS" => "1" }, emoji: "🐬" }
-    ]
-
-    results = {}
-
-    databases.each do |db|
-      puts "\n" + "="*60
-      puts "#{db[:emoji]} Testing with #{db[:name]}..."
-      puts "="*60
-
-      begin
-        env = ENV.to_h.merge(db[:env])
-        success = system(env, "rails test:all")
-
-        results[db[:name]] = success ? "✅ PASSED" : "❌ FAILED"
-      rescue => e
-        results[db[:name]] = "❌ FAILED"
-        puts "Error: #{e.message}"
+    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}"
+        end
       end
     end
 
-    # Print summary
-    puts "\n" + "="*60
-    puts "🏁 TEST MATRIX SUMMARY"
-    puts "="*60
-    results.each do |db, status|
-      puts "#{status} #{db}"
-    end
-    puts "="*60
+    puts "\n" + "=" * 80
+    puts "🏁 Local Test Matrix Results"
+    puts "(CI automatically tests SQLite3 + PostgreSQL only)"
+    puts "=" * 80
 
-    # Fail if any tests failed
-    failed_count = results.values.count { |status| status.include?("FAILED") }
-    if failed_count > 0
-      puts "\n❌ #{failed_count} database(s) failed tests"
-      exit 1
+    if failed_combinations.empty?
+      puts "✅ All combinations passed!"
     else
-      puts "\n🎉 All databases passed!"
-    end
-  end
-
-  desc "Run full test matrix (SQLite + PostgreSQL + MySQL)"
-  task :matrix_full do
-    puts "\n🧪 Running full test matrix...\n"
-
-    databases = [
-      { name: "SQLite", env: {}, emoji: "🗂️" },
-      { name: "PostgreSQL", env: { "DATABASE_ADAPTER" => "postgresql", "FORCE_DB_CONFIG" => "true" }, emoji: "🐘" },
-      { name: "MySQL", env: { "DATABASE_ADAPTER" => "mysql2", "FORCE_DB_CONFIG" => "true", "PARALLEL_WORKERS" => "1" }, emoji: "🐬" }
-    ]
-
-    results = {}
-
-    databases.each do |db|
-      puts "\n" + "="*60
-      puts "#{db[:emoji]} Testing with #{db[:name]}..."
-      puts "="*60
-
-      begin
-        env = ENV.to_h.merge(db[:env])
-        success = system(env, "rails test:all")
-
-        results[db[:name]] = success ? "✅ PASSED" : "❌ FAILED"
-      rescue => e
-        results[db[:name]] = "❌ FAILED"
-        puts "Error: #{e.message}"
-      end
-    end
-
-    # Print summary
-    puts "\n" + "="*60
-    puts "🏁 FULL TEST MATRIX SUMMARY"
-    puts "="*60
-    results.each do |db, status|
-      puts "#{status} #{db}"
-    end
-    puts "="*60
-
-    # Fail if any tests failed
-    failed_count = results.values.count { |status| status.include?("FAILED") }
-    if failed_count > 0
-      puts "\n❌ #{failed_count} database(s) failed tests"
+      puts "❌ Failed combinations:"
+      failed_combinations.each { |combo| puts "  - #{combo}" }
       exit 1
-    else
-      puts "\n🎉 All databases passed!"
     end
   end
 end
 
-# Helper methods
-def mysql_available?
-  system("mysql --version > /dev/null 2>&1")
-end
-
-def postgresql_available?
-  system("psql --version > /dev/null 2>&1")
-end
+# Override default test task
+desc "Run all tests"
+task test: "test:all"

data/app/assets/stylesheets/rails_pulse/application.css

@@ -80,18 +80,6 @@ a:hover {
   position:absolute;
   top:0
 }
-.bar.db {
-  background-color:#92c282
-}
-.bar.app {
-  background-color:#00adc4
-}
-.bar.gc {
-  background-color:#323333
-}
-.bar.view {
-  background-color:#b48da3
-}
 .bar:first-child {
   border-bottom-left-radius:1px;
   border-top-left-radius:1px

data/app/controllers/concerns/chart_table_concern.rb

@@ -16,14 +16,17 @@ module ChartTableConcern
   def setup_chart_and_table_data
     ransack_params = params[:q] || {}
 
-    # Setup chart data first using original time range (no sorting from table)
     unless turbo_frame_request?
-      setup_chart_formatters
+      # Setup chart data first using original time range (no sorting from table)
       setup_chart_data(ransack_params)
+      setup_chart_formatters
     end
 
     # Setup table data using zoom parameters if present, otherwise use chart parameters
     setup_table_data(ransack_params)
+
+    # Set flag to determine if we have meaningful data to display
+    @has_data = has_meaningful_data?
   end
 
   def setup_chart_data(ransack_params)
@@ -31,7 +34,10 @@ module ChartTableConcern
     chart_ransack_query = chart_model.ransack(chart_ransack_params)
     @chart_data = chart_class.new(
       ransack_query: chart_ransack_query,
-      group_by: group_by,
+      period_type: period_type,
+      start_time: @start_time,
+      end_time: @end_time,
+      start_duration: @start_duration,
       **chart_options
     ).to_rails_chart
   end
@@ -43,6 +49,7 @@ module ChartTableConcern
 
     table_results = build_table_results
     handle_pagination
+
     @pagy, @table_data = pagy(table_results, limit: session_pagination_limit)
   end
 
@@ -56,14 +63,24 @@ module ChartTableConcern
   end
 
   def setup_chart_formatters
-    @xaxis_formatter = RailsPulse::ChartFormatters.occurred_at_as_time_or_date(@time_diff_hours)
+    @xaxis_formatter = RailsPulse::ChartFormatters.period_as_time_or_date(@time_diff_hours)
     @tooltip_formatter = RailsPulse::ChartFormatters.tooltip_as_time_or_date_with_marker(@time_diff_hours)
   end
 
+  def period_type
+    @time_diff_hours <= 25 ? :hour : :day
+  end
+
   def group_by
     @time_diff_hours <= 25 ? :group_by_hour : :group_by_day
   end
 
+  def has_meaningful_data?
+    has_chart_data = @chart_data && @chart_data.values.any? { |v| v > 0 }
+    has_table_data = @table_data && @table_data.any?
+    has_chart_data || has_table_data
+  end
+
   def handle_pagination
     method = pagination_method
     send(method, params[:limit]) if params[:limit].present?

data/app/controllers/concerns/response_range_concern.rb

@@ -5,10 +5,13 @@ module ResponseRangeConcern
     ransack_params = params[:q] || {}
     thresholds = RailsPulse.configuration.public_send("#{type}_thresholds")
 
-    if ransack_params[:duration].present?
-      selected_range = ransack_params[:duration]
+    # Check both avg_duration (for Summary) and duration (for Request/Operation)
+    duration_param = ransack_params[:avg_duration] || ransack_params[:duration]
+
+    if duration_param.present?
+      selected_range = duration_param
       start_duration =
-        case ransack_params[:duration].to_sym
+        case duration_param.to_sym
         when :slow then thresholds[:slow]
         when :very_slow then thresholds[:very_slow]
         when :critical then thresholds[:critical]

data/app/controllers/concerns/time_range_concern.rb

@@ -6,8 +6,7 @@ module TimeRangeConcern
     const_set(:TIME_RANGE_OPTIONS, [
       [ "Last 24 hours", :last_day ],
       [ "Last Week", :last_week ],
-      [ "Last Month", :last_month ],
-      [ "All Time", :all_time ]
+      [ "Last Month", :last_month ]
     ].freeze)
   end
 
@@ -18,23 +17,19 @@ module TimeRangeConcern
 
     ransack_params = params[:q] || {}
 
-    if ransack_params[:requests_occurred_at_gteq].present?
-      # Custom time range from routes index chart zoom which filters requests through an association
-      start_time = parse_time_param(ransack_params[:requests_occurred_at_gteq])
-      end_time = parse_time_param(ransack_params[:requests_occurred_at_lt])
-    elsif ransack_params[:occurred_at_gteq].present?
+    if ransack_params[:occurred_at_gteq].present?
       # Custom time range from chart zoom where there is no association
       start_time = parse_time_param(ransack_params[:occurred_at_gteq])
       end_time = parse_time_param(ransack_params[:occurred_at_lt])
-    elsif ransack_params[:occurred_at_range]
+    elsif ransack_params[:period_start_range]
       # Predefined time range from dropdown
-      selected_time_range = ransack_params[:occurred_at_range]
+      selected_time_range = ransack_params[:period_start_range]
       start_time =
         case selected_time_range.to_sym
         when :last_day then 1.day.ago
         when :last_week then 1.week.ago
         when :last_month then 1.month.ago
-        when :all_time then 100.years.ago
+        else 1.day.ago # Default fallback
         end
     end
 

data/app/controllers/concerns/zoom_range_concern.rb

@@ -35,6 +35,6 @@ module ZoomRangeConcern
       end_time = end_time_obj&.end_of_day || end_time_obj
     end
 
-    [ start_time, end_time ]
+    [ start_time.to_i, end_time.to_i ]
   end
 end

data/app/controllers/rails_pulse/application_controller.rb

@@ -2,8 +2,9 @@ module RailsPulse
   class ApplicationController < ActionController::Base
     before_action :authenticate_rails_pulse_user!
 
-    def set_pagination_limit
-      session[:pagination_limit] = params[:limit].to_i if params[:limit].present?
+    def set_pagination_limit(limit = nil)
+      limit = limit || params[:limit]
+      session[:pagination_limit] = limit.to_i if limit.present?
       render json: { status: "ok" }
     end
 
@@ -54,8 +55,11 @@ module RailsPulse
     end
 
     def session_pagination_limit
-      # Keep default small for optimal performance
-      session[:pagination_limit] || 10
+      # Use URL param if present, otherwise session, otherwise default
+      limit = params[:limit].presence || session[:pagination_limit] || 10
+      # Update session if URL param was used
+      session[:pagination_limit] = limit.to_i if params[:limit].present?
+      limit.to_i
     end
 
     def store_pagination_limit(limit)

data/app/controllers/rails_pulse/dashboard_controller.rb

@@ -1,6 +1,18 @@
 module RailsPulse
   class DashboardController < ApplicationController
     def index
+      @average_query_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
+
+      # Generate chart data for inline rendering
+      @average_response_time_chart_data = RailsPulse::Dashboard::Charts::AverageResponseTime.new.to_chart_data
+      @p95_response_time_chart_data = RailsPulse::Dashboard::Charts::P95ResponseTime.new.to_chart_data
+
+      # Generate table data for inline rendering
+      @slow_routes_table_data = RailsPulse::Dashboard::Tables::SlowRoutes.new.to_table_data
+      @slow_queries_table_data = RailsPulse::Dashboard::Tables::SlowQueries.new.to_table_data
     end
   end
 end

data/app/controllers/rails_pulse/queries_controller.rb

@@ -5,21 +5,23 @@ module RailsPulse
     before_action :set_query, only: :show
 
     def index
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     def show
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     private
 
     def chart_model
-      show_action? ? Operation : Query
+      Summary
     end
 
     def table_model
-      show_action? ? Operation : Query
+      show_action? ? Operation : Summary
     end
 
     def chart_class
@@ -31,73 +33,67 @@ module RailsPulse
     end
 
     def build_chart_ransack_params(ransack_params)
-      base_params = ransack_params.except(:s)
+      base_params = ransack_params.except(:s).merge(
+        period_start_gteq: Time.at(@start_time),
+        period_start_lt: Time.at(@end_time)
+      )
+
+      # Only add duration filter if we have a meaningful threshold
+      base_params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
 
       if show_action?
-        base_params.merge(
-          query_id_eq: @query.id,
-          occurred_at_gteq: @start_time,
-          occurred_at_lt: @end_time,
-          duration_gteq: @start_duration
-        )
+        base_params.merge(summarizable_id_eq: @query.id)
       else
-        base_params.merge(
-          operations_occurred_at_gteq: @start_time,
-          operations_occurred_at_lt: @end_time,
-          operations_duration_gteq: @start_duration
-        )
+        base_params
       end
     end
 
     def build_table_ransack_params(ransack_params)
       if show_action?
-        ransack_params.merge(
-          query_id_eq: @query.id,
-          occurred_at_gteq: @table_start_time,
-          occurred_at_lt: @table_end_time,
-          duration_gteq: @start_duration
+        # For Operation 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
         )
+        params[:duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params
       else
-        ransack_params.merge(
-          operations_occurred_at_gteq: @table_start_time,
-          operations_occurred_at_lt: @table_end_time,
-          operations_duration_gteq: @start_duration
+        # For Summary model on index page
+        params = ransack_params.merge(
+          period_start_gteq: Time.at(@table_start_time),
+          period_start_lt: Time.at(@table_end_time)
         )
+        params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params
       end
     end
 
     def default_table_sort
-      "occurred_at desc"
+      show_action? ? "occurred_at desc" : "period_start desc"
     end
 
     def build_table_results
       if show_action?
-        @ransack_query.result.select("id", "occurred_at", "duration")
+        @ransack_query.result
       else
-        # Optimized query: Use INNER JOIN since we only want queries with operations in time range
-        # This dramatically reduces the dataset before aggregation
-        @ransack_query.result(distinct: false)
-          .joins("INNER JOIN rails_pulse_operations ON rails_pulse_operations.query_id = rails_pulse_queries.id")
-          .where("rails_pulse_operations.occurred_at >= ? AND rails_pulse_operations.occurred_at < ?",
-                 @table_start_time, @table_end_time)
-          .group("rails_pulse_queries.id, rails_pulse_queries.normalized_sql, rails_pulse_queries.created_at, rails_pulse_queries.updated_at")
-          .select(
-            "rails_pulse_queries.*",
-            optimized_aggregations_sql
-          )
+        Queries::Tables::Index.new(
+          ransack_query: @ransack_query,
+          period_type: period_type,
+          start_time: @start_time,
+          params: params
+        ).to_table
       end
     end
 
     private
 
-    def optimized_aggregations_sql
-      # Efficient aggregations that work with our composite indexes
-      [
-        "COALESCE(AVG(rails_pulse_operations.duration), 0) AS average_query_time_ms",
-        "COUNT(rails_pulse_operations.id) AS execution_count",
-        "COALESCE(SUM(rails_pulse_operations.duration), 0) AS total_time_consumed",
-        "MAX(rails_pulse_operations.occurred_at) AS occurred_at"
-      ].join(", ")
+    def setup_metric_cards
+      return if turbo_frame_request?
+
+      @average_query_times_metric_card = RailsPulse::Queries::Cards::AverageQueryTimes.new(query: @query).to_metric_card
+      @percentile_query_times_metric_card = RailsPulse::Queries::Cards::PercentileQueryTimes.new(query: @query).to_metric_card
+      @execution_rate_metric_card = RailsPulse::Queries::Cards::ExecutionRate.new(query: @query).to_metric_card
     end
 
     def show_action?
@@ -108,14 +104,33 @@ module RailsPulse
       show_action? ? :set_pagination_limit : :store_pagination_limit
     end
 
-    def set_query
-      @query = Query.find(params[:id])
+    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 Queries::Tables::Index (which handles its own sorting)
+      if show_action?
+        @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 setup_metic_cards
-      @average_query_times_card = Queries::Cards::AverageQueryTimes.new(query: @query).to_metric_card
-      @percentile_response_times_card = Queries::Cards::PercentileQueryTimes.new(query: @query).to_metric_card
-      @execution_rate_card = Queries::Cards::ExecutionRate.new(query: @query).to_metric_card
+    def setup_time_and_response_ranges
+      @start_time, @end_time, @selected_time_range, @time_diff_hours = setup_time_range
+      @start_duration, @selected_response_range = setup_duration_range(:query)
+    end
+
+    def set_query
+      @query = Query.find(params[:id])
     end
   end
 end