rails_pulse 0.1.0

data/app/models/rails_pulse/operation.rb

@@ -0,0 +1,87 @@
+module RailsPulse
+  class Operation < RailsPulse::ApplicationRecord
+    self.table_name = "rails_pulse_operations"
+
+    OPERATION_TYPES = %w[
+      sql
+      controller
+      template
+      partial
+      layout
+      collection
+      cache_read
+      cache_write
+      http
+      job
+      mailer
+      storage
+    ].freeze
+
+    # Associations
+    belongs_to :request, class_name: "RailsPulse::Request"
+    belongs_to :query, class_name: "RailsPulse::Query", optional: true
+
+    # Validations
+    validates :request_id, presence: true
+    validates :operation_type, presence: true, inclusion: { in: OPERATION_TYPES }
+    validates :label, presence: true
+    validates :occurred_at, presence: true
+    validates :duration, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    # Scopes (optional, for convenience)
+    scope :by_type, ->(type) { where(operation_type: type) }
+
+    before_validation :associate_query
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id occurred_at label duration start_time average_query_time_ms query_count operation_type]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[]
+    end
+
+    ransacker :average_query_time_ms do
+      Arel.sql("COALESCE(AVG(rails_pulse_operations.duration), 0)")
+    end
+
+    ransacker :query_count do
+      Arel.sql("COUNT(rails_pulse_operations.id)")
+    end
+
+    ransacker :occurred_at, formatter: ->(val) {
+      # Handle different time formats for database compatibility
+      case val
+      when Time, DateTime, ActiveSupport::TimeWithZone
+        val.utc.iso8601
+      when String
+        Time.zone.parse(val).utc.iso8601
+      when Integer
+        Time.at(val).utc.iso8601
+      else
+        # Fallback: try to parse as integer timestamp
+        Time.at(val.to_i).utc.iso8601
+      end
+    } do |parent|
+      parent.table[:occurred_at]
+    end
+
+    def to_s
+      id
+    end
+
+    private
+
+    def associate_query
+      return unless operation_type == "sql" && label.present?
+
+      normalized = normalize_query_label(label)
+      self.query = RailsPulse::Query.find_or_create_by(normalized_sql: normalized)
+    end
+
+    # Normalize SQL query using the dedicated service
+    def normalize_query_label(label)
+      RailsPulse::SqlQueryNormalizer.normalize(label)
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module RailsPulse
+  module Queries
+    module Cards
+      class AverageQueryTimes
+        def initialize(query:)
+          @query = query
+        end
+
+        def to_metric_card
+          operations = if @query
+            RailsPulse::Operation.where(query: @query)
+          else
+            RailsPulse::Operation.all
+          end
+
+          # Calculate overall average response time
+          average_query_time = operations.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 = operations.where("occurred_at >= ?", last_7_days).average(:duration) || 0
+          previous_period_avg = operations.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 = operations
+            .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 Query Time",
+            summary: "#{average_query_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/queries/cards/execution_rate.rb

@@ -0,0 +1,57 @@
+module RailsPulse
+  module Queries
+    module Cards
+      class ExecutionRate
+        def initialize(query: nil)
+          @query = query
+        end
+
+        def to_metric_card
+          operations = if @query
+            RailsPulse::Operation.where(query: @query)
+          else
+            RailsPulse::Operation.all
+          end
+
+          # Calculate total request count
+          total_request_count = operations.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 = operations.where("occurred_at >= ?", last_7_days).count
+          previous_period_count = operations.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 = operations
+            .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 operations per minute
+          min_time = operations.minimum(:occurred_at)
+          max_time = operations.maximum(:occurred_at)
+          total_minutes = min_time && max_time && min_time != max_time ? (max_time - min_time) / 60.0 : 1
+          average_operations_per_minute = total_request_count / total_minutes
+
+          {
+            title: "Execution Rate",
+            summary: "#{average_operations_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/queries/cards/percentile_query_times.rb

@@ -0,0 +1,71 @@
+module RailsPulse
+  module Queries
+    module Cards
+      class PercentileQueryTimes
+        def initialize(query: nil)
+          @query = query
+        end
+
+        def to_metric_card
+          operations = if @query
+            RailsPulse::Operation.where(query: @query)
+          else
+            RailsPulse::Operation.all
+          end
+
+          # Calculate overall 95th percentile response time
+          count = operations.count
+          percentile_95th = if count > 0
+            operations.select("duration").order("duration").limit(1).offset((count * 0.95).floor).pluck(:duration).first || 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 = operations.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 = operations.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 = operations
+            .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 Query 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/queries/charts/average_query_times.rb

@@ -0,0 +1,112 @@
+module RailsPulse
+  module Queries
+    module Charts
+      class AverageQueryTimes
+        def initialize(ransack_query:, group_by: :group_by_day, query: nil)
+          @ransack_query = ransack_query
+          @group_by = group_by
+          @query = query
+        end
+
+        def to_rails_chart
+          # Get actual data using existing logic
+          actual_data = if @query
+            @ransack_query.result(distinct: false)
+              .public_send(@group_by, "occurred_at", series: true, time_zone: "UTC")
+              .average(:duration)
+          else
+            @ransack_query.result(distinct: false)
+              .left_joins(:operations)
+              .public_send(
+                @group_by,
+                "rails_pulse_operations.occurred_at",
+                series: true,
+                time_zone: "UTC"
+              )
+              .average("rails_pulse_operations.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 @query
+            # For specific query, 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 operations, look for rails_pulse_operations_occurred_at conditions
+            start_condition = conditions.find { |c| c.a.first == "rails_pulse_operations_occurred_at" && c.p == "gteq" }
+            end_condition = conditions.find { |c| c.a.first == "rails_pulse_operations_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/query.rb

@@ -0,0 +1,58 @@
+module RailsPulse
+  class Query < RailsPulse::ApplicationRecord
+    self.table_name = "rails_pulse_queries"
+
+    # Associations
+    has_many :operations, class_name: "RailsPulse::Operation", inverse_of: :query
+
+    # Validations
+    validates :normalized_sql, presence: true, uniqueness: true
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id normalized_sql average_query_time_ms execution_count total_time_consumed performance_status occurred_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[operations]
+    end
+
+    ransacker :average_query_time_ms do
+      Arel.sql("COALESCE(AVG(rails_pulse_operations.duration), 0)")
+    end
+
+    ransacker :execution_count do
+      Arel.sql("COUNT(rails_pulse_operations.id)")
+    end
+
+    ransacker :total_time_consumed do
+      Arel.sql("COALESCE(SUM(rails_pulse_operations.duration), 0)")
+    end
+
+    ransacker :performance_status do
+      # Calculate status indicator based on query_thresholds with safe defaults
+      config = RailsPulse.configuration rescue nil
+      thresholds = config&.query_thresholds || { slow: 200, very_slow: 500, critical: 1000 }
+
+      slow = (thresholds[:slow] || 200).to_f
+      very_slow = (thresholds[:very_slow] || 500).to_f
+      critical = (thresholds[:critical] || 1000).to_f
+
+      # Use Arel to safely construct the SQL with parameterized values
+      avg_duration = Arel.sql("COALESCE(AVG(rails_pulse_operations.duration), 0)")
+
+      Arel::Nodes::Case.new(avg_duration)
+        .when(avg_duration.lt(slow)).then(0)
+        .when(avg_duration.lt(very_slow)).then(1)
+        .when(avg_duration.lt(critical)).then(2)
+        .else(3)
+    end
+
+    ransacker :occurred_at do
+      Arel.sql("MAX(rails_pulse_operations.occurred_at)")
+    end
+
+    def to_s
+      id
+    end
+  end
+end

data/app/models/rails_pulse/request.rb

@@ -0,0 +1,64 @@
+module RailsPulse
+  class Request < RailsPulse::ApplicationRecord
+    self.table_name = "rails_pulse_requests"
+
+    # Associations
+    belongs_to :route, class_name: "RailsPulse::Route"
+    has_many :operations, class_name: "RailsPulse::Operation", foreign_key: "request_id", dependent: :destroy
+
+    # Validations
+    validates :route_id, presence: true
+    validates :occurred_at, presence: true
+    validates :duration, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :status, presence: true
+    validates :is_error, inclusion: { in: [ true, false ] }
+    validates :request_uuid, presence: true, uniqueness: true
+
+    before_create :set_request_uuid
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id route_id occurred_at duration status status_indicator route_path]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[route]
+    end
+
+    ransacker :occurred_at do |parent|
+      parent.table[:occurred_at]
+    end
+
+    ransacker :route_path do |parent|
+      Arel.sql("rails_pulse_routes.path")
+    end
+
+    ransacker :status_indicator do |parent|
+      # Calculate status indicator based on request_thresholds with safe defaults
+      config = RailsPulse.configuration rescue nil
+      thresholds = config&.request_thresholds || { slow: 500, very_slow: 1000, critical: 2000 }
+
+      slow = thresholds[:slow] || 500
+      very_slow = thresholds[:very_slow] || 1000
+      critical = thresholds[:critical] || 2000
+
+      Arel.sql("
+        CASE
+          WHEN rails_pulse_requests.duration < #{slow} THEN 0
+          WHEN rails_pulse_requests.duration < #{very_slow} THEN 1
+          WHEN rails_pulse_requests.duration < #{critical} THEN 2
+          ELSE 3
+        END
+      ")
+    end
+
+    def to_s
+      occurred_at.strftime("%b %d, %Y %l:%M %p")
+    end
+
+    private
+
+    def set_request_uuid
+      self.request_uuid = SecureRandom.uuid if request_uuid.blank?
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module RailsPulse
+  module Requests
+    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 = @ransack_query.result(distinct: false)
+            .public_send(
+              @group_by,
+              "rails_pulse_requests.occurred_at",
+              series: true,
+              time_zone: "UTC"
+            )
+            .average("rails_pulse_requests.duration")
+
+          # 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
+
+          # For requests, look for occurred_at conditions on rails_pulse_requests
+          start_condition = conditions.find { |c| c.a.first == "rails_pulse_requests_occurred_at" && c.p == "gteq" }
+          end_condition = conditions.find { |c| c.a.first == "rails_pulse_requests_occurred_at" && c.p == "lt" }
+
+          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/requests/charts/operations_chart.rb

@@ -0,0 +1,35 @@
+module RailsPulse
+  module Requests
+    module Charts
+      class OperationsChart
+        OperationBar = Struct.new(:operation, :duration, :left_pct, :width_pct)
+
+        attr_reader :bars, :min_start, :max_end, :total_duration
+
+        HORIZONTAL_OFFSET_PX = 20
+
+        def initialize(operations)
+          @operations = operations
+          @min_start = @operations.map(&:start_time).min || 0
+          @max_end = @operations.map { |op| op.start_time + op.duration }.max || 1
+          @total_duration = (@max_end - @min_start).nonzero? || 1
+          @bars = build_bars
+        end
+
+        private
+
+        def build_bars
+          @operations.map do |operation|
+            left_pct = ((operation.start_time - @min_start).to_f / @total_duration) * (100 - px_to_pct) + px_to_pct / 2
+            width_pct = (operation.duration.to_f / @total_duration) * (100 - px_to_pct)
+            OperationBar.new(operation, operation.duration.round(0), left_pct, width_pct)
+          end
+        end
+
+        def px_to_pct
+          (HORIZONTAL_OFFSET_PX.to_f / 1000) * 100
+        end
+      end
+    end
+  end
+end