qa_server 5.5.1 → 6.0.0

data/app/prepends/prepended_rdf/rdf_graph.rb

@@ -17,15 +17,15 @@ module PrependedRdf::RdfGraph
     raise TypeError, "#{self} is immutable" if immutable?
     phid, real_url = parse_phid(url)
     performance_udpates = {}
-    start_time_s = QaServer.current_time_s
+    start_time_s = QaServer::TimeService.current_time_s
 
     reader = RDF::Reader.open(real_url, { base_uri: real_url }.merge(options))
 
-    end_time_s = QaServer.current_time_s
+    end_time_s = QaServer::TimeService.current_time_s
     performance_udpates[:retrieve_time_ms] = (end_time_s - start_time_s) * 1000
     QaServer.config.performance_tracker.write "#{format('%.6f', end_time_s - start_time_s)}, " # read data
 
-    start_time_s = QaServer.current_time_s
+    start_time_s = QaServer::TimeService.current_time_s
 
     if graph_name
       statements = []
@@ -40,7 +40,7 @@ module PrependedRdf::RdfGraph
       nil
     end
 
-    end_time_s = QaServer.current_time_s
+    end_time_s = QaServer::TimeService.current_time_s
     performance_udpates[:graph_load_time_ms] = (end_time_s - start_time_s) * 1000
     QaServer.config.performance_cache.update(id: phid, updates: performance_udpates)
     QaServer.config.performance_tracker.write "#{format('%.6f', end_time_s - start_time_s)}, " # load graph

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

@@ -94,6 +94,28 @@ module QaServer::MonitorStatus
       end
     end
 
+    def performance_data_start
+      start_dt = case expected_time_period
+                 when :day
+                   performance_data_end_dt - 1.day
+                 when :month
+                   performance_data_end_dt - 1.month
+                 when :year
+                   performance_data_end_dt - 1.year
+                 else
+                   @parent.first_updated_dt
+                 end
+      QaServer::TimeService.pretty_date(start_dt)
+    end
+
+    def performance_data_end_dt
+      @parent.last_updated_dt
+    end
+
+    def performance_data_end
+      QaServer::TimeService.pretty_date(performance_data_end_dt)
+    end
+
     private
 
       def expected_time_period
@@ -101,7 +123,7 @@ module QaServer::MonitorStatus
       end
 
       def data_table_for(authority_data, action)
-        authority_data[action][FOR_DATATABLE]
+        authority_data[action]
       end
 
       def unsupported_action?(stats)

data/app/presenters/qa_server/check_status_presenter.rb

@@ -76,11 +76,11 @@ module QaServer
     end
 
     def value_check_param
-      QaServer::AuthorityValidationController::VALIDATION_TYPE_PARAM
+      QaServer::AuthorityValidationBehavior::VALIDATION_TYPE_PARAM
     end
 
     def value_check_connections
-      QaServer::AuthorityValidationController::VALIDATE_CONNECTIONS
+      QaServer::AuthorityValidationBehavior::VALIDATE_CONNECTIONS
     end
 
     def label_check_connections
@@ -88,7 +88,7 @@ module QaServer
     end
 
     def value_check_accuracy
-      QaServer::AuthorityValidationController::VALIDATE_ACCURACY
+      QaServer::AuthorityValidationBehavior::VALIDATE_ACCURACY
     end
 
     def label_check_accuracy
@@ -96,7 +96,7 @@ module QaServer
     end
 
     def value_all_checks
-      QaServer::AuthorityValidationController::ALL_VALIDATIONS
+      QaServer::AuthorityValidationBehavior::ALL_VALIDATIONS
     end
 
     def label_all_checks

data/app/presenters/qa_server/monitor_status/current_status_presenter.rb

@@ -2,23 +2,35 @@
 # This presenter class provides data related to last test run as needed by the view that monitors status of authorities.
 module QaServer::MonitorStatus
   class CurrentStatusPresenter
+    # @param parent [QaServer::MonitorStatusPresenter] parent presenter
     # @param current_summary [ScenarioRunSummary] summary status of the latest run of test scenarios
     # @param current_data [Array<Hash>] current set of failures for the latest test run, if any
-    def initialize(current_summary:, current_failure_data:)
+    def initialize(parent:, current_summary:, current_failure_data:)
+      @parent = parent
       @current_summary = current_summary
       @current_failure_data = current_failure_data
     end
 
-    # @return [String] date of last test run
+    # @return [ActiveSupport::TimeWithZone] date time stamp of last test run
+    def last_updated_dt
+      @current_summary.run_dt_stamp
+    end
+
+    # @return [String] date with time of last test run
     def last_updated
-      @current_summary.run_dt_stamp.in_time_zone("Eastern Time (US & Canada)").strftime("%m/%d/%y - %I:%M %p")
+      QaServer::TimeService.pretty_time(last_updated_dt)
     end
 
-    # @return [String] date of first recorded test run
-    def first_updated
+    # @return [ActiveSupport::TimeWithZone] date time stamp of first recorded test run
+    def first_updated_dt
       QaServer::ScenarioRunRegistry.first_run_dt
     end
 
+    # @return [String] date with time of first recorded test run
+    def first_updated
+      QaServer::TimeService.pretty_time(first_updated_dt)
+    end
+
     # @return [Integer] number of loaded authorities
     def authorities_count
       @current_summary.authority_count

data/app/presenters/qa_server/monitor_status/history_presenter.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 # This presenter class provides historical testing data needed by the view that monitors status of authorities.
 module QaServer::MonitorStatus
-  class HistoryPresenter
-    HISTORICAL_AUTHORITY_NAME_IDX = 0
-    HISTORICAL_FAILURE_COUNT_IDX = 1
-    HISTORICAL_PASSING_COUNT_IDX = 2
-
+  class HistoryPresenter # rubocop:disable Metrics/ClassLength
     include QaServer::MonitorStatus::GruffGraph
 
+    # @param parent [QaServer::MonitorStatusPresenter] parent presenter
     # @param historical_summary_data [Array<Hash>] summary of past failuring runs per authority to drive chart
-    def initialize(historical_summary_data:)
+    def initialize(parent:, historical_summary_data:)
+      @parent = parent
       @historical_summary_data = historical_summary_data
     end
 
@@ -23,8 +21,33 @@ module QaServer::MonitorStatus
 
     # @return [Boolean] true if historical test data exists; otherwise false
     def history?
-      return true if @historical_summary_data.present?
-      false
+      @historical_summary_data.present?
+    end
+
+    # Return the first date of data represented in the history graph and data table
+    # @return [String] string version of date formatted with just date (e.g. "02/01/2020")
+    def history_start
+      start_dt = case QaServer.config.historical_datatable_default_time_period
+                 when :month
+                   history_end_dt - 1.month
+                 when :year
+                   history_end_dt - 1.year
+                 else
+                   @parent.first_updated_dt
+                 end
+      QaServer::TimeService.pretty_date(start_dt)
+    end
+
+    # Return the last date of data represented in the history graph and data table
+    # @return [ActiveSupport::TimeWithZone] date time stamp
+    def history_end_dt
+      @parent.last_updated_dt
+    end
+
+    # Return the last date of data represented in the history graph and data table
+    # @return [String] string version of date formatted with just date (e.g. "02/01/2020")
+    def history_end
+      QaServer::TimeService.pretty_date(history_end_dt)
     end
 
     def historical_graph
@@ -57,15 +80,15 @@ module QaServer::MonitorStatus
     end
 
     def historical_data_authority_name(historical_entry)
-      historical_entry[HISTORICAL_AUTHORITY_NAME_IDX]
+      historical_entry[0]
     end
 
     def days_authority_passing(historical_entry)
-      historical_entry[HISTORICAL_PASSING_COUNT_IDX]
+      historical_entry[1]["good"]
     end
 
     def days_authority_failing(historical_entry)
-      historical_entry[HISTORICAL_FAILURE_COUNT_IDX]
+      historical_entry[1]["bad"]
     end
 
     def days_authority_tested(historical_entry)
@@ -82,13 +105,11 @@ module QaServer::MonitorStatus
 
     def failure_style_class(historical_entry)
       return "status-neutral" if days_authority_failing(historical_entry) <= 0
-      return "status-unknown" if percent_authority_failing(historical_entry) < 0.1
-      "status-bad"
+      percent_authority_failing(historical_entry) < 0.1 ? "status-unknown" : "status-bad"
     end
 
     def passing_style_class(historical_entry)
-      return "status-bad" if days_authority_passing(historical_entry) <= 0
-      "status-good"
+      days_authority_passing(historical_entry) <= 0 ? "status-bad" : "status-good"
     end
 
     def display_history_details?
@@ -125,11 +146,11 @@ module QaServer::MonitorStatus
         pass_data = []
         fail_data = []
         i = 0
-        historical_summary.each do |data|
-          labels[i] = data[0]
+        historical_summary.each do |auth, data|
+          labels[i] = auth
           i += 1
-          fail_data << data[1]
-          pass_data << data[2]
+          fail_data << data["bad"]
+          pass_data << data["good"]
         end
         [labels, fail_data, pass_data]
       end

data/app/presenters/qa_server/monitor_status/performance_presenter.rb

@@ -7,8 +7,10 @@ module QaServer::MonitorStatus
     include QaServer::MonitorStatus::PerformanceGraphBehavior
     include QaServer::PerformanceHistoryDataKeys
 
+    # @param parent [QaServer::MonitorStatusPresenter] parent presenter
     # @param performance_data [Hash<Hash>] performance data
-    def initialize(performance_data:)
+    def initialize(parent:, performance_data:)
+      @parent = parent
       @performance_data = performance_data
     end
 

data/app/presenters/qa_server/monitor_status_presenter.rb

@@ -7,21 +7,21 @@ module QaServer
     # @param current_summary [ScenarioRunSummary] summary status of the latest run of test scenarios
     # @param current_data [Array<Hash>] current set of failures for the latest test run, if any
     # @param historical_summary_data [Array<Hash>] summary of past failuring runs per authority to drive chart
-    # @param performance_data [Hash<Hash>] performance data
+    # @param performance_data [Hash<Hash>] performance datatable data
     def initialize(current_summary:, current_failure_data:, historical_summary_data:, performance_data:)
-      @current_status_presenter = QaServer::MonitorStatus::CurrentStatusPresenter.new(current_summary: current_summary, current_failure_data: current_failure_data)
-      @history_presenter = QaServer::MonitorStatus::HistoryPresenter.new(historical_summary_data: historical_summary_data)
-      @performance_presenter = QaServer::MonitorStatus::PerformancePresenter.new(performance_data: performance_data)
+      @current_status_presenter = QaServer::MonitorStatus::CurrentStatusPresenter.new(parent: self, current_summary: current_summary, current_failure_data: current_failure_data)
+      @history_presenter = QaServer::MonitorStatus::HistoryPresenter.new(parent: self, historical_summary_data: historical_summary_data)
+      @performance_presenter = QaServer::MonitorStatus::PerformancePresenter.new(parent: self, performance_data: performance_data)
     end
 
-    def_delegators :@current_status_presenter, :last_updated, :first_updated, :authorities_count, :failing_authorities_count,
-                   :authorities_count_style, :tests_count, :passing_tests_count, :failing_tests_count, :failing_tests_style,
-                   :failures, :failures?
+    def_delegators :@current_status_presenter, :last_updated_dt, :last_updated, :first_updated_dt, :first_updated, :authorities_count,
+                   :failing_authorities_count, :authorities_count_style, :tests_count, :passing_tests_count, :failing_tests_count,
+                   :failing_tests_style, :failures, :failures?
 
     def_delegators :@history_presenter, :historical_summary, :history?, :historical_graph, :status_style_class, :status_label,
                    :historical_data_authority_name, :days_authority_passing, :days_authority_failing, :days_authority_tested,
                    :percent_authority_failing, :percent_authority_failing_str, :failure_style_class, :passing_style_class,
-                   :display_history_details?, :display_historical_graph?, :display_historical_datatable?
+                   :display_history_details?, :display_historical_graph?, :display_historical_datatable?, :history_start, :history_end
 
     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,
@@ -35,6 +35,6 @@ module QaServer
                    :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
+                   :performance_graph_action, :performance_data_start, :performance_data_end
   end
 end

data/app/services/qa_server/monitor_cache_service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# Helper methods for caching for monitoring status.
+module QaServer
+  class MonitorCacheService
+    class << self
+      # @return [Float] number of seconds until cache should expire
+      def cache_expiry
+        monitoring_expires_at - QaServer::TimeService.current_time
+      end
+
+      private
+
+        # @return [ActiveSupport::TimeWithZone] DateTime at which cache should expire
+        def monitoring_expires_at
+          offset = QaServer.config.hour_offset_to_expire_cache
+          offset_time = QaServer::TimeService.current_time
+          offset_time = offset_time.tomorrow unless (offset_time + 5.minutes).hour < offset
+          offset_time.beginning_of_day + offset.hours - 5.minutes
+        end
+    end
+  end
+end

data/app/services/qa_server/performance_calculator_service.rb

@@ -14,18 +14,29 @@ module QaServer
       @stats = {}
     end
 
-    # Calculate performance statistics for a set of PerformanceHistory records.  Min is at the 10th percentile.  Max is at the 90th percentile.
+    # Calculate performance statistics with percentiles.  Min is at the 10th percentile.  Max is at the 90th percentile.
     # @return [Hash] hash of the statistics
     # @example
     #   { 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_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
+    def calculate_stats_with_percentiles
+      calculate_retrieve_stats(true, true, true)
+      calculate_graph_load_stats(true, true, true)
+      calculate_normalization_stats(true, true, true)
+      calculate_action_stats(true, true, true)
+      stats
+    end
+
+    # Calculate performance statistics including averages only.
+    # @return [Hash] hash of the statistics
+    # @example
+    #   { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5 }
+    def calculate_average_stats
+      calculate_load_stats(true, false, false) # used for backward compatibility only
+      calculate_retrieve_stats(true, false, false)
+      calculate_graph_load_stats(true, false, false)
+      calculate_normalization_stats(true, false, false)
       stats
     end
 

data/app/services/qa_server/performance_datatable_service.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+# This class calculates performance stats for the performance datatable.
+module QaServer
+  class PerformanceDatatableService
+    class << self
+      include QaServer::PerformanceHistoryDataKeys
+
+      class_attribute :stats_calculator_class, :performance_data_class, :authority_list_class
+      self.stats_calculator_class = QaServer::PerformanceCalculatorService
+      self.performance_data_class = QaServer::PerformanceHistory
+      self.authority_list_class = QaServer::AuthorityListerService
+
+      # Summary of performance by action for each authority for the configured time period (e.g. :day, :month, :year, :all).
+      # @param force [Boolean] if true, calculate the stats even if the cache hasn't expired; otherwise, use cache if not expired
+      # @returns [Hash] performance statistics for configured time period by action for each authority
+      # @example
+      #   { all_authorities:
+      #     { search:
+      #       { 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 },
+      #       fetch: { ... # same data as for search_stats },
+      #       all: { ... # same data as for search_stats }
+      #     },
+      #     AGROVOC_LD4L_CACHE: { ... # same data for each authority  }
+      #   }
+      def calculate_datatable_data(force:)
+        Rails.cache.fetch("QaServer::PerformanceDatatableService/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 5.minutes, force: force) do
+          QaServer.config.monitor_logger.info("(QaServer::PerformanceDatatableService##{__method__}) - calculating performance datatable stats - cache expired or refresh requested (force: #{force})")
+          data = {}
+          auths = authority_list_class.authorities_list
+          data[ALL_AUTH] = datatable_data_for_authority
+          auths.each { |auth_name| data[auth_name] = datatable_data_for_authority(authority_name: auth_name) }
+          data
+        end
+      end
+
+      private
+
+        def datatable_data_for_authority(authority_name: nil)
+          [:search, :fetch, :all_actions].each_with_object({}) do |action, hash|
+            hash[action] = data_table_stats(authority_name, action)
+          end
+        end
+
+        # Get statistics for data table.
+        # @param auth_name [String] limit statistics to records for the given authority (default: all authorities)
+        # @param action [Symbol] one of :search, :fetch, :all_actions
+        # @returns [Hash] performance statistics for the datatable during the expected time period
+        # @example
+        #   { 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 data_table_stats(auth_name, action)
+          records = records_for_authority(auth_name)
+          stats_calculator_class.new(records, action: action).calculate_stats_with_percentiles
+        end
+
+        def expected_time_period
+          QaServer.config.performance_datatable_default_time_period
+        end
+
+        def records_for_authority(auth_name)
+          case expected_time_period
+          when :day
+            QaServer.config.performance_cache.write_all # only need to write if just using today's data
+            performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_24_hours(auth_name: auth_name))
+          when :month
+            performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_30_days(auth_name: auth_name))
+          when :year
+            performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_12_months(auth_name: auth_name))
+          else
+            all_records(auth_name)
+          end
+        end
+
+        def all_records(auth_name)
+          auth_name.nil? ? performance_data_class.all : performance_data_class.where(authority: auth_name)
+        end
+    end
+  end
+end

data/app/services/qa_server/performance_graph_data_service.rb

@@ -1,76 +1,133 @@
 # frozen_string_literal: true
 # This class sets performance stats for the last 24 hours, past 30 days, and the past 12 months.
 module QaServer
-  class PerformanceGraphDataService
+  class PerformanceGraphDataService # rubocop:disable Metrics/ClassLength
     class << self
       include QaServer::PerformanceHistoryDataKeys
 
-      class_attribute :stats_calculator_class, :performance_data_class
+      class_attribute :stats_calculator_class, :performance_data_class, :authority_list_class
       self.stats_calculator_class = QaServer::PerformanceCalculatorService
       self.performance_data_class = QaServer::PerformanceHistory
+      self.authority_list_class = QaServer::AuthorityListerService
 
-      # Get hourly average for the past 24 hours.
-      # @param authority_name [String] limit statistics to records for the given authority (default: all authorities)
-      # @param action [Symbol] one of :search, :fetch, :all_actions
-      # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
+      # 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
-      #   { 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. }}
+      #   { all_authorities:
+      #     { search:
+      #       {
+      #         day:
+      #           { 0: { hour: '1400', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             1: { hour: '1500', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             2: { hour: '1600', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             ...,
+      #             23: { hour: 'NOW', retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
+      #           },
+      #         month:
+      #           { 0: { day: '07-15-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             1: { day: '07-16-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             2: { day: '07-17-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             ...,
+      #             29: { day: 'TODAY', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
+      #           },
+      #         year:
+      #           { 0: { month: '09-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             1: { month: '10-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             2: { month: '11-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #             ...,
+      #             11: { month: '08-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
+      #           }
+      #       },
+      #       fetch: { ... # same data as for search_stats },
+      #       all: { ... # same data as for search_stats }
+      #     },
+      #     AGROVOC_LD4L_CACHE: { ... # same data for each authority  }
       #   }
-      def average_last_24_hours(authority_name: nil, action: nil, force: false)
-        Rails.cache.fetch("#{self.class}/#{__method__}/#{authority_name || ALL_AUTH}/#{action}/#{FOR_DAY}",
-                          expires_in: QaServer.current_time.end_of_hour - QaServer.current_time,
-                          race_condition_ttl: 1.hour, force: force) do
-          Rails.logger.info("#{self.class}##{__method__} - calculating performance stats for last 24 hours - cache expired or refresh requested (#{force})")
-          calculate_last_24_hours(authority_name, action)
-        end
+      def calculate_graph_data(force:)
+        QaServer.config.monitor_logger.info("(QaServer::PerformanceGraphDataService##{__method__}) - calculating performance graph data")
+        QaServer.config.performance_cache.write_all
+        data = {}
+        auths = authority_list_class.authorities_list
+        calculate_all = force || cache_expired?
+        data[ALL_AUTH] = graph_data_for_authority(force: force, calculate_all: calculate_all)
+        auths.each { |auth_name| data[auth_name] = graph_data_for_authority(authority_name: auth_name, force: force, calculate_all: calculate_all) }
+        data
       end
 
-      # Get daily average for the past 30 days.
-      # @param authority_name [String] limit statistics to records for the given authority (default: all authorities)
-      # @param action [Symbol] one of :search, :fetch, :all_actions
-      # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
-      # @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(authority_name: nil, action: nil, force: false)
-        Rails.cache.fetch("#{self.class}/#{__method__}/#{authority_name || ALL_AUTH}/#{action}/#{FOR_MONTH}",
-                          expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: force) do
-          Rails.logger.info("#{self.class}##{__method__} - calculating performance stats for last 30 days - cache expired or refresh requested (#{force})")
-          calculate_last_30_days(authority_name, action)
+      private
+
+        def graph_data_for_authority(authority_name: nil, force:, calculate_all:)
+          [:search, :fetch, :all_actions].each_with_object({}) do |action, hash|
+            data = {}
+            data[FOR_DAY] = average_last_24_hours(authority_name: authority_name, action: action, force: force)
+            data[FOR_MONTH] = average_last_30_days(authority_name: authority_name, action: action, force: force) if calculate_all
+            data[FOR_YEAR] = average_last_12_months(authority_name: authority_name, action: action, force: force) if calculate_all
+            hash[action] = data
+          end
         end
-      end
 
-      # Get daily average for the past 12 months.
-      # @param authority_name [String] limit statistics to records for the given authority (default: all authorities)
-      # @param action [Symbol] one of :search, :fetch, :all_actions
-      # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
-      # @returns [Hash] performance statistics for the past 12 months
-      # @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(authority_name: nil, action: nil, force: false)
-        Rails.cache.fetch("#{self.class}/#{__method__}/#{authority_name || ALL_AUTH}/#{action}/#{FOR_YEAR}",
-                          expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: force) do
-          Rails.logger.info("#{self.class}##{__method__} - calculating performance stats for last 12 months - cache expired or refresh requested (#{force})")
-          calculate_last_12_months(authority_name, action)
+        # Get hourly average for the past 24 hours.
+        # @param authority_name [String] limit statistics to records for the given authority (default: all authorities)
+        # @param action [Symbol] one of :search, :fetch, :all_actions
+        # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
+        # @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(authority_name: nil, action: nil, force: false)
+          avgs = Rails.cache.fetch("QaServer::PerformanceGraphDataService/#{__method__}/#{authority_name || ALL_AUTH}/#{action}/#{FOR_DAY}",
+                                   expires_in: QaServer::TimeService.current_time.end_of_hour - QaServer::TimeService.current_time,
+                                   race_condition_ttl: 1.hour, force: force) do
+            QaServer.config.monitor_logger.info("(QaServer::PerformanceGraphDataService##{__method__}) - calculating performance stats - cache expired or refresh requested (force: #{force})")
+            calculate_last_24_hours(authority_name, action)
+          end
+          calculate_last_hour(authority_name, action, avgs)
         end
-      end
 
-      private
+        # Get daily average for the past 30 days.
+        # @param authority_name [String] limit statistics to records for the given authority (default: all authorities)
+        # @param action [Symbol] one of :search, :fetch, :all_actions
+        # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
+        # @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(authority_name: nil, action: nil, force: false)
+          Rails.cache.fetch("QaServer::PerformanceGraphDataService/#{__method__}/#{authority_name || ALL_AUTH}/#{action}/#{FOR_MONTH}",
+                            expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 1.hour, force: force) do
+            QaServer.config.monitor_logger.info("(QaServer::PerformanceGraphDataService##{__method__}) - calculating performance stats - cache expired or refresh requested (force: #{force})")
+            calculate_last_30_days(authority_name, action)
+          end
+        end
+
+        # Get daily average for the past 12 months.
+        # @param authority_name [String] limit statistics to records for the given authority (default: all authorities)
+        # @param action [Symbol] one of :search, :fetch, :all_actions
+        # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
+        # @returns [Hash] performance statistics for the past 12 months
+        # @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(authority_name: nil, action: nil, force: false)
+          Rails.cache.fetch("QaServer::PerformanceGraphDataService/#{__method__}/#{authority_name || ALL_AUTH}/#{action}/#{FOR_YEAR}",
+                            expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 1.hour, force: force) do
+            QaServer.config.monitor_logger.info("(QaServer::PerformanceGraphDataService##{__method__}) - calculating performance stats - cache expired or refresh requested (force: #{force})")
+            calculate_last_12_months(authority_name, action)
+          end
+        end
 
         def records_by(authority_name, action, time_period)
           where_clause = { dt_stamp: time_period }
@@ -99,49 +156,50 @@ module QaServer
           end
         end
 
+        def calculate_from_records(records, range_idx, range_label)
+          stats = stats_calculator_class.new(records).calculate_average_stats
+          { STATS => stats, range_idx => range_label }
+        end
+
+        def calculate_last_hour(authority_name, action, avgs)
+          start_hour = QaServer::TimeService.current_time.beginning_of_hour
+          records = records_by(authority_name, action, start_hour..start_hour.end_of_hour)
+          avgs[23] = calculate_from_records(records, BY_HOUR, performance_by_hour_label(23, start_hour))
+          avgs
+        end
+
         def calculate_last_24_hours(authority_name, action)
-          start_hour = QaServer.current_time.beginning_of_hour - 23.hours
-          avgs = {}
-          0.upto(23).each do |idx|
+          start_hour = QaServer::TimeService.current_time.beginning_of_hour - 23.hours
+          0.upto(23).each_with_object({}) do |idx, avgs|
             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)
-            data[STATS] = stats
-            avgs[idx] = data
+            avgs[idx] = calculate_from_records(records, BY_HOUR, performance_by_hour_label(idx, start_hour))
             start_hour += 1.hour
           end
-          avgs
         end
 
         def calculate_last_30_days(authority_name, action)
-          start_day = QaServer.current_time.beginning_of_day - 29.days
-          avgs = {}
-          0.upto(29).each do |idx|
+          start_day = QaServer::TimeService.current_time.beginning_of_day - 29.days
+          0.upto(29).each_with_object({}) do |idx, avgs|
             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)
-            data[STATS] = stats
-            avgs[idx] = data
+            avgs[idx] = calculate_from_records(records, BY_DAY, performance_by_day_label(idx, start_day))
             start_day += 1.day
           end
-          avgs
         end
 
         def calculate_last_12_months(authority_name, action)
-          start_month = QaServer.current_time.beginning_of_month - 11.months
-          avgs = {}
-          0.upto(11).each do |idx|
+          start_month = QaServer::TimeService.current_time.beginning_of_month - 11.months
+          0.upto(11).each_with_object({}) do |idx, avgs|
             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")
-            data[STATS] = stats
-            avgs[idx] = data
+            avgs[idx] = calculate_from_records(records, BY_MONTH, start_month.strftime("%m-%Y"))
             start_month += 1.month
           end
-          avgs
+        end
+
+        # @returns [Boolean] true if cache has expired; otherwise, false
+        def cache_expired?
+          expired = Rails.cache.fetch("QaServer::PerformanceGraphDataService/#{__method__}", expires_in: 5.seconds) { true }
+          Rails.cache.fetch("QaServer::PerformanceGraphDataService/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, force: expired) { false } # reset if expired
+          expired
         end
     end
   end