rails_pulse 0.1.0

data/app/controllers/rails_pulse/operations_controller.rb

@@ -0,0 +1,219 @@
+module RailsPulse
+  class OperationsController < ApplicationController
+    before_action :set_operation, only: :show
+
+    def show
+      @request = @operation.request
+      @related_operations = find_related_operations
+      @performance_context = calculate_performance_context
+      @optimization_suggestions = generate_optimization_suggestions
+
+      respond_to do |format|
+        format.html
+      end
+    end
+
+    private
+
+    def set_operation
+      @operation = Operation.find(params[:id])
+    end
+
+    def find_related_operations
+      case @operation.operation_type
+      when "sql"
+        # Find other SQL operations in the same request with similar queries
+        @operation.request.operations
+          .where(operation_type: [ "sql" ])
+          .where.not(id: @operation.id)
+          .limit(5)
+      when "template", "partial", "layout", "collection"
+        # Find other view operations in the same request
+        @operation.request.operations
+          .where(operation_type: [ "template", "partial", "layout", "collection" ])
+          .where.not(id: @operation.id)
+          .limit(5)
+      else
+        # Find operations of the same type in the same request
+        @operation.request.operations
+          .where(operation_type: @operation.operation_type)
+          .where.not(id: @operation.id)
+          .limit(5)
+      end
+    end
+
+    def calculate_performance_context
+      # Calculate percentiles and comparisons for this operation type
+      similar_operations = Operation.where(operation_type: @operation.operation_type)
+        .where("occurred_at >= ?", 7.days.ago)
+        .limit(1000)
+
+      return {} if similar_operations.empty?
+
+      durations = similar_operations.pluck(:duration).sort
+      total_count = durations.length
+
+      {
+        percentile_50: durations[(total_count * 0.5).floor] || 0,
+        percentile_75: durations[(total_count * 0.75).floor] || 0,
+        percentile_90: durations[(total_count * 0.9).floor] || 0,
+        percentile_95: durations[(total_count * 0.95).floor] || 0,
+        average: durations.sum / total_count.to_f,
+        count: total_count,
+        current_percentile: calculate_percentile(@operation.duration, durations)
+      }
+    end
+
+    def calculate_percentile(value, sorted_array)
+      return 0 if sorted_array.empty?
+
+      index = sorted_array.bsearch_index { |x| x >= value } || sorted_array.length
+      (index.to_f / sorted_array.length * 100).round(1)
+    end
+
+    def generate_optimization_suggestions
+      suggestions = []
+
+      case @operation.operation_type
+      when "sql"
+        suggestions.concat(sql_optimization_suggestions)
+      when "template", "partial", "layout", "collection"
+        suggestions.concat(view_optimization_suggestions)
+      when "controller"
+        suggestions.concat(controller_optimization_suggestions)
+      when "cache_read", "cache_write"
+        suggestions.concat(cache_optimization_suggestions)
+      when "http"
+        suggestions.concat(http_optimization_suggestions)
+      end
+
+      suggestions
+    end
+
+    def sql_optimization_suggestions
+      suggestions = []
+
+      if @operation.duration > 100
+        suggestions << {
+          type: "performance",
+          icon: "zap",
+          title: "Slow Query Detected",
+          description: "This query took #{@operation.duration.round(2)}ms. Consider adding database indexes or optimizing the query.",
+          priority: "high"
+        }
+      end
+
+      if @operation.label&.match?(/SELECT.*FROM\s+(\w+)/i)
+        table_name = @operation.label.match(/FROM\s+(\w+)/i)&.captures&.first
+        if table_name
+          suggestions << {
+            type: "index",
+            icon: "database",
+            title: "Index Optimization",
+            description: "Review indexes on the '#{table_name}' table. Consider composite indexes for WHERE clauses.",
+            priority: "medium"
+          }
+        end
+      end
+
+      # Check for potential N+1 queries
+      similar_queries = @operation.request.operations
+        .where(operation_type: [ "sql" ])
+        .where("label LIKE ?", "%#{@operation.label.split.first(3).join(' ')}%")
+        .where.not(id: @operation.id)
+
+      if similar_queries.count > 2
+        suggestions << {
+          type: "n_plus_one",
+          icon: "alert-triangle",
+          title: "Potential N+1 Query",
+          description: "#{similar_queries.count + 1} similar queries detected. Consider using includes() or joins().",
+          priority: "high"
+        }
+      end
+
+      suggestions
+    end
+
+    def view_optimization_suggestions
+      suggestions = []
+
+      if @operation.duration > 100
+        suggestions << {
+          type: "performance",
+          icon: "zap",
+          title: "Slow View Rendering",
+          description: "This view took #{@operation.duration.round(2)}ms to render. Consider fragment caching or reducing database calls.",
+          priority: "high"
+        }
+      end
+
+      # Check for database queries in views
+      view_db_operations = @operation.request.operations
+        .where(operation_type: [ "sql" ])
+        .where("occurred_at >= ? AND occurred_at <= ?",
+               @operation.occurred_at,
+               @operation.occurred_at + @operation.duration)
+
+      if view_db_operations.count > 0
+        suggestions << {
+          type: "database",
+          icon: "database",
+          title: "Database Queries in View",
+          description: "#{view_db_operations.count} database queries during view rendering. Move data fetching to the controller.",
+          priority: "medium"
+        }
+      end
+
+      suggestions
+    end
+
+    def controller_optimization_suggestions
+      suggestions = []
+
+      if @operation.duration > 500
+        suggestions << {
+          type: "performance",
+          icon: "zap",
+          title: "Slow Controller Action",
+          description: "This action took #{@operation.duration.round(2)}ms. Consider moving heavy computation to background jobs.",
+          priority: "high"
+        }
+      end
+
+      suggestions
+    end
+
+    def cache_optimization_suggestions
+      suggestions = []
+
+      if @operation.operation_type == "cache_read" && @operation.duration > 10
+        suggestions << {
+          type: "performance",
+          icon: "clock",
+          title: "Slow Cache Read",
+          description: "Cache read took #{@operation.duration.round(2)}ms. Check cache backend performance.",
+          priority: "medium"
+        }
+      end
+
+      suggestions
+    end
+
+    def http_optimization_suggestions
+      suggestions = []
+
+      if @operation.duration > 1000
+        suggestions << {
+          type: "performance",
+          icon: "globe",
+          title: "Slow External Request",
+          description: "HTTP request took #{@operation.duration.round(2)}ms. Consider caching responses or using background jobs.",
+          priority: "high"
+        }
+      end
+
+      suggestions
+    end
+  end
+end

data/app/controllers/rails_pulse/queries_controller.rb

@@ -0,0 +1,121 @@
+module RailsPulse
+  class QueriesController < ApplicationController
+    include ChartTableConcern
+
+    before_action :set_query, only: :show
+
+    def index
+      setup_chart_and_table_data
+    end
+
+    def show
+      setup_chart_and_table_data
+    end
+
+    private
+
+    def chart_model
+      show_action? ? Operation : Query
+    end
+
+    def table_model
+      show_action? ? Operation : Query
+    end
+
+    def chart_class
+      Queries::Charts::AverageQueryTimes
+    end
+
+    def chart_options
+      show_action? ? { query: @query } : {}
+    end
+
+    def build_chart_ransack_params(ransack_params)
+      base_params = ransack_params.except(:s)
+
+      if show_action?
+        base_params.merge(
+          query_id_eq: @query.id,
+          occurred_at_gteq: @start_time,
+          occurred_at_lt: @end_time,
+          duration_gteq: @start_duration
+        )
+      else
+        base_params.merge(
+          operations_occurred_at_gteq: @start_time,
+          operations_occurred_at_lt: @end_time,
+          operations_duration_gteq: @start_duration
+        )
+      end
+    end
+
+    def build_table_ransack_params(ransack_params)
+      if show_action?
+        ransack_params.merge(
+          query_id_eq: @query.id,
+          occurred_at_gteq: @table_start_time,
+          occurred_at_lt: @table_end_time,
+          duration_gteq: @start_duration
+        )
+      else
+        ransack_params.merge(
+          operations_occurred_at_gteq: @table_start_time,
+          operations_occurred_at_lt: @table_end_time,
+          operations_duration_gteq: @start_duration
+        )
+      end
+    end
+
+    def default_table_sort
+      "occurred_at desc"
+    end
+
+    def build_table_results
+      if show_action?
+        @ransack_query.result.select("id", "occurred_at", "duration")
+      else
+        # Optimized query: Use INNER JOIN since we only want queries with operations in time range
+        # This dramatically reduces the dataset before aggregation
+        @ransack_query.result(distinct: false)
+          .joins("INNER JOIN rails_pulse_operations ON rails_pulse_operations.query_id = rails_pulse_queries.id")
+          .where("rails_pulse_operations.occurred_at >= ? AND rails_pulse_operations.occurred_at < ?",
+                 @table_start_time, @table_end_time)
+          .group("rails_pulse_queries.id, rails_pulse_queries.normalized_sql, rails_pulse_queries.created_at, rails_pulse_queries.updated_at")
+          .select(
+            "rails_pulse_queries.*",
+            optimized_aggregations_sql
+          )
+      end
+    end
+
+    private
+
+    def optimized_aggregations_sql
+      # Efficient aggregations that work with our composite indexes
+      [
+        "COALESCE(AVG(rails_pulse_operations.duration), 0) AS average_query_time_ms",
+        "COUNT(rails_pulse_operations.id) AS execution_count",
+        "COALESCE(SUM(rails_pulse_operations.duration), 0) AS total_time_consumed",
+        "MAX(rails_pulse_operations.occurred_at) AS occurred_at"
+      ].join(", ")
+    end
+
+    def show_action?
+      action_name == "show"
+    end
+
+    def pagination_method
+      show_action? ? :set_pagination_limit : :store_pagination_limit
+    end
+
+    def set_query
+      @query = Query.find(params[:id])
+    end
+
+    def setup_metic_cards
+      @average_query_times_card = Queries::Cards::AverageQueryTimes.new(query: @query).to_metric_card
+      @percentile_response_times_card = Queries::Cards::PercentileQueryTimes.new(query: @query).to_metric_card
+      @execution_rate_card = Queries::Cards::ExecutionRate.new(query: @query).to_metric_card
+    end
+  end
+end

data/app/controllers/rails_pulse/requests_controller.rb

@@ -0,0 +1,69 @@
+module RailsPulse
+  class RequestsController < ApplicationController
+    include ChartTableConcern
+
+    before_action :set_request, only: :show
+
+    def index
+      setup_chart_and_table_data
+    end
+
+    def show
+      @operation_timeline = RailsPulse::Requests::Charts::OperationsChart.new(@request.operations)
+    end
+
+    private
+
+    def chart_model
+      Request
+    end
+
+    def table_model
+      Request
+    end
+
+    def chart_class
+      Requests::Charts::AverageResponseTimes
+    end
+
+    def chart_options
+      { route: true }
+    end
+
+    def build_chart_ransack_params(ransack_params)
+      ransack_params.except(:s).merge(
+        occurred_at_gteq: @start_time,
+        occurred_at_lt: @end_time,
+        duration_gteq: @start_duration
+      )
+    end
+
+    def build_table_ransack_params(ransack_params)
+      ransack_params.merge(
+        occurred_at_gteq: @table_start_time,
+        occurred_at_lt: @table_end_time,
+        duration_gteq: @start_duration
+      )
+    end
+
+    def default_table_sort
+      "occurred_at desc"
+    end
+
+    def build_table_results
+      @ransack_query.result
+        .includes(:route)
+        .select(
+          "rails_pulse_requests.id",
+          "rails_pulse_requests.occurred_at",
+          "rails_pulse_requests.duration",
+          "rails_pulse_requests.status",
+          "rails_pulse_requests.route_id"
+        )
+    end
+
+    def set_request
+      @request = Request.find(params[:id])
+    end
+  end
+end

data/app/controllers/rails_pulse/routes_controller.rb

@@ -0,0 +1,99 @@
+module RailsPulse
+  class RoutesController < ApplicationController
+    include ChartTableConcern
+
+    before_action :set_route, only: :show
+
+    def index
+      setup_chart_and_table_data
+    end
+
+    def show
+      setup_chart_and_table_data
+    end
+
+    private
+
+    def chart_model
+      show_action? ? Request : Route
+    end
+
+    def table_model
+      show_action? ? Request : Route
+    end
+
+    def chart_class
+      Routes::Charts::AverageResponseTimes
+    end
+
+    def chart_options
+      show_action? ? { route: @route } : {}
+    end
+
+    def build_chart_ransack_params(ransack_params)
+      base_params = ransack_params.except(:s).merge(duration_field => @start_duration)
+
+      if show_action?
+        base_params.merge(
+          route_id_eq: @route.id,
+          occurred_at_gteq: @start_time,
+          occurred_at_lt: @end_time
+        )
+      else
+        base_params.merge(
+          requests_occurred_at_gteq: @start_time,
+          requests_occurred_at_lt: @end_time
+        )
+      end
+    end
+
+    def build_table_ransack_params(ransack_params)
+      base_params = ransack_params.merge(duration_field => @start_duration)
+
+      if show_action?
+        base_params.merge(
+          route_id_eq: @route.id,
+          occurred_at_gteq: @table_start_time,
+          occurred_at_lt: @table_end_time
+        )
+      else
+        base_params.merge(
+          requests_occurred_at_gteq: @table_start_time,
+          requests_occurred_at_lt: @table_end_time
+        )
+      end
+    end
+
+    def default_table_sort
+      show_action? ? "occurred_at desc" : "average_response_time_ms desc"
+    end
+
+    def build_table_results
+      if show_action?
+        @ransack_query.result.select("id", "route_id", "occurred_at", "duration", "status")
+      else
+        Routes::Tables::Index.new(
+          ransack_query: @ransack_query,
+          start_time: @start_time,
+          params: params
+        ).to_table
+      end
+    end
+
+    def duration_field
+      show_action? ? :duration_gteq : :requests_duration_gteq
+    end
+
+    def show_action?
+      action_name == "show"
+    end
+
+    def pagination_method
+      show_action? ? :set_pagination_limit : :store_pagination_limit
+    end
+
+    def set_route
+      @route = Route.find(params[:id])
+    end
+  end
+end

data/app/helpers/rails_pulse/application_helper.rb

@@ -0,0 +1,111 @@
+module RailsPulse
+  module ApplicationHelper
+    include Pagy::Frontend
+
+    include BreadcrumbsHelper
+    include CachedComponentHelper
+    include ChartHelper
+    include FormattingHelper
+    include StatusHelper
+    include TableHelper
+
+    # Replacement for lucide_icon helper that works with pre-compiled assets
+    # Outputs a custom element that will be hydrated by Stimulus
+    def rails_pulse_icon(name, options = {})
+      width = options[:width] || options["width"] || 24
+      height = options[:height] || options["height"] || 24
+      css_class = options[:class] || options["class"] || ""
+
+      # Additional HTML attributes
+      attrs = options.except(:width, :height, :class, "width", "height", "class")
+
+      content_tag("rails-pulse-icon",
+        "",
+        data: {
+          controller: "rails-pulse--icon",
+          'rails-pulse--icon-name-value': name,
+          'rails-pulse--icon-width-value': width,
+          'rails-pulse--icon-height-value': height
+        },
+        class: css_class,
+        **attrs
+      )
+    end
+
+    # Backward compatibility alias - can be removed after migration
+    alias_method :lucide_icon, :rails_pulse_icon
+
+    # Make Rails Pulse routes available as rails_pulse in views
+    def rails_pulse
+      @rails_pulse_helper ||= RailsPulseHelper.new(self)
+    end
+
+    # Helper class to provide both routes and asset methods
+    class RailsPulseHelper
+      def initialize(view_context)
+        @view_context = view_context
+      end
+
+      # Delegate route methods to engine routes
+      def method_missing(method, *args, &block)
+        if RailsPulse::Engine.routes.url_helpers.respond_to?(method)
+          RailsPulse::Engine.routes.url_helpers.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        RailsPulse::Engine.routes.url_helpers.respond_to?(method, include_private) || super
+      end
+
+      # Generate asset paths that work with our custom asset serving
+      def asset_path(asset_name)
+        "/rails-pulse-assets/#{asset_name}"
+      end
+    end
+
+    # CSP nonce helper for Rails Pulse
+    def rails_pulse_csp_nonce
+      # Try various methods to get the CSP nonce from the host application
+      nonce = nil
+
+      # Method 1: Check for Rails 6+ CSP nonce helper
+      if respond_to?(:content_security_policy_nonce)
+        nonce = content_security_policy_nonce
+      end
+
+      # Method 2: Check for custom csp_nonce helper (common in many apps)
+      if nonce.blank? && respond_to?(:csp_nonce)
+        nonce = csp_nonce
+      end
+
+      # Method 3: Try to extract from request environment (where CSP gems often store it)
+      if nonce.blank? && defined?(request) && request
+        nonce = request.env["action_dispatch.content_security_policy_nonce"] ||
+                request.env["secure_headers.content_security_policy_nonce"] ||
+                request.env["csp_nonce"]
+      end
+
+      # Method 4: Check content_for CSP nonce (some apps set it this way)
+      if nonce.blank? && respond_to?(:content_for) && content_for?(:csp_nonce)
+        nonce = content_for(:csp_nonce)
+      end
+
+      # Method 5: Extract from meta tag if present (less efficient but works)
+      if nonce.blank? && defined?(content_security_policy_nonce_tag)
+        begin
+          tag_content = content_security_policy_nonce_tag
+          if tag_content && tag_content.include?("nonce-")
+            nonce = tag_content.match(/nonce-([^"']+)/)[1] if tag_content.match(/nonce-([^"']+)/)
+          end
+        rescue
+          # Ignore parsing errors
+        end
+      end
+
+      # Return the nonce or nil (Rails will handle CSP properly with nil)
+      nonce.presence
+    end
+  end
+end

data/app/helpers/rails_pulse/breadcrumbs_helper.rb

@@ -0,0 +1,62 @@
+module RailsPulse
+  module BreadcrumbsHelper
+    def breadcrumbs
+      # Get the engine's mount point by removing the leading slash and splitting
+      mount_point = RailsPulse::Engine.routes.find_script_name({}).sub(/^\//, "")
+
+      # Split the full path and remove empty segments
+      path_segments = request.path.split("/").reject(&:empty?)
+
+      # Find the index of the mount point in the path segments
+      mount_point_index = path_segments.index(mount_point)
+
+      # If we can't find the mount point or it's the last segment, return empty
+      return [] if mount_point_index.nil? || mount_point_index == path_segments.length - 1
+
+      # Only keep segments after the mount point
+      path_segments = path_segments[(mount_point_index + 1)..-1]
+
+      # Start with the Home link
+      crumbs = [ {
+        title: "Home",
+        path: main_app.rails_pulse_path,
+        current: path_segments.empty?
+      } ]
+
+      return crumbs if path_segments.empty?
+
+      current_path = "/rails_pulse"
+
+      path_segments.each_with_index do |segment, index|
+        current_path += "/#{segment}"
+
+        # Convert segment to a more readable format
+        title = if segment =~ /^\d+$/
+          # If it's a numeric ID, try to find a title from the resource
+          resource_name = path_segments[index - 1]&.singularize
+          # Look up the class in the RailsPulse namespace
+          resource_class = "RailsPulse::#{resource_name&.classify}".safe_constantize
+          if resource_class
+            resource = resource_class.find(segment)
+            # Try to_breadcrumb first, fall back to to_s
+            resource.try(:to_breadcrumb) || resource.to_s
+          else
+            segment
+          end
+        else
+          segment.titleize
+        end
+
+        is_last = index == path_segments.length - 1
+
+        crumbs << {
+          title: title,
+          path: current_path,
+          current: is_last
+        }
+      end
+
+      crumbs
+    end
+  end
+end