rails_pulse 0.1.0

data/app/models/rails_pulse/route.rb

@@ -0,0 +1,77 @@
+module RailsPulse
+  class Route < RailsPulse::ApplicationRecord
+    self.table_name = "rails_pulse_routes"
+
+    # Associations
+    has_many :requests, class_name: "RailsPulse::Request", foreign_key: "route_id", dependent: :restrict_with_exception
+
+    # Validations
+    validates :method, presence: true
+    validates :path, presence: true, uniqueness: { scope: :method, message: "and method combination must be unique" }
+
+    # Scopes (optional, for convenience)
+    scope :by_method_and_path, ->(method, path) { where(method: method, path: path).first_or_create }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[path average_response_time_ms max_response_time_ms request_count requests_per_minute occurred_at requests_occurred_at error_count error_rate_percentage status_indicator]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[requests]
+    end
+
+    ransacker :average_response_time_ms do
+      Arel.sql("COALESCE(AVG(rails_pulse_requests.duration), 0)")
+    end
+
+    ransacker :request_count do
+      Arel.sql("COUNT(rails_pulse_requests.id)")
+    end
+
+    ransacker :occurred_at do |parent|
+      parent.table[:occurred_at]
+    end
+
+    ransacker :requests_occurred_at do |_parent|
+      Arel.sql("rails_pulse_requests.occurred_at")
+    end
+
+    ransacker :error_count do
+      Arel.sql(
+        "COALESCE(SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END), 0)"
+      )
+    end
+
+    ransacker :max_response_time_ms do
+      Arel.sql("COALESCE(MAX(rails_pulse_requests.duration), 0)")
+    end
+
+    ransacker :error_rate_percentage do
+      Arel.sql("CASE WHEN COUNT(rails_pulse_requests.id) > 0 THEN ROUND((COALESCE(SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END), 0) * 100.0) / COUNT(rails_pulse_requests.id), 2) ELSE 0 END")
+    end
+
+    ransacker :requests_per_minute do
+      # Use a simpler database-agnostic approach - this is mainly used for sorting/filtering
+      # so exact precision isn't as critical as avoiding database-specific functions
+      Arel.sql("COUNT(rails_pulse_requests.id)")
+    end
+
+    # Remove the problematic ransacker that causes SQL syntax errors
+    # The status_indicator will be handled differently or removed from filtering
+    # ransacker :status_indicator do
+    #   # Removed to fix SQL generation issues in tests
+    # end
+
+    def to_breadcrumb
+      path
+    end
+
+    def self.average_response_time
+      joins(:requests).average("rails_pulse_requests.duration") || 0
+    end
+
+    def path_and_method
+      "#{path} #{method}"
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module RailsPulse
+  module Routes
+    module Cards
+      class AverageResponseTimes
+        def initialize(route:)
+          @route = route
+        end
+
+        def to_metric_card
+          requests = if @route
+            RailsPulse::Request.where(route: @route)
+          else
+            RailsPulse::Request.all
+          end
+
+          requests = requests.where("occurred_at >= ?", 2.weeks.ago.beginning_of_day)
+
+          # Calculate overall average response time
+          average_response_time = requests.average(:duration)&.round(0) || 0
+
+          # Calculate trend by comparing last 7 days vs previous 7 days
+          last_7_days = 7.days.ago.beginning_of_day
+          previous_7_days = 14.days.ago.beginning_of_day
+          current_period_avg = requests.where("occurred_at >= ?", last_7_days).average(:duration) || 0
+          previous_period_avg = requests.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days).average(:duration) || 0
+
+          percentage = previous_period_avg.zero? ?  0 : ((previous_period_avg - current_period_avg) / previous_period_avg * 100).abs.round(1)
+          trend_icon = percentage < 0.1 ?  "move-right" : current_period_avg < previous_period_avg ? "trending-down" : "trending-up"
+          trend_amount = previous_period_avg.zero? ? "0%" : "#{percentage}%"
+
+          sparkline_data = requests
+            .group_by_week(:occurred_at, time_zone: "UTC")
+            .average(:duration)
+            .each_with_object({}) do |(date, avg), hash|
+              formatted_date = date.strftime("%b %-d")
+              value = avg&.round(0) || 0
+              hash[formatted_date] = {
+                value: value
+              }
+            end
+
+          {
+            title: "Average Response Time",
+            summary: "#{average_response_time} ms",
+            line_chart_data: sparkline_data,
+            trend_icon: trend_icon,
+            trend_amount: trend_amount,
+            trend_text: "Compared to last week"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module RailsPulse
+  module Routes
+    module Cards
+      class ErrorRatePerRoute
+        def initialize(route: nil)
+          @route = route
+        end
+
+        def to_metric_card
+          # Calculate error rate for each route or a specific route
+          routes = if @route
+            RailsPulse::Route.where(id: @route)
+          else
+            RailsPulse::Route.all
+          end
+
+          routes = routes.where("occurred_at >= ?", 2.weeks.ago.beginning_of_day)
+
+          error_rates = routes.joins(:requests)
+            .select("rails_pulse_routes.id, rails_pulse_routes.path, COUNT(rails_pulse_requests.id) as total_requests, SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END) as error_count")
+            .group("rails_pulse_routes.id, rails_pulse_routes.path")
+            .map do |route|
+              error_rate = route.error_count.to_f / route.total_requests * 100
+              {
+                path: route.path,
+                error_rate: error_rate.round(2)
+              }
+            end
+
+          # Calculate overall error rate summary as errors per day
+          requests = @route ? RailsPulse::Request.where(route: @route) : RailsPulse::Request.all
+          total_errors = requests.where(is_error: true).count
+          min_time = requests.minimum(:occurred_at)
+          max_time = requests.maximum(:occurred_at)
+          total_days = min_time && max_time && min_time != max_time ? (max_time - min_time) / 1.day : 1
+          errors_per_day = total_errors / total_days
+          error_rate_summary = "#{errors_per_day.round(2)} / day"
+
+          # Generate sparkline data
+          sparkline_data = requests
+            .where(is_error: true)
+            .group_by_week(:occurred_at, time_zone: "UTC")
+            .count
+            .each_with_object({}) do |(date, count), hash|
+              formatted_date = date.strftime("%b %-d")
+              hash[formatted_date] = {
+                value: count
+              }
+            end
+
+          # Determine trend direction and amount
+          last_7_days = 7.days.ago.beginning_of_day
+          previous_7_days = 14.days.ago.beginning_of_day
+          current_period_errors = requests.where("occurred_at >= ? AND is_error = ?", last_7_days, true).count
+          previous_period_errors = requests.where("occurred_at >= ? AND occurred_at < ? AND is_error = ?", previous_7_days, last_7_days, true).count
+
+          trend_amount = previous_period_errors.zero? ? "0%" : "#{((current_period_errors - previous_period_errors) / previous_period_errors.to_f * 100).round(1)}%"
+          trend_icon = trend_amount.to_f < 0.1 ? "move-right" : current_period_errors < previous_period_errors ? "trending-down" : "trending-up"
+
+          {
+            title: "Error Rate Per Route",
+            data: error_rates,
+            summary: error_rate_summary,
+            line_chart_data: sparkline_data,
+            trend_icon: trend_icon,
+            trend_amount: trend_amount,
+            trend_text: "Compared to last week"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module RailsPulse
+  module Routes
+    module Cards
+      class PercentileResponseTimes
+        def initialize(route: nil)
+          @route = route
+        end
+
+        def to_metric_card
+          requests = if @route
+            RailsPulse::Request.where(route: @route)
+          else
+            RailsPulse::Request.all
+          end
+
+          requests = requests.where("occurred_at >= ?", 2.weeks.ago.beginning_of_day)
+
+          # Calculate overall 95th percentile response time
+          count = requests.count
+          percentile_95th = if count > 0
+            requests.select("duration").order("duration").limit(1).offset((count * 0.95).floor).pluck(:duration).first.round(0) || 0
+          else
+            0
+          end
+
+          # Calculate trend by comparing last 7 days vs previous 7 days for 95th percentile
+          last_7_days = 7.days.ago.beginning_of_day
+          previous_7_days = 14.days.ago.beginning_of_day
+
+          current_period = requests.where("occurred_at >= ?", last_7_days)
+          current_count = current_period.count
+          current_period_95th = if current_count > 0
+            current_period.select("duration").order("duration").limit(1).offset((current_count * 0.95).floor).pluck(:duration).first || 0
+          else
+            0
+          end
+
+          previous_period = requests.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days)
+          previous_count = previous_period.count
+          previous_period_95th = if previous_count > 0
+            previous_period.select("duration").order("duration").limit(1).offset((previous_count * 0.95).floor).pluck(:duration).first || 0
+          else
+            0
+          end
+
+          percentage = previous_period_95th.zero? ?  0 : ((previous_period_95th - current_period_95th) / previous_period_95th * 100).abs.round(1)
+          trend_icon = percentage < 0.1 ?  "move-right" : current_period_95th < previous_period_95th ? "trending-down" : "trending-up"
+          trend_amount = previous_period_95th.zero? ? "0%" : "#{percentage}%"
+
+          sparkline_data = requests
+            .group_by_week(:occurred_at, time_zone: "UTC")
+            .average(:duration)
+            .each_with_object({}) do |(date, avg), hash|
+              formatted_date = date.strftime("%b %-d")
+              value = avg&.round(0) || 0
+              hash[formatted_date] = {
+                value: value
+              }
+            end
+
+          {
+            title: "95th Percentile Response Time",
+            summary: "#{percentile_95th} ms",
+            line_chart_data: sparkline_data,
+            trend_icon: trend_icon,
+            trend_amount: trend_amount,
+            trend_text: "Compared to last week"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module RailsPulse
+  module Routes
+    module Cards
+      class RequestCountTotals
+        def initialize(route: nil)
+          @route = route
+        end
+
+        def to_metric_card
+          requests = if @route
+            RailsPulse::Request.where(route: @route)
+          else
+            RailsPulse::Request.all
+          end
+
+          requests = requests.where("occurred_at >= ?", 2.weeks.ago.beginning_of_day)
+
+          # Calculate total request count
+          total_request_count = requests.count
+
+          # Calculate trend by comparing last 7 days vs previous 7 days
+          last_7_days = 7.days.ago.beginning_of_day
+          previous_7_days = 14.days.ago.beginning_of_day
+          current_period_count = requests.where("occurred_at >= ?", last_7_days).count
+          previous_period_count = requests.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days).count
+
+          percentage = previous_period_count.zero? ? 0 : ((previous_period_count - current_period_count) / previous_period_count.to_f * 100).abs.round(1)
+          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 = requests
+            .group_by_week(:occurred_at, time_zone: "UTC")
+            .count
+            .each_with_object({}) do |(date, count), hash|
+              formatted_date = date.strftime("%b %-d")
+              hash[formatted_date] = {
+                value: count
+              }
+            end
+
+          # Calculate average requests per minute
+          min_time = requests.minimum(:occurred_at)
+          max_time = requests.maximum(:occurred_at)
+          total_minutes = min_time && max_time && min_time != max_time ? (max_time - min_time) / 60.0 : 1
+          average_requests_per_minute = total_request_count / total_minutes
+
+          {
+            title: "Request Count Total",
+            summary: "#{average_requests_per_minute.round(2)} / min",
+            line_chart_data: sparkline_data,
+            trend_icon: trend_icon,
+            trend_amount: trend_amount,
+            trend_text: "Compared to last week"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module RailsPulse
+  module Routes
+    module Charts
+      class AverageResponseTimes
+        def initialize(ransack_query:, group_by: :group_by_day, route: nil)
+          @ransack_query = ransack_query
+          @group_by = group_by
+          @route = route
+        end
+
+        def to_rails_chart
+          # Get actual data using existing logic
+          actual_data = if @route
+            # These are the requests for the specific route so it will just be a collection of Requests that we can
+            # filter and sort using the attributes on each Request
+            @ransack_query.result(distinct: false)
+              .public_send(@group_by, "occurred_at", series: true, time_zone: "UTC")
+              .average(:duration)
+          else
+            # Use the existing query structure with left_joins from ransack
+            @ransack_query.result(distinct: false)
+              .left_joins(:requests)
+              .public_send(
+                @group_by,
+                "rails_pulse_requests.occurred_at",
+                series: true,
+                time_zone: "UTC"
+              )
+              .average("rails_pulse_requests.duration")
+          end
+
+          # Create full time range and fill in missing periods
+          fill_missing_periods(actual_data)
+        end
+
+        private
+
+        def fill_missing_periods(actual_data)
+          # Extract actual time range from ransack query conditions
+          start_time, end_time = extract_time_range_from_ransack
+
+          # Create time range based on grouping type
+          case @group_by
+          when :group_by_hour
+            time_range = generate_hour_range(start_time, end_time)
+          else # :group_by_day
+            time_range = generate_day_range(start_time, end_time)
+          end
+
+          # Fill in all periods with zero values for missing periods
+          time_range.each_with_object({}) do |period, result|
+            occurred_at = period.is_a?(String) ? Time.parse(period) : period
+            occurred_at = (occurred_at.is_a?(Time) || occurred_at.is_a?(Date)) ? occurred_at : Time.current
+
+            normalized_occurred_at =
+              case @group_by
+              when :group_by_hour
+                occurred_at&.beginning_of_hour || occurred_at
+              when :group_by_day
+                occurred_at&.beginning_of_day || occurred_at
+              else
+                occurred_at
+              end
+
+            # Use actual data if available, otherwise default to 0
+            average_duration = actual_data[period] || 0
+            result[normalized_occurred_at.to_i] = {
+              value: average_duration.to_f
+            }
+          end
+        end
+
+        def generate_day_range(start_time, end_time)
+          (start_time.to_date..end_time.to_date).map(&:beginning_of_day)
+        end
+
+        def generate_hour_range(start_time, end_time)
+          current = start_time
+          hours = []
+          while current <= end_time
+            hours << current
+            current += 1.hour
+          end
+          hours
+        end
+
+        def extract_time_range_from_ransack
+          # Extract time range from ransack conditions
+          conditions = @ransack_query.conditions
+
+          if @route
+            # For specific route queries, look for occurred_at conditions
+            start_condition = conditions.find { |c| c.a.first == "occurred_at" && c.p == "gteq" }
+            end_condition = conditions.find { |c| c.a.first == "occurred_at" && c.p == "lt" }
+          else
+            # For general route queries, look for requests_occurred_at conditions
+            start_condition = conditions.find { |c| c.a.first == "requests_occurred_at" && c.p == "gteq" }
+            end_condition = conditions.find { |c| c.a.first == "requests_occurred_at" && c.p == "lt" }
+          end
+
+          start_time = start_condition&.v || 2.weeks.ago
+          end_time = end_condition&.v || Time.current
+
+          # Normalize time boundaries based on grouping
+          case @group_by
+          when :group_by_hour
+            [ start_time.beginning_of_hour, end_time.beginning_of_hour ]
+          else
+            [ start_time.beginning_of_day, end_time.beginning_of_day ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module RailsPulse
+  module Routes
+    module Tables
+      class Index
+        def initialize(ransack_query:, start_time:, params:)
+          @ransack_query = ransack_query
+          @start_time = start_time
+          @params = params
+        end
+
+        def to_table
+          # Pre-calculate values to avoid SQL injection and improve readability
+          minutes_elapsed = calculate_minutes_elapsed
+
+          # Get thresholds with safe defaults to avoid nil access errors
+          config = RailsPulse.configuration rescue nil
+          thresholds = config&.route_thresholds || { slow: 500, very_slow: 1500, critical: 3000 }
+
+          requests_per_minute_divisor = minutes_elapsed > 0 ? minutes_elapsed : 1
+
+          status_sql = build_status_sql(thresholds)
+
+          @ransack_query.result(distinct: false)
+            .left_joins(:requests)
+            .group("rails_pulse_routes.id")
+            .select(
+              "rails_pulse_routes.*",
+              "COALESCE(AVG(rails_pulse_requests.duration), 0) AS average_response_time_ms",
+              "COUNT(rails_pulse_requests.id) AS request_count",
+              "COALESCE(COUNT(rails_pulse_requests.id) / #{requests_per_minute_divisor}, 0) AS requests_per_minute",
+              "COALESCE(SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END), 0) AS error_count",
+              "CASE WHEN COUNT(rails_pulse_requests.id) > 0 THEN ROUND((COALESCE(SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END), 0) * 100.0) / COUNT(rails_pulse_requests.id), 2) ELSE 0 END AS error_rate_percentage",
+              "COALESCE(MAX(rails_pulse_requests.duration), 0) AS max_response_time_ms",
+              "#{status_sql} AS status_indicator"
+            )
+        end
+
+        private
+
+        def calculate_minutes_elapsed
+          start_timestamp = Time.at(@start_time.to_i).utc
+          ((Time.current.utc - start_timestamp) / 60.0).round(2)
+        end
+
+        def build_status_sql(thresholds)
+          # Ensure all thresholds have default values
+          slow = thresholds[:slow] || 500
+          very_slow = thresholds[:very_slow] || 1500
+          critical = thresholds[:critical] || 3000
+
+          <<-SQL.squish
+            CASE
+              WHEN COALESCE(AVG(rails_pulse_requests.duration), 0) >= #{critical} THEN 3
+              WHEN COALESCE(AVG(rails_pulse_requests.duration), 0) >= #{very_slow} THEN 2
+              WHEN COALESCE(AVG(rails_pulse_requests.duration), 0) >= #{slow} THEN 1
+              ELSE 0
+            END
+          SQL
+        end
+      end
+    end
+  end
+end

data/app/services/rails_pulse/sql_query_normalizer.rb

@@ -0,0 +1,124 @@
+module RailsPulse
+  class SqlQueryNormalizer
+    # Smart normalization: preserve table/column names, replace only literal values
+    def self.normalize(query_string)
+      new(query_string).normalize
+    end
+
+    def initialize(query_string)
+      @query_string = query_string
+    end
+
+    def normalize
+      return nil if @query_string.nil?
+      return "" if @query_string.empty?
+
+      normalized = @query_string.dup
+
+      # Step 1: Temporarily protect quoted identifiers
+      protected_identifiers = protect_identifiers(normalized)
+      normalized = protected_identifiers[:normalized]
+
+      # Step 2: Replace literal values
+      normalized = replace_literal_values(normalized)
+
+      # Step 3: Handle special SQL constructs
+      normalized = handle_special_constructs(normalized)
+
+      # Step 4: Restore protected identifiers
+      normalized = restore_identifiers(normalized, protected_identifiers[:mapping])
+
+      # Step 5: Clean up and normalize whitespace
+      normalize_whitespace(normalized)
+    end
+
+    private
+
+    def protect_identifiers(query)
+      protected_identifiers = {}
+      identifier_counter = 0
+      normalized = query.dup
+
+      # Protect backticked identifiers (MySQL style)
+      normalized = normalized.gsub(/`([^`]+)`/) do |match|
+        placeholder = "__IDENTIFIER_#{identifier_counter}__"
+        protected_identifiers[placeholder] = match
+        identifier_counter += 1
+        placeholder
+      end
+
+      # Protect double-quoted identifiers (PostgreSQL/SQL standard style)
+      # Only protect if they appear in contexts where identifiers are expected
+      normalized = normalized.gsub(/"([^"]+)"/) do |match|
+        content = $1
+        # Only protect if it looks like an identifier (no spaces, not a sentence)
+        if looks_like_identifier?(content)
+          placeholder = "__IDENTIFIER_#{identifier_counter}__"
+          protected_identifiers[placeholder] = match
+          identifier_counter += 1
+          placeholder
+        else
+          match  # Leave it as-is for now, will be replaced as string literal
+        end
+      end
+
+      { normalized: normalized, mapping: protected_identifiers }
+    end
+
+    def looks_like_identifier?(content)
+      content.match?(/^[a-zA-Z_][a-zA-Z0-9_]*$/) || content.include?(".")
+    end
+
+    def replace_literal_values(query)
+      normalized = query.dup
+
+      # Replace floating-point numbers FIRST (before integers) to avoid double replacement
+      normalized = normalized.gsub(/(?<![a-zA-Z_])\b\d+\.\d+\b(?![a-zA-Z_])/, "?")
+
+      # Replace integer literals with placeholders, but preserve identifiers containing numbers
+      # Negative lookbehind/lookahead prevents replacing numbers in table/column names
+      normalized = normalized.gsub(/(?<![a-zA-Z_])\b\d+\b(?![a-zA-Z_])/, "?")
+
+      # Replace string literals (single quotes)
+      normalized = normalized.gsub(/'(?:[^']|'')*'/, "?")
+
+      # Replace double-quoted string literals (not protected identifiers)
+      normalized = normalized.gsub(/"(?:[^"]|"")*"/, "?")
+
+      # Handle boolean literals
+      normalized = normalized.gsub(/\b(true|false)\b/i, "?")
+
+      normalized
+    end
+
+    def handle_special_constructs(query)
+      normalized = query.dup
+
+      # Handle IN clauses with multiple values - replace content but preserve structure
+      normalized = normalized.gsub(/\bIN\s*\(\s*([^)]+)\)/i) do |match|
+        content = $1
+        # Count commas to determine number of values
+        value_count = content.split(",").length
+        placeholders = Array.new(value_count, "?").join(", ")
+        "IN (#{placeholders})"
+      end
+
+      # Handle BETWEEN clauses
+      normalized = normalized.gsub(/\bBETWEEN\s+\?\s+AND\s+\?/i, "BETWEEN ? AND ?")
+
+      normalized
+    end
+
+    def restore_identifiers(query, identifier_mapping)
+      normalized = query.dup
+      identifier_mapping.each do |placeholder, original|
+        normalized = normalized.gsub(placeholder, original)
+      end
+      normalized
+    end
+
+    def normalize_whitespace(query)
+      query.gsub(/\s+/, " ").strip
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+<%= link_to root_path, class: 'btn sidebar-menu__button' do %>
+  <%= rails_pulse_icon 'layout-dashboard', width: '16' %>
+  <span class="overflow-ellipsis">Dashboard</span>
+<% end %>
+
+<%= link_to routes_path, class: 'btn sidebar-menu__button' do %>
+  <%= rails_pulse_icon 'route', width: '16' %>
+  <span class="overflow-ellipsis">Routes</span>
+<% end %>
+
+<%= link_to requests_path, class: 'btn sidebar-menu__button' do %>
+  <%= rails_pulse_icon 'audio-lines', width: '16' %>
+  <span class="overflow-ellipsis">Requests</span>
+<% end %>
+
+<%= link_to queries_path, class: 'btn sidebar-menu__button' do %>
+  <%= rails_pulse_icon 'database', width: '16' %>
+  <span class="overflow-ellipsis">Queries</span>
+<% end %>