rails_pulse 0.1.1 → 0.1.3

data/app/assets/stylesheets/rails_pulse/components/badge.css

@@ -56,3 +56,16 @@
   --badge-border-color: transparent;
   --badge-color: var(--color-negative);
 }
+
+/* Trend badge icon lightening (dark mode only) */
+.badge--trend rails-pulse-icon { color: var(--badge-color, currentColor); }
+html[data-color-scheme="dark"] .badge--trend rails-pulse-icon {
+  /* Lighten icon relative to badge text color for contrast */
+  color: color-mix(in srgb, var(--badge-color) 55%, white 45%);
+}
+
+/* Trend amount lightening (dark mode only) */
+.badge--trend .badge__trend-amount { color: var(--badge-color, currentColor); }
+html[data-color-scheme="dark"] .badge--trend .badge__trend-amount {
+  color: color-mix(in srgb, var(--badge-color) 55%, white 45%);
+}

data/app/assets/stylesheets/rails_pulse/components/base.css

@@ -5,6 +5,10 @@
   --color-text-reversed: white;
   --color-text-subtle: var(--zinc-500);
   --color-link: var(--blue-700);
+  /* Header tokens */
+  --header-bg: #ffc91f;
+  --header-link: black;
+  --header-link-hover-bg: #ffe284;
   --color-border-light: var(--zinc-100);
   --color-border: var(--zinc-200);
   --color-border-dark: var(--zinc-400);
@@ -30,8 +34,9 @@ html[data-color-scheme="dark"] {
   --color-bg: var(--zinc-800);
   --color-text: white;
   --color-text-reversed: black;
-  --color-text-subtle: var(--zinc-400);
-  --color-link: var(--blue-400);
+  --color-text-subtle: var(--zinc-300);
+  /* Use brand yellow for links in dark mode */
+  --color-link: #ffc91f;
   --color-border-light: var(--zinc-900);
   --color-border: var(--zinc-800);
   --color-border-dark: var(--zinc-600);
@@ -39,6 +44,11 @@ html[data-color-scheme="dark"] {
   --color-selected-dark: var(--blue-800);
   --color-highlight: var(--yellow-900);
 
+  /* Header tokens */
+  --header-bg: rgb(32, 32, 32);
+  --header-link: #ffc91f;
+  --header-link-hover-bg: #ffe284; /* keep existing hover color */
+
   /* Accent colors */
   --color-primary: var(--zinc-50);
   --color-secondary: var(--zinc-800);

data/app/assets/stylesheets/rails_pulse/components/collapsible.css

@@ -0,0 +1,30 @@
+.collapsible-code.collapsed pre {
+  max-height: 4.5em;
+  overflow: hidden;
+  position: relative;
+}
+
+.collapsible-code.collapsed pre::after {
+  content: '';
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  height: 1em;
+  background: linear-gradient(transparent, var(--color-border-light));
+  pointer-events: none;
+}
+
+.collapsible-toggle {
+  margin-top: 0.5rem;
+  font-size: 0.875rem;
+  color: var(--color-link);
+  text-decoration: underline;
+  transform: lowercase;
+  cursor: pointer;
+  border: none;
+  background: none;
+  padding: 0;
+  font-weight: normal;
+  margin-left: 10px;
+}

data/app/assets/stylesheets/rails_pulse/components/popover.css

@@ -31,6 +31,5 @@
     left: var(--popover-x, 0) !important;
     top: var(--popover-y, 0) !important;
     margin: 0 !important;
-    inset: unset !important;
   }
 }

data/app/assets/stylesheets/rails_pulse/components/row.css

@@ -3,22 +3,74 @@
   justify-content: space-between;
   width: 100%;
   gap: var(--column-gap, 0.5rem);
+  align-items: stretch;
 }
 
 .row > * {
   flex: 1;
   min-width: 0;
+  display: flex;
+  flex-direction: column;
 }
 
-/* Stack items on smaller screens */
+/* Ensure metric cards and their panels stretch to full height */
+.row > .grid-item {
+  display: flex;
+  flex-direction: column;
+}
+
+.row > .grid-item > * {
+  flex: 1;
+}
+
+/* Responsive layout for screens smaller than 768px */
 @media (max-width: 768px) {
   .row {
-      flex-direction: column;
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: space-between;
       gap: 0.5rem;
+      align-items: flex-start;
   }
 
   .row > * {
+      flex: 0 0 calc(50% - 0.25rem);
+      min-width: 0;
+      height: auto;
+  }
+
+  .row > .grid-item {
+      height: auto;
+  }
+
+  .row > .grid-item > * {
       flex: none;
-      width: 100%;
+  }
+
+  /* Tables should stack in single column on mobile */
+  .row:has(.table-container) > * {
+      flex: 0 0 100%;
+  }
+
+  /* Single column for very small screens */
+  @media (max-width: 480px) {
+    .row > * {
+        flex: 0 0 100%;
+    }
+
+    .row > .grid-item {
+        min-height: auto;
+    }
+
+    /* Make metric cards more compact on mobile */
+    .row > .grid-item .card {
+        padding: var(--size-3);
+    }
+
+    /* Make charts smaller on mobile */
+    .row > .grid-item .chart-container {
+        height: 60px !important;
+        max-height: 60px;
+    }
   }
 }

data/app/assets/stylesheets/rails_pulse/components/sidebar_menu.css

@@ -77,3 +77,26 @@
   padding: var(--size-0_5) var(--size-2);
   row-gap: var(--size-1);
 }
+
+/* Sheet component styles for mobile menu */
+.sheet {
+  border: 0;
+  background: var(--color-bg);
+  max-block-size: none;
+  max-inline-size: none;
+  padding: 0;
+}
+
+.sheet--left {
+  block-size: 100vh;
+  inline-size: var(--sheet-size, 288px);
+  inset-block-start: 0;
+  inset-inline-start: 0;
+}
+
+.sheet__content {
+  block-size: 100%;
+  display: flex;
+  flex-direction: column;
+  overflow-y: auto;
+}

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

@@ -2,10 +2,22 @@ module ZoomRangeConcern
   extend ActiveSupport::Concern
 
   def setup_zoom_range(main_start_time, main_end_time)
+    # Extract column selection parameter (but don't delete it yet - we need it for the view)
+    selected_column_time = params[:selected_column_time]
+
     # Extract zoom parameters from params (this removes them from params)
     zoom_start = params.delete(:zoom_start_time)
     zoom_end = params.delete(:zoom_end_time)
 
+    # Handle column selection with highest precedence for table filtering
+    if selected_column_time
+      column_start, column_end = normalize_column_time(selected_column_time.to_i, main_start_time, main_end_time)
+      table_start_time = column_start
+      table_end_time = column_end
+      # Don't set zoom times for column selection - let chart show full range
+      return [ zoom_start, zoom_end, table_start_time, table_end_time ]
+    end
+
     # Normalize zoom times to beginning/end of day or hour like we do for main time range
     if zoom_start && zoom_end
       zoom_start, zoom_end = normalize_zoom_times(zoom_start.to_i, zoom_end.to_i)
@@ -20,6 +32,25 @@ module ZoomRangeConcern
 
   private
 
+  def normalize_column_time(column_time, main_start_time, main_end_time)
+    # Determine period type based on main time range (same logic as ChartTableConcern)
+    time_diff_hours = (main_end_time - main_start_time) / 3600.0
+
+    if time_diff_hours <= 25
+      # Hourly period - normalize to beginning/end of hour
+      column_time_obj = Time.zone&.at(column_time) || Time.at(column_time)
+      start_time = column_time_obj&.beginning_of_hour || column_time_obj
+      end_time = column_time_obj&.end_of_hour || column_time_obj
+    else
+      # Daily period - normalize to beginning/end of day
+      column_time_obj = Time.zone&.at(column_time) || Time.at(column_time)
+      start_time = column_time_obj&.beginning_of_day || column_time_obj
+      end_time = column_time_obj&.end_of_day || column_time_obj
+    end
+
+    [ start_time.to_i, end_time.to_i ]
+  end
+
   def normalize_zoom_times(start_time, end_time)
     time_diff = (end_time - start_time) / 3600.0
 
@@ -35,6 +66,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,9 +2,14 @@ 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?
-      render json: { status: "ok" }
+    def set_pagination_limit(limit = nil)
+      limit = limit || params[:limit]
+      session[:pagination_limit] = limit.to_i if limit.present?
+
+      # Render JSON for direct API calls or AJAX requests (but not turbo frame requests)
+      if (request.xhr? && !turbo_frame_request?) || (request.patch? && action_name == "set_pagination_limit")
+        render json: { status: "ok" }
+      end
     end
 
     private
@@ -54,8 +59,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

@@ -2,24 +2,60 @@ module RailsPulse
   class QueriesController < ApplicationController
     include ChartTableConcern
 
-    before_action :set_query, only: :show
+    before_action :set_query, only: [ :show, :analyze ]
 
     def index
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     def show
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
+    def analyze
+      begin
+        @analysis_results = QueryAnalysisService.analyze_query(@query.id)
+
+        respond_to do |format|
+          format.turbo_stream {
+            render turbo_stream: turbo_stream.replace(
+              "query_analysis",
+              partial: "rails_pulse/queries/analysis_section",
+              locals: { query: @query.reload }
+            )
+          }
+          format.html {
+            redirect_to query_path(@query), notice: "Query analysis completed successfully."
+          }
+        end
+      rescue => e
+        Rails.logger.error("[QueryAnalysis] Analysis failed for query #{@query.id}: #{e.message}")
+
+        respond_to do |format|
+          format.turbo_stream {
+            render turbo_stream: turbo_stream.replace(
+              "query_analysis",
+              partial: "rails_pulse/queries/analysis_section",
+              locals: { query: @query, error_message: "Analysis failed: #{e.message}" }
+            )
+          }
+          format.html {
+            redirect_to query_path(@query), alert: "Query analysis failed: #{e.message}"
+          }
+        end
+      end
+    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 +67,78 @@ 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")
+        # 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
       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 +149,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_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 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 set_query
+      @query = Query.find(params[:id])
     end
   end
 end