qa_server 6.2.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b602ac44639871d5021eb47493edf93fb8abdc25
-  data.tar.gz: bf9e6a5ece3786edab98ed79d1fc3edb8e54f8b7
+  metadata.gz: fb73032a8e4f6dfb0d782a8635d8f43668b63a06
+  data.tar.gz: a857cd62d41bc035a241419815e9fff67fdf1d5a
 SHA512:
-  metadata.gz: ec1fec69f78b763fc7012c92118fddeb6e0f6ad98d53d9ae80d959f80f0c1373c435626452644294ecbcf1b1843ac37517af58a71e04ece333a9d14afa99486f
-  data.tar.gz: d4e87a9c8157f8d03b3fdbc26ded7698f294cee41f9c7a2222355db878c26ab7e7d121d32dda69fbf1660f5b7942de7ec05688431a364b1e06f22b9b73967598
+  metadata.gz: 490cfcc14713a0fad8e3d5d60aa5d23a5699c5c3ab23359164848a8f5a3223bbf8fb2bbbffbd9f59b5220efed3eec4f4d63a8fece546dee916886f91a51f0287
+  data.tar.gz: '04027957aeb5955a65a4a5d23d4fd11c7b98827c650ba9b736512953fb10c260e11c9ad4f76de85991861706874eedd7e04bb523184c2a1693e079dc0317b142'

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+### 7.0.0 (2020-02-19)
+
+* refactor of caching system to simplify the process
+  * rename monitor_cache_service to cache_expiry_service
+  * move generation of hourly graph to cache_processors
+  * move generation of daily and monthly graphs to cache_processors
+  * move performance datatable cache control to cache_processors
+  * move caching of summary and historical data to cache_processors
+  * move caching of test execution marker to cache_processors
+  * move performance cache of performance data to cache_processors
+  
 ### 6.2.0 (2020-02-17)
 
 * use authentication for refreshing monitor tests

data/app/cache_processors/concerns/qa_server/cache_keys.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# This module sets up the keys used to identify data in Rails.cache
+module QaServer
+  module CacheKeys
+    SCENARIO_RUN_TEST_DATA_CACHE_KEY = "QaServer--CacheKeys--scenario_run_test_data"
+    SCENARIO_RUN_SUMMARY_DATA_CACHE_KEY = "QaServer--CacheKeys--scenario_run_summary_data"
+    SCENARIO_RUN_FAILURE_DATA_CACHE_KEY = "QaServer--CacheKeys--scenario_run_failure_data"
+    SCENARIO_RUN_HISTORY_DATA_CACHE_KEY = "QaServer--CacheKeys--scenario_run_history_data"
+
+    PERFORMANCE_DATATABLE_DATA_CACHE_KEY = "QaServer--Cache--performance_datatable_data"
+    PERFORMANCE_GRAPH_HOURLY_DATA_CACHE_KEY = "QaServer--CacheKeys--performance_graph_hourly_data"
+    PERFORMANCE_GRAPH_DAILY_DATA_CACHE_KEY = "QaServer--CacheKeys--performance_graph_daily_data"
+    PERFORMANCE_GRAPH_MONTHLY_DATA_CACHE_KEY = "QaServer--CacheKeys--performance_graph_monthly_data"
+  end
+end

data/app/cache_processors/qa_server/cache_expiry_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# Helper methods for caching for monitoring status.
+module QaServer
+  class CacheExpiryService
+    class << self
+      # @return [Float] number of seconds until cache should expire
+      def cache_expiry
+        cache_expires_at - QaServer::TimeService.current_time
+      end
+
+      # @param key [String] cache key
+      # @param force [Boolean] if true, forces cache to regenerate by returning true; otherwise, uses cache expiry to determine whether cache has expired
+      # @return [Boolean] true if cache has expired or is being forced to expire
+      def cache_expired?(key:, force:, next_expiry:)
+        # will return true only if the full expiry has passed or force was requested
+        force = Rails.cache.fetch(key, expires_in: 5.minutes, race_condition_ttl: 30.seconds, force: force) { true }
+        # reset cache so it will next expired at expected time
+        Rails.cache.fetch(key, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: true) { false }
+        force
+      end
+
+      private
+
+        # @return [ActiveSupport::TimeWithZone] DateTime at which cache should expire
+        def cache_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/cache_processors/qa_server/performance_daily_graph_cache.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# Generate graphs for the past 30 days using cached data.  Graphs are generated only if the cache has expired.
+module QaServer
+  class PerformanceDailyGraphCache
+    class_attribute :authority_list_class, :graph_data_service, :graphing_service
+    self.authority_list_class = QaServer::AuthorityListerService
+    self.graph_data_service = QaServer::PerformanceGraphDataService
+    self.graphing_service = QaServer::PerformanceGraphingService
+
+    class << self
+      include QaServer::CacheKeys
+      include QaServer::PerformanceHistoryDataKeys
+
+      # Generates graphs for the past 30 days for :search, :fetch, and :all actions for each authority.
+      # @param force [Boolean] if true, run the tests even if the cache hasn't expired; otherwise, use cache if not expired
+      def generate_graphs(force: false)
+        return unless QaServer::CacheExpiryService.cache_expired?(key: cache_key_for_force, force: force, next_expiry: next_expiry)
+        QaServer.config.monitor_logger.debug("(QaServer::PerformanceDailyGraphCache) - GENERATING daily performance graphs (force: #{force})")
+        generate_graphs_for_authorities
+      end
+
+      private
+
+        def generate_graphs_for_authorities
+          auths = authority_list_class.authorities_list
+          generate_graphs_for_authority(authority_name: ALL_AUTH) # generates graph for all authorities
+          auths.each { |authname| generate_graphs_for_authority(authority_name: authname) }
+        end
+
+        def generate_graphs_for_authority(authority_name:)
+          [SEARCH, FETCH, ALL_ACTIONS].each_with_object({}) do |action, hash|
+            hash[action] = generate_30_day_graph(authority_name: authority_name, action: action)
+          end
+        end
+
+        def generate_30_day_graph(authority_name:, action:)
+          # real expiration or force caught by cache_expired?  So if we are here, either the cache has expired
+          # or force was requested.  We still expire the cache and use ttl to catch race conditions.
+          Rails.cache.fetch(cache_key_for_authority_action(authority_name: authority_name, action: action),
+                            expires_in: next_expiry, race_condition_ttl: 1.hour, force: true) do
+            data = graph_data_service.calculate_last_30_days(authority_name: authority_name, action: action)
+            graphing_service.generate_daily_graph(authority_name: authority_name, action: action, data: data)
+            data
+          end
+        end
+
+        def cache_key_for_authority_action(authority_name:, action:)
+          "#{PERFORMANCE_GRAPH_DAILY_DATA_CACHE_KEY}--#{authority_name}--#{action}"
+        end
+
+        def cache_key_for_force
+          "#{PERFORMANCE_GRAPH_DAILY_DATA_CACHE_KEY}--force"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/performance_datatable_cache.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# Maintain a cache of data for the Performance Datatable
+module QaServer
+  class PerformanceDatatableCache
+    include QaServer::CacheKeys
+
+    class_attribute :performance_data_service
+    self.performance_data_service = QaServer::PerformanceDatatableService
+
+    # Retrieve performance datatable data from the cache
+    # @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 self.data(force: false)
+      Rails.cache.fetch(PERFORMANCE_DATATABLE_DATA_CACHE_KEY,
+                        expires_in: QaServer::CacheExpiryService.cache_expiry,
+                        race_condition_ttl: 5.minutes, force: force) do
+        QaServer.config.monitor_logger.debug("(QaServer::PerformanceDatatableCache) - CALCULATING performance datatable stats (force: #{force})")
+        performance_data_service.calculate_datatable_data
+      end
+    end
+  end
+end

data/app/cache_processors/qa_server/performance_hourly_graph_cache.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# Generate graphs for the past 24 hours using cached data.  The last hour of data is always calculated and all graphs
+# for are generated.
+module QaServer
+  class PerformanceHourlyGraphCache
+    class_attribute :authority_list_class, :graph_data_service, :graphing_service
+    self.authority_list_class = QaServer::AuthorityListerService
+    self.graph_data_service = QaServer::PerformanceGraphDataService
+    self.graphing_service = QaServer::PerformanceGraphingService
+
+    class << self
+      include QaServer::CacheKeys
+      include QaServer::PerformanceHistoryDataKeys
+
+      # Generates graphs for the past 24 hours for :search, :fetch, and :all actions for each authority.
+      # @param force [Boolean] if true, run the tests even if the cache hasn't expired; otherwise, use cache if not expired
+      def generate_graphs(force: false)
+        QaServer.config.monitor_logger.debug("(QaServer::PerformanceHourlyGraphCache) - GENERATING hourly performance graphs (force: #{force})")
+        QaServer.config.performance_cache.write_all
+        generate_graphs_for_authorities(force: force)
+      end
+
+      private
+
+        def generate_graphs_for_authorities(force:)
+          auths = authority_list_class.authorities_list
+          generate_graphs_for_authority(authority_name: ALL_AUTH, force: force) # generates graph for all authorities
+          auths.each { |authname| generate_graphs_for_authority(authority_name: authname, force: force) }
+        end
+
+        def generate_graphs_for_authority(authority_name:, force:)
+          [SEARCH, FETCH, ALL_ACTIONS].each_with_object({}) do |action, hash|
+            hash[action] = generate_24_hour_graph(authority_name: authority_name, action: action, force: force)
+          end
+        end
+
+        def generate_24_hour_graph(authority_name:, action:, force:)
+          graph_created = false
+          data = Rails.cache.fetch(cache_key_for_authority_action(authority_name: authority_name, action: action),
+                                   expires_in: QaServer::TimeService.current_time.end_of_hour - QaServer::TimeService.current_time,
+                                   race_condition_ttl: 1.hour, force: force) do
+            data = graph_data_service.calculate_last_24_hours(authority_name: authority_name, action: action)
+            graphing_service.generate_hourly_graph(authority_name: authority_name, action: action, data: data)
+            graph_created = true
+            data
+          end
+          regen_last_hour_and_graph(authority_name: authority_name, action: action, data: data) unless graph_created
+        end
+
+        def regen_last_hour_and_graph(authority_name:, action:, data:)
+          Rails.cache.fetch(cache_key_for_authority_action(authority_name: authority_name, action: action),
+                            expires_in: QaServer::TimeService.current_time.end_of_hour - QaServer::TimeService.current_time,
+                            race_condition_ttl: 1.hour, force: true) do
+            data = graph_data_service.recalculate_last_hour(authority_name: authority_name, action: action, averages: data)
+            graphing_service.generate_hourly_graph(authority_name: authority_name, action: action, data: data)
+            data
+          end
+        end
+
+        def cache_key_for_authority_action(authority_name:, action:)
+          "#{PERFORMANCE_GRAPH_HOURLY_DATA_CACHE_KEY}--#{authority_name}--#{action}"
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/performance_monthly_graph_cache.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# Generate graphs for the past 12 months using cached data.  Graphs are generated only if the cache has expired.
+module QaServer
+  class PerformanceMonthlyGraphCache
+    class_attribute :authority_list_class, :graph_data_service, :graphing_service
+    self.authority_list_class = QaServer::AuthorityListerService
+    self.graph_data_service = QaServer::PerformanceGraphDataService
+    self.graphing_service = QaServer::PerformanceGraphingService
+
+    class << self
+      include QaServer::CacheKeys
+      include QaServer::PerformanceHistoryDataKeys
+
+      # Generates graphs for the past 30 days for :search, :fetch, and :all actions for each authority.
+      # @param force [Boolean] if true, run the tests even if the cache hasn't expired; otherwise, use cache if not expired
+      def generate_graphs(force: false)
+        return unless QaServer::CacheExpiryService.cache_expired?(key: cache_key_for_force, force: force, next_expiry: next_expiry)
+        QaServer.config.monitor_logger.debug("(QaServer::PerformanceMonthlyGraphCache) - GENERATING monthly performance graphs (force: #{force})")
+        generate_graphs_for_authorities
+      end
+
+      private
+
+        def generate_graphs_for_authorities
+          auths = authority_list_class.authorities_list
+          generate_graphs_for_authority(authority_name: ALL_AUTH) # generates graph for all authorities
+          auths.each { |authname| generate_graphs_for_authority(authority_name: authname) }
+        end
+
+        def generate_graphs_for_authority(authority_name:)
+          [SEARCH, FETCH, ALL_ACTIONS].each_with_object({}) do |action, hash|
+            hash[action] = generate_12_month_graph(authority_name: authority_name, action: action)
+          end
+        end
+
+        def generate_12_month_graph(authority_name:, action:)
+          # real expiration or force caught by cache_expired?  So if we are here, either the cache has expired
+          # or force was requested.  We still expire the cache and use ttl to catch race conditions.
+          Rails.cache.fetch(cache_key_for_authority_action(authority_name: authority_name, action: action),
+                            expires_in: next_expiry, race_condition_ttl: 1.hour, force: true) do
+            data = graph_data_service.calculate_last_12_months(authority_name: authority_name, action: action)
+            graphing_service.generate_monthly_graph(authority_name: authority_name, action: action, data: data)
+            data
+          end
+        end
+
+        def cache_key_for_authority_action(authority_name:, action:)
+          "#{PERFORMANCE_GRAPH_MONTHLY_DATA_CACHE_KEY}--#{authority_name}--#{action}"
+        end
+
+        def cache_key_for_force
+          "#{PERFORMANCE_GRAPH_MONTHLY_DATA_CACHE_KEY}--force"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/scenario_history_cache.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# Maintain a cache of data for Authority Connection History table displayed on Monitor Status page
+module QaServer
+  class ScenarioHistoryCache
+    class_attribute :scenario_history_class
+    self.scenario_history_class = QaServer::ScenarioRunHistory
+
+    class << self
+      include QaServer::CacheKeys
+
+      # Get a summary of the number of days passing/failing for scenario runs during configured time period
+      # @param force [Boolean] if true, run the tests even if the cache hasn't expired; otherwise, use cache if not expired
+      # @returns [Array<Hash>] count of days with passing/failing tests for each authority
+      # @example [auth_name, failing, passing]
+      #   { 'agrovoc' => { good: 31, bad: 2 },
+      #     'geonames_ld4l_cache' => { good: 32, bad: 1 } }
+      def historical_summary(force: false)
+        Rails.cache.fetch(cache_key_for_historical_data, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: force) do
+          QaServer.config.monitor_logger.debug("(QaServer::ScenarioHistoryCache) - CALCULATING HISTORY of scenario runs (force: force)")
+          scenario_history_class.historical_summary
+        end
+      end
+
+      private
+
+        def cache_key_for_historical_data
+          SCENARIO_RUN_HISTORY_DATA_CACHE_KEY
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/scenario_run_cache.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# Maintain a cache controlling the execution of scenario tests.
+module QaServer
+  class ScenarioRunCache
+    class << self
+      include QaServer::CacheKeys
+
+      # Run connection tests
+      def run_tests(force: false)
+        Rails.cache.fetch(cache_key_for_running_tests, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: force) do
+          QaServer.config.monitor_logger.debug("(QaServer::ScenarioRunCache) - KICKING OFF TEST RUN (force: #{force})")
+          QaServer::MonitorTestsJob.perform_later
+          "Test run initiated at #{QaServer::TimeService.current_time}"
+        end
+      end
+
+      private
+
+        def cache_key_for_running_tests
+          SCENARIO_RUN_TEST_DATA_CACHE_KEY
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/scenario_run_failures_cache.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# Maintain a cache of failure data for scenario runs
+module QaServer
+  class ScenarioRunFailuresCache
+    class_attribute :scenario_history_class
+    self.scenario_history_class = QaServer::ScenarioRunHistory
+
+    class << self
+      include QaServer::CacheKeys
+
+      # Set of failures for a run
+      # @param run [QaServer::ScenarioRunRegistry]
+      # @returns [Array<Hash>] details for any failing scenarios in the run
+      # @example
+      #   [ { status: :bad,
+      #       authority_name: "geonames_ld4l_cache",
+      #       subauthority_name: "area",
+      #       service: "ld4l_cache",
+      #       action: "search",
+      #       url: "/qa/search/linked_data/geonames_ld4l_cache/area?q=France&maxRecords=4",
+      #       err_message: "Unable to connect to authority",
+      #       scenario_type: :connection
+      #       run_time: 11.2 },
+      #     { status: :unknown,
+      #       authority_name: "oclcfast_ld4l_cache",
+      #       subauthority_name: "Person",
+      #       service: "ld4l_cache",
+      #       action: "search",
+      #       url: "/qa/search/linked_data/oclcfast_ld4l_cache/person?q=mark twain&maxRecords=4",
+      #       err_message: "Not enough search results returned",
+      #       scenario_type: :connection
+      #       run_time: 0.123 } ]
+      def failures_for_run(run:)
+        Rails.cache.fetch(cache_key_for_run_failures(run.id), expires_in: next_expiry, race_condition_ttl: 30.seconds) do
+          QaServer.config.monitor_logger.debug("(QaServer::ScenarioRunFailuresCache) - CALCULATING FAILURES for scenario run #{run.id}")
+          scenario_history_class.run_failures(run_id: run.id)
+        end
+      end
+
+      private
+
+        def cache_key_for_run_failures(id)
+          "#{SCENARIO_RUN_FAILURE_DATA_CACHE_KEY}--#{id}{"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/scenario_run_summary_cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# Maintain a cache of summary test data for scenario runs
+module QaServer
+  class ScenarioRunSummaryCache
+    class_attribute :scenario_history_class
+    self.scenario_history_class = QaServer::ScenarioRunHistory
+
+    class << self
+      include QaServer::CacheKeys
+
+      # Summary for a run
+      # @param run [QaServer::ScenarioRunRegistry]
+      # @returns [QaServer::ScenarioRunSummary] statistics on the requested run
+      # @example ScenarioRunSummary includes methods for accessing
+      #   * run_id           [Integer] e.g. 14
+      #   * run_dt_stamp     [ActiveSupport::TimeWithZone] e.g. Wed, 19 Feb 2020 16:01:07 UTC +00:00
+      #   * authority_count  [Integer] e.g. 22
+      #   * failing_authority_count [Integer] e.g. 1
+      #   * passing_scenario_count  [Integer] e.g. 156
+      #   * failing_scenario_count  [Integer] e.g. 3
+      #   * total_scenario_count    [Integer] e.g. 159
+      def summary_for_run(run:)
+        Rails.cache.fetch(cache_key_for_run_summary(run.id), expires_in: next_expiry, race_condition_ttl: 30.seconds) do
+          QaServer.config.monitor_logger.debug("(QaServer::ScenarioRunSummaryCache) - CALCULATING SUMMARY for scenario run #{run.id}")
+          scenario_history_class.run_summary(scenario_run: run)
+        end
+      end
+
+      private
+
+        def cache_key_for_run_summary(id)
+          "#{SCENARIO_RUN_SUMMARY_DATA_CACHE_KEY}--#{id}"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/controllers/qa_server/monitor_status_controller.rb

@@ -7,78 +7,63 @@ module QaServer
     include QaServer::AuthorityValidationBehavior
 
     class_attribute :presenter_class,
-                    :scenario_run_registry_class,
-                    :scenario_history_class,
-                    :performance_history_class,
-                    :graphing_service_class
+                    :scenario_run_registry_class
     self.presenter_class = QaServer::MonitorStatusPresenter
     self.scenario_run_registry_class = QaServer::ScenarioRunRegistry
-    self.scenario_history_class = QaServer::ScenarioRunHistory
-    self.performance_history_class = QaServer::PerformanceHistory
-    self.graphing_service_class = QaServer::PerformanceGraphingService
 
     # Sets up presenter with data to display in the UI
     def index
       log_header
-      latest_test_run
+      update_tests
+      update_performance_graphs
       commit_cache if commit_cache?
       @presenter = presenter_class.new(current_summary: latest_summary,
                                        current_failure_data: latest_failures,
                                        historical_summary_data: historical_data,
                                        performance_data: performance_table_data)
-      update_performance_graphs
-      QaServer.config.monitor_logger.debug("(#{self.class}##{__method__}) DONE rendering")
+      QaServer.config.monitor_logger.debug("~~~~~~~~ DONE rendering monitor status")
       render 'index', status: :internal_server_error if latest_summary.failing_authority_count.positive?
     end
 
     private
 
-      # Sets @latest_test_run [QaServer::ScenarioRunRegistry]
-      def latest_test_run
-        @latest_test_run ||= latest_test_run_from_cache
+      def update_tests
+        QaServer::ScenarioRunCache.run_tests(force: refresh_tests?)
       end
 
-      # cache of latest run; runs tests if cache is expired
-      # @see #latest_test_run_from_temp_cache
-      def latest_test_run_from_cache
-        Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 5.minutes, force: refresh_tests?) do
-          QaServer.config.monitor_logger.debug("(#{self.class}##{__method__}) get latest run of monitoring tests - cache expired or refresh requested (force: #{refresh_tests?})")
-          QaServer::MonitorTestsJob.perform_later
-          scenario_run_registry_class.latest_run
-        end
+      # Sets @latest_test_run [QaServer::ScenarioRunRegistry]
+      def latest_test_run
+        @latest_test_run ||= scenario_run_registry_class.latest_run
       end
 
-      # Sets @latest_summary [QaServer::ScenarioRunSummary]
+      # @returns [QaServer::ScenarioRunSummary] summary statistics on the latest run
       def latest_summary
-        scenario_history_class.run_summary(scenario_run: latest_test_run, force: refresh_tests?)
+        QaServer::ScenarioRunSummaryCache.summary_for_run(run: latest_test_run)
       end
 
+      # @returns [Array<Hash>] scenario details for any failing scenarios in the latest run
+      # @see QaServer::ScenarioRunHistory#run_failures for structure of output
       def latest_failures
-        scenario_history_class.run_failures(run_id: latest_test_run.id, force: refresh_tests?)
+        QaServer::ScenarioRunFailuresCache.failures_for_run(run: latest_test_run)
       end
 
-      # Sets @historical_data [Array<Hash>]
+      # Get a summary level of historical data
+      # @returns [Array<Hash>] summary of passing/failing tests for each authority
+      # @see QaServer::ScenarioRunHistory#historical_summary for structure of output
       def historical_data
-        scenario_history_class.historical_summary(force: refresh_history?)
+        QaServer::ScenarioHistoryCache.historical_summary(force: refresh_history?)
       end
 
-      # Sets @performance_table_data [Hash<Hash>]
       def performance_table_data
-        display_performance_datatable? ? performance_history_class.performance_table_data(force: refresh_performance?) : {}
+        return {} unless QaServer.config.display_performance_graph?
+        QaServer::PerformanceDatatableCache.data(force: refresh_performance_table?)
       end
 
       def update_performance_graphs
-        return unless display_performance_graph?
-        data = performance_history_class.performance_graph_data(force: refresh_performance?)
-        graphing_service_class.create_performance_graphs(performance_data: data)
-      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?
+        return unless QaServer.config.display_performance_graph?
+        QaServer::PerformanceHourlyGraphCache.generate_graphs(force: refresh_performance_graphs?)
+        QaServer::PerformanceDailyGraphCache.generate_graphs(force: refresh_performance_graphs?)
+        QaServer::PerformanceMonthlyGraphCache.generate_graphs(force: refresh_performance_graphs?)
       end
 
       def refresh?
@@ -91,18 +76,23 @@ module QaServer
       end
 
       def refresh_tests?
-        return false unless refresh?
-        refresh_all? || params[:refresh].casecmp?('tests')
+        refresh? ? (refresh_all? || params[:refresh].casecmp?('tests')) : false
       end
 
       def refresh_history?
-        return false unless refresh?
-        refresh_all? || params[:refresh].casecmp?('history')
+        refresh? ? (refresh_all? || params[:refresh].casecmp?('history')) : false
       end
 
       def refresh_performance?
-        return false unless refresh?
-        refresh_all? || params[:refresh].casecmp?('performance')
+        refresh? ? (refresh_all? || params[:refresh].casecmp?('performance')) : false
+      end
+
+      def refresh_performance_table?
+        refresh? ? (refresh_performance? || params[:refresh].casecmp?('performance_table')) : false
+      end
+
+      def refresh_performance_graphs?
+        refresh? ? (refresh_performance? || params[:refresh].casecmp?('performance_graphs')) : false
       end
 
       def commit_cache?
@@ -124,9 +114,10 @@ module QaServer
       end
 
       def log_header
-        QaServer.config.monitor_logger.debug("-------------------------------------  monitor status  ---------------------------------")
-        QaServer.config.monitor_logger.debug("(#{self.class}##{__method__}) monitor status page request (refresh_tests? # #{refresh_tests?}, " \
-                                             "refresh_history? # #{refresh_history?}, refresh_performance? # #{refresh_performance?})")
+        QaServer.config.monitor_logger.debug("------------------------------------  monitor status  -----------------------------------")
+        QaServer.config.monitor_logger.debug("refresh_all? #{refresh_all?}, refresh_tests? #{refresh_tests?}, refresh_history? #{refresh_history?}")
+        QaServer.config.monitor_logger.debug("refresh_performance? #{refresh_performance?}, refresh_performance_table? #{refresh_performance_table?}, " \
+                                             "refresh_performance_graphs? #{refresh_performance_graphs?})")
       end
   end
 end

data/app/jobs/qa_server/monitor_tests_job.rb

@@ -10,7 +10,7 @@ module QaServer
     self.scenario_run_registry_class = QaServer::ScenarioRunRegistry
 
     def perform
-      Rails.cache.fetch("QaServer::MonitorStatusController/latest_test_run_from_cache", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 5.minutes, force: true) do
+      Rails.cache.fetch("QaServer::MonitorStatusController/latest_test_run_from_cache", expires_in: QaServer::CacheExpiryService.cache_expiry, race_condition_ttl: 5.minutes, force: true) do
         job_id = SecureRandom.uuid
         monitor_tests_job_id = job_id unless monitor_tests_job_id
         run_tests if monitor_tests_job_id == job_id # avoid race conditions