rails_pulse 0.2.2 → 0.2.4

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

@@ -0,0 +1,229 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = {
+    type: String,        // "bar", "line", "area", "sparkline"
+    data: Object,        // Chart data
+    options: Object,     // ECharts configuration
+    theme: String        // ECharts theme
+  }
+
+  connect() {
+    this.initializeChart()
+    this.handleColorSchemeChange = this.onColorSchemeChange.bind(this)
+    document.addEventListener('rails-pulse:color-scheme-changed', this.handleColorSchemeChange)
+  }
+
+  disconnect() {
+    document.removeEventListener('rails-pulse:color-scheme-changed', this.handleColorSchemeChange)
+    this.disposeChart()
+  }
+
+  // Main initialization with retry logic
+  initializeChart() {
+    this.retryCount = 0
+    this.maxRetries = 100 // 5 seconds
+    this.attemptInit()
+  }
+
+  attemptInit() {
+    if (typeof echarts === 'undefined') {
+      this.retryCount++
+      if (this.retryCount >= this.maxRetries) {
+        console.error('[RailsPulse] echarts not loaded after 5 seconds for', this.element.id)
+        this.showError()
+        return
+      }
+      setTimeout(() => this.attemptInit(), 50)
+      return
+    }
+
+    this.renderChart()
+  }
+
+  renderChart() {
+    try {
+      // Initialize chart
+      this.chart = echarts.init(this.element, this.themeValue || 'railspulse')
+
+      // Build and set options
+      const config = this.buildChartConfig()
+      this.chart.setOption(config)
+
+      // Apply current color scheme
+      this.applyColorScheme()
+
+      // Dispatch event for other controllers (event-based communication)
+      document.dispatchEvent(new CustomEvent('stimulus:echarts:rendered', {
+        detail: {
+          containerId: this.element.id,
+          chart: this.chart,
+          controller: this
+        }
+      }))
+
+      // Responsive resize
+      this.resizeObserver = new ResizeObserver(() => {
+        if (this.chart) {
+          this.chart.resize()
+        }
+      })
+      this.resizeObserver.observe(this.element)
+
+      // Mark as rendered for tests
+      this.element.setAttribute('data-chart-rendered', 'true')
+
+    } catch (error) {
+      console.error('[RailsPulse] Error initializing chart:', error)
+      this.showError()
+    }
+  }
+
+  buildChartConfig() {
+    // Start with provided options
+    const config = { ...this.optionsValue }
+
+    // Process formatters (convert function strings to actual functions)
+    this.processFormatters(config)
+
+    // Set data (xAxis and series)
+    this.setChartData(config)
+
+    return config
+  }
+
+  setChartData(config) {
+    const data = this.dataValue
+
+    // Extract labels and values
+    const labels = Object.keys(data).map(k => {
+      const num = Number(k)
+      return isNaN(num) ? k : num
+    })
+
+    const values = Object.values(data).map(v => {
+      if (typeof v === 'object' && v !== null) {
+        return v.value !== undefined ? v.value : v
+      }
+      return v
+    })
+
+    // Set xAxis data
+    config.xAxis = config.xAxis || {}
+    config.xAxis.type = 'category'
+    config.xAxis.data = labels
+
+    // Set yAxis
+    config.yAxis = config.yAxis || {}
+    config.yAxis.type = 'value'
+
+    // Set series data
+    if (Array.isArray(config.series)) {
+      // If series is already an array, update first series
+      config.series[0] = config.series[0] || {}
+      config.series[0].type = this.typeValue
+      config.series[0].data = values
+    } else if (config.series && typeof config.series === 'object') {
+      // If series is a single object (from helper), convert to array
+      const seriesConfig = { ...config.series }
+      config.series = [{
+        type: this.typeValue,
+        data: values,
+        ...seriesConfig
+      }]
+    } else {
+      // No series provided, create default
+      config.series = [{
+        type: this.typeValue,
+        data: values
+      }]
+    }
+  }
+
+  processFormatters(config) {
+    // Process tooltip formatter
+    if (config.tooltip?.formatter && typeof config.tooltip.formatter === 'string') {
+      config.tooltip.formatter = this.parseFormatter(config.tooltip.formatter)
+    }
+
+    // Process xAxis formatter
+    if (config.xAxis?.axisLabel?.formatter && typeof config.xAxis.axisLabel.formatter === 'string') {
+      config.xAxis.axisLabel.formatter = this.parseFormatter(config.xAxis.axisLabel.formatter)
+    }
+
+    // Process yAxis formatter
+    if (config.yAxis?.axisLabel?.formatter && typeof config.yAxis.axisLabel.formatter === 'string') {
+      config.yAxis.axisLabel.formatter = this.parseFormatter(config.yAxis.axisLabel.formatter)
+    }
+  }
+
+  parseFormatter(formatterString) {
+    // Remove function markers if present
+    const cleanString = formatterString.replace(/__FUNCTION_START__|__FUNCTION_END__/g, '')
+
+    // If it's a function string, parse it
+    if (cleanString.trim().startsWith('function')) {
+      try {
+        // eslint-disable-next-line no-eval
+        return eval(`(${cleanString})`)
+      } catch (error) {
+        console.error('[RailsPulse] Error parsing formatter function:', error)
+        return cleanString
+      }
+    }
+    return cleanString
+  }
+
+  showError() {
+    this.element.classList.add('chart-error')
+    this.element.innerHTML = '<p class="text-subtle p-4">Chart failed to load</p>'
+  }
+
+  // Public accessor for chart instance
+  get chartInstance() {
+    return this.chart
+  }
+
+  disposeChart() {
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect()
+    }
+
+    if (this.chart) {
+      this.chart.dispose()
+      this.chart = null
+    }
+  }
+
+  // Action for dynamic updates
+  update(event) {
+    if (event.detail?.data) {
+      this.dataValue = event.detail.data
+    }
+    if (event.detail?.options) {
+      this.optionsValue = event.detail.options
+    }
+    if (this.chart) {
+      const config = this.buildChartConfig()
+      this.chart.setOption(config, true) // true = not merge
+    }
+  }
+
+  // Color scheme management
+  onColorSchemeChange() {
+    this.applyColorScheme()
+  }
+
+  applyColorScheme() {
+    if (!this.chart) return
+
+    const scheme = document.documentElement.getAttribute('data-color-scheme')
+    const isDark = scheme === 'dark'
+    const axisColor = isDark ? '#ffffff' : '#999999'
+
+    this.chart.setOption({
+      xAxis: { axisLabel: { color: axisColor } },
+      yAxis: { axisLabel: { color: axisColor } }
+    })
+  }
+}

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

@@ -15,21 +15,16 @@ export default class extends Controller {
   originalSeriesOption = null;
 
   connect() {
-    // Listen for the custom event 'chart:initialized' to set up the chart.
-    // This event is sent from the RailsCharts library when the chart is ready.
+    // Listen for the custom event 'stimulus:echarts:rendered' to set up the chart.
+    // This event is dispatched by the chart controller when the chart is ready.
     this.handleChartInitialized = this.onChartInitialized.bind(this);
 
-    document.addEventListener('chart:rendered', this.handleChartInitialized);
-
-    // If the chart is already initialized (e.g., on back navigation), set up immediately
-    if (window.RailsCharts?.charts?.[this.chartIdValue]) {
-      this.setup();
-    }
+    document.addEventListener('stimulus:echarts:rendered', this.handleChartInitialized);
   }
 
   disconnect() {
-    // Remove the event listener from RailsCharts when the controller is disconnected
-    document.removeEventListener('chart:rendered', this.handleChartInitialized);
+    // Remove the event listener when the controller is disconnected
+    document.removeEventListener('stimulus:echarts:rendered', this.handleChartInitialized);
 
     // Remove chart event listeners if they exist
     if (this.hasChartTarget && this.chartTarget) {
@@ -47,6 +42,8 @@ export default class extends Controller {
   // After the chart is initialized, set up the event listeners and data tracking
   onChartInitialized(event) {
     if (event.detail.containerId === this.chartIdValue) {
+      // Store the chart instance from the event
+      this.chart = event.detail.chart;
       this.setup();
     }
   }
@@ -56,7 +53,7 @@ export default class extends Controller {
       return; // Prevent multiple setups
     }
 
-    // We need both the chart target in DOM and the chart object from RailsCharts
+    // We need both the chart target in DOM and the chart object from the event
     let hasTarget = false;
     try {
       hasTarget = !!this.chartTarget;
@@ -64,10 +61,8 @@ export default class extends Controller {
       hasTarget = false;
     }
 
-    // Get the chart element which the RailsCharts library has created
-    this.chart = window.RailsCharts.charts[this.chartIdValue];
-
     // Only proceed if we have BOTH the DOM target and the chart object
+    // (chart is set by onChartInitialized from the event)
     if (!hasTarget || !this.chart) {
       return;
     }

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

@@ -3,56 +3,50 @@ import { Controller } from "@hotwired/stimulus"
 export default class extends Controller {
   static targets = ["limit"]
   static values = {
-    storageKey: { type: String, default: "rails_pulse_pagination_limit" },
-    url: String
+    storageKey: { type: String, default: "rails_pulse_pagination_limit" }
   }
 
   connect() {
     this.restorePaginationLimit()
   }
 
-  // Update pagination limit and refresh the turbo frame
+  // Update pagination limit and navigate to page 1 with new limit
   updateLimit() {
     const limit = this.limitTarget.value
 
-    // Save to session storage only - no server request needed
+    // Save to session storage for persistence
     sessionStorage.setItem(this.storageKeyValue, limit)
 
-    // Find the closest turbo frame and reload it to apply new pagination
-    const turboFrame = this.element.closest('turbo-frame')
-    if (turboFrame) {
-      // Add the limit as a URL parameter so server picks it up
-      const currentUrl = new URL(window.location)
-      currentUrl.searchParams.set('limit', limit)
-      turboFrame.src = currentUrl.pathname + currentUrl.search
+    // Build URL with limit parameter and reset to page 1
+    const currentUrl = new URL(window.location)
+    currentUrl.searchParams.set('limit', limit)
+    currentUrl.searchParams.delete('page')
+
+    // Use Turbo.visit for smooth navigation that preserves query params
+    if (typeof Turbo !== 'undefined') {
+      Turbo.visit(currentUrl.toString(), { action: 'replace' })
     } else {
-      // Fallback to page reload if not within a turbo frame
-      const currentUrl = new URL(window.location)
-      currentUrl.searchParams.set('limit', limit)
-      window.location.href = currentUrl.pathname + currentUrl.search
+      window.location.href = currentUrl.toString()
     }
   }
 
-  // Get CSRF token from meta tag
-  getCSRFToken() {
-    const token = document.querySelector('meta[name="csrf-token"]')
-    return token ? token.getAttribute('content') : ''
-  }
-
-  // Save the pagination limit to session storage when it changes
-  savePaginationLimit() {
-    const limit = this.limitTarget.value
-    sessionStorage.setItem(this.storageKeyValue, limit)
-  }
-
-  // Restore the pagination limit from session storage on page load
+  // Restore the pagination limit from URL or session storage on page load
   restorePaginationLimit() {
-    const savedLimit = sessionStorage.getItem(this.storageKeyValue)
-    if (savedLimit && this.limitTarget) {
-      // Only set if the current value is different (prevents unnecessary DOM updates)
-      if (this.limitTarget.value !== savedLimit) {
+    // URL params take precedence over session storage
+    const urlParams = new URLSearchParams(window.location.search)
+    const urlLimit = urlParams.get('limit')
+
+    if (urlLimit && this.limitTarget) {
+      // Sync sessionStorage with URL param
+      sessionStorage.setItem(this.storageKeyValue, urlLimit)
+      if (this.limitTarget.value !== urlLimit) {
+        this.limitTarget.value = urlLimit
+      }
+    } else {
+      // Fall back to sessionStorage if no URL param
+      const savedLimit = sessionStorage.getItem(this.storageKeyValue)
+      if (savedLimit && this.limitTarget && this.limitTarget.value !== savedLimit) {
         this.limitTarget.value = savedLimit
-        // Don't trigger change event when restoring from session - prevents infinite loops
       }
     }
   }

data/app/jobs/rails_pulse/backfill_summaries_job.rb

@@ -1,7 +1,5 @@
 module RailsPulse
   class BackfillSummariesJob < ApplicationJob
-    queue_as :low_priority
-
     def perform(start_date, end_date, period_types = [ "hour", "day" ])
       start_date = start_date.to_datetime
       end_date = end_date.to_datetime

data/app/jobs/rails_pulse/cleanup_job.rb

@@ -1,7 +1,5 @@
 module RailsPulse
   class CleanupJob < ApplicationJob
-    queue_as :default
-
     def perform
       return unless RailsPulse.configuration.archiving_enabled
 

data/app/jobs/rails_pulse/summary_job.rb

@@ -1,7 +1,5 @@
 module RailsPulse
   class SummaryJob < ApplicationJob
-    queue_as :low_priority
-
     def perform(target_hour = nil)
       target_hour ||= 1.hour.ago.beginning_of_hour
 

data/app/models/concerns/rails_pulse/taggable.rb

@@ -0,0 +1,63 @@
+module RailsPulse
+  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
+end

data/app/models/rails_pulse/dashboard/charts/average_response_time.rb

@@ -2,6 +2,11 @@ module RailsPulse
   module Dashboard
     module Charts
       class AverageResponseTime
+        def initialize(disabled_tags: [], show_non_tagged: true)
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
+        end
+
         def to_chart_data
           # Create a range of all dates in the past 2 weeks
           start_date = 2.weeks.ago.beginning_of_day.to_date
@@ -9,11 +14,13 @@ module RailsPulse
           date_range = (start_date..end_date)
 
           # Get the actual data from Summary records (routes)
-          summaries = RailsPulse::Summary.where(
-            summarizable_type: "RailsPulse::Route",
-            period_type: "day",
-            period_start: start_date.beginning_of_day..end_date.end_of_day
-          )
+          summaries = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
+            .where(
+              summarizable_type: "RailsPulse::Route",
+              period_type: "day",
+              period_start: start_date.beginning_of_day..end_date.end_of_day
+            )
 
           # Group by day manually for cross-database compatibility
           actual_data = {}

data/app/models/rails_pulse/dashboard/charts/p95_response_time.rb

@@ -2,6 +2,11 @@ module RailsPulse
   module Dashboard
     module Charts
       class P95ResponseTime
+        def initialize(disabled_tags: [], show_non_tagged: true)
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
+        end
+
         def to_chart_data
           # Create a range of all dates in the past 2 weeks
           start_date = 2.weeks.ago.beginning_of_day.to_date
@@ -9,11 +14,13 @@ module RailsPulse
           date_range = (start_date..end_date)
 
           # Get the actual data from Summary records (queries for P95)
-          summaries = RailsPulse::Summary.where(
-            summarizable_type: "RailsPulse::Query",
-            period_type: "day",
-            period_start: start_date.beginning_of_day..end_date.end_of_day
-          )
+          summaries = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              period_type: "day",
+              period_start: start_date.beginning_of_day..end_date.end_of_day
+            )
 
           actual_data = summaries
             .group_by_day(:period_start, time_zone: Time.zone)

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

@@ -3,6 +3,12 @@ module RailsPulse
     module Tables
       class SlowQueries
         include RailsPulse::FormattingHelper
+
+        def initialize(disabled_tags: [], show_non_tagged: true)
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
+        end
+
         def to_table_data
           # Get data for this week
           this_week_start = 1.week.ago.beginning_of_week
@@ -10,6 +16,7 @@ module RailsPulse
 
           # Fetch query data from Summary records for this week
           query_data = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
             .joins("INNER JOIN rails_pulse_queries ON rails_pulse_queries.id = rails_pulse_summaries.summarizable_id")
             .where(
               summarizable_type: "RailsPulse::Query",

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

@@ -4,6 +4,11 @@ module RailsPulse
       class SlowRoutes
         include RailsPulse::FormattingHelper
 
+        def initialize(disabled_tags: [], show_non_tagged: true)
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
+        end
+
         def to_table_data
           # Get data for this week
           this_week_start = 1.week.ago.beginning_of_week
@@ -11,6 +16,7 @@ module RailsPulse
 
           # Fetch route data from Summary records for this week
           route_data = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
             .joins("INNER JOIN rails_pulse_routes ON rails_pulse_routes.id = rails_pulse_summaries.summarizable_id")
             .where(
               summarizable_type: "RailsPulse::Route",

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

@@ -2,8 +2,10 @@ module RailsPulse
   module Queries
     module Cards
       class AverageQueryTimes
-        def initialize(query: nil)
+        def initialize(query: nil, disabled_tags: [], show_non_tagged: true)
           @query = query
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
         end
 
         def to_metric_card
@@ -11,11 +13,13 @@ module RailsPulse
           previous_7_days = 14.days.ago.beginning_of_day
 
           # Single query to get all aggregated metrics with conditional sums
-          base_query = RailsPulse::Summary.where(
-            summarizable_type: "RailsPulse::Query",
-            period_type: "day",
-            period_start: 2.weeks.ago.beginning_of_day..Time.current
-          )
+          base_query = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              period_type: "day",
+              period_start: 2.weeks.ago.beginning_of_day..Time.current
+            )
           base_query = base_query.where(summarizable_id: @query.id) if @query
 
           metrics = base_query.select(

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

@@ -2,8 +2,10 @@ module RailsPulse
   module Queries
     module Cards
       class ExecutionRate
-        def initialize(query: nil)
+        def initialize(query: nil, disabled_tags: [], show_non_tagged: true)
           @query = query
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
         end
 
         def to_metric_card
@@ -12,20 +14,24 @@ module RailsPulse
 
           # 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"
+            RailsPulse::Summary
+              .with_tag_filters(@disabled_tags, @show_non_tagged)
+              .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: period_type,
-            period_start: 2.weeks.ago.beginning_of_day..Time.current
-          )
+          base_query = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              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
 
           metrics = base_query.select(

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

@@ -2,8 +2,10 @@ module RailsPulse
   module Queries
     module Cards
       class PercentileQueryTimes
-        def initialize(query: nil)
+        def initialize(query: nil, disabled_tags: [], show_non_tagged: true)
           @query = query
+          @disabled_tags = disabled_tags
+          @show_non_tagged = show_non_tagged
         end
 
         def to_metric_card
@@ -11,11 +13,13 @@ module RailsPulse
           previous_7_days = 14.days.ago.beginning_of_day
 
           # Single query to get all P95 metrics with conditional aggregation
-          base_query = RailsPulse::Summary.where(
-            summarizable_type: "RailsPulse::Query",
-            period_type: "day",
-            period_start: 2.weeks.ago.beginning_of_day..Time.current
-          )
+          base_query = RailsPulse::Summary
+            .with_tag_filters(@disabled_tags, @show_non_tagged)
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              period_type: "day",
+              period_start: 2.weeks.ago.beginning_of_day..Time.current
+            )
           base_query = base_query.where(summarizable_id: @query.id) if @query
 
           metrics = base_query.select(