rails_pulse 0.1.1 → 0.1.2

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

@@ -1,69 +1,108 @@
 import { Controller } from "@hotwired/stimulus"
 
 export default class extends Controller {
-  static targets = ["chart", "paginationLimit", "indexTable"] // The chart element to be monitored
+  static targets = ["chart", "paginationLimit", "indexTable"]
 
   static values = {
     chartId: String        // The ID of the chart to be monitored
   }
 
-  // Add a property to track the last request time
+  // Add properties for improved debouncing
   lastTurboFrameRequestAt = 0;
+  pendingRequestTimeout = null;
+  pendingRequestData = 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.
     this.handleChartInitialized = this.onChartInitialized.bind(this);
-    document.addEventListener('chart:initialized', this.handleChartInitialized);
+
+    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(); }
+    if (window.RailsCharts?.charts?.[this.chartIdValue]) {
+      this.setup();
+    }
   }
 
   disconnect() {
     // Remove the event listener from RailsCharts when the controller is disconnected
-    document.removeEventListener('chart:initialized', this.handleChartInitialized);
+    document.removeEventListener('chart:rendered', this.handleChartInitialized);
 
     // Remove chart event listeners if they exist
-    if (this.chartTarget) {
+    if (this.hasChartTarget && this.chartTarget) {
       this.chartTarget.removeEventListener('mousedown', this.handleChartMouseDown);
       this.chartTarget.removeEventListener('mouseup', this.handleChartMouseUp);
     }
     document.removeEventListener('mouseup', this.handleDocumentMouseUp);
+
+    // Clear any pending timeout
+    if (this.pendingRequestTimeout) {
+      clearTimeout(this.pendingRequestTimeout);
+    }
   }
 
   // After the chart is initialized, set up the event listeners and data tracking
   onChartInitialized(event) {
-    if (event.detail.chartId === this.chartIdValue) { this.setup(); }
+    if (event.detail.containerId === this.chartIdValue) {
+      this.setup();
+    }
   }
 
   setup() {
-    if (this.setupDone) return; // Prevent multiple setups
+    if (this.setupDone) {
+      return; // Prevent multiple setups
+    }
 
+    // We need both the chart target in DOM and the chart object from RailsCharts
+    let hasTarget = false;
+    try {
+      hasTarget = !!this.chartTarget;
+    } catch (e) {
+      hasTarget = false;
+    }
+    
     // Get the chart element which the RailsCharts library has created
     this.chart = window.RailsCharts.charts[this.chartIdValue];
-    if (!this.chart) return;
+    
+    // Only proceed if we have BOTH the DOM target and the chart object
+    if (!hasTarget || !this.chart) {
+      return;
+    }
 
     this.visibleData = this.getVisibleData();
     this.setupChartEventListeners();
     this.setupDone = true;
+
+    // Mark the chart as fully rendered for testing
+    if (hasTarget) {
+      document.getElementById(this.chartIdValue)?.setAttribute('data-chart-rendered', 'true');
+    }
   }
 
   // Add some event listeners to the chart so we can track the zoom changes
   setupChartEventListeners() {
     // When clicking on the chart, we want to store the current visible data so we can compare it later
-    this.handleChartMouseDown = () => { this.visibleData = this.getVisibleData(); };
+    this.handleChartMouseDown = () => {
+      this.visibleData = this.getVisibleData();
+    };
     this.chartTarget.addEventListener('mousedown', this.handleChartMouseDown);
 
     // When releasing the mouse button, we want to check if the visible data has changed
-    this.handleChartMouseUp = () => { this.handleZoomChange(); };
+    this.handleChartMouseUp = () => {
+      this.handleZoomChange();
+    };
     this.chartTarget.addEventListener('mouseup', this.handleChartMouseUp);
 
     // When the chart is zoomed, we want to check if the visible data has changed
-    this.chart.on('datazoom', () => { this.handleZoomChange(); });
+    this.chart.on('datazoom', () => {
+      this.handleZoomChange();
+    });
 
     // When releasing the mouse button outside the chart, we want to check if the visible data has changed
-    this.handleDocumentMouseUp = () => { this.handleZoomChange(); };
+    this.handleDocumentMouseUp = () => {
+      this.handleZoomChange();
+    };
     document.addEventListener('mouseup', this.handleDocumentMouseUp);
   }
 
@@ -71,18 +110,37 @@ export default class extends Controller {
   // The xAxis data and series data are sliced based on the start and end values of the dataZoom component.
   // The series data will contain the actual data points that are visible in the chart.
   getVisibleData() {
-    const currentOption = this.chart.getOption();
-    const dataZoom = currentOption.dataZoom[1];
-    const xAxisData = currentOption.xAxis[0].data;
-    const seriesData = currentOption.series[0].data;
+    try {
+      const currentOption = this.chart.getOption();
 
-    const startValue = dataZoom.startValue;
-    const endValue = dataZoom.endValue;
+      if (!currentOption.dataZoom || currentOption.dataZoom.length === 0) {
+        return { xAxis: [], series: [] };
+      }
 
-    return {
-      xAxis: xAxisData.slice(startValue, endValue + 1),
-      series: seriesData.slice(startValue, endValue + 1)
-    };
+      // Try to find the correct dataZoom component
+      let dataZoom = currentOption.dataZoom[1] || currentOption.dataZoom[0];
+
+      if (!currentOption.xAxis || !currentOption.xAxis[0] || !currentOption.xAxis[0].data) {
+        return { xAxis: [], series: [] };
+      }
+
+      if (!currentOption.series || !currentOption.series[0] || !currentOption.series[0].data) {
+        return { xAxis: [], series: [] };
+      }
+
+      const xAxisData = currentOption.xAxis[0].data;
+      const seriesData = currentOption.series[0].data;
+
+      const startValue = dataZoom.startValue || 0;
+      const endValue = dataZoom.endValue || xAxisData.length - 1;
+
+      return {
+        xAxis: xAxisData.slice(startValue, endValue + 1),
+        series: seriesData.slice(startValue, endValue + 1)
+      };
+    } catch (error) {
+      return { xAxis: [], series: [] };
+    }
   }
 
   // When the zoom level changes, we want to check if the visible data has changed
@@ -90,7 +148,10 @@ export default class extends Controller {
   // we can update the table with the new data that is visible in the chart.
   handleZoomChange() {
     const newVisibleData = this.getVisibleData();
-    if (newVisibleData.xAxis.join() !== this.visibleData.xAxis.join()) {
+    const newDataString = newVisibleData.xAxis.join();
+    const currentDataString = this.visibleData.xAxis.join();
+
+    if (newDataString !== currentDataString) {
       this.visibleData = newVisibleData;
       this.updateUrlWithZoomParams(newVisibleData);
       this.sendTurboFrameRequest(newVisibleData);
@@ -124,14 +185,35 @@ export default class extends Controller {
       window.history.replaceState({}, '', url);
     }
 
-  // After the zoom level changes, we want to send a request to the server with the new visible data.
-  // The server will then return the full page HTML with the updated table data wrapped in a turbo-frame.
-  // We will then replace the innerHTML of the turbo-frame with the new HTML.
+  // Improved debouncing with guaranteed final request
   sendTurboFrameRequest(data) {
     const now = Date.now();
-    // If less than 1 second since last request, ignore this call
-    if (now - this.lastTurboFrameRequestAt < 1000) { return; }
-    this.lastTurboFrameRequestAt = now;
+    const timeSinceLastRequest = now - this.lastTurboFrameRequestAt;
+    
+    // Store the latest data for potential delayed execution
+    this.pendingRequestData = data;
+    
+    // Clear any existing timeout
+    if (this.pendingRequestTimeout) {
+      clearTimeout(this.pendingRequestTimeout);
+    }
+    
+    // If enough time has passed since last request, execute immediately
+    if (timeSinceLastRequest >= 1000) {
+      this.executeTurboFrameRequest(data);
+    } else {
+      // Otherwise, schedule execution for later to ensure final request goes through
+      const remainingTime = 1000 - timeSinceLastRequest;
+      this.pendingRequestTimeout = setTimeout(() => {
+        this.executeTurboFrameRequest(this.pendingRequestData);
+        this.pendingRequestTimeout = null;
+      }, remainingTime);
+    }
+  }
+
+  // Execute the actual AJAX request
+  executeTurboFrameRequest(data) {
+    this.lastTurboFrameRequestAt = Date.now();
 
     // Start with the current page's URL
     const url = new URL(window.location.href);
@@ -159,7 +241,9 @@ export default class extends Controller {
         'Turbo-Frame': this.chartIdValue
       }
     })
-    .then(response => response.text()) // Get the raw HTML response
+    .then(response => {
+      return response.text();
+    })
     .then(html => {
       // Find the turbo-frame in the document using the target
       const frame = this.indexTableTarget;
@@ -179,7 +263,7 @@ export default class extends Controller {
         }
       }
     })
-    .catch(error => console.error('Error:', error));
+    .catch(error => console.error('[IndexController] Fetch error:', error));
   }
 
   // CSP-safe method to replace frame content using DOM methods
@@ -209,7 +293,7 @@ export default class extends Controller {
       // Parse HTML safely
       const parser = new DOMParser();
       const doc = parser.parseFromString(html, 'text/html');
-      
+
       // Clear existing content
       while (targetFrame.firstChild) {
         targetFrame.removeChild(targetFrame.firstChild);

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

@@ -11,33 +11,25 @@ export default class extends Controller {
     this.restorePaginationLimit()
   }
 
-  // Update pagination limit via AJAX and reload the page to reflect changes
-  async updateLimit() {
+  // Update pagination limit and refresh the turbo frame
+  updateLimit() {
     const limit = this.limitTarget.value
 
-    // Save to session storage
+    // Save to session storage only - no server request needed
     sessionStorage.setItem(this.storageKeyValue, limit)
 
-    try {
-      // Send AJAX request to update server session using Rails.ajax
-      const response = await fetch(this.urlValue, {
-        method: 'PATCH',
-        headers: {
-          'Content-Type': 'application/json',
-          'X-CSRF-Token': this.getCSRFToken()
-        },
-        body: JSON.stringify({ limit: limit })
-      })
-
-      if (response.ok) {
-        // Reload the page to reflect the new pagination limit
-        // This preserves all current URL parameters including Ransack search params
-        window.location.reload()
-      } else {
-        throw new Error(`HTTP error! status: ${response.status}`)
-      }
-    } catch (error) {
-      console.error('Error updating pagination limit:', error)
+    // 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
+    } 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
     }
   }
 
@@ -60,10 +52,8 @@ export default class extends Controller {
       // Only set if the current value is different (prevents unnecessary DOM updates)
       if (this.limitTarget.value !== savedLimit) {
         this.limitTarget.value = savedLimit
-
-        // Trigger a change event to ensure any other listeners are notified
-        this.limitTarget.dispatchEvent(new Event('change', { bubbles: true }))
+        // Don't trigger change event when restoring from session - prevents infinite loops
       }
     }
   }
-}
+}

data/app/jobs/rails_pulse/backfill_summaries_job.rb

@@ -0,0 +1,41 @@
+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
+
+      period_types.each do |period_type|
+        backfill_period(period_type, start_date, end_date)
+      end
+    end
+
+    private
+
+    def backfill_period(period_type, start_date, end_date)
+      current = Summary.normalize_period_start(period_type, start_date)
+      period_end = Summary.calculate_period_end(period_type, end_date)
+
+      while current <= period_end
+        Rails.logger.info "[RailsPulse] Backfilling #{period_type} summary for #{current}"
+
+        SummaryService.new(period_type, current).perform
+
+        current = advance_period(current, period_type)
+
+        # Add small delay to avoid overwhelming the database
+        sleep 0.1
+      end
+    end
+
+    def advance_period(time, period_type)
+      case period_type
+      when "hour"  then time + 1.hour
+      when "day"   then time + 1.day
+      when "week"  then time + 1.week
+      when "month" then time + 1.month
+      end
+    end
+  end
+end

data/app/jobs/rails_pulse/summary_job.rb

@@ -0,0 +1,53 @@
+module RailsPulse
+  class SummaryJob < ApplicationJob
+    queue_as :low_priority
+
+    def perform(target_hour = nil)
+      target_hour ||= 1.hour.ago.beginning_of_hour
+
+      # Always run hourly summary
+      process_hourly_summary(target_hour)
+
+      # Check if we should run daily summary (at the start of a new day)
+      if target_hour.hour == 0
+        process_daily_summary(target_hour.to_date - 1.day)
+
+        # Check if we should run weekly summary (Monday at midnight)
+        if target_hour.wday == 1
+          process_weekly_summary((target_hour.to_date - 1.week).beginning_of_week)
+        end
+
+        # Check if we should run monthly summary (first day of month)
+        if target_hour.day == 1
+          process_monthly_summary((target_hour.to_date - 1.month).beginning_of_month)
+        end
+      end
+    rescue => e
+      Rails.logger.error "[RailsPulse] Summary job failed: #{e.message}"
+      Rails.logger.error e.backtrace.join("\n")
+      raise
+    end
+
+    private
+
+    def process_hourly_summary(hour)
+      Rails.logger.info "[RailsPulse] Processing hourly summary for #{hour}"
+      SummaryService.new("hour", hour).perform
+    end
+
+    def process_daily_summary(date)
+      Rails.logger.info "[RailsPulse] Processing daily summary for #{date}"
+      SummaryService.new("day", date).perform
+    end
+
+    def process_weekly_summary(week_start)
+      Rails.logger.info "[RailsPulse] Processing weekly summary for week starting #{week_start}"
+      SummaryService.new("week", week_start).perform
+    end
+
+    def process_monthly_summary(month_start)
+      Rails.logger.info "[RailsPulse] Processing monthly summary for month starting #{month_start}"
+      SummaryService.new("month", month_start).perform
+    end
+  end
+end

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

@@ -8,17 +8,38 @@ module RailsPulse
           end_date = Time.current.to_date
           date_range = (start_date..end_date)
 
-          # Get the actual data
-          requests = RailsPulse::Request.where("occurred_at >= ?", start_date.beginning_of_day)
-          actual_data = requests
-            .group_by_day(:occurred_at)
-            .average(:duration)
+          # 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
+          )
+
+          # Group by day manually for cross-database compatibility
+          actual_data = {}
+          summaries.each do |summary|
+            date = summary.period_start.to_date
+
+            if actual_data[date]
+              actual_data[date][:total_weighted] += (summary.avg_duration || 0) * (summary.count || 0)
+              actual_data[date][:total_count] += (summary.count || 0)
+            else
+              actual_data[date] = {
+                total_weighted: (summary.avg_duration || 0) * (summary.count || 0),
+                total_count: (summary.count || 0)
+              }
+            end
+          end
+
+          # Convert to final values
+          actual_data = actual_data.transform_values do |data|
+            data[:total_count] > 0 ? (data[:total_weighted] / data[:total_count]).round(0) : 0
+          end
 
           # Fill in all dates with zero values for missing days
           date_range.each_with_object({}) do |date, result|
             formatted_date = date.strftime("%b %-d")
-            avg_duration = actual_data[date]
-            result[formatted_date] = avg_duration&.round(0) || 0
+            result[formatted_date] = actual_data[date] || 0
           end
         end
       end

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

@@ -3,32 +3,28 @@ module RailsPulse
     module Charts
       class P95ResponseTime
         def to_chart_data
-          start_date = 2.weeks.ago.beginning_of_day
+          # Create a range of all dates in the past 2 weeks
+          start_date = 2.weeks.ago.beginning_of_day.to_date
+          end_date = Time.current.to_date
+          date_range = (start_date..end_date)
 
-          # Performance optimization: Single query instead of N+1 queries (15 queries -> 1 query)
-          # Fetch all requests for 2-week period, pre-sorted by date and duration
-          # For optimal performance, ensure index exists: (occurred_at, duration)
-          requests_by_day = RailsPulse::Request
-            .where(occurred_at: start_date..)
-            .select("occurred_at, duration, DATE(occurred_at) as request_date")
-            .order("request_date, duration")
-            .group_by { |r| r.request_date.to_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
+          )
 
-          # Generate all dates in range and calculate P95 for each
-          (start_date.to_date..Time.current.to_date).each_with_object({}) do |date, hash|
-            day_requests = requests_by_day[date] || []
-
-            if day_requests.empty?
-              p95_value = 0
-            else
-              # Calculate P95 from in-memory sorted array (already sorted by DB)
-              count = day_requests.length
-              p95_index = (count * 0.95).ceil - 1
-              p95_value = day_requests[p95_index].duration.round(0)
-            end
+          actual_data = summaries
+            .group_by_day(:period_start, time_zone: Time.zone)
+            .average(:p95_duration)
+            .transform_keys { |date| date.to_date }
+            .transform_values { |avg| avg&.round(0) || 0 }
 
+          # Fill in all dates with zero values for missing days
+          date_range.each_with_object({}) do |date, result|
             formatted_date = date.strftime("%b %-d")
-            hash[formatted_date] = p95_value
+            result[formatted_date] = actual_data[date] || 0
           end
         end
       end

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

@@ -8,11 +8,22 @@ module RailsPulse
           this_week_start = 1.week.ago.beginning_of_week
           this_week_end = Time.current.end_of_week
 
-          # Fetch query data for this week
-          query_data = RailsPulse::Operation.joins(:query)
-            .where(occurred_at: this_week_start..this_week_end)
-            .group("rails_pulse_queries.id, rails_pulse_queries.normalized_sql")
-            .select("rails_pulse_queries.id, rails_pulse_queries.normalized_sql, AVG(rails_pulse_operations.duration) as avg_duration, COUNT(*) as request_count, MAX(rails_pulse_operations.occurred_at) as last_seen")
+          # Fetch query data from Summary records for this week
+          query_data = RailsPulse::Summary
+            .joins("INNER JOIN rails_pulse_queries ON rails_pulse_queries.id = rails_pulse_summaries.summarizable_id")
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              period_type: "day",
+              period_start: this_week_start..this_week_end
+            )
+            .group("rails_pulse_summaries.summarizable_id, rails_pulse_queries.normalized_sql")
+            .select(
+              "rails_pulse_summaries.summarizable_id as query_id",
+              "rails_pulse_queries.normalized_sql",
+              "SUM(rails_pulse_summaries.avg_duration * rails_pulse_summaries.count) / SUM(rails_pulse_summaries.count) as avg_duration",
+              "SUM(rails_pulse_summaries.count) as request_count",
+              "MAX(rails_pulse_summaries.period_end) as last_seen"
+            )
             .order("avg_duration DESC")
             .limit(5)
 
@@ -20,8 +31,8 @@ module RailsPulse
           data_rows = query_data.map do |record|
             {
               query_text: truncate_query(record.normalized_sql),
-              query_id: record.id,
-              query_link: "/rails_pulse/queries/#{record.id}",
+              query_id: record.query_id,
+              query_link: "/rails_pulse/queries/#{record.query_id}",
               average_time: record.avg_duration.to_f.round(0),
               request_count: record.request_count,
               last_request: time_ago_in_words(record.last_seen)

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

@@ -5,58 +5,51 @@ module RailsPulse
         include RailsPulse::FormattingHelper
 
         def to_table_data
-          # Get data for this week and last week
+          # Get data for this week
           this_week_start = 1.week.ago.beginning_of_week
           this_week_end = Time.current.end_of_week
-          last_week_start = 2.weeks.ago.beginning_of_week
-          last_week_end = 1.week.ago.beginning_of_week
 
-          # Get this week's data
-          this_week_data = RailsPulse::Request.joins(:route)
-            .where(occurred_at: this_week_start..this_week_end)
-            .group("rails_pulse_routes.path, rails_pulse_routes.id")
-            .select("rails_pulse_routes.path, rails_pulse_routes.id, AVG(rails_pulse_requests.duration) as avg_duration, COUNT(*) as request_count")
+          # Fetch route data from Summary records for this week
+          route_data = RailsPulse::Summary
+            .joins("INNER JOIN rails_pulse_routes ON rails_pulse_routes.id = rails_pulse_summaries.summarizable_id")
+            .where(
+              summarizable_type: "RailsPulse::Route",
+              period_type: "day",
+              period_start: this_week_start..this_week_end
+            )
+            .group("rails_pulse_summaries.summarizable_id, rails_pulse_routes.path")
+            .select(
+              "rails_pulse_summaries.summarizable_id as route_id",
+              "rails_pulse_routes.path",
+              "SUM(rails_pulse_summaries.avg_duration * rails_pulse_summaries.count) / SUM(rails_pulse_summaries.count) as avg_duration",
+              "SUM(rails_pulse_summaries.count) as request_count",
+              "MAX(rails_pulse_summaries.period_end) as last_seen"
+            )
             .order("avg_duration DESC")
             .limit(5)
 
-          # Get last week's data for comparison
-          last_week_averages = RailsPulse::Request.joins(:route)
-            .where(occurred_at: last_week_start..last_week_end)
-            .group("rails_pulse_routes.path")
-            .average("rails_pulse_requests.duration")
-
-          # Build result array matching test expectations
-          this_week_data.map do |record|
-            this_week_avg = record.avg_duration.to_f.round(0)
-            last_week_avg = last_week_averages[record.path]&.round(0) || 0
-
-            # Calculate percentage change
-            percentage_change = if last_week_avg == 0
-              this_week_avg > 0 ? 100.0 : 0.0
-            else
-              ((this_week_avg - last_week_avg) / last_week_avg.to_f * 100).round(1)
-            end
-
-            # Determine trend (worse = slower response times)
-            trend = if last_week_avg == 0
-              this_week_avg > 0 ? "worse" : "stable"
-            elsif this_week_avg > last_week_avg
-              "worse"  # Slower = worse
-            elsif this_week_avg < last_week_avg
-              "better" # Faster = better
-            else
-              "stable"
-            end
-
+          # Build data rows
+          data_rows = route_data.map do |record|
             {
               route_path: record.path,
-              this_week_avg: this_week_avg,
-              last_week_avg: last_week_avg,
-              percentage_change: percentage_change,
+              route_id: record.route_id,
+              route_link: "/rails_pulse/routes/#{record.route_id}",
+              average_time: record.avg_duration.to_f.round(0),
               request_count: record.request_count,
-              trend: trend
+              last_request: time_ago_in_words(record.last_seen)
             }
           end
+
+          # Return new structure with columns and data
+          {
+            columns: [
+              { field: :route_path, label: "Route", link_to: :route_link, class: "w-auto" },
+              { field: :average_time, label: "Average Time", class: "w-32" },
+              { field: :request_count, label: "Requests", class: "w-24" },
+              { field: :last_request, label: "Last Request", class: "w-32" }
+            ],
+            data: data_rows
+          }
         end
       end
     end

data/app/models/rails_pulse/operation.rb

@@ -34,7 +34,7 @@ module RailsPulse
     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]
+      %w[id occurred_at label duration start_time average_query_time_ms query_count operation_type query_id]
     end
 
     def self.ransackable_associations(auth_object = nil)