rails_pulse 0.1.1 → 0.1.2

data/app/models/rails_pulse/summary.rb

@@ -0,0 +1,143 @@
+module RailsPulse
+  class Summary < RailsPulse::ApplicationRecord
+    self.table_name = "rails_pulse_summaries"
+
+    PERIOD_TYPES = %w[hour day week month].freeze
+
+    # Polymorphic association
+    belongs_to :summarizable, polymorphic: true, optional: true  # Optional for Request summaries
+
+    # Convenience associations for easier querying
+    belongs_to :route, -> { where(rails_pulse_summaries: { summarizable_type: "RailsPulse::Route" }) },
+               foreign_key: "summarizable_id", class_name: "RailsPulse::Route", optional: true
+    belongs_to :query, -> { where(rails_pulse_summaries: { summarizable_type: "RailsPulse::Query" }) },
+               foreign_key: "summarizable_id", class_name: "RailsPulse::Query", optional: true
+
+    # Validations
+    validates :period_type, inclusion: { in: PERIOD_TYPES }
+    validates :period_start, presence: true
+    validates :period_end, presence: true
+
+    # Scopes
+    scope :for_period_type, ->(type) { where(period_type: type) }
+    scope :for_date_range, ->(start_date, end_date) {
+      where(period_start: start_date..end_date)
+    }
+    scope :for_requests, -> { where(summarizable_type: "RailsPulse::Request") }
+    scope :for_routes, -> { where(summarizable_type: "RailsPulse::Route") }
+    scope :for_queries, -> { where(summarizable_type: "RailsPulse::Query") }
+    scope :recent, -> { order(period_start: :desc) }
+
+    # Special scope for overall request summaries
+    scope :overall_requests, -> {
+      where(summarizable_type: "RailsPulse::Request", summarizable_id: 0)
+    }
+
+    # Ransack configuration
+    def self.ransackable_attributes(auth_object = nil)
+      %w[
+        period_start period_end avg_duration max_duration count error_count
+        requests_per_minute error_rate_percentage route_path_cont
+        execution_count total_time_consumed normalized_sql
+      ]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[route query]
+    end
+
+    # Custom ransackers for calculated fields (designed to work with GROUP BY queries)
+    ransacker :count do
+      Arel.sql("SUM(rails_pulse_summaries.count)")  # Use SUM for proper grouping
+    end
+
+    ransacker :requests_per_minute do
+      Arel.sql("SUM(rails_pulse_summaries.count) / 60.0")  # Use SUM for consistency
+    end
+
+    ransacker :error_rate_percentage do
+      Arel.sql("(SUM(rails_pulse_summaries.error_count) * 100.0) / SUM(rails_pulse_summaries.count)")  # Use SUM for both
+    end
+
+
+    # Ransacker for route path sorting (when joined with routes table)
+    ransacker :route_path do
+      Arel.sql("rails_pulse_routes.path")
+    end
+
+    # Ransacker for route path filtering using subquery (works without JOIN)
+    ransacker :route_path_cont do |parent|
+      Arel.sql(<<-SQL)
+        rails_pulse_summaries.summarizable_id IN (
+          SELECT id FROM rails_pulse_routes
+          WHERE rails_pulse_routes.path LIKE '%' || ? || '%'
+        )
+      SQL
+    end
+
+    # Sorting-specific ransackers for GROUP BY compatibility (used only in ORDER BY)
+    # These use different names to avoid conflicts with filtering
+    ransacker :avg_duration_sort do
+      Arel.sql("AVG(rails_pulse_summaries.avg_duration)")
+    end
+
+    ransacker :max_duration_sort do
+      Arel.sql("MAX(rails_pulse_summaries.max_duration)")
+    end
+
+    ransacker :count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.count)")
+    end
+
+    ransacker :error_count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.error_count)")
+    end
+
+    ransacker :success_count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.success_count)")
+    end
+
+    ransacker :total_time_consumed_sort do
+      Arel.sql("SUM(rails_pulse_summaries.count * rails_pulse_summaries.avg_duration)")
+    end
+
+    # Alias execution_count_sort to count_sort for queries table compatibility
+    ransacker :execution_count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.count)")
+    end
+
+    # Ransackers for queries table calculated fields
+    ransacker :execution_count do
+      Arel.sql("SUM(rails_pulse_summaries.count)")  # Total executions
+    end
+
+    ransacker :total_time_consumed do
+      Arel.sql("SUM(rails_pulse_summaries.count * rails_pulse_summaries.avg_duration)")  # Total time consumed
+    end
+
+    # Ransacker for query SQL sorting (when joined with queries table)
+    ransacker :normalized_sql do
+      Arel.sql("rails_pulse_queries.normalized_sql")
+    end
+
+    class << self
+      def calculate_period_end(period_type, start_time)
+        case period_type
+        when "hour"  then start_time.end_of_hour
+        when "day"   then start_time.end_of_day
+        when "week"  then start_time.end_of_week
+        when "month" then start_time.end_of_month
+        end
+      end
+
+      def normalize_period_start(period_type, time)
+        case period_type
+        when "hour"  then time.beginning_of_hour
+        when "day"   then time.beginning_of_day
+        when "week"  then time.beginning_of_week
+        when "month" then time.beginning_of_month
+        end
+      end
+    end
+  end
+end

data/app/services/rails_pulse/summary_service.rb

@@ -0,0 +1,199 @@
+
+module RailsPulse
+  class SummaryService
+    attr_reader :period_type, :start_time, :end_time
+
+    def initialize(period_type, start_time)
+      @period_type = period_type
+      @start_time = Summary.normalize_period_start(period_type, start_time)
+      @end_time = Summary.calculate_period_end(period_type, @start_time)
+    end
+
+    def perform
+      Rails.logger.info "[RailsPulse] Starting #{period_type} summary for #{start_time}"
+
+      ActiveRecord::Base.transaction do
+        aggregate_requests  # Overall system metrics
+        aggregate_routes    # Per-route metrics
+        aggregate_queries   # Per-query metrics
+      end
+
+      Rails.logger.info "[RailsPulse] Completed #{period_type} summary"
+    rescue => e
+      Rails.logger.error "[RailsPulse] Summary failed: #{e.message}"
+      raise
+    end
+
+    private
+
+    def aggregate_requests
+      # Create a single summary for ALL requests in this period
+      requests = Request.where(occurred_at: start_time...end_time)
+
+      return if requests.empty?
+
+      # Get all durations and statuses for percentile calculations
+      request_data = requests.pluck(:duration, :status)
+      durations = request_data.map(&:first).compact.sort
+      statuses = request_data.map(&:second)
+
+      # Find or create the overall request summary
+      summary = Summary.find_or_initialize_by(
+        summarizable_type: "RailsPulse::Request",
+        summarizable_id: 0,  # Use 0 as a special ID for overall summaries
+        period_type: period_type,
+        period_start: start_time
+      )
+
+      summary.assign_attributes(
+        period_end: end_time,
+        count: durations.size,
+        avg_duration: durations.any? ? durations.sum.to_f / durations.size : 0,
+        min_duration: durations.min,
+        max_duration: durations.max,
+        total_duration: durations.sum,
+        p50_duration: calculate_percentile(durations, 0.5),
+        p95_duration: calculate_percentile(durations, 0.95),
+        p99_duration: calculate_percentile(durations, 0.99),
+        stddev_duration: calculate_stddev(durations, durations.sum.to_f / durations.size),
+        error_count: statuses.count { |s| s >= 400 },
+        success_count: statuses.count { |s| s < 400 },
+        status_2xx: statuses.count { |s| s.between?(200, 299) },
+        status_3xx: statuses.count { |s| s.between?(300, 399) },
+        status_4xx: statuses.count { |s| s.between?(400, 499) },
+        status_5xx: statuses.count { |s| s >= 500 }
+      )
+
+      summary.save!
+    end
+
+    private
+
+    def aggregate_routes
+      # Use ActiveRecord for cross-database compatibility
+      route_groups = Request
+        .where(occurred_at: start_time...end_time)
+        .where.not(route_id: nil)
+        .group(:route_id)
+
+      # Calculate basic aggregates
+      basic_stats = route_groups.pluck(
+        :route_id,
+        Arel.sql("COUNT(*) as request_count"),
+        Arel.sql("AVG(duration) as avg_duration"),
+        Arel.sql("MIN(duration) as min_duration"),
+        Arel.sql("MAX(duration) as max_duration"),
+        Arel.sql("SUM(duration) as total_duration")
+      )
+
+      basic_stats.each do |stats|
+        route_id = stats[0]
+
+        # Calculate percentiles and status counts separately for cross-DB compatibility
+        durations = Request
+          .where(occurred_at: start_time...end_time)
+          .where(route_id: route_id)
+          .pluck(:duration, :status)
+
+        sorted_durations = durations.map(&:first).compact.sort
+        statuses = durations.map(&:last)
+
+        summary = Summary.find_or_initialize_by(
+          summarizable_type: "RailsPulse::Route",
+          summarizable_id: route_id,
+          period_type: period_type,
+          period_start: start_time
+        )
+
+        summary.assign_attributes(
+          period_end: end_time,
+          count: stats[1],
+          avg_duration: stats[2],
+          min_duration: stats[3],
+          max_duration: stats[4],
+          total_duration: stats[5],
+          p50_duration: calculate_percentile(sorted_durations, 0.5),
+          p95_duration: calculate_percentile(sorted_durations, 0.95),
+          p99_duration: calculate_percentile(sorted_durations, 0.99),
+          stddev_duration: calculate_stddev(sorted_durations, stats[2]),
+          error_count: statuses.count { |s| s >= 400 },
+          success_count: statuses.count { |s| s < 400 },
+          status_2xx: statuses.count { |s| s.between?(200, 299) },
+          status_3xx: statuses.count { |s| s.between?(300, 399) },
+          status_4xx: statuses.count { |s| s.between?(400, 499) },
+          status_5xx: statuses.count { |s| s >= 500 }
+        )
+
+        summary.save!
+      end
+    end
+
+    def aggregate_queries
+      query_groups = Operation
+        .where(occurred_at: start_time...end_time)
+        .where.not(query_id: nil)
+        .group(:query_id)
+
+      basic_stats = query_groups.pluck(
+        :query_id,
+        Arel.sql("COUNT(*) as execution_count"),
+        Arel.sql("AVG(duration) as avg_duration"),
+        Arel.sql("MIN(duration) as min_duration"),
+        Arel.sql("MAX(duration) as max_duration"),
+        Arel.sql("SUM(duration) as total_duration")
+      )
+
+      basic_stats.each do |stats|
+        query_id = stats[0]
+
+        # Calculate percentiles separately
+        durations = Operation
+          .where(occurred_at: start_time...end_time)
+          .where(query_id: query_id)
+          .pluck(:duration)
+          .compact
+          .sort
+
+        summary = Summary.find_or_initialize_by(
+          summarizable_type: "RailsPulse::Query",
+          summarizable_id: query_id,
+          period_type: period_type,
+          period_start: start_time
+        )
+
+        summary.assign_attributes(
+          period_end: end_time,
+          count: stats[1],
+          avg_duration: stats[2],
+          min_duration: stats[3],
+          max_duration: stats[4],
+          total_duration: stats[5],
+          p50_duration: calculate_percentile(durations, 0.5),
+          p95_duration: calculate_percentile(durations, 0.95),
+          p99_duration: calculate_percentile(durations, 0.99),
+          stddev_duration: calculate_stddev(durations, stats[2])
+        )
+
+        summary.save!
+      end
+    end
+
+    def calculate_percentile(sorted_array, percentile)
+      return nil if sorted_array.empty?
+
+      k = (percentile * (sorted_array.length - 1)).floor
+      f = (percentile * (sorted_array.length - 1)) - k
+
+      return sorted_array[k] if f == 0 || k + 1 >= sorted_array.length
+
+      sorted_array[k] + (sorted_array[k + 1] - sorted_array[k]) * f
+    end
+
+    def calculate_stddev(values, mean)
+      return nil if values.empty? || values.size == 1
+
+      sum_of_squares = values.sum { |v| (v - mean) ** 2 }
+      Math.sqrt(sum_of_squares / (values.size - 1))
+    end
+  end
+end

data/app/views/layouts/rails_pulse/application.html.erb

@@ -28,12 +28,12 @@
         <dialog class="sheet sheet--left" style="--sheet-size: 288px;" data-rails-pulse--dialog-target="menu" data-action="click->rails-pulse--dialog#closeOnClickOutside">
           <div class="sheet__content p-2">
             <div class="sidebar-menu">
-              <a class="btn sidebar-menu__button" href="#">
+              <%= link_to rails_pulse.root_path, class: "btn sidebar-menu__button" do %>
                 <div class="flex flex-col text-start leading-tight overflow-hidden">
                   <span class="overflow-ellipsis font-semibold">Rails Pulse</span>
                   <span class="overflow-ellipsis text-xs">Open Source</span>
                 </div>
-              </a>
+              <% end %>
               <div class="sidebar-menu__content">
                 <div class="sidebar-menu__group">
                   <nav class="sidebar-menu__items">
@@ -47,9 +47,9 @@
       </div>
 
       <div class="flex items-center gap">
-        <a class="flex items-center gap mie-2" href="#">
+        <%= link_to rails_pulse.root_path, class: "flex items-center gap mie-2" do %>
           <span class="font-bold">Rails Pulse</span>
-        </a>
+        <% end %>
         <nav class="flex items-center gap text-sm text-subtle show@md" style="--column-gap: 1rem">
           <%= render 'layouts/rails_pulse/menu_items' %>
         </nav>

data/app/views/rails_pulse/components/_empty_state.html.erb

@@ -0,0 +1,11 @@
+<div class="flex items-center justify-center pbs-12 pbe-12 pis-6 pie-6 mb-8">
+  <div class="flex items-center gap">
+    <div class="shrink-0">
+      <img src="<%= asset_path('search.svg') %>" class="w-32 h-24 opacity-50" alt="No data available" />
+    </div>
+    <div class="text-subtle pis-8">
+      <p class="text-lg font-semibold mbe-2"><%= title %></p>
+      <p class="text-sm"><%= description %></p>
+    </div>
+  </div>
+</div>

data/app/views/rails_pulse/components/_metric_card.html.erb

@@ -1,15 +1,15 @@
 <%
-  @component_data ||= {}
-  id ||= @component_data[:id]
-  context ||= @component_data[:context]
-  title ||= @component_data[:title]
-  summary ||= @component_data[:summary]
-  line_chart_data ||= @component_data[:line_chart_data]
-  trend_icon ||= @component_data[:trend_icon]
-  trend_amount ||= @component_data[:trend_amount]
-  trend_text ||= @component_data[:trend_text]
+  # Use the passed data object directly
+  id = data[:id]
+  context = data[:context]
+  title = data[:title]
+  summary = data[:summary]
+  line_chart_data = data[:line_chart_data]
+  trend_icon = data[:trend_icon]
+  trend_amount = data[:trend_amount]
+  trend_text = data[:trend_text]
 %>
-<div class="grid-item" data-controller="rails-pulse--chart">
+<div class="grid-item" data-controller="rails-pulse--chart" id="<%= id %>">
   <%= render 'rails_pulse/components/panel', { title: title, card_classes: 'card-compact' } do %>
     <div class="row mbs-2" style="height: 50px; margin-bottom: 0;">
       <div class="grid-item">
@@ -35,20 +35,6 @@
           <%= trend_amount %>
           <p class="mis-2 text-subtle text-xs"><%= trend_text %></p>
         </span>
-        <%
-          refresh_path = rails_pulse.cache_path(id: id, context: context, refresh: true)
-          cached_iso = @cached_at ? @cached_at.iso8601 : nil
-        %>
-        <%= link_to refresh_path,
-            data: {
-              controller: "rails-pulse--timezone",
-              rails_pulse__timezone_target_frame_value: "#{id}_card",
-              rails_pulse__timezone_cached_at_value: cached_iso,
-              turbo_frame: "#{id}_card",
-              turbo_prefetch: "false"
-            } do %>
-          <%= rails_pulse_icon 'refresh-cw', height: "15px", width: "15px" %>
-        <% end %>
       </div>
     </div>
   <% end %>

data/app/views/rails_pulse/dashboard/index.html.erb

@@ -1,64 +1,82 @@
 <div class="row">
-  <%= cached_component(component: "metric_card", id: "average_response_times", class: "grid-item block") %>
-  <%= cached_component(component: "metric_card", id: "percentile_response_times", class: "grid-item block") %>
-  <%= cached_component(component: "metric_card", id: "request_count_totals", class: "grid-item block") %>
-  <%= cached_component(component: "metric_card", id: "error_rate_per_route", class: "grid-item block") %>
+  <%= render 'rails_pulse/components/metric_card', { class: "grid-item block", data: @average_query_times_metric_card } %>
+  <%= render 'rails_pulse/components/metric_card', { class: "grid-item block", data: @percentile_response_times_metric_card } %>
+  <%= render 'rails_pulse/components/metric_card', { class: "grid-item block", data: @request_count_totals_metric_card } %>
+  <%= render 'rails_pulse/components/metric_card', { class: "grid-item block", data: @error_rate_per_route_metric_card } %>
 </div>
 
 <div class="row">
   <div class="grid-item" style="height:300px">
-    <%= cached_component(
-      component: "panel",
-      id: "dashboard_average_response_time",
-      card_classes: 'b-full',
+    <%= render 'rails_pulse/components/panel', {
       title: 'Average Response Time',
+      card_classes: 'b-full',
       help_heading: 'Average Response Time',
       help_text: 'This panel measures the average server-side response time in milliseconds for all HTTP requests processed by your application. This is the time it takes from the server receiving a request until the request is returned to the client in milliseconds.',
-      actions: [{ url: routes_path, icon: 'external-link', title: 'View details', data: { turbo_frame: '_top' } }],
-      refresh_action: true,
-      content_partial: 'rails_pulse/dashboard/charts/bar_chart')
-    %>
+      actions: [{ url: routes_path, icon: 'external-link', title: 'View details', data: { turbo_frame: '_top' } }]
+    } do %>
+      <% if @average_response_time_chart_data.present? %>
+        <div class="chart-container chart-container--slim">
+          <%= bar_chart(
+            @average_response_time_chart_data,
+            code: false,
+            id: "dashboard_average_response_time_chart",
+            height: "100%",
+            options: bar_chart_options(
+              units: "ms"
+            )
+          ) %>
+        </div>
+      <% end %>
+    <% end %>
   </div>
 
   <div class="grid-item">
-    <%= cached_component(
-      component: "panel",
-      id: "dashboard_p95_response_time",
-      card_classes: 'b-full',
+    <%= render 'rails_pulse/components/panel', {
       title: 'Query Performance',
+      card_classes: 'b-full',
       help_heading: 'Query Performance',
       help_text: 'This panel measures the 95th percentile response time in milliseconds for queries in your application. This represents the query performance below which 95% of queries fall, indicating the upper-bound performance for most database operations.',
-      actions: [{ url: routes_path, icon: 'external-link', title: 'View details', data: { turbo_frame: '_top' } }],
-      refresh_action: true,
-      content_partial: 'rails_pulse/dashboard/charts/bar_chart')
-    %>
+      actions: [{ url: queries_path, icon: 'external-link', title: 'View details', data: { turbo_frame: '_top' } }]
+    } do %>
+      <% if @p95_response_time_chart_data.present? %>
+        <div class="chart-container chart-container--slim">
+          <%= bar_chart(
+            @p95_response_time_chart_data,
+            code: false,
+            id: "dashboard_p95_response_time_chart",
+            height: "100%",
+            options: bar_chart_options(
+              units: "ms"
+            )
+          ) %>
+        </div>
+      <% end %>
+    <% end %>
   </div>
 </div>
 
 <div class="row">
   <div class="grid-item">
-    <%= cached_component(
-      component: "panel",
-      id: "dashboard_slow_routes",
+    <%= render 'rails_pulse/components/panel', {
       title: 'Slowest Routes This Week',
       help_heading: 'Slowest Routes',
-      help_text: 'This panel shows the slowest routes in your application this week compared to last week, including average response time, week-over-week change, and total request count.',
-      refresh_action: true,
-      content_partial: 'rails_pulse/dashboard/tables/standard_table',
-      class: "table-container")
-    %>
+      help_text: 'This panel shows the slowest routes in your application this week, including average response time and total request count.',
+      actions: [{ url: routes_path, icon: 'external-link', title: 'View details', data: { turbo_frame: '_top' } }],
+      card_classes: 'table-container'
+    } do %>
+      <%= render 'rails_pulse/components/table', table_data: @slow_routes_table_data %>
+    <% end %>
   </div>
 
   <div class="grid-item">
-    <%= cached_component(
-      component: "panel",
-      id: "dashboard_slow_queries",
+    <%= render 'rails_pulse/components/panel', {
       title: 'Slowest Queries This Week',
-      help_heading: 'Slowest Queries',
+      help_heading: 'Slowest Queries', 
       help_text: 'This panel shows the slowest database queries in your application this week, including average execution time and when they were last seen.',
-      refresh_action: true,
-      content_partial: 'rails_pulse/dashboard/tables/standard_table',
-      class: "table-container")
-    %>
+      actions: [{ url: queries_path, icon: 'external-link', title: 'View details', data: { turbo_frame: '_top' } }],
+      card_classes: 'table-container'
+    } do %>
+      <%= render 'rails_pulse/components/table', table_data: @slow_queries_table_data %>
+    <% end %>
   </div>
 </div>

data/app/views/rails_pulse/queries/_show_table.html.erb

@@ -1,5 +1,5 @@
 <% columns = [
-  { field: :occurred_at, label: 'Occurred At', class: 'w-auto' },
+  { field: :occurred_at, label: 'Timestamp', class: 'w-auto' },
   { field: :duration, label: 'Duration', class: 'w-32'}
 ] %>
 

data/app/views/rails_pulse/queries/_table.html.erb

@@ -1,28 +1,26 @@
 <% columns = [
   { field: :normalized_sql, label: 'Query', class: 'w-auto' },
-  { field: :execution_count, label: 'Executions', class: 'w-24' },
-  { field: :average_query_time_ms, label: 'Avg Time', class: 'w-24' },
-  { field: :total_time_consumed, label: 'Total Time', class: 'w-28' },
-  { field: :performance_status, label: 'Status', class: 'w-16' },
-  { field: :occurred_at, label: 'Last Seen', class: 'w-32' }
+  { field: :execution_count_sort, label: 'Executions', class: 'w-24' },
+  { field: :avg_duration_sort, label: 'Avg Time', class: 'w-24' },
+  { field: :total_time_consumed_sort, label: 'Total Time', class: 'w-28' },
+  { field: :performance_status, label: 'Status', class: 'w-16', sortable: false }
 ] %>
 
 <table class="table mbs-4">
   <%= render "rails_pulse/components/table_head", columns: columns %>
 
   <tbody>
-    <% @table_data.each do |query| %>
+    <% @table_data.each do |summary| %>
       <tr>
         <td class="whitespace-nowrap">
           <div>
-            <%= link_to html_escape(truncate_sql(query.normalized_sql)), query_path(query), data: { turbo_frame: '_top', } %>
+            <%= link_to html_escape(truncate_sql(summary.normalized_sql)), query_path(summary.query_id), data: { turbo_frame: '_top', } %>
           </div>
         </td>
-        <td class="whitespace-nowrap"><%= number_with_delimiter query.execution_count %></td>
-        <td class="whitespace-nowrap"><%= query.average_query_time_ms.to_i %> ms</td>
-        <td class="whitespace-nowrap"><%= number_with_delimiter query.total_time_consumed.to_i %> ms</td>
-        <td class="whitespace-nowrap text-center"><%= query_status_indicator(query.average_query_time_ms) %></td>
-        <td class="whitespace-nowrap"><%= human_readable_occurred_at(query.occurred_at) if query.occurred_at %></td>
+        <td class="whitespace-nowrap"><%= number_with_delimiter summary.execution_count %></td>
+        <td class="whitespace-nowrap"><%= summary.avg_duration.to_i %> ms</td>
+        <td class="whitespace-nowrap"><%= number_with_delimiter summary.total_time_consumed.to_i %> ms</td>
+        <td class="whitespace-nowrap text-center"><%= query_status_indicator(summary.avg_duration) %></td>
       </tr>
     <% end %>
   </tbody>