rails_pulse 0.1.0

data/app/helpers/rails_pulse/cached_component_helper.rb

@@ -0,0 +1,73 @@
+module RailsPulse
+  module CachedComponentHelper
+    def cached_component(options)
+      # cache_key = ComponentCacheKey.build(options[:id], options[:context])
+
+      # Add refresh action for panels if requested
+      if options[:refresh_action] && options[:component] == "panel"
+        options[:actions] ||= []
+        options[:actions] << refresh_action_params(options[:id], options[:context], options[:content_partial])
+      end
+
+      # if Rails.cache.exist?(cache_key)
+      if false
+        render_cached_content(options)
+      else
+        render_skeleton_with_frame(options)
+      end
+    end
+
+    private
+
+    def render_cached_content(options)
+      cache_key = ComponentCacheKey.build(options[:id], options[:context])
+      cached_data = Rails.cache.read(cache_key)
+      @component_data = cached_data[:component_data]
+      @cached_at = cached_data[:cached_at]
+      component_options = cached_data[:component_options] || {}
+
+      # Wrap the cached content in a Turbo Frame so it can be refreshed using a refresh link in the component
+      turbo_frame_tag "#{options[:id]}_#{options[:component]}", class: options[:class] do
+        render "rails_pulse/components/#{options[:component]}", component_options
+      end
+    end
+
+    def render_skeleton_with_frame(options)
+      # Store component options temporarily so CachesController can access them
+      cache_key = ComponentCacheKey.build(options[:id], options[:context])
+      Rails.cache.write(cache_key, component_options: options, expires_in: 5.minutes)
+      path_options = options.slice :id, :context
+
+      turbo_frame_tag "#{options[:id]}_#{options[:component]}",
+                      src: rails_pulse.cache_path(**path_options),
+                      loading: "eager",
+                      class: options[:class] do
+        render "rails_pulse/skeletons/#{options[:component]}", options
+      end
+    end
+
+    def refresh_action_params(id, context, content_partial)
+      refresh_params = {
+        id: id,
+        component_type: "panel",
+        refresh: true
+      }
+
+      # Include content_partial in refresh URL if available
+      refresh_params[:content_partial] = content_partial if content_partial
+
+      {
+        url: rails_pulse.cache_path(refresh_params),
+        icon: "refresh-cw",
+        title: "Refresh data",
+        data: {
+          controller: "rails-pulse--timezone",
+          rails_pulse__timezone_target_frame_value: "#{id}_panel",
+          rails_pulse__timezone_cached_at_value: Time.current.iso8601,
+          turbo_frame: "#{id}_panel",
+          turbo_prefetch: "false"
+        }
+      }
+    end
+  end
+end

data/app/helpers/rails_pulse/chart_formatters.rb

@@ -0,0 +1,43 @@
+module RailsPulse
+  module ChartFormatters
+    def self.occurred_at_as_time_or_date(time_diff_hours)
+      if time_diff_hours <= 25
+        <<~JS
+          function(value) {
+            const date = new Date(value * 1000);
+            return date.getHours().toString().padStart(2, '0') + ':00';
+          }
+        JS
+      else
+        <<~JS
+          function(value) {
+            const date = new Date(value * 1000);
+            return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+          }
+        JS
+      end
+    end
+
+    def self.tooltip_as_time_or_date_with_marker(time_diff_hours)
+      if time_diff_hours <= 25
+        <<~JS
+          function(params) {
+            const data = params[0];
+            const date = new Date(data.axisValue * 1000);
+            const dateString = date.getHours().toString().padStart(2, '0') + ':00';
+            return `${dateString} <br /> ${data.marker} ${parseInt(data.data.value)} ms`;
+          }
+        JS
+      else
+        <<~JS
+          function(params) {
+            const data = params[0];
+            const date = new Date(data.axisValue * 1000);
+            const dateString = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+            return `${dateString} <br /> ${data.marker} ${parseInt(data.data.value)} ms`;
+          }
+        JS
+      end
+    end
+  end
+end

data/app/helpers/rails_pulse/chart_helper.rb

@@ -0,0 +1,140 @@
+module RailsPulse
+  module ChartHelper
+    # Base chart options shared across all chart types
+    def base_chart_options(units: nil, zoom: false)
+      {
+        tooltip: {
+          trigger: "axis",
+          axisPointer: { type: "shadow" }
+        },
+        toolbox: {
+          feature: { saveAsImage: { show: false } }
+        },
+        xAxis: {
+          axisLine: { show: false },
+          axisTick: { show: false }
+        },
+        yAxis: {
+          splitArea: { show: false },
+          axisLabel: {
+            formatter: "{value} #{units}"
+          }
+        },
+        grid: {
+          left: "0",
+          right: "2%",
+          bottom: (zoom ? "60" : "0"),
+          top: "10%",
+          containLabel: true
+        },
+        animation: false
+      }
+    end
+
+    def bar_chart_options(units: nil, zoom: false, chart_start: 0, chart_end: 100, xaxis_formatter: nil, tooltip_formatter: nil, zoom_start: nil, zoom_end: nil, chart_data: nil)
+      options = base_chart_options(units: units, zoom: zoom).deep_merge({
+        series: {
+          itemStyle: { borderRadius: [ 5, 5, 5, 5 ] }
+        }
+      })
+
+      apply_tooltip_formatter(options, tooltip_formatter)
+      apply_xaxis_formatter(options, xaxis_formatter)
+      apply_zoom_configuration(options, zoom, zoom_start, zoom_end, chart_data)
+
+      options
+    end
+
+    def line_chart_options(units: nil, zoom: false, chart_start: 0, chart_end: 100, xaxis_formatter: nil, tooltip_formatter: nil, zoom_start: nil, zoom_end: nil, chart_data: nil)
+      options = base_chart_options(units: units, zoom: zoom).deep_merge({
+        series: {
+          smooth: true,
+          lineStyle: { width: 3 },
+          symbol: "circle",
+          symbolSize: 8
+        }
+      })
+
+      apply_tooltip_formatter(options, tooltip_formatter)
+      apply_xaxis_formatter(options, xaxis_formatter)
+      apply_zoom_configuration(options, zoom, zoom_start, zoom_end, chart_data)
+
+      options
+    end
+
+    def sparkline_chart_options
+      base_chart_options.deep_merge({
+        series: {
+          type: "line",
+          smooth: true,
+          lineStyle: { width: 2 },
+          symbol: "none"
+        },
+        yAxis: { show: false },
+        xAxis: { splitLine: { show: false } },
+        grid: { show: false }
+      })
+    end
+
+    def area_chart_options
+      base_chart_options.deep_merge({
+        series: {
+          smooth: true,
+          lineStyle: { width: 3 },
+          symbol: "roundRect",
+          symbolSize: 8
+        }
+      })
+    end
+
+    private
+
+    def apply_tooltip_formatter(options, tooltip_formatter)
+      return unless tooltip_formatter.present?
+
+      options[:tooltip][:formatter] = RailsCharts.js(tooltip_formatter)
+    end
+
+    def apply_xaxis_formatter(options, xaxis_formatter)
+      return unless xaxis_formatter.present?
+
+      options[:xAxis][:axisLabel] ||= { formatter: RailsCharts.js(xaxis_formatter) }
+    end
+
+    def apply_zoom_configuration(options, zoom, zoom_start, zoom_end, chart_data)
+      return unless zoom
+
+      zoom_config = {
+        type: "slider",
+        height: 20,
+        bottom: 10,
+        showDetail: false
+      }
+
+      # Initialize zoom range if zoom parameters are provided
+      if zoom_start.present? && zoom_end.present? && chart_data.present?
+        # Find closest matching timestamps in the actual chart data
+        # Chart data is a hash like: { 1234567890 => { value: 123.45 } }
+        chart_timestamps = chart_data.keys
+
+        if chart_timestamps.any?
+          closest_start = chart_timestamps.min_by { |ts| (ts - zoom_start).abs }
+          closest_end = chart_timestamps.min_by { |ts| (ts - zoom_end).abs }
+
+          # Find the array indices of these timestamps
+          start_index = chart_timestamps.index(closest_start)
+          end_index = chart_timestamps.index(closest_end)
+
+          # Use array indices for dataZoom instead of timestamp values
+          zoom_config[:startValue] = start_index
+          zoom_config[:endValue] = end_index
+        end
+      end
+
+      options[:dataZoom] = [
+        zoom_config,
+        { type: "inside" }
+      ]
+    end
+  end
+end

data/app/helpers/rails_pulse/formatting_helper.rb

@@ -0,0 +1,29 @@
+module RailsPulse
+  module FormattingHelper
+    def human_readable_occurred_at(occurred_at)
+      return "" unless occurred_at.present?
+      time = occurred_at.is_a?(String) ? Time.parse(occurred_at) : occurred_at
+      time.strftime("%b %d, %Y %l:%M %p")
+    end
+
+    def time_ago_in_words(time)
+      return "Unknown" if time.blank?
+
+      # Convert to Time object if it's a string
+      time = Time.parse(time.to_s) if time.is_a?(String)
+
+      seconds_ago = Time.current - time
+
+      case seconds_ago
+      when 0..59
+        "#{seconds_ago.to_i}s ago"
+      when 60..3599
+        "#{(seconds_ago / 60).to_i}m ago"
+      when 3600..86399
+        "#{(seconds_ago / 3600).to_i}h ago"
+      else
+        "#{(seconds_ago / 86400).to_i}d ago"
+      end
+    end
+  end
+end

data/app/helpers/rails_pulse/status_helper.rb

@@ -0,0 +1,279 @@
+module RailsPulse
+  module StatusHelper
+    def route_status_indicator(status_value)
+      case status_value.to_i
+      when 0
+        # Healthy routes show no icon to reduce visual clutter
+        ""
+      when 1
+        content_tag(
+          :span,
+          lucide_icon("alert-triangle", width: "16", height: "16", class: "text-yellow-600"),
+          title: "Warning - Response time > #{RailsPulse.configuration.route_thresholds[:slow]} ms"
+        )
+      when 2
+        content_tag(
+          :span,
+          lucide_icon("alert-circle", width: "16", height: "16", class: "text-orange-600"),
+          title: "Slow - Response time > #{RailsPulse.configuration.route_thresholds[:very_slow]} ms"
+        )
+      when 3
+        content_tag(
+          :span,
+          lucide_icon("x-circle", width: "16", height: "16", class: "text-red-600"),
+          title: "Critical - Response time > #{RailsPulse.configuration.route_thresholds[:critical]} ms"
+        )
+      else
+        content_tag(
+          :span,
+          lucide_icon("help-circle", width: "16", height: "16", class: "text-gray-400"),
+          title: "Unknown status"
+        )
+      end
+    end
+
+    def request_status_indicator(duration)
+      thresholds = RailsPulse.configuration.request_thresholds
+      status_value = case duration.to_i
+      when 0...thresholds[:slow]
+        0 # Healthy
+      when thresholds[:slow]...thresholds[:very_slow]
+        1 # Warning
+      when thresholds[:very_slow]...thresholds[:critical]
+        2 # Slow
+      else
+        3 # Critical
+      end
+
+      case status_value
+      when 0
+        # Healthy requests show no icon to reduce visual clutter
+        ""
+      when 1
+        content_tag(
+          :span,
+          lucide_icon("alert-triangle", width: "16", height: "16", class: "text-yellow-600"),
+          title: "Warning - Response time > #{thresholds[:slow]} ms"
+        )
+      when 2
+        content_tag(
+          :span,
+          lucide_icon("alert-circle", width: "16", height: "16", class: "text-orange-600"),
+          title: "Slow - Response time > #{thresholds[:very_slow]} ms"
+        )
+      when 3
+        content_tag(
+          :span,
+          lucide_icon("x-circle", width: "16", height: "16", class: "text-red-600"),
+          title: "Critical - Response time > #{thresholds[:critical]} ms"
+        )
+      else
+        content_tag(
+          :span,
+          lucide_icon("help-circle", width: "16", height: "16", class: "text-gray-400"),
+          title: "Unknown status"
+        )
+      end
+    end
+
+    def query_status_indicator(avg_duration)
+      thresholds = RailsPulse.configuration.query_thresholds
+      status_value = case avg_duration.to_f
+      when 0...thresholds[:slow]
+        0 # Healthy
+      when thresholds[:slow]...thresholds[:very_slow]
+        1 # Warning
+      when thresholds[:very_slow]...thresholds[:critical]
+        2 # Slow
+      else
+        3 # Critical
+      end
+
+      case status_value
+      when 0
+        # Healthy queries show no icon to reduce visual clutter
+        ""
+      when 1
+        content_tag(
+          :span,
+          lucide_icon("alert-triangle", width: "16", height: "16", class: "text-yellow-600"),
+          title: "Warning - Query time > #{thresholds[:slow]} ms"
+        )
+      when 2
+        content_tag(
+          :span,
+          lucide_icon("alert-circle", width: "16", height: "16", class: "text-orange-600"),
+          title: "Slow - Query time > #{thresholds[:very_slow]} ms"
+        )
+      when 3
+        content_tag(
+          :span,
+          lucide_icon("x-circle", width: "16", height: "16", class: "text-red-600"),
+          title: "Critical - Query time > #{thresholds[:critical]} ms"
+        )
+      else
+        content_tag(
+          :span,
+          lucide_icon("help-circle", width: "16", height: "16", class: "text-gray-400"),
+          title: "Unknown status"
+        )
+      end
+    end
+
+    def operation_status_indicator(operation)
+      # Define operation-specific thresholds
+      thresholds = case operation.operation_type
+      when "sql"
+        { slow: 50, very_slow: 100, critical: 500 }
+      when "template", "partial", "layout", "collection"
+        { slow: 50, very_slow: 150, critical: 300 }
+      when "controller"
+        { slow: 200, very_slow: 500, critical: 1000 }
+      when "cache_read", "cache_write"
+        { slow: 10, very_slow: 50, critical: 100 }
+      when "http"
+        { slow: 500, very_slow: 1000, critical: 3000 }
+      when "job"
+        { slow: 1000, very_slow: 5000, critical: 10000 }
+      when "mailer"
+        { slow: 500, very_slow: 2000, critical: 5000 }
+      when "storage"
+        { slow: 500, very_slow: 1000, critical: 3000 }
+      else
+        { slow: 100, very_slow: 300, critical: 1000 }
+      end
+
+      duration = operation.duration.to_f
+      status_value = case duration
+      when 0...thresholds[:slow]
+        0 # Healthy
+      when thresholds[:slow]...thresholds[:very_slow]
+        1 # Warning
+      when thresholds[:very_slow]...thresholds[:critical]
+        2 # Slow
+      else
+        3 # Critical
+      end
+
+      case status_value
+      when 0
+        # Healthy operations show no icon to reduce visual clutter
+        ""
+      when 1
+        content_tag(
+          :span,
+          lucide_icon("alert-triangle", width: "16", height: "16", class: "text-yellow-600"),
+          title: "Warning - Operation time > #{thresholds[:slow]} ms"
+        )
+      when 2
+        content_tag(
+          :span,
+          lucide_icon("alert-circle", width: "16", height: "16", class: "text-orange-600"),
+          title: "Slow - Operation time > #{thresholds[:very_slow]} ms"
+        )
+      when 3
+        content_tag(
+          :span,
+          lucide_icon("x-circle", width: "16", height: "16", class: "text-red-600"),
+          title: "Critical - Operation time > #{thresholds[:critical]} ms"
+        )
+      else
+        content_tag(
+          :span,
+          lucide_icon("help-circle", width: "16", height: "16", class: "text-gray-400"),
+          title: "Unknown status"
+        )
+      end
+    end
+
+    def operations_performance_breakdown(operations)
+      return { database: 0, view: 0, application: 0, other: 0 } if operations.empty?
+
+      total_duration = operations.sum(&:duration).to_f
+      return { database: 0, view: 0, application: 0, other: 0 } if total_duration.zero?
+
+      breakdown = operations.group_by { |op| categorize_operation(op.operation_type) }
+        .transform_values { |ops| ops.sum(&:duration) }
+
+      {
+        database: ((breakdown[:database] || 0) / total_duration * 100).round(1),
+        view: ((breakdown[:view] || 0) / total_duration * 100).round(1),
+        application: ((breakdown[:application] || 0) / total_duration * 100).round(1),
+        other: ((breakdown[:other] || 0) / total_duration * 100).round(1)
+      }
+    end
+
+    def categorize_operation(operation_type)
+      case operation_type
+      when "sql"
+        :database
+      when "template", "partial", "layout", "collection"
+        :view
+      when "controller"
+        :application
+      else
+        :other
+      end
+    end
+
+    def operation_category_label(operation_type)
+      case categorize_operation(operation_type)
+      when :database
+        "Database"
+      when :view
+        "View Rendering"
+      when :application
+        "Application Logic"
+      else
+        "Other Operations"
+      end
+    end
+
+    def performance_badge_class(percentile)
+      case percentile
+      when 0..50
+        "badge--positive"
+      when 51..75
+        "badge--warning"
+      when 76..90
+        "badge--negative"
+      else
+        "badge--critical"
+      end
+    end
+
+    def rescue_template_missing
+      yield
+      true
+    rescue ActionView::MissingTemplate
+      false
+    end
+
+    def truncate_sql(sql, length: 100)
+      return sql if sql.length <= length
+      sql.truncate(length)
+    end
+
+    def event_color(operation_type)
+      case operation_type
+      when "sql" then "#92c282;"
+      when "template", "partial", "layout", "collection" then "#b77cbf"
+      when "controller" then "#00adc4"
+      else "gray"
+      end
+    end
+
+    def duration_options(type = :route)
+      thresholds = RailsPulse.configuration.public_send("#{type}_thresholds")
+
+      first_label = "All #{type.to_s.humanize.pluralize}"
+
+      [
+        [ first_label, :all ],
+        [ "Slow (≥ #{thresholds[:slow]}ms)", :slow ],
+        [ "Very Slow (≥ #{thresholds[:very_slow]}ms)", :very_slow ],
+        [ "Critical (≥ #{thresholds[:critical]}ms)", :critical ]
+      ]
+    end
+  end
+end

data/app/helpers/rails_pulse/table_helper.rb

@@ -0,0 +1,54 @@
+module RailsPulse
+  module TableHelper
+    def render_cell_content(row_data, column)
+      value = row_data[column[:field]]
+
+      # Handle links
+      if column[:link_to] && row_data[column[:link_to]]
+        # Direct link provided
+        link_to value, row_data[column[:link_to]], data: { turbo_frame: "_top" }
+      elsif column[:link_field] && row_data[column[:link_field]]
+        # Generate link based on field type and ID
+        case column[:link_field]
+        when :query_id
+          link_to value, query_path(row_data[column[:link_field]]), data: { turbo_frame: "_top" }
+        when :route_id
+          link_to value, route_path(row_data[column[:link_field]]), data: { turbo_frame: "_top" }
+        else
+          value
+        end
+      elsif column[:format] == :percentage && value.is_a?(Numeric)
+        "#{value > 0 ? '+' : ''}#{value}%"
+      elsif value.is_a?(Numeric) && column[:field].to_s.include?("time")
+        "#{value.round(0)} ms"
+      else
+        value
+      end
+    end
+
+    def cell_highlight_class(row_data, column)
+      return "" unless column[:highlight]
+
+      case column[:highlight]
+      when :trend
+        trend = row_data[:trend]
+        case trend
+        when "worse" then "highlight-red"
+        when "better" then "highlight-green"
+        else ""
+        end
+      when :percentage_change
+        change = row_data[:percentage_change]
+        if change && change > 5
+          "highlight-red"
+        elsif change && change < -5
+          "highlight-green"
+        else
+          ""
+        end
+      else
+        ""
+      end
+    end
+  end
+end