qa_server 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9a28076a2932c11c2dcfa1d833665d623ab3969
-  data.tar.gz: 0e5eeb1c0c5535029f60c8a5f1a4bead059e4bbc
+  metadata.gz: fcedba0845e78467d54d898c86ad03498dbc1754
+  data.tar.gz: f00bc15be82518d374575eca094c418aa48cb78a
 SHA512:
-  metadata.gz: f891059ddd3ef9453bf857dbd7e5cc0ce5cab4beead2897b02efac28803f82a06fb00fb94ce3de487e30bb00f085049e14c80052a8c80565ae4931401c962f7b
-  data.tar.gz: e4c733a195568694b0bd9ed8fe7704aa62a3ab07c90c6ed2d3876869be33e439c68f28dc081c631182cb9b2dcba42a392b45420a5392a9079eb73c0e25c73040
+  metadata.gz: 4bd795410ea1f40b60595933d220a800bfeef12ca2bf7c9210cb3f8b6ff9ca3e77d085447ecea99b50d5f14f85ba359ec5a76533a51bce621dfc05120e465f43
+  data.tar.gz: 9f164a65faac0b9f73918b242a5d8eafbc1f769b492be648abf08a050e64b6df0e740962cdbd73777fc0f4f73d4f9f6cf896a7312d2135e0028335b593efaff8

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+### 2.2.2 (2019-09-10)
+
+* handle stat calculation and formatting when 0 records or missing stats
+* switch performance graph to stacked_bar
+* Use 10th and 90th percentiles for datatable
+* display day graph for every authority for default time period
+* cache performance graphs
+* include authority data for performance graphs
+* move some of the performance data construction code to services
+
 ### 2.2.1 (2019-09-04)
 
 * config to optionally display of the performance graph/datatable

data/app/assets/stylesheets/qa_server/_monitor-status.scss

@@ -12,6 +12,14 @@ p.status-update-dtstamp {
   font-style: italic;
 }
 
+div.performance-data-section-hidden {
+  display: none;
+}
+
+div.performance-data-section-visible {
+  display: block;
+}
+
 div.right-menu-section {
   padding-top: 50px;
 }

data/app/controllers/qa_server/check_status_controller.rb

@@ -32,7 +32,7 @@ module QaServer
 
       def authority_name
         return @authority_name if @authority_name.present?
-        @authority_name = (params.key? :authority) ? params[:authority].downcase : nil # rubocop:disable Style/TernaryParentheses
+        @authority_name = params.key?(:authority) ? params[:authority].downcase : nil
       end
   end
 end

data/app/controllers/qa_server/monitor_status_controller.rb

@@ -6,7 +6,6 @@ module QaServer
                     :scenario_run_registry_class,
                     :scenario_history_class,
                     :performance_history_class
-
     self.presenter_class = QaServer::MonitorStatusPresenter
     self.scenario_run_registry_class = QaServer::ScenarioRunRegistry
     self.scenario_history_class = QaServer::ScenarioRunHistory
@@ -14,15 +13,13 @@ module QaServer
 
     # Sets up presenter with data to display in the UI
     def index
-      if refresh? || expired?
-        validate(authorities_list)
-        update_summary_and_data
-      end
-      # TODO: Include historical data and performance data too
+      refresh_tests
+      historical_data = refresh_history
+      performance_data = refresh_performance
       @presenter = presenter_class.new(current_summary: latest_summary,
                                        current_failure_data: latest_failures,
-                                       historical_summary_data: historical_summary_data,
-                                       performance_data: performance_history_class.performance_data)
+                                       historical_summary_data: historical_data,
+                                       performance_data: performance_data)
       render 'index', status: :internal_server_error if latest_summary.failing_authority_count.positive?
     end
 
@@ -46,20 +43,81 @@ module QaServer
         @latest_failures = nil # reset so next request recalculates
       end
 
-      def historical_summary_data
-        @historical_summary_data ||= scenario_history_class.historical_summary
-      end
-
       def expired?
-        latest_summary.blank? || latest_summary.run_dt_stamp < yesterday_midnight_et
+        @expired ||= latest_summary.blank? || latest_summary.run_dt_stamp < yesterday_midnight_et
       end
 
       def yesterday_midnight_et
         (DateTime.yesterday.midnight.to_time + 4.hours).to_datetime.in_time_zone("Eastern Time (US & Canada)")
       end
 
+      def historical_summary_data(refresh: false)
+        # TODO: Make this refresh the same way performance data refreshes.
+        #       Requires historical graph to move out of presenter so it can be created here only with refresh.
+        if refresh
+          @historical_summary_data = scenario_history_class.historical_summary
+          # TODO: Need to recreate graph here.  And need to only read the graph in presenter.
+        end
+        @historical_summary_data ||= scenario_history_class.historical_summary
+      end
+
+      def performance_data(refresh: false)
+        datatype = performance_datatype(refresh)
+        return if datatype == :none
+        @performance_data = nil if refresh
+        @performance_data ||= performance_history_class.performance_data(datatype: datatype)
+      end
+
+      def performance_datatype(refresh) # rubocop:disable Metrics/CyclomaticComplexity
+        return :all if display_performance_datatable? && display_performance_graph? && refresh
+        return :datatable if display_performance_datatable?
+        return :graph if display_performance_graph? && refresh
+        :none
+      end
+
+      def display_performance_datatable?
+        @display_performance_datatable ||= QaServer.config.display_performance_datatable?
+      end
+
+      def display_performance_graph?
+        @display_performance_graph ||= QaServer.config.display_performance_graph?
+      end
+
+      def refresh_tests
+        return unless refresh_tests?
+        validate(authorities_list)
+        update_summary_and_data
+      end
+
+      def refresh_history
+        historical_summary_data(refresh: refresh_history?)
+      end
+
+      def refresh_performance
+        performance_data(refresh: refresh_performance?)
+      end
+
       def refresh?
         params.key? :refresh
       end
+
+      def refresh_all?
+        params[:refresh].nil? || params[:refresh].casecmp?('all') # nil is for backward compatibility
+      end
+
+      def refresh_tests?
+        return false unless refresh? || expired?
+        refresh_all? || params[:refresh].casecmp?('tests') || expired?
+      end
+
+      def refresh_history?
+        return false unless refresh?
+        refresh_all? || params[:refresh].casecmp?('history')
+      end
+
+      def refresh_performance?
+        return false unless refresh?
+        refresh_all? || params[:refresh].casecmp?('performance')
+      end
   end
 end

data/app/models/concerns/qa_server/performance_history_data_keys.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# This module sets up the hash keys for performance data and allows them to be used across all classes
+# setting and reading from the performance data hash.
+module QaServer
+  module PerformanceHistoryDataKeys
+    ALL_AUTH = :all_authorities
+    STATS = :stats
+    FOR_DATATABLE = :datatable_stats
+
+    FOR_DAY = :day
+    BY_HOUR = :hour
+
+    FOR_MONTH = :month
+    BY_DAY = :day
+
+    FOR_YEAR = :year
+    BY_MONTH = :month
+
+    LOW_LOAD = :low_load_ms
+    LOW_NORM = :low_normalization_ms
+    LOW_FULL = :low_full_request_ms
+    AVG_LOAD = :avg_load_ms
+    AVG_NORM = :avg_normalization_ms
+    AVG_FULL = :avg_full_request_ms
+    HIGH_LOAD = :max_load_ms
+    HIGH_NORM = :max_normalization_ms
+    HIGH_FULL = :max_full_request_ms
+  end
+end

data/app/models/qa_server/performance_history.rb

@@ -1,55 +1,38 @@
 # frozen_string_literal: true
 # Provide access to the scenario_results_history database table which tracks specific scenario runs over time.
 module QaServer
-  class PerformanceHistory < ActiveRecord::Base # rubocop:disable Metrics/ClassLength
+  class PerformanceHistory < ActiveRecord::Base
     self.table_name = 'performance_history'
 
     enum action: [:fetch, :search]
 
-    PERFORMANCE_ALL_KEY = :all_authorities
-    PERFORMANCE_STATS_KEY = :stats
-    PERFORMANCE_FOR_LIFETIME_KEY = :lifetime_stats
-
-    PERFORMANCE_FOR_DAY_KEY = :day
-    PERFORMANCE_BY_HOUR_KEY = :hour
-
-    PERFORMANCE_FOR_MONTH_KEY = :month
-    PERFORMANCE_BY_DAY_KEY = :day
-
-    PERFORMANCE_FOR_YEAR_KEY = :year
-    PERFORMANCE_BY_MONTH_KEY = :month
-
-    SUM_LOAD_TIME_KEY = :load_sum_ms
-    SUM_NORMALIZATION_TIME_KEY = :normalization_sum_ms
-    SUM_FULL_REQUEST_TIME_KEY = :full_request_sum_ms
-    MIN_LOAD_TIME_KEY = :load_min_ms
-    MIN_NORMALIZATION_TIME_KEY = :normalization_min_ms
-    MIN_FULL_REQUEST_TIME_KEY = :full_request_min_ms
-    MAX_LOAD_TIME_KEY = :load_max_ms
-    MAX_NORMALIZATION_TIME_KEY = :normalization_max_ms
-    MAX_FULL_REQUEST_TIME_KEY = :full_request_max_ms
-    AVG_LOAD_TIME_KEY = :load_avg_ms
-    AVG_NORMALIZATION_TIME_KEY = :normalization_avg_ms
-    AVG_FULL_REQUEST_TIME_KEY = :full_request_avg_ms
+    class_attribute :stats_calculator_class, :graph_data_service_class, :graphing_service_class, :authority_list_class
+    self.stats_calculator_class = QaServer::PerformanceCalculatorService
+    self.graph_data_service_class = QaServer::PerformanceGraphDataService
+    self.graphing_service_class = QaServer::PerformanceGraphingService
+    self.authority_list_class = QaServer::AuthorityListerService
 
     class << self
+      include QaServer::PerformanceHistoryDataKeys
+
       # Save a scenario result
       # @param run_id [Integer] the run on which to gather statistics
       # @param result [Hash] the scenario result to be saved
       def save_result(dt_stamp:, authority:, action:, size_bytes:, load_time_ms:, normalization_time_ms:) # rubocop:disable Metrics/ParameterLists
-        QaServer::PerformanceHistory.create(dt_stamp: dt_stamp,
-                                            authority: authority,
-                                            action: action,
-                                            size_bytes: size_bytes,
-                                            load_time_ms: load_time_ms,
-                                            normalization_time_ms: normalization_time_ms)
+        create(dt_stamp: dt_stamp,
+               authority: authority,
+               action: action,
+               size_bytes: size_bytes,
+               load_time_ms: load_time_ms,
+               normalization_time_ms: normalization_time_ms)
       end
 
-      # Performance data for a day, a month, and a year.
+      # Performance data for a day, a month, a year, and all time for each authority.
+      # @param datatype [Symbol] what type of data should be calculated (e.g. :datatable, :graph, :all)
       # @returns [Hash] performance statistics for the past 24 hours
       # @example
       #   { all_authorities:
-      #     { lifetime_stats:
+      #     { datatable_stats:
       #       { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }
       #     }
       #     { day:
@@ -76,179 +59,92 @@ module QaServer
       #         11: { month: '08-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #       }
       #     }
+      #     { AGROVOC_LD4L_CACHE: ... # same data for each authority  }
       #   }
-      def performance_data
-        data = {}
-        data[PERFORMANCE_ALL_KEY] = {
-          PERFORMANCE_FOR_LIFETIME_KEY => lifetime,
-          PERFORMANCE_FOR_DAY_KEY => average_last_24_hours,
-          PERFORMANCE_FOR_MONTH_KEY => average_last_30_days,
-          PERFORMANCE_FOR_YEAR_KEY => average_last_12_months
-        }
+      def performance_data(datatype: :datatable)
+        return if datatype == :none
+        data = calculate_data(datatype)
+        graphing_service_class.create_performance_graphs(performance_data: data) if calculate_graphdata? datatype
         data
       end
 
       private
 
-        # Get hourly average for the past 24 hours.
-        # @returns [Hash] performance statistics across all records
-        # @example
-        #   { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }
-        def lifetime
-          records = PerformanceHistory.all
-          calculate_stats(records)
+        def calculate_datatable?(datatype)
+          datatype == :datatable || datatype == :all
         end
 
-        # Get hourly average for the past 24 hours.
-        # @returns [Hash] performance statistics for the past 24 hours
-        # @example
-        #   { 0: { hour: '1400', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     1: { hour: '1500', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     2: { hour: '1600', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     ...,
-        #     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
-          start_hour = Time.now.beginning_of_hour - 23.hours
-          avgs = {}
-          0.upto(23).each do |idx|
-            records = PerformanceHistory.where(dt_stamp: start_hour..start_hour.end_of_hour)
-            stats = calculate_stats(records)
-            data = {}
-            data[PERFORMANCE_BY_HOUR_KEY] = performance_by_hour_label(idx, start_hour)
-            data[PERFORMANCE_STATS_KEY] = stats
-            avgs[idx] = data
-            start_hour += 1.hour
-          end
-          avgs
+        def calculate_graphdata?(datatype)
+          datatype == :graph || datatype == :all
         end
 
-        def performance_by_hour_label(idx, start_hour)
-          if idx == 23
-            I18n.t('qa_server.monitor_status.performance.now')
-          elsif ((idx + 1) % 2).zero?
-            (start_hour.hour * 100).to_s
-          else
-            ""
-          end
+        def calculate_data(datatype)
+          data = {}
+          auths = authority_list_class.authorities_list
+          data[ALL_AUTH] = data_for_authority(datatype: datatype)
+          auths.each { |auth_name| data[auth_name] = data_for_authority(authority_name: auth_name, datatype: datatype) }
+          data
         end
 
-        # Get daily average for the past 30 days.
-        # @returns [Hash] performance statistics for the past 30 days
-        # @example
-        #   { 0: { day: '07-15-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     1: { day: '07-16-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     2: { day: '07-17-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     ...,
-        #     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
-          start_day = Time.now.beginning_of_day - 29.days
-          avgs = {}
-          0.upto(29).each do |idx|
-            records = PerformanceHistory.where(dt_stamp: start_day..start_day.end_of_day)
-            stats = calculate_stats(records)
-            data = {}
-            data[PERFORMANCE_BY_DAY_KEY] = performance_by_day_label(idx, start_day)
-            data[PERFORMANCE_STATS_KEY] = stats
-            avgs[idx] = data
-            start_day += 1.day
+        def data_for_authority(authority_name: nil, datatype:)
+          data = {}
+          data[FOR_DATATABLE] = data_table_stats(authority_name) if calculate_datatable?(datatype)
+          if calculate_graphdata?(datatype)
+            data[FOR_DAY] = graph_data_service_class.average_last_24_hours(authority_name)
+            data[FOR_MONTH] = graph_data_service_class.average_last_30_days(authority_name)
+            data[FOR_YEAR] = graph_data_service_class.average_last_12_months(authority_name)
           end
-          avgs
+          data
         end
 
-        def performance_by_day_label(idx, start_day)
-          if idx == 29
-            I18n.t('qa_server.monitor_status.performance.today')
-          elsif ((idx + 1) % 5).zero?
-            start_day.strftime("%m-%d")
-          else
-            ""
-          end
-        end
-
-        # Get daily average for the past 12 months.
-        # @returns [Hash] performance statistics for the past 12 months
+        # Get statistics for all available data.
+        # @param [String] auth_name - limit statistics to records for the given authority (default: all authorities)
+        # @returns [Hash] performance statistics for the datatable during the expected time period
         # @example
-        #   { 0: { month: '09-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     1: { month: '10-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     2: { month: '11-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
-        #     ...,
-        #     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
-          start_month = Time.now.beginning_of_month - 11.months
-          avgs = {}
-          0.upto(11).each do |idx|
-            records = PerformanceHistory.where(dt_stamp: start_month..start_month.end_of_month)
-            stats = calculate_stats(records)
-            data = {}
-            data[PERFORMANCE_BY_MONTH_KEY] = start_month.strftime("%m-%Y")
-            data[PERFORMANCE_STATS_KEY] = stats
-            avgs[idx] = data
-            start_month += 1.month
-          end
-          avgs
-        end
-
-        def calculate_stats(records)
-          stats = init_stats
-          return stats if records.count.zero?
-          first = true
-          records.each do |record|
-            update_sum_stats(stats, record)
-            update_min_stats(stats, record)
-            update_max_stats(stats, record)
-            first = false
-          end
-          calculate_avg_stats(stats, records)
-          stats
+        #   { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }
+        def data_table_stats(auth_name)
+          records = records_for_last_24_hours(auth_name) ||
+                    records_for_last_30_days(auth_name) ||
+                    records_for_last_12_months(auth_name) ||
+                    all_records(auth_name)
+          stats_calculator_class.new(records).calculate_stats(avg: true, low: true, high: true)
         end
 
-        MIN_STARTING_TIME = 999_999_999
-        def init_stats
-          stats = {}
-          stats[SUM_LOAD_TIME_KEY] = 0
-          stats[SUM_NORMALIZATION_TIME_KEY] = 0
-          stats[SUM_FULL_REQUEST_TIME_KEY] = 0
-          stats[AVG_LOAD_TIME_KEY] = 0
-          stats[AVG_NORMALIZATION_TIME_KEY] = 0
-          stats[AVG_FULL_REQUEST_TIME_KEY] = 0
-          stats[MIN_LOAD_TIME_KEY] = MIN_STARTING_TIME
-          stats[MIN_NORMALIZATION_TIME_KEY] = MIN_STARTING_TIME
-          stats[MIN_FULL_REQUEST_TIME_KEY] = MIN_STARTING_TIME
-          stats[MAX_LOAD_TIME_KEY] = 0
-          stats[MAX_NORMALIZATION_TIME_KEY] = 0
-          stats[MAX_FULL_REQUEST_TIME_KEY] = 0
-          stats
+        def expected_time_period
+          QaServer.config.performance_datatable_default_time_period
         end
 
-        def update_sum_stats(stats, record)
-          stats[SUM_LOAD_TIME_KEY] += record.load_time_ms
-          stats[SUM_NORMALIZATION_TIME_KEY] += record.normalization_time_ms
-          stats[SUM_FULL_REQUEST_TIME_KEY] += full_request_time_ms(record)
+        def records_for_last_24_hours(auth_name)
+          return unless expected_time_period == :day
+          end_hour = Time.now.getlocal
+          start_hour = end_hour - 23.hours
+          where_clause = { dt_stamp: start_hour..end_hour }
+          records_for_authority(auth_name, where_clause)
         end
 
-        def update_min_stats(stats, record)
-          stats[MIN_LOAD_TIME_KEY] = [stats[MIN_LOAD_TIME_KEY], record.load_time_ms].min
-          stats[MIN_NORMALIZATION_TIME_KEY] = [stats[MIN_NORMALIZATION_TIME_KEY], record.normalization_time_ms].min
-          stats[MIN_FULL_REQUEST_TIME_KEY] = [stats[MIN_FULL_REQUEST_TIME_KEY], full_request_time_ms(record)].min
+        def records_for_last_30_days(auth_name)
+          return unless expected_time_period == :month
+          end_day = Time.now.getlocal
+          start_day = end_day - 29.days
+          where_clause = { dt_stamp: start_day..end_day }
+          records_for_authority(auth_name, where_clause)
         end
 
-        def update_max_stats(stats, record)
-          stats[MAX_LOAD_TIME_KEY] = [stats[MAX_LOAD_TIME_KEY], record.load_time_ms].max
-          stats[MAX_NORMALIZATION_TIME_KEY] = [stats[MAX_NORMALIZATION_TIME_KEY], record.normalization_time_ms].max
-          stats[MAX_FULL_REQUEST_TIME_KEY] = [stats[MAX_FULL_REQUEST_TIME_KEY], full_request_time_ms(record)].max
+        def records_for_last_12_months(auth_name)
+          return unless expected_time_period == :year
+          end_month = Time.now.getlocal
+          start_month = end_month - 11.months
+          where_clause = { dt_stamp: start_month..end_month }
+          records_for_authority(auth_name, where_clause)
         end
 
-        def calculate_avg_stats(stats, records)
-          stats[AVG_LOAD_TIME_KEY] = stats[SUM_LOAD_TIME_KEY] / records.count
-          stats[AVG_NORMALIZATION_TIME_KEY] = stats[SUM_NORMALIZATION_TIME_KEY] / records.count
-          stats[AVG_FULL_REQUEST_TIME_KEY] = stats[SUM_FULL_REQUEST_TIME_KEY] / records.count
+        def all_records(auth_name)
+          auth_name.nil? ? PerformanceHistory.all : where(authority: auth_name)
         end
 
-        def full_request_time_ms(record)
-          record.load_time_ms + record.normalization_time_ms
+        def records_for_authority(auth_name, where_clause)
+          where_clause[:authority] = auth_name unless auth_name.nil?
+          where(where_clause)
         end
     end
   end

data/app/prepends/prepended_linked_data/find_term.rb

@@ -6,7 +6,7 @@ module PrependedLinkedData::FindTerm
     saved_performance_data = performance_data
     performance_data = true
     full_results = super
-    QaServer::PerformanceHistory.save_result(dt_stamp: Time.now,
+    QaServer::PerformanceHistory.save_result(dt_stamp: Time.now.getlocal,
                                              authority: authority_name,
                                              action: 'fetch',
                                              size_bytes: full_results[:performance][:fetched_bytes],

data/app/prepends/prepended_linked_data/search_query.rb

@@ -6,7 +6,7 @@ module PrependedLinkedData::SearchQuery
     saved_performance_data = performance_data
     performance_data = true
     full_results = super
-    QaServer::PerformanceHistory.save_result(dt_stamp: Time.now,
+    QaServer::PerformanceHistory.save_result(dt_stamp: Time.now.getlocal,
                                              authority: authority_name,
                                              action: 'search',
                                              size_bytes: full_results[:performance][:fetched_bytes],

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

@@ -18,4 +18,3 @@ module QaServer::MonitorStatus
       end
   end
 end
-# frozen_string_literal: true

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+# This module provides access methods into the performance data hash.
+module QaServer::MonitorStatus
+  module PerformanceDatatableBehavior
+    include QaServer::PerformanceHistoryDataKeys
+
+    def datatable_stats(authority_data)
+      authority_data[FOR_DATATABLE]
+    end
+
+    def low_load(stats)
+      format_stat stats[LOW_LOAD]
+    end
+
+    def low_normalization(stats)
+      format_stat stats[LOW_NORM]
+    end
+
+    def low_full_request(stats)
+      format_stat stats[LOW_FULL]
+    end
+
+    def high_load(stats)
+      format_stat stats[HIGH_LOAD]
+    end
+
+    def high_normalization(stats)
+      format_stat stats[HIGH_NORM]
+    end
+
+    def high_full_request(stats)
+      format_stat stats[HIGH_FULL]
+    end
+
+    def avg_load(stats)
+      format_stat stats[AVG_LOAD]
+    end
+
+    def avg_normalization(stats)
+      format_stat stats[AVG_NORM]
+    end
+
+    def avg_full_request(stats)
+      format_stat stats[AVG_FULL]
+    end
+
+    def low_full_request_style(stats)
+      performance_style_class(stats, LOW_FULL)
+    end
+
+    def high_full_request_style(stats)
+      performance_style_class(stats, HIGH_FULL)
+    end
+
+    def avg_full_request_style(stats)
+      performance_style_class(stats, AVG_FULL)
+    end
+
+    def performance_table_description
+      case expected_time_period
+      when :day
+        I18n.t('qa_server.monitor_status.performance.datatable_day_desc')
+      when :month
+        I18n.t('qa_server.monitor_status.performance.datatable_month_desc')
+      when :year
+        I18n.t('qa_server.monitor_status.performance.datatable_year_desc')
+      else
+        I18n.t('qa_server.monitor_status.performance.datatable_all_desc')
+      end
+    end
+
+    private
+
+      def expected_time_period
+        QaServer.config.performance_datatable_default_time_period
+      end
+
+      def format_stat(stat)
+        return '' if stat.nil?
+        format("%0.1f", stat)
+      end
+
+      def performance_style_class(stats, stat_key)
+        return "status-bad" if max_threshold_exceeded(stats, stat_key)
+        return "status-unknown" if desired_threshold_not_met(stats, stat_key)
+        "status-good"
+      end
+
+      def max_threshold_exceeded(stats, stat_key)
+        return false if stats[stat_key].nil?
+        return true if stats[stat_key] > QaServer.config.performance_datatable_max_threshold
+        false
+      end
+
+      def desired_threshold_not_met(stats, stat_key)
+        return false if stats[stat_key].nil?
+        return true unless stats[stat_key] < QaServer.config.performance_datatable_warning_threshold
+        false
+      end
+  end
+end