qa_server 7.2.1 → 7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a11e25bb0e1f04c1f4d6a9e1970f1cb438fc752
-  data.tar.gz: 4a97306cce9c2b6dff9a4e417db000a06c79f3e5
+  metadata.gz: fd13388cd52b97f47cbc007512409654b26e4742
+  data.tar.gz: 2e7fd2e75b65e662460c334cb9c87a39bb246e9e
 SHA512:
-  metadata.gz: c8902939fc36473dbbf7979d0166f72d8e05912ad8b1713268cbe9297f9cfe5c0d01f96cb7b248864c6952c9c9430a061702e783eb37b2536bacc318e04ef637
-  data.tar.gz: f831642e258fa4d658b283151b73d792242f999629febf58f8f82297b0bed98df5641a4cf03158ffcb689c50438e716ef54734d4bac8182a3be7a8c21cde17c6
+  metadata.gz: cc1aff80d3bf495a4dbedc6fdef33ec4e580f38d3e9953048ac5a991e550b807e5a772059a7ef934cada9243506ef48ef717ef973419a8b0bce8b1aae38de480
+  data.tar.gz: aa8a277abc68f7db17bec6653990e5c3476e89d0860f670cf99f846cb82e26b76c187502c7bd059781a9212596184fd97654363b0b8be885cea29c1088fb94c2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 7.3.0 (2020-04-08)
+
+* move generation of graphs to background jobs
+
 ### 7.2.1 (2020-02-23)
 
 * fix graph fails generation when any label is empty string

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

@@ -2,15 +2,10 @@
 # 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"
-    SCENARIO_RUN_HISTORY_GRAPH_CACHE_KEY = "QaServer--CacheKeys--scenario_run_history_graph"
 
     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

@@ -8,6 +8,11 @@ module QaServer
         cache_expires_at - QaServer::TimeService.current_time
       end
 
+      def end_of_hour_expiry
+        ct = QaServer::TimeService.current_time
+        ct.end_of_hour - ct
+      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

data/app/cache_processors/qa_server/job_id_cache.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# Provide service methods for getting a list of all authorities and scenarios for an authority.
+module QaServer
+  class JobIdCache
+    class << self
+      # Is the passed in job_id the active one for the job_key?
+      # @param job_key [String] key unique to the job being run (e.g. "QaServer::Jobs::MonitorTestsJob")
+      # @param job_id [String] UUID for job running the tests
+      # @param expires_in [ActiveSupport::Duration]  This should be at least as long as the expected job run time to avoid multiple instances of the job running at the same time.
+      # @note When job completes, call reset_job_id to invalidate the cache
+      def active_job_id?(job_key:, job_id:, expires_in: 30.minutes)
+        cached_job_id = Rails.cache.fetch(cache_key(job_key), expires_in: expires_in, race_condition_ttl: 5.minutes) { job_id }
+        cached_job_id == job_id
+      end
+
+      # Delete cache for job id for the job represented by job_key.  Call this when the job completes.
+      # @param job_key [String] key unique to the job being run (e.g. "QaServer::Jobs::MonitorTestsJob")
+      def reset_job_id(job_key:)
+        Rails.cache.delete(cache_key(job_key))
+      end
+
+      private
+
+        def cache_key(job_key)
+          "#{job_key}-job_id"
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/performance_day_graph_cache.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# Cache the datetime_stamp of the last time the performance day graph was generated.  Calls job to generate the graph if expired.
+module QaServer
+  class PerformanceDayGraphCache
+    class << self
+      # 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)
+        Rails.cache.fetch(cache_key, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: force) do
+          QaServer.config.monitor_logger.debug("(QaServer::PerformanceDayGraphCache) - KICKING OFF PERFORMANCE DAY GRAPH GENERATION (force: #{force})")
+          QaServer::PerformanceDayGraphJob.perform_later
+          "Graphs generation initiated at #{QaServer::TimeService.current_time}"
+        end
+      end
+
+      private
+
+        def cache_key
+          "QaServer::PerformanceDayGraphCache.generate_graphs--latest_generation_initiated"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.end_of_hour_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/performance_month_graph_cache.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# Cache the datetime_stamp of the last time the performance month graph was generated.  Calls job to generate the graph if expired.
+module QaServer
+  class PerformanceMonthGraphCache
+    class << self
+      # 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)
+        Rails.cache.fetch(cache_key, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: force) do
+          QaServer.config.monitor_logger.debug("(QaServer::PerformanceMonthGraphCache) - KICKING OFF PERFORMANCE MONTH GRAPH GENERATION (force: #{force})")
+          QaServer::PerformanceMonthGraphJob.perform_later
+          "Graphs generation initiated at #{QaServer::TimeService.current_time}"
+        end
+      end
+
+      private
+
+        def cache_key
+          "QaServer::PerformanceMonthGraphCache.generate_graphs--latest_generation_initiated"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/performance_year_graph_cache.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# Cache the datetime_stamp of the last time the performance year graph was generated.  Calls job to generate the graph if expired.
+module QaServer
+  class PerformanceYearGraphCache
+    class << self
+      # Generates graphs for the 12 months 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)
+        Rails.cache.fetch(cache_key, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: force) do
+          QaServer.config.monitor_logger.debug("(QaServer::PerformanceYearGraphCache) - KICKING OFF PERFORMANCE YEAR GRAPH GENERATION (force: #{force})")
+          QaServer::PerformanceYearGraphJob.perform_later
+          "Graphs generation initiated at #{QaServer::TimeService.current_time}"
+        end
+      end
+
+      private
+
+        def cache_key
+          "QaServer::PerformanceYearGraphCache.generate_graphs--latest_generation_initiated"
+        end
+
+        def next_expiry
+          QaServer::CacheExpiryService.cache_expiry
+        end
+    end
+  end
+end

data/app/cache_processors/qa_server/scenario_history_graph_cache.rb

@@ -2,26 +2,21 @@
 # Generate graphs for the past 30 days using cached data.  Graphs are generated only if the cache has expired.
 module QaServer
   class ScenarioHistoryGraphCache
-    class_attribute :graphing_service
-    self.graphing_service = QaServer::HistoryGraphingService
-
     class << self
-      include QaServer::CacheKeys
-
-      HISTORICAL_GRAPH_FILENAME = 'historical_side_stacked_bar.png'
-
       # 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_graph(data:, 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::ScenarioHistoryGraphCache) - GENERATING historical summary graph (force: #{force})")
-        graphing_service.generate_graph(data)
+        Rails.cache.fetch(cache_key, expires_in: next_expiry, race_condition_ttl: 30.seconds, force: force) do
+          QaServer.config.monitor_logger.debug("(QaServer::ScenarioHistoryGraphCache) - KICKING OFF HISTORY GRAPH GENERATION (force: #{force})")
+          QaServer::HistoryGraphJob.perform_later(data: data)
+          "Graph generation initiated at #{QaServer::TimeService.current_time}"
+        end
       end
 
       private
 
-        def cache_key_for_force
-          "#{SCENARIO_RUN_HISTORY_GRAPH_CACHE_KEY}--force"
+        def cache_key
+          "QaServer::ScenarioHistoryGraphCache.generate_graph--latest_generation_initiated"
         end
 
         def next_expiry

data/app/cache_processors/qa_server/scenario_run_cache.rb

@@ -7,7 +7,7 @@ module QaServer
 
       # 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
+        Rails.cache.fetch(cache_key, 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}"
@@ -16,8 +16,8 @@ module QaServer
 
       private
 
-        def cache_key_for_running_tests
-          SCENARIO_RUN_TEST_DATA_CACHE_KEY
+        def cache_key
+          "QaServer::ScenarioRunCache.run_tests--latest_run_initiated"
         end
 
         def next_expiry

data/app/controllers/qa_server/monitor_status_controller.rb

@@ -71,9 +71,9 @@ module QaServer
 
       def update_performance_graphs
         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?)
+        QaServer::PerformanceDayGraphCache.generate_graphs(force: refresh_performance_graphs?)
+        QaServer::PerformanceMonthGraphCache.generate_graphs(force: refresh_performance_graphs?)
+        QaServer::PerformanceYearGraphCache.generate_graphs(force: refresh_performance_graphs?)
       end
 
       def refresh?

data/app/jobs/qa_server/history_graph_job.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# Job to generate the graph of historical test runs per authority.
+module QaServer
+  class HistoryGraphJob < ApplicationJob
+    queue_as :default
+
+    class_attribute :graphing_service
+    self.graphing_service = QaServer::HistoryGraphingService
+
+    def perform(data:)
+      # checking active_job_id? prevents race conditions for long running jobs
+      generate_graph(data) if QaServer::JobIdCache.active_job_id?(job_key: job_key, job_id: job_id)
+    end
+
+    private
+
+      def generate_graph(data)
+        QaServer.config.monitor_logger.debug("(#{self.class}##{__method__}-#{job_id}) - GENERATING historical summary graph")
+        graphing_service.generate_graph(data)
+        QaServer.config.monitor_logger.debug("(#{self.class}##{__method__}-#{job_id}) COMPLETED historical summary graph generation")
+        QaServer::JobIdCache.reset_job_id(job_key: job_key)
+      end
+
+      def job_key
+        "QaServer::HistoryGraphJob--job_id"
+      end
+  end
+end

data/app/jobs/qa_server/monitor_tests_job.rb

@@ -10,12 +10,8 @@ module QaServer
     self.scenario_run_registry_class = QaServer::ScenarioRunRegistry
 
     def perform
-      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
-        scenario_run_registry_class.latest_run
-      end
+      # checking active_job_id? prevents race conditions for long running jobs
+      run_tests if QaServer::JobIdCache.active_job_id?(job_key: job_key, job_id: job_id, expires_in: 2.hours)
     end
 
     private
@@ -27,32 +23,16 @@ module QaServer
         scenario_run_registry_class.save_run(scenarios_results: status_log.to_a)
         QaServer.config.monitor_logger.debug("(#{self.class}##{__method__}-#{job_id}) COMPLETED monitoring tests")
         QaServer.config.performance_cache.write_all # write out cache after completing tests
-        reset_monitor_tests_job_id
-      end
-
-      # @return [String, Boolean] Returns job id of the job currently running tests; otherwise, false if tests are not running
-      def monitor_tests_job_id
-        Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 5.minutes) { false }
-      end
-
-      # Set the id of the job that will run the tests.
-      # @param job_id [String] UUID for job running the tests
-      def monitor_tests_job_id=(job_id)
-        # check to see if there is a current job already running tests
-        current_job_id = Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 5.seconds) { job_id }
-
-        # current_job_id may be false meaning tests are not currently running; in which case, it is ok to force set job_id
-        Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 30.seconds, force: true) { job_id } unless current_job_id
-      end
-
-      # Set job id for monitor tests to false indicating that tests are not currently running
-      def reset_monitor_tests_job_id
-        Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 30.seconds, force: true) { false }
+        QaServer::JobIdCache.reset_job_id(job_key: job_key)
       end
 
       def log_results(authorities_list, results)
         QaServer.config.monitor_logger.warn("(#{self.class}##{__method__}-#{job_id}) authorities_list is empty") if authorities_list&.empty?
         QaServer.config.monitor_logger.warn("(#{self.class}##{__method__}-#{job_id}) test results are empty") if results&.empty?
       end
+
+      def job_key
+        "QaServer::MonitorTestsJob--job_id"
+      end
   end
 end

data/app/jobs/qa_server/performance_day_graph_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+# Job to generate the performance day graph covering the last 24 hours.
+module QaServer
+  class PerformanceDayGraphJob < ApplicationJob
+    include QaServer::PerformanceHistoryDataKeys
+
+    queue_as :default
+
+    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
+
+    def perform
+      # checking active_job_id? prevents race conditions for long running jobs
+      generate_graphs_for_authorities if QaServer::JobIdCache.active_job_id?(job_key: job_key, job_id: job_id)
+    end
+
+    private
+
+      def generate_graphs_for_authorities
+        QaServer.config.monitor_logger.debug("(#{self.class}-#{job_id}) - GENERATING performance day graph")
+        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) }
+        QaServer.config.monitor_logger.debug("(#{self.class}-#{job_id}) COMPLETED performance day graph generation")
+        QaServer::JobIdCache.reset_job_id(job_key: job_key)
+      end
+
+      def generate_graphs_for_authority(authority_name:)
+        [SEARCH, FETCH, ALL_ACTIONS].each_with_object({}) do |action, hash|
+          hash[action] = generate_24_hour_graph(authority_name: authority_name, action: action)
+        end
+      end
+
+      def generate_24_hour_graph(authority_name:, action:)
+        data = graph_data_service.calculate_last_24_hours(authority_name: authority_name, action: action)
+        graphing_service.generate_day_graph(authority_name: authority_name, action: action, data: data)
+      end
+
+      def job_key
+        "QaServer::PerformanceDayGraphJob--job_id"
+      end
+  end
+end

data/app/jobs/qa_server/performance_month_graph_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+# Job to generate the performance month graph covering the last 30 days.
+module QaServer
+  class PerformanceMonthGraphJob < ApplicationJob
+    include QaServer::PerformanceHistoryDataKeys
+
+    queue_as :default
+
+    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
+
+    def perform
+      # checking active_job_id? prevents race conditions for long running jobs
+      generate_graphs_for_authorities if QaServer::JobIdCache.active_job_id?(job_key: job_key, job_id: job_id)
+    end
+
+    private
+
+      def generate_graphs_for_authorities
+        QaServer.config.monitor_logger.debug("(#{self.class}-#{job_id}) - GENERATING performance month graph")
+        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) }
+        QaServer.config.monitor_logger.debug("(#{self.class}-#{job_id}) COMPLETED performance month graph generation")
+        QaServer::JobIdCache.reset_job_id(job_key: job_key)
+      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:)
+        data = graph_data_service.calculate_last_30_days(authority_name: authority_name, action: action)
+        graphing_service.generate_month_graph(authority_name: authority_name, action: action, data: data)
+      end
+
+      def job_key
+        "QaServer::PerformanceMonthGraphJob--job_id"
+      end
+  end
+end

data/app/jobs/qa_server/performance_year_graph_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+# Job to generate the performance year graph covering the last 12 months.
+module QaServer
+  class PerformanceYearGraphJob < ApplicationJob
+    include QaServer::PerformanceHistoryDataKeys
+
+    queue_as :default
+
+    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
+
+    def perform
+      # checking active_job_id? prevents race conditions for long running jobs
+      generate_graphs_for_authorities if QaServer::JobIdCache.active_job_id?(job_key: job_key, job_id: job_id)
+    end
+
+    private
+
+      def generate_graphs_for_authorities
+        QaServer.config.monitor_logger.debug("(#{self.class}-#{job_id}) - GENERATING performance year graph")
+        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) }
+        QaServer.config.monitor_logger.debug("(#{self.class}-#{job_id}) COMPLETED performance year graph generation")
+        QaServer::JobIdCache.reset_job_id(job_key: job_key)
+      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:)
+        data = graph_data_service.calculate_last_12_months(authority_name: authority_name, action: action)
+        graphing_service.generate_year_graph(authority_name: authority_name, action: action, data: data)
+      end
+
+      def job_key
+        "QaServer::PerformanceYearGraphJob--job_id"
+      end
+  end
+end

data/app/services/qa_server/performance_graph_data_service.rb

@@ -73,7 +73,7 @@ module QaServer
       # @param authority_name [String] name of an authority
       # @param action [Symbol] :search, :fetch, or :all_actions
       # @param averages [Hash] existing data for each hour
-      # @returns [Hash] existing hourly data with the last hour updated
+      # @returns [Hash] existing day data with the last hour updated
       # @example returns
       #   { 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. }},

data/app/services/qa_server/performance_graphing_service.rb

@@ -31,7 +31,7 @@ module QaServer
       # @param action [Symbol] action performed by the request (e.g. :search, :fetch, :all_actions)
       # @param data [Hash] data to use to generate the graph
       # @see QaServer::PerformanceGraphDataService.calculate_last_12_months
-      def generate_monthly_graph(authority_name: ALL_AUTH, action:, data:)
+      def generate_year_graph(authority_name: ALL_AUTH, action:, data:)
         gruff_data = rework_performance_data_for_gruff(data, BY_MONTH)
         create_gruff_graph(gruff_data,
                            performance_graph_full_path(authority_name, action, FOR_YEAR),
@@ -44,7 +44,7 @@ module QaServer
       # @param action [Symbol] action performed by the request (e.g. :search, :fetch, :all_actions)
       # @param data [Hash] data to use to generate the graph
       # @see QaServer::PerformanceGraphDataService.calculate_last_30_days
-      def generate_daily_graph(authority_name: ALL_AUTH, action:, data:)
+      def generate_month_graph(authority_name: ALL_AUTH, action:, data:)
         gruff_data = rework_performance_data_for_gruff(data, BY_DAY)
         create_gruff_graph(gruff_data,
                            performance_graph_full_path(authority_name, action, FOR_MONTH),
@@ -56,7 +56,7 @@ module QaServer
       # @param action [Symbol] action performed by the request (e.g. :search, :fetch, :all_actions)
       # @param data [Hash] data to use to generate the graph
       # @see QaServer::PerformanceGraphDataService.calculate_last_24_hours
-      def generate_hourly_graph(authority_name: ALL_AUTH, action:, data:)
+      def generate_day_graph(authority_name: ALL_AUTH, action:, data:)
         gruff_data = rework_performance_data_for_gruff(data, BY_HOUR)
         create_gruff_graph(gruff_data,
                            performance_graph_full_path(authority_name, action, FOR_DAY),

data/lib/qa_server/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module QaServer
-  VERSION = '7.2.1'
+  VERSION = '7.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qa_server
 version: !ruby/object:Gem::Version
-  version: 7.2.1
+  version: 7.3.0
 platform: ruby
 authors:
 - E. Lynette Rayle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-23 00:00:00.000000000 Z
+date: 2020-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -340,11 +340,12 @@ files:
 - app/assets/stylesheets/qa_server/_usage.scss
 - app/cache_processors/concerns/qa_server/cache_keys.rb
 - app/cache_processors/qa_server/cache_expiry_service.rb
+- app/cache_processors/qa_server/job_id_cache.rb
 - app/cache_processors/qa_server/performance_cache.rb
-- app/cache_processors/qa_server/performance_daily_graph_cache.rb
 - app/cache_processors/qa_server/performance_datatable_cache.rb
-- app/cache_processors/qa_server/performance_hourly_graph_cache.rb
-- app/cache_processors/qa_server/performance_monthly_graph_cache.rb
+- app/cache_processors/qa_server/performance_day_graph_cache.rb
+- app/cache_processors/qa_server/performance_month_graph_cache.rb
+- app/cache_processors/qa_server/performance_year_graph_cache.rb
 - app/cache_processors/qa_server/scenario_history_cache.rb
 - app/cache_processors/qa_server/scenario_history_graph_cache.rb
 - app/cache_processors/qa_server/scenario_run_cache.rb
@@ -357,7 +358,11 @@ files:
 - app/controllers/qa_server/homepage_controller.rb
 - app/controllers/qa_server/monitor_status_controller.rb
 - app/controllers/qa_server/usage_controller.rb
+- app/jobs/qa_server/history_graph_job.rb
 - app/jobs/qa_server/monitor_tests_job.rb
+- app/jobs/qa_server/performance_day_graph_job.rb
+- app/jobs/qa_server/performance_month_graph_job.rb
+- app/jobs/qa_server/performance_year_graph_job.rb
 - app/loggers/qa_server/scenario_logger.rb
 - app/models/concerns/qa_server/performance_history_data_keys.rb
 - app/models/qa_server/authority_scenario.rb

data/app/cache_processors/qa_server/performance_daily_graph_cache.rb

@@ -1,60 +0,0 @@
-# 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_hourly_graph_cache.rb

@@ -1,65 +0,0 @@
-# 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

@@ -1,60 +0,0 @@
-# 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