rails_pulse 0.1.3 → 0.2.2

data/app/javascript/rails_pulse/controllers/global_filters_controller.js

@@ -0,0 +1,110 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["wrapper", "dialog", "dateRange", "indicator", "form"]
+  static values = {
+    active: { type: Boolean, default: false }
+  }
+
+  connect() {
+    this.updateIndicator()
+  }
+
+  // Open the global filters dialog
+  open(event) {
+    event.preventDefault()
+
+    // If there's a value in the date range input, make sure flatpickr knows about it
+    if (this.dateRangeTarget.value) {
+      const datepickerController = this.application.getControllerForElementAndIdentifier(
+        this.dateRangeTarget,
+        'rails-pulse--datepicker'
+      )
+
+      if (datepickerController && datepickerController.flatpickr) {
+        const value = this.dateRangeTarget.value
+        // Parse the "start to end" format
+        if (value.includes(' to ')) {
+          const [start, end] = value.split(' to ').map(d => d.trim())
+          // Set the dates in flatpickr
+          datepickerController.flatpickr.setDate([start, end], false)
+        }
+      }
+    }
+
+    this.wrapperTarget.style.display = 'flex'
+    // Prevent body scroll when dialog is open
+    document.body.style.overflow = 'hidden'
+  }
+
+  // Close the dialog
+  close(event) {
+    if (event) {
+      event.preventDefault()
+    }
+    this.wrapperTarget.style.display = 'none'
+    // Restore body scroll
+    document.body.style.overflow = ''
+  }
+
+  // Close dialog when clicking outside
+  closeOnClickOutside(event) {
+    if (event.target === this.wrapperTarget) {
+      this.close(event)
+    }
+  }
+
+  // Handle form submission - parse date range and add individual params
+  submit(event) {
+    // If clear button was clicked, let it through as-is
+    if (event.submitter && event.submitter.name === "clear") {
+      return
+    }
+
+    const dateRangeValue = this.dateRangeTarget.value
+    const form = event.target
+
+    // Parse date range if provided
+    if (dateRangeValue && dateRangeValue.includes(' to ')) {
+      const [startTime, endTime] = dateRangeValue.split(' to ').map(d => d.trim())
+
+      // Remove any existing hidden inputs
+      form.querySelectorAll('input[name="start_time"], input[name="end_time"]').forEach(el => el.remove())
+
+      // Add new hidden inputs
+      const startInput = document.createElement('input')
+      startInput.type = 'hidden'
+      startInput.name = 'start_time'
+      startInput.value = startTime
+      form.appendChild(startInput)
+
+      const endInput = document.createElement('input')
+      endInput.type = 'hidden'
+      endInput.name = 'end_time'
+      endInput.value = endTime
+      form.appendChild(endInput)
+    }
+
+    // Tag switches are already being submitted as enabled_tags[]
+    // The controller will convert these to disabled_tags
+    // No additional processing needed here
+
+    // No validation needed - user can apply any combination of filters
+  }
+
+  // Update visual indicator based on activeValue
+  updateIndicator() {
+    if (this.hasIndicatorTarget) {
+      if (this.activeValue) {
+        this.indicatorTarget.classList.add("global-filters-active")
+      } else {
+        this.indicatorTarget.classList.remove("global-filters-active")
+      }
+    }
+  }
+
+  // Called when activeValue changes
+  activeValueChanged() {
+    this.updateIndicator()
+  }
+}

data/app/javascript/rails_pulse/controllers/index_controller.js

@@ -192,6 +192,8 @@ export default class extends Controller {
   updatePaginationLimit() {
       // Update or set the limit param in the browser so if the user refreshes the page,
       // the limit will be preserved.
+      if (!this.hasPaginationLimitTarget) return;
+
       const url = new URL(window.location.href);
       const currentParams = new URLSearchParams(url.search);
       const limit = this.paginationLimitTarget.value;
@@ -244,7 +246,9 @@ export default class extends Controller {
     currentParams.set('zoom_end_time', endTimestamp);
 
     // Set the limit param based on the value in the pagination selector
-    currentParams.set('limit', this.paginationLimitTarget.value);
+    if (this.hasPaginationLimitTarget) {
+      currentParams.set('limit', this.paginationLimitTarget.value);
+    }
 
     // Update the URL's search parameters
     url.search = currentParams.toString();
@@ -443,7 +447,9 @@ export default class extends Controller {
     currentParams.set('selected_column_time', selectedTimestamp);
 
     // Preserve pagination limit
-    currentParams.set('limit', this.paginationLimitTarget.value);
+    if (this.hasPaginationLimitTarget) {
+      currentParams.set('limit', this.paginationLimitTarget.value);
+    }
 
     url.search = currentParams.toString();
 
@@ -463,7 +469,9 @@ export default class extends Controller {
     currentParams.delete('selected_column_time');
 
     // Preserve pagination limit
-    currentParams.set('limit', this.paginationLimitTarget.value);
+    if (this.hasPaginationLimitTarget) {
+      currentParams.set('limit', this.paginationLimitTarget.value);
+    }
 
     url.search = currentParams.toString();
 

data/app/models/concerns/taggable.rb

@@ -0,0 +1,61 @@
+module Taggable
+  extend ActiveSupport::Concern
+
+  included do
+    # Callbacks
+    before_save :ensure_tags_is_array
+
+    # Scopes with table name qualification to avoid ambiguity
+    scope :with_tag, ->(tag) { where("#{table_name}.tags LIKE ?", "%#{tag}%") }
+    scope :without_tag, ->(tag) { where.not("#{table_name}.tags LIKE ?", "%#{tag}%") }
+    scope :with_tags, -> { where("#{table_name}.tags IS NOT NULL AND #{table_name}.tags != '[]'") }
+  end
+
+  # Tag management methods
+  def tag_list
+    parsed_tags || []
+  end
+
+  def tag_list=(value)
+    self.tags = value.to_json
+  end
+
+  def has_tag?(tag)
+    tag_list.include?(tag.to_s)
+  end
+
+  def add_tag(tag)
+    current_tags = tag_list
+    unless current_tags.include?(tag.to_s)
+      current_tags << tag.to_s
+      self.tag_list = current_tags
+      save
+    end
+  end
+
+  def remove_tag(tag)
+    current_tags = tag_list
+    if current_tags.include?(tag.to_s)
+      current_tags.delete(tag.to_s)
+      self.tag_list = current_tags
+      save
+    end
+  end
+
+  private
+
+  def parsed_tags
+    return [] if tags.nil? || tags.empty?
+    JSON.parse(tags)
+  rescue JSON::ParserError
+    []
+  end
+
+  def ensure_tags_is_array
+    if tags.nil?
+      self.tags = "[]"
+    elsif tags.is_a?(Array)
+      self.tags = tags.to_json
+    end
+  end
+end

data/app/models/rails_pulse/dashboard/tables/slow_queries.rb

@@ -32,7 +32,7 @@ module RailsPulse
             {
               query_text: truncate_query(record.normalized_sql),
               query_id: record.query_id,
-              query_link: "/rails_pulse/queries/#{record.query_id}",
+              query_link: RailsPulse::Engine.routes.url_helpers.query_path(record.query_id),
               average_time: record.avg_duration.to_f.round(0),
               request_count: record.request_count,
               last_request: time_ago_in_words(record.last_seen)

data/app/models/rails_pulse/dashboard/tables/slow_routes.rb

@@ -33,7 +33,7 @@ module RailsPulse
             {
               route_path: record.path,
               route_id: record.route_id,
-              route_link: "/rails_pulse/routes/#{record.route_id}",
+              route_link: RailsPulse::Engine.routes.url_helpers.route_path(record.route_id),
               average_time: record.avg_duration.to_f.round(0),
               request_count: record.request_count,
               last_request: time_ago_in_words(record.last_seen)

data/app/models/rails_pulse/queries/cards/average_query_times.rb

@@ -64,7 +64,7 @@ module RailsPulse
             context: "queries",
             title: "Average Query Time",
             summary: "#{average_query_time} ms",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

data/app/models/rails_pulse/queries/cards/execution_rate.rb

@@ -10,10 +10,20 @@ module RailsPulse
           last_7_days = 7.days.ago.beginning_of_day
           previous_7_days = 14.days.ago.beginning_of_day
 
+          # Get the most common period type for this query, or fall back to "day"
+          period_type = if @query
+            RailsPulse::Summary.where(
+              summarizable_type: "RailsPulse::Query",
+              summarizable_id: @query.id
+            ).group(:period_type).count.max_by(&:last)&.first || "day"
+          else
+            "day"
+          end
+
           # Single query to get all count metrics with conditional aggregation
           base_query = RailsPulse::Summary.where(
             summarizable_type: "RailsPulse::Query",
-            period_type: "day",
+            period_type: period_type,
             period_start: 2.weeks.ago.beginning_of_day..Time.current
           )
           base_query = base_query.where(summarizable_id: @query.id) if @query
@@ -33,31 +43,60 @@ module RailsPulse
           trend_icon = percentage < 0.1 ? "move-right" : current_period_count < previous_period_count ? "trending-down" : "trending-up"
           trend_amount = previous_period_count.zero? ? "0%" : "#{percentage}%"
 
-          # Sparkline data by day with zero-filled days over the last 14 days
-          grouped_daily = base_query
-            .group_by_day(:period_start, time_zone: "UTC")
-            .sum(:count)
+          # Sparkline data with zero-filled periods over the last 14 days
+          if period_type == "day"
+            grouped_data = base_query
+              .group_by_day(:period_start, time_zone: "UTC")
+              .sum(:count)
+
+            start_period = 2.weeks.ago.beginning_of_day.to_date
+            end_period = Time.current.to_date
 
-          start_day = 2.weeks.ago.beginning_of_day.to_date
-          end_day = Time.current.to_date
+            sparkline_data = {}
+            (start_period..end_period).each do |day|
+              total = grouped_data[day] || 0
+              label = day.strftime("%b %-d")
+              sparkline_data[label] = { value: total }
+            end
+          else
+            # For hourly data, group by day for sparkline display
+            grouped_data = base_query
+              .group("DATE(period_start)")
+              .sum(:count)
 
-          sparkline_data = {}
-          (start_day..end_day).each do |day|
-            total = grouped_daily[day] || 0
-            label = day.strftime("%b %-d")
-            sparkline_data[label] = { value: total }
+            start_period = 2.weeks.ago.beginning_of_day.to_date
+            end_period = Time.current.to_date
+
+            sparkline_data = {}
+            (start_period..end_period).each do |day|
+              date_key = day.strftime("%Y-%m-%d")
+              total = grouped_data[date_key] || 0
+              label = day.strftime("%b %-d")
+              sparkline_data[label] = { value: total }
+            end
           end
 
-          # Calculate average executions per minute over 2-week period
-          total_minutes = 2.weeks / 1.minute
-          average_executions_per_minute = total_execution_count / total_minutes
+          # Calculate appropriate rate display based on frequency
+          total_minutes = 2.weeks / 1.minute.to_f
+          executions_per_minute = total_execution_count.to_f / total_minutes
+
+          # Choose appropriate time unit for display
+          if executions_per_minute >= 1
+            summary = "#{executions_per_minute.round(2)} / min"
+          elsif executions_per_minute * 60 >= 1
+            executions_per_hour = executions_per_minute * 60
+            summary = "#{executions_per_hour.round(2)} / hour"
+          else
+            executions_per_day = executions_per_minute * 60 * 24
+            summary = "#{executions_per_day.round(2)} / day"
+          end
 
           {
             id: "execution_rate",
             context: "queries",
             title: "Execution Rate",
-            summary: "#{average_executions_per_minute.round(2)} / min",
-            line_chart_data: sparkline_data,
+            summary: summary,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

data/app/models/rails_pulse/queries/cards/percentile_query_times.rb

@@ -53,7 +53,7 @@ module RailsPulse
             context: "queries",
             title: "95th Percentile Query Time",
             summary: "#{p95_query_time} ms",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

data/app/models/rails_pulse/queries/charts/average_query_times.rb

@@ -12,13 +12,9 @@ module RailsPulse
         end
 
         def to_rails_chart
-          summaries = @ransack_query.result(distinct: false).where(
-            summarizable_type: "RailsPulse::Query",
-            period_type: @period_type
-          )
-
-          summaries = summaries.where(summarizable_id: @query.id) if @query
-          summaries = summaries
+          # The ransack query already contains the correct filters, just add period_type
+          summaries = @ransack_query.result(distinct: false)
+            .where(period_type: @period_type)
             .group(:period_start)
             .having("AVG(avg_duration) > ?", @start_duration || 0)
             .average(:avg_duration)

data/app/models/rails_pulse/queries/tables/index.rb

@@ -2,12 +2,13 @@ module RailsPulse
   module Queries
     module Tables
       class Index
-        def initialize(ransack_query:, period_type: nil, start_time:, params:, query: nil)
+        def initialize(ransack_query:, period_type: nil, start_time:, params:, query: nil, disabled_tags: [])
           @ransack_query = ransack_query
           @period_type = period_type
           @start_time = start_time
           @params = params
           @query = query
+          @disabled_tags = disabled_tags
         end
 
         def to_table
@@ -21,6 +22,11 @@ module RailsPulse
               period_type: @period_type
             )
 
+          # Apply tag filters by excluding queries with disabled tags
+          @disabled_tags.each do |tag|
+            base_query = base_query.where.not("rails_pulse_queries.tags LIKE ?", "%#{tag}%")
+          end
+
           base_query = base_query.where(summarizable_id: @query.id) if @query
 
           # Apply grouping and aggregation
@@ -29,13 +35,15 @@ module RailsPulse
               "rails_pulse_summaries.summarizable_id",
               "rails_pulse_summaries.summarizable_type",
               "rails_pulse_queries.id",
-              "rails_pulse_queries.normalized_sql"
+              "rails_pulse_queries.normalized_sql",
+              "rails_pulse_queries.tags"
             )
             .select(
               "rails_pulse_summaries.summarizable_id",
               "rails_pulse_summaries.summarizable_type",
               "rails_pulse_queries.id as query_id",
               "rails_pulse_queries.normalized_sql",
+              "rails_pulse_queries.tags",
               "AVG(rails_pulse_summaries.avg_duration) as avg_duration",
               "MAX(rails_pulse_summaries.max_duration) as max_duration",
               "SUM(rails_pulse_summaries.count) as execution_count",

data/app/models/rails_pulse/query.rb

@@ -1,5 +1,7 @@
 module RailsPulse
   class Query < RailsPulse::ApplicationRecord
+    include Taggable
+
     self.table_name = "rails_pulse_queries"
 
     # Associations

data/app/models/rails_pulse/request.rb

@@ -1,5 +1,7 @@
 module RailsPulse
   class Request < RailsPulse::ApplicationRecord
+    include Taggable
+
     self.table_name = "rails_pulse_requests"
 
     # Associations
@@ -17,7 +19,7 @@ module RailsPulse
     before_create :set_request_uuid
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id route_id occurred_at duration status status_indicator route_path]
+      %w[id route_id occurred_at duration status status_category status_indicator route_path]
     end
 
     def self.ransackable_associations(auth_object = nil)
@@ -32,6 +34,12 @@ module RailsPulse
       Arel.sql("rails_pulse_routes.path")
     end
 
+    ransacker :status_category do |parent|
+      # Returns the first digit of the status code (2, 3, 4, or 5)
+      # Use FLOOR instead of CAST for cross-database compatibility
+      Arel.sql("FLOOR(#{parent.table[:status].name} / 100)")
+    end
+
     ransacker :status_indicator do |parent|
       # Calculate status indicator based on request_thresholds with safe defaults
       config = RailsPulse.configuration rescue nil
@@ -52,7 +60,7 @@ module RailsPulse
     end
 
     def to_s
-      occurred_at.strftime("%b %d, %Y %l:%M %p")
+      occurred_at.getlocal.strftime("%b %d, %Y %l:%M %p")
     end
 
     private

data/app/models/rails_pulse/requests/charts/average_response_times.rb

@@ -13,11 +13,11 @@ module RailsPulse
 
         def to_rails_chart
           summaries = @ransack_query.result(distinct: false).where(
-            summarizable_type: "RailsPulse::Route",
+            summarizable_type: "RailsPulse::Request",
+            summarizable_id: 0,  # Overall request summaries
             period_type: @period_type
           )
 
-          summaries = summaries.where(summarizable_id: @route.id) if @route
           summaries = summaries
             .group(:period_start)
             .having("AVG(avg_duration) > ?", @start_duration || 0)

data/app/models/rails_pulse/requests/tables/index.rb

@@ -0,0 +1,77 @@
+module RailsPulse
+  module Requests
+    module Tables
+      class Index
+        def initialize(ransack_query:, period_type: nil, start_time:, params:)
+          @ransack_query = ransack_query
+          @period_type = period_type
+          @start_time = start_time
+          @params = params
+        end
+
+        def to_table
+          # Check if we have explicit ransack sorts
+          has_sorts = @ransack_query.sorts.any?
+
+          base_query = @ransack_query.result(distinct: false)
+            .where(
+              summarizable_type: "RailsPulse::Request",
+              summarizable_id: 0,  # Overall request summaries
+              period_type: @period_type
+            )
+
+          # Apply grouping and aggregation for time periods
+          grouped_query = base_query
+            .group(
+              "rails_pulse_summaries.period_start",
+              "rails_pulse_summaries.period_end",
+              "rails_pulse_summaries.period_type"
+            )
+            .select(
+              "rails_pulse_summaries.period_start",
+              "rails_pulse_summaries.period_end",
+              "rails_pulse_summaries.period_type",
+              "AVG(rails_pulse_summaries.avg_duration) as avg_duration",
+              "MAX(rails_pulse_summaries.max_duration) as max_duration",
+              "MIN(rails_pulse_summaries.min_duration) as min_duration",
+              "SUM(rails_pulse_summaries.count) as count",
+              "SUM(rails_pulse_summaries.error_count) as error_count",
+              "SUM(rails_pulse_summaries.success_count) as success_count"
+            )
+
+          # Apply sorting based on ransack sorts or use default
+          if has_sorts
+            # Apply custom sorting based on ransack parameters
+            sort = @ransack_query.sorts.first
+            direction = sort.dir == "desc" ? :desc : :asc
+
+            case sort.name
+            when "avg_duration"
+              grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").send(direction))
+            when "max_duration"
+              grouped_query = grouped_query.order(Arel.sql("MAX(rails_pulse_summaries.max_duration)").send(direction))
+            when "min_duration"
+              grouped_query = grouped_query.order(Arel.sql("MIN(rails_pulse_summaries.min_duration)").send(direction))
+            when "count"
+              grouped_query = grouped_query.order(Arel.sql("SUM(rails_pulse_summaries.count)").send(direction))
+            when "requests_per_minute"
+              grouped_query = grouped_query.order(Arel.sql("SUM(rails_pulse_summaries.count) / 60.0").send(direction))
+            when "error_rate_percentage"
+              grouped_query = grouped_query.order(Arel.sql("(SUM(rails_pulse_summaries.error_count) * 100.0) / SUM(rails_pulse_summaries.count)").send(direction))
+            when "period_start"
+              grouped_query = grouped_query.order(period_start: direction)
+            else
+              # Unknown sort field, fallback to default
+              grouped_query = grouped_query.order(period_start: :desc)
+            end
+          else
+            # Apply default sort when no explicit sort is provided (matches controller default_table_sort)
+            grouped_query = grouped_query.order(period_start: :desc)
+          end
+
+          grouped_query
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/route.rb

@@ -1,5 +1,7 @@
 module RailsPulse
   class Route < RailsPulse::ApplicationRecord
+    include Taggable
+
     self.table_name = "rails_pulse_routes"
 
     # Associations

data/app/models/rails_pulse/routes/cards/average_response_times.rb

@@ -62,7 +62,7 @@ module RailsPulse
             context: "routes",
             title: "Average Response Time",
             summary: "#{average_response_time} ms",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

data/app/models/rails_pulse/routes/cards/error_rate_per_route.rb

@@ -59,7 +59,7 @@ module RailsPulse
             context: "routes",
             title: "Error Rate Per Route",
             summary: "#{overall_error_rate}%",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

data/app/models/rails_pulse/routes/cards/percentile_response_times.rb

@@ -53,7 +53,7 @@ module RailsPulse
             context: "routes",
             title: "95th Percentile Response Time",
             summary: "#{p95_response_time} ms",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

data/app/models/rails_pulse/routes/cards/request_count_totals.rb

@@ -48,16 +48,27 @@ module RailsPulse
             sparkline_data[label] = { value: total }
           end
 
-          # Calculate average requests per minute over 2-week period
-          total_minutes = 2.weeks / 1.minute
-          average_requests_per_minute = total_request_count / total_minutes
+          # Calculate appropriate rate display based on frequency
+          total_minutes = 2.weeks / 1.minute.to_f
+          requests_per_minute = total_request_count.to_f / total_minutes
+
+          # Choose appropriate time unit for display
+          if requests_per_minute >= 1
+            summary = "#{requests_per_minute.round(2)} / min"
+          elsif requests_per_minute * 60 >= 1
+            requests_per_hour = requests_per_minute * 60
+            summary = "#{requests_per_hour.round(2)} / hour"
+          else
+            requests_per_day = requests_per_minute * 60 * 24
+            summary = "#{requests_per_day.round(2)} / day"
+          end
 
           {
             id: "request_count_totals",
             context: "routes",
             title: "Request Count Total",
-            summary: "#{average_requests_per_minute.round(2)} / min",
-            line_chart_data: sparkline_data,
+            summary: summary,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"