qa_server 2.2.3 → 3.0.0

data/app/presenters/concerns/qa_server/monitor_status/performance_graph_behavior.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 # This module provides methods for creating and accessing performance graphs.
 module QaServer::MonitorStatus
-  module PerformanceGraphBehavior
+  module PerformanceGraphBehavior # rubocop:disable Metrics/ModuleLength
     include QaServer::PerformanceHistoryDataKeys
     include QaServer::MonitorStatus::GruffGraph
 
@@ -29,12 +29,20 @@ module QaServer::MonitorStatus
       "performance-for-day-#{ALL_AUTH}"
     end
 
+    def performance_graph_time_period(graph_info)
+      graph_info[:time_period]
+    end
+
+    def performance_graph_action(graph_info)
+      graph_info[:action]
+    end
+
     def performance_graph_id(graph_info)
-      "#{graph_info[:base_id]}-during-#{graph_info[:time_period]}-chart"
+      "#{graph_info[:base_id]}-#{performance_graph_action(graph_info)}-during-#{performance_graph_time_period(graph_info)}-chart"
     end
 
     def performance_graph_data_section_id(graph_info)
-      "#{graph_info[:base_id]}-during-#{graph_info[:time_period]}"
+      "#{graph_info[:base_id]}-#{performance_graph_action(graph_info)}-during-#{performance_graph_time_period(graph_info)}"
     end
 
     def performance_graph_data_section_base_id(graph_info)
@@ -46,63 +54,84 @@ module QaServer::MonitorStatus
       'performance-data-section-hidden'
     end
 
-    def performance_day_graph_selected?(graph_info)
-      return true if graph_info[:time_period] == :day
+    def performance_day_graph?(graph_info)
+      return true if performance_graph_time_period(graph_info) == :day
+      false
+    end
+
+    def performance_month_graph?(graph_info)
+      return true if performance_graph_time_period(graph_info) == :month
+      false
+    end
+
+    def performance_year_graph?(graph_info)
+      return true if performance_graph_time_period(graph_info) == :year
+      false
+    end
+
+    def performance_all_actions_graph?(graph_info)
+      return true if performance_graph_action(graph_info) == :all_actions
       false
     end
 
-    def performance_month_graph_selected?(graph_info)
-      return true if graph_info[:time_period] == :month
+    def performance_search_graph?(graph_info)
+      return true if performance_graph_action(graph_info) == :search
       false
     end
 
-    def performance_year_graph_selected?(graph_info)
-      return true if graph_info[:time_period] == :year
+    def performance_fetch_graph?(graph_info)
+      return true if performance_graph_action(graph_info) == :fetch
       false
     end
 
     private
 
-      def default_graph?(graph_info) # rubocop:disable Metrics/CyclomaticComplexity
-        return true if QaServer.config.performance_graph_default_time_period == :day && performance_day_graph_selected?(graph_info)
-        return true if QaServer.config.performance_graph_default_time_period == :month && performance_month_graph_selected?(graph_info)
-        return true if QaServer.config.performance_graph_default_time_period == :year && performance_year_graph_selected?(graph_info)
+      def default_graph?(graph_info) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        return false unless performance_all_actions_graph?(graph_info)
+        return true if QaServer.config.performance_graph_default_time_period == :day && performance_day_graph?(graph_info)
+        return true if QaServer.config.performance_graph_default_time_period == :month && performance_month_graph?(graph_info)
+        return true if QaServer.config.performance_graph_default_time_period == :year && performance_year_graph?(graph_info)
         false
       end
 
       def performance_graphs_for_authority(graphs, auth_name)
-        graphs << performance_for_day_graph(auth_name)
-        graphs << performance_for_month_graph(auth_name)
-        graphs << performance_for_year_graph(auth_name)
+        [:search, :fetch, :all_actions].each do |action|
+          graphs << performance_for_day_graph(auth_name, action)
+          graphs << performance_for_month_graph(auth_name, action)
+          graphs << performance_for_year_graph(auth_name, action)
+        end
       end
 
-      def performance_for_day_graph(auth_name)
+      def performance_for_day_graph(auth_name, action)
         {
+          action: action,
           time_period: :day,
-          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, time_period: :day),
+          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, action: action, time_period: :day),
           label: "Performance data for the last 24 hours.",
           authority_name: auth_name,
-          base_id: "performance-for-#{auth_name}"
+          base_id: "performance-of-#{auth_name}"
         }
       end
 
-      def performance_for_month_graph(auth_name)
+      def performance_for_month_graph(auth_name, action)
         {
+          action: action,
           time_period: :month,
-          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, time_period: :month),
+          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, action: action, time_period: :month),
           label: "Performance data for the last 30 days.",
           authority_name: auth_name,
-          base_id: "performance-for-#{auth_name}"
+          base_id: "performance-of-#{auth_name}"
         }
       end
 
-      def performance_for_year_graph(auth_name)
+      def performance_for_year_graph(auth_name, action)
         {
+          action: action,
           time_period: :year,
-          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, time_period: :year),
+          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, action: action, time_period: :year),
           label: "Performance data for the last 12 months.",
           authority_name: auth_name,
-          base_id: "performance-for-#{auth_name}"
+          base_id: "performance-of-#{auth_name}"
         }
       end
   end

data/app/presenters/qa_server/monitor_status_presenter.rb

@@ -25,13 +25,16 @@ module QaServer
 
     def_delegators :@performance_presenter, :performance_data, :performance_data?, :display_performance?, :display_performance_graph?,
                    :display_performance_datatable?, :performance_data_authority_name, :performance_for_day_graph, :performance_for_month_graph,
-                   :performance_for_year_graph, :datatable_stats, :low_load, :low_normalization, :low_full_request, :high_load,
-                   :high_normalization, :high_full_request, :avg_load, :avg_normalization, :avg_full_request, :low_load_style,
-                   :low_normalization_style, :low_full_request_style, :high_load_style, :high_normalization_style, :high_full_request_style,
-                   :avg_load_style, :avg_normalization_style, :avg_full_request_style, :performance_style_class, :high_threshold_exceeded,
-                   :low_threshold_not_met, :performance_graphs, :performance_graph, :performance_graph_authority, :performance_graph_label,
-                   :performance_default_graph_id, :performance_graph_id, :performance_graph_data_section_id, :performance_graph_data_section_base_id,
-                   :performance_data_section_class, :performance_day_graph_selected?, :performance_month_graph_selected?,
-                   :performance_year_graph_selected?, :performance_table_description
+                   :performance_for_year_graph, :datatable_search_stats, :datatable_fetch_stats, :datatable_all_actions_stats,
+                   :low_retrieve, :low_graph_load, :low_normalization, :low_full_request, :high_retrieve, :high_graph_load,
+                   :high_normalization, :high_full_request, :avg_retrieve, :avg_graph_load, :avg_normalization, :avg_full_request,
+                   :datatable_data_style, :low_load_style, :low_normalization_style, :low_full_request_style, :high_load_style,
+                   :high_normalization_style, :high_full_request_style, :avg_load_style, :avg_normalization_style, :avg_full_request_style,
+                   :performance_style_class, :high_threshold_exceeded, :low_threshold_not_met, :performance_graphs, :performance_graph,
+                   :performance_graph_authority, :performance_graph_label, :performance_default_graph_id, :performance_graph_id,
+                   :performance_graph_data_section_id, :performance_graph_data_section_base_id, :performance_data_section_class,
+                   :performance_day_graph?, :performance_month_graph?, :performance_year_graph?, :performance_all_actions_graph?,
+                   :performance_search_graph?, :performance_fetch_graph?, :performance_table_description, :performance_graph_time_period,
+                   :performance_graph_action
   end
 end

data/app/services/qa_server/performance_calculator_service.rb

@@ -5,99 +5,102 @@ module QaServer
   class PerformanceCalculatorService
     include QaServer::PerformanceHistoryDataKeys
 
-    attr_reader :records
-    attr_reader :stats
+    attr_reader :records, :stats, :action
 
     # @param records [Array <Qa::PerformanceHistory>] set of records used to calculate the statistics
-    def initialize(records)
+    def initialize(records, action: nil)
       @records = records
+      @action = [:search, :fetch].include?(action) ? action : nil
       @stats = {}
     end
 
     # Calculate performance statistics for a set of PerformanceHistory records.  Min is at the 10th percentile.  Max is at the 90th percentile.
     # @return [Hash] hash of the statistics
     # @example
-    # { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5,
-    #   load_min_ms: 12.3, normalization_min_ms: 4.2, full_request_min_ms: 16.5,
-    #   load_max_ms: 12.3, normalization_max_ms: 4.2, full_request_max_ms: 16.5 }
+    #   { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5,
+    #     retrieve_10th_ms: 12.3, graph_load_10th_ms: 12.3, normalization_10th_ms: 4.2, full_request_10th_ms: 16.5,
+    #     retrieve_90th_ms: 12.3, graph_load_90th_ms: 12.3, normalization_90th_ms: 4.2, full_request_90th_ms: 16.5 }
     def calculate_stats(avg: false, low: false, high: false, load: true, norm: true, full: true) # rubocop:disable Metrics/ParameterLists
-      calculate_load_stats(avg, low, high) if load
-      calculate_norm_stats(avg, low, high) if norm
-      calculate_full_stats(avg, low, high) if full
+      calculate_retrieve_stats(avg, low, high) if load
+      calculate_graph_load_stats(avg, low, high) if load
+      calculate_normalization_stats(avg, low, high) if norm
+      calculate_action_stats(avg, low, high) if full
       stats
     end
 
     private
 
-      def calculate_load_stats(avg, low, high)
-        stats[AVG_LOAD] = calculate_average(load_times) if avg
-        stats[LOW_LOAD] = calculate_10th_percentile(load_times_sorted) if low
-        stats[HIGH_LOAD] = calculate_90th_percentile(load_times_sorted) if high
+      def calculate_retrieve_stats(avg, low, high)
+        stats[AVG_RETR] = calculate_average(retrieve_times) if avg
+        stats[LOW_RETR] = calculate_10th_percentile(retrieve_times) if low
+        stats[HIGH_RETR] = calculate_90th_percentile(retrieve_times) if high
       end
 
-      def calculate_norm_stats(avg, low, high)
+      def calculate_graph_load_stats(avg, low, high)
+        stats[AVG_GRPH] = calculate_average(graph_load_times) if avg
+        stats[LOW_GRPH] = calculate_10th_percentile(graph_load_times) if low
+        stats[HIGH_GRPH] = calculate_90th_percentile(graph_load_times) if high
+      end
+
+      def calculate_normalization_stats(avg, low, high)
         stats[AVG_NORM] = calculate_average(norm_times) if avg
-        stats[LOW_NORM] = calculate_10th_percentile(norm_times_sorted) if low
-        stats[HIGH_NORM] = calculate_90th_percentile(norm_times_sorted) if high
+        stats[LOW_NORM] = calculate_10th_percentile(norm_times) if low
+        stats[HIGH_NORM] = calculate_90th_percentile(norm_times) if high
       end
 
-      def calculate_full_stats(avg, low, high)
-        stats[AVG_FULL] = calculate_average(full_times) if avg
-        stats[LOW_FULL] = calculate_10th_percentile(full_times_sorted) if low
-        stats[HIGH_FULL] = calculate_90th_percentile(full_times_sorted) if high
+      def calculate_action_stats(avg, low, high)
+        stats[AVG_ACTN] = calculate_average(action_times) if avg
+        stats[LOW_ACTN] = calculate_10th_percentile(action_times) if low
+        stats[HIGH_ACTN] = calculate_90th_percentile(action_times) if high
       end
 
       def count
         @count ||= records.count
       end
 
-      def tenth_percentile_count
-        return @tenth_percentile_count if @tenth_percentile_count.present?
-        percentile_count = (count * 0.1).round
+      def tenth_percentile_count(times)
+        percentile_count = (times.count * 0.1).round
         percentile_count = 1 if percentile_count.zero? && count > 1
-        @tenth_percentile_count = percentile_count
-      end
-
-      def load_times
-        @load_times ||= records.pluck(:load_time_ms).to_a
+        percentile_count
       end
 
-      def load_times_sorted
-        @load_times_sorted ||= load_times.sort
+      def times(column)
+        where_clause = action.nil? ? "" : { "action" => action }
+        records.where(where_clause).where.not(column => nil).order(column).pluck(column)
       end
 
-      def norm_times
-        @norm_times ||= records.pluck(:normalization_time_ms).to_a
+      def retrieve_times
+        @retrieve_times ||= times(:retrieve_time_ms)
       end
 
-      def norm_times_sorted
-        @norm_times_sorted ||= norm_times.sort
+      def graph_load_times
+        @graph_load_times ||= times(:graph_load_time_ms)
       end
 
-      def full_times
-        @full_times ||= (Vector.elements(load_times) + Vector.elements(norm_times)).to_a
+      def norm_times
+        @norm_times ||= times(:normalization_time_ms)
       end
 
-      def full_times_sorted
-        @full_times_sorted ||= full_times.sort
+      def action_times
+        @action_times ||= times(:action_time_ms)
       end
 
       def calculate_average(times)
         return 0 if count.zero?
         return times[0] if count == 1
-        times.inject(0.0) { |sum, el| sum + el } / count
+        times.inject(0.0) { |sum, el| sum + el } / times.count
       end
 
-      def calculate_10th_percentile(sorted_times)
-        return 0 if count.zero?
-        return sorted_times[0] if count == 1
-        sorted_times[tenth_percentile_count - 1]
+      def calculate_10th_percentile(times)
+        return 0 if times.count.zero?
+        return times[0] if times.count == 1
+        times[tenth_percentile_count(times) - 1]
       end
 
-      def calculate_90th_percentile(sorted_times)
-        return 0 if count.zero?
-        return sorted_times[0] if count == 1
-        sorted_times[count - tenth_percentile_count]
+      def calculate_90th_percentile(times)
+        return 0 if times.count.zero?
+        return times[0] if times.count == 1
+        times[times.count - tenth_percentile_count(times)]
       end
   end
 end

data/app/services/qa_server/performance_graph_data_service.rb

@@ -18,13 +18,11 @@ module QaServer
       #     ...,
       #     23: { hour: 'NOW', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #   }
-      def average_last_24_hours(auth_name = nil)
+      def average_last_24_hours(authority_name: nil, action: nil)
         start_hour = Time.now.getlocal.beginning_of_hour - 23.hours
         avgs = {}
         0.upto(23).each do |idx|
-          where_clause = { dt_stamp: start_hour..start_hour.end_of_hour }
-          where_clause[:authority] = auth_name unless auth_name.nil?
-          records = performance_data_class.where(where_clause)
+          records = records_by(authority_name, action, start_hour..start_hour.end_of_hour)
           stats = stats_calculator_class.new(records).calculate_stats(avg: true, full: false)
           data = {}
           data[BY_HOUR] = performance_by_hour_label(idx, start_hour)
@@ -44,13 +42,11 @@ module QaServer
       #     ...,
       #     29: { day: 'TODAY', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #   }
-      def average_last_30_days(auth_name = nil)
+      def average_last_30_days(authority_name: nil, action: nil)
         start_day = Time.now.getlocal.beginning_of_day - 29.days
         avgs = {}
         0.upto(29).each do |idx|
-          where_clause = { dt_stamp: start_day..start_day.end_of_day }
-          where_clause[:authority] = auth_name unless auth_name.nil?
-          records = performance_data_class.where(where_clause)
+          records = records_by(authority_name, action, start_day..start_day.end_of_day)
           stats = stats_calculator_class.new(records).calculate_stats(avg: true, full: false)
           data = {}
           data[BY_DAY] = performance_by_day_label(idx, start_day)
@@ -70,13 +66,11 @@ module QaServer
       #     ...,
       #     11: { month: '08-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #   }
-      def average_last_12_months(auth_name = nil)
+      def average_last_12_months(authority_name: nil, action: nil)
         start_month = Time.now.getlocal.beginning_of_month - 11.months
         avgs = {}
         0.upto(11).each do |idx|
-          where_clause = { dt_stamp: start_month..start_month.end_of_month }
-          where_clause[:authority] = auth_name unless auth_name.nil?
-          records = performance_data_class.where(where_clause)
+          records = records_by(authority_name, action, start_month..start_month.end_of_month)
           stats = stats_calculator_class.new(records).calculate_stats(avg: true, full: false)
           data = {}
           data[BY_MONTH] = start_month.strftime("%m-%Y")
@@ -89,6 +83,13 @@ module QaServer
 
       private
 
+        def records_by(authority_name, action, time_period)
+          where_clause = { dt_stamp: time_period }
+          where_clause[:authority] = authority_name unless authority_name.nil?
+          where_clause[:action] = action unless action.nil? || action == :all_actions
+          performance_data_class.where(where_clause)
+        end
+
         def performance_by_hour_label(idx, start_hour)
           if idx == 23
             I18n.t('qa_server.monitor_status.performance.now')

data/app/services/qa_server/performance_graphing_service.rb

@@ -12,45 +12,50 @@ module QaServer
       # @param performance_data [Hash] hash of all performance data for all authorities
       # @see QaServer:PerformanceHistory
       def create_performance_graphs(performance_data:)
-        performance_data.each_key { |auth_name| create_graphs_for_authority(performance_data, auth_name.to_sym) }
+        performance_data.each_key do |auth_name|
+          create_graphs_for_authority(performance_data, auth_name.to_sym, :search)
+          create_graphs_for_authority(performance_data, auth_name.to_sym, :fetch)
+          create_graphs_for_authority(performance_data, auth_name.to_sym, :all_actions)
+        end
       end
 
       # @param authority_name [String] name of the authority
+      # @param action [Symbol] action performed by the request (e.g. :search, :fetch, :all_actions)
       # @param time_period [Symbol] time period for the graph (i.e. :day, :month, :year)
-      def performance_graph_file(authority_name: ALL_AUTH, time_period:)
-        File.join(graph_relative_path, graph_filename(authority_name, time_period))
+      def performance_graph_file(authority_name: ALL_AUTH, action:, time_period:)
+        File.join(graph_relative_path, graph_filename(authority_name, action, time_period))
       end
 
       private
 
-        def create_graphs_for_authority(performance_data, authority_name)
-          create_performance_for_day_graph(performance_data, authority_name)
-          create_performance_for_month_graph(performance_data, authority_name)
-          create_performance_for_year_graph(performance_data, authority_name)
+        def create_graphs_for_authority(performance_data, authority_name, action)
+          create_performance_for_day_graph(performance_data, authority_name, action)
+          create_performance_for_month_graph(performance_data, authority_name, action)
+          create_performance_for_year_graph(performance_data, authority_name, action)
         end
 
-        def create_performance_for_day_graph(performance_data, authority_name)
+        def create_performance_for_day_graph(performance_data, authority_name, action)
           auth_data = authority_performance_data(performance_data, authority_name)
           return unless auth_data
-          gruff_data = rework_performance_data_for_gruff(auth_data[FOR_DAY], BY_HOUR)
+          gruff_data = rework_performance_data_for_gruff(auth_data[action][FOR_DAY], BY_HOUR)
           create_gruff_graph(gruff_data,
-                             performance_for_day_graph_full_path(authority_name),
+                             performance_for_day_graph_full_path(authority_name, action),
                              I18n.t('qa_server.monitor_status.performance.x_axis_hour'))
         end
 
-        def create_performance_for_month_graph(performance_data, authority_name)
+        def create_performance_for_month_graph(performance_data, authority_name, action)
           auth_data = authority_performance_data(performance_data, authority_name)
-          gruff_data = rework_performance_data_for_gruff(auth_data[FOR_MONTH], BY_DAY)
+          gruff_data = rework_performance_data_for_gruff(auth_data[action][FOR_MONTH], BY_DAY)
           create_gruff_graph(gruff_data,
-                             performance_for_month_graph_full_path(authority_name),
+                             performance_for_month_graph_full_path(authority_name, action),
                              I18n.t('qa_server.monitor_status.performance.x_axis_day'))
         end
 
-        def create_performance_for_year_graph(performance_data, authority_name)
+        def create_performance_for_year_graph(performance_data, authority_name, action)
           auth_data = authority_performance_data(performance_data, authority_name)
-          gruff_data = rework_performance_data_for_gruff(auth_data[FOR_YEAR], BY_MONTH)
+          gruff_data = rework_performance_data_for_gruff(auth_data[action][FOR_YEAR], BY_MONTH)
           create_gruff_graph(gruff_data,
-                             performance_for_year_graph_full_path(authority_name),
+                             performance_for_year_graph_full_path(authority_name, action),
                              I18n.t('qa_server.monitor_status.performance.x_axis_month'))
         end
 
@@ -59,44 +64,47 @@ module QaServer
           data[auth_name]
         end
 
-        def performance_graph_theme(g, x_axis_label)
-          g.theme_pastel
-          g.colors = [QaServer.config.performance_normalization_color,
-                      QaServer.config.performance_load_color]
-          g.marker_font_size = 12
-          g.x_axis_increment = 10
-          g.x_axis_label = x_axis_label
-          g.y_axis_label = I18n.t('qa_server.monitor_status.performance.y_axis_ms')
-          g.minimum_value = 0
-          g.maximum_value = 2000
-        end
-
-        def performance_for_day_graph_full_path(authority_name)
-          graph_full_path(graph_filename(authority_name, :day))
+        def performance_for_day_graph_full_path(authority_name, action)
+          graph_full_path(graph_filename(authority_name, action, :day))
         end
 
-        def performance_for_month_graph_full_path(authority_name)
-          graph_full_path(graph_filename(authority_name, :month))
+        def performance_for_month_graph_full_path(authority_name, action)
+          graph_full_path(graph_filename(authority_name, action, :month))
         end
 
-        def performance_for_year_graph_full_path(authority_name)
-          graph_full_path(graph_filename(authority_name, :year))
+        def performance_for_year_graph_full_path(authority_name, action)
+          graph_full_path(graph_filename(authority_name, action, :year))
         end
 
-        def graph_filename(authority_name, time_period)
-          "performance_of_#{authority_name}_for_#{time_period}_graph.png"
+        def graph_filename(authority_name, action, time_period)
+          "performance_of_#{authority_name}_#{action}_for_#{time_period}_graph.png"
         end
 
         def rework_performance_data_for_gruff(performance_data, label_key)
           labels = {}
-          load_data = []
+          retrieve_data = []
+          graph_load_data = []
           normalization_data = []
           performance_data.each do |i, data|
             labels[i] = data[label_key]
-            load_data << data[STATS][AVG_LOAD]
+            retrieve_data << data[STATS][AVG_RETR]
+            graph_load_data << data[STATS][AVG_GRPH]
             normalization_data << data[STATS][AVG_NORM]
           end
-          [labels, normalization_data, load_data]
+          [labels, normalization_data, graph_load_data, retrieve_data]
+        end
+
+        def performance_graph_theme(g, x_axis_label)
+          g.theme_pastel
+          g.colors = [QaServer.config.performance_normalization_color,
+                      QaServer.config.performance_graph_load_color,
+                      QaServer.config.performance_retrieve_color]
+          g.marker_font_size = 12
+          g.x_axis_increment = 10
+          g.x_axis_label = x_axis_label
+          g.y_axis_label = I18n.t('qa_server.monitor_status.performance.y_axis_ms')
+          g.minimum_value = 0
+          g.maximum_value = QaServer.config.performance_y_axis_max
         end
 
         def create_gruff_graph(performance_data, performance_graph_full_path, x_axis_label)
@@ -105,7 +113,8 @@ module QaServer
           g.title = ''
           g.labels = performance_data[0]
           g.data(I18n.t('qa_server.monitor_status.performance.normalization_time_ms'), performance_data[1])
-          g.data(I18n.t('qa_server.monitor_status.performance.load_time_ms'), performance_data[2])
+          g.data(I18n.t('qa_server.monitor_status.performance.graph_load_time_ms'), performance_data[2])
+          g.data(I18n.t('qa_server.monitor_status.performance.retrieve_time_ms'), performance_data[3])
           g.write performance_graph_full_path
         end
     end