qa_server 5.4.0 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab89fc6147c1cf32de828a8b2cecaab3ca66b296
-  data.tar.gz: 027160d4a1e0f0090a1c6d81cfdcd74fba5d1423
+  metadata.gz: cfe60b29f718a16c9c86b62e0bd7807c746147b1
+  data.tar.gz: 51dc3758debb4b924b7859ca82f9ed49eb3475a6
 SHA512:
-  metadata.gz: aa48a9de27b5b612d590981dfbb9f4316f496a6ecee810bc25735f7ffd1d5fc73c4a6e9f63af65aaeb767a35d983a9c3680ab1cd27b5558ef7b4c11958d73efe
-  data.tar.gz: 12c86bbeb3d41de071788f93fdfd3ef632a1300c77182a114124a5fd5895ac733e0c4f76b72e973a3cd7b5a691224b2fb7be21b2651e04a0a935ad283ca8a973
+  metadata.gz: 56e1811a7ee5b562a3e24d77fecba594955b5410824863a0745f895b2541d5d735e21c33b29b33047c4cb1d257489dc498d9bdb774f097a74c64954c2c7e0da8
+  data.tar.gz: '084ba6a28a84a2a235c2cb69f2aed5285399ba2e3718135302a5dbf3c297a225407a348cbf6b87ef1705b5cc59016b1bd3ae49a7b0947dda28c215961f9e0f9a'

data/.rubocop.yml

@@ -22,3 +22,7 @@ Metrics/BlockLength:
   Exclude:
     - 'qa_server.gemspec'
     - 'spec/**/*.rb'
+
+Metrics/ClassLength:
+  Exclude:
+    - 'lib/qa_server/configuration.rb'

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 5.5.0 (2020-01-10)
+
+* use caching with expiry for monitor status page
+
 ### 5.4.0 (2020-01-07)
 
 * adds config hour_offset_to_expire_cache

data/app/controllers/qa_server/monitor_status_controller.rb

@@ -13,9 +13,7 @@ module QaServer
 
     # Sets up presenter with data to display in the UI
     def index
-      refresh_tests
-      historical_data = refresh_history
-      performance_data = refresh_performance
+      latest_run
       @presenter = presenter_class.new(current_summary: latest_summary,
                                        current_failure_data: latest_failures,
                                        historical_summary_data: historical_data,
@@ -25,49 +23,39 @@ module QaServer
 
     private
 
+      # Sets @latest_run [QaServer::ScenarioRunRegistry]
       def latest_run
-        @latest_run ||= scenario_run_registry_class.latest_run
+        Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: refresh_tests?) do
+          Rails.logger.info("#{self.class}##{__method__} - Running Tests - cache expired or refresh requested (#{refresh_tests?})")
+          validate(authorities_list)
+          scenario_run_registry_class.save_run(scenarios_results: status_log.to_a)
+          scenario_run_registry_class.latest_run
+        end
       end
 
+      # Sets @latest_summary [QaServer::ScenarioRunSummary]
       def latest_summary
-        @latest_summary ||= scenario_history_class.run_summary(scenario_run: latest_run)
+        scenario_history_class.run_summary(scenario_run: latest_run, force: refresh_tests?)
       end
 
       def latest_failures
-        @status_data ||= scenario_history_class.run_failures(run_id: latest_run.id)
-      end
-
-      def update_summary_and_data
-        scenario_run_registry_class.save_run(scenarios_results: status_log.to_a)
-        @latest_summary = nil # reset so next request recalculates
-        @latest_failures = nil # reset so next request recalculates
+        scenario_history_class.run_failures(run_id: latest_run.id, force: refresh_tests?)
       end
 
-      def expired?
-        @expired ||= latest_summary.blank? || latest_summary.run_dt_stamp < QaServer.monitoring_expires_at
-      end
-
-      def historical_summary_data(refresh: false)
-        # TODO: Make this refresh the same way performance data refreshes.
-        #       Requires historical graph to move out of presenter so it can be created here only with refresh.
-        if refresh
-          @historical_summary_data = scenario_history_class.historical_summary
-          # TODO: Need to recreate graph here.  And need to only read the graph in presenter.
-        end
-        @historical_summary_data ||= scenario_history_class.historical_summary
+      # Sets @historical_data [Array<Hash>]
+      def historical_data
+        scenario_history_class.historical_summary(force: refresh_history?)
       end
 
-      def performance_data(refresh: false)
-        datatype = performance_datatype(refresh)
-        return if datatype == :none
-        @performance_data = nil if refresh
-        @performance_data ||= performance_history_class.performance_data(datatype: datatype)
+      # Sets @performance_data [Hash<Hash>]
+      def performance_data
+        performance_history_class.performance_data(datatype: performance_datatype, force: refresh_performance?)
       end
 
-      def performance_datatype(refresh) # rubocop:disable Metrics/CyclomaticComplexity
-        return :all if display_performance_datatable? && display_performance_graph? && refresh
+      def performance_datatype
+        return :all if display_performance_datatable? && display_performance_graph?
         return :datatable if display_performance_datatable?
-        return :graph if display_performance_graph? && refresh
+        return :graph if display_performance_graph?
         :none
       end
 
@@ -79,12 +67,6 @@ module QaServer
         @display_performance_graph ||= QaServer.config.display_performance_graph?
       end
 
-      def refresh_tests
-        return unless refresh_tests?
-        validate(authorities_list)
-        update_summary_and_data
-      end
-
       def refresh_history
         historical_summary_data(refresh: refresh_history?)
       end
@@ -98,12 +80,13 @@ module QaServer
       end
 
       def refresh_all?
+        return false unless refresh?
         params[:refresh].nil? || params[:refresh].casecmp?('all') # nil is for backward compatibility
       end
 
       def refresh_tests?
-        return false unless refresh? || expired?
-        refresh_all? || params[:refresh].casecmp?('tests') || expired?
+        return false unless refresh?
+        refresh_all? || params[:refresh].casecmp?('tests')
       end
 
       def refresh_history?
@@ -112,8 +95,8 @@ module QaServer
       end
 
       def refresh_performance?
-        return false unless refresh? || expired?
-        refresh_all? || params[:refresh].casecmp?('performance') || expired?
+        return false unless refresh?
+        refresh_all? || params[:refresh].casecmp?('performance')
       end
   end
 end

data/app/models/qa_server/performance_cache.rb

@@ -41,6 +41,7 @@ module QaServer
     end
 
     def log(id:)
+      return if QaServer.config.suppress_logging_performance_datails
       Rails.logger.debug("*** performance data for id: #{id} ***")
       Rails.logger.debug(@cache[id].to_yaml)
     end

data/app/models/qa_server/performance_history.rb

@@ -64,10 +64,10 @@ module QaServer
       #     },
       #     AGROVOC_LD4L_CACHE: { ... # same data for each authority  }
       #   }
-      def performance_data(datatype: :datatable)
+      def performance_data(datatype: :datatable, force: false)
         return if datatype == :none
         QaServer.config.performance_cache.write_all
-        data = calculate_data(datatype)
+        data = calculate_data(datatype, force: force)
         graphing_service_class.create_performance_graphs(performance_data: data) if calculate_graphdata? datatype
         data
       end
@@ -82,23 +82,23 @@ module QaServer
           datatype == :graph || datatype == :all
         end
 
-        def calculate_data(datatype)
+        def calculate_data(datatype, force:)
           data = {}
           auths = authority_list_class.authorities_list
-          data[ALL_AUTH] = data_for_authority(datatype: datatype)
-          auths.each { |auth_name| data[auth_name] = data_for_authority(authority_name: auth_name, datatype: datatype) }
+          data[ALL_AUTH] = data_for_authority(datatype: datatype, force: force)
+          auths.each { |auth_name| data[auth_name] = data_for_authority(authority_name: auth_name, datatype: datatype, force: force) }
           data
         end
 
-        def data_for_authority(authority_name: nil, datatype:)
+        def data_for_authority(authority_name: nil, datatype:, force:)
           action_data = {}
           [:search, :fetch, :all_actions].each do |action|
             data = {}
-            data[FOR_DATATABLE] = data_table_stats(authority_name, action) if calculate_datatable?(datatype)
+            data[FOR_DATATABLE] = data_table_stats(authority_name, action, force: force) if calculate_datatable?(datatype)
             if calculate_graphdata?(datatype)
-              data[FOR_DAY] = graph_data_service_class.average_last_24_hours(authority_name: authority_name, action: action)
-              data[FOR_MONTH] = graph_data_service_class.average_last_30_days(authority_name: authority_name, action: action)
-              data[FOR_YEAR] = graph_data_service_class.average_last_12_months(authority_name: authority_name, action: action)
+              data[FOR_DAY] = graph_data_service_class.average_last_24_hours(authority_name: authority_name, action: action, force: force)
+              data[FOR_MONTH] = graph_data_service_class.average_last_30_days(authority_name: authority_name, action: action, force: force)
+              data[FOR_YEAR] = graph_data_service_class.average_last_12_months(authority_name: authority_name, action: action, force: force)
             end
             action_data[action] = data
           end
@@ -106,18 +106,23 @@ module QaServer
         end
 
         # Get statistics for all available data.
-        # @param [String] auth_name - limit statistics to records for the given authority (default: all authorities)
+        # @param auth_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 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_last_24_hours(auth_name) ||
-                    records_for_last_30_days(auth_name) ||
-                    records_for_last_12_months(auth_name) ||
-                    all_records(auth_name)
-          stats_calculator_class.new(records, action: action).calculate_stats(avg: true, low: true, high: true)
+        def data_table_stats(auth_name, action, force:)
+          Rails.cache.fetch("#{self.class}/#{__method__}/#{auth_name || ALL_AUTH}/#{action}/#{FOR_DATATABLE}", expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: force) do
+            Rails.logger.info("#{self.class}##{__method__} - calculating performance datatable stats - cache expired or refresh requested (#{force})")
+            records = records_for_last_24_hours(auth_name) ||
+                      records_for_last_30_days(auth_name) ||
+                      records_for_last_12_months(auth_name) ||
+                      all_records(auth_name)
+            stats_calculator_class.new(records, action: action).calculate_stats(avg: true, low: true, high: true)
+          end
         end
 
         def expected_time_period

data/app/models/qa_server/scenario_run_history.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 # Provide access to the scenario_results_history database table which tracks specific scenario runs over time.
 module QaServer
-  class ScenarioRunHistory < ActiveRecord::Base
+  class ScenarioRunHistory < ActiveRecord::Base # rubocop:disable Metrics/ClassLength
     self.table_name = 'scenario_run_history'
     belongs_to :scenario_run_registry
     enum scenario_type: [:connection, :accuracy, :performance], _suffix: :type
@@ -31,24 +31,28 @@ module QaServer
     end
 
     # Get a summary of passing/failing tests for a run.
-    # @param scenario_run [ScenarioRunRegistry] the run on which to gather statistics
-    # @returns [Hash] statistics on the requested run
-    # @example
-    #   { run_id: 14,
-    #     failing_count: 3,
-    #     passing_count: 156,
-    #     total_count: 159,
-    #     authority_count: 22,
-    #     failing_authority_count: 1 }
-    def self.run_summary(scenario_run:)
-      return nil unless scenario_run&.id
-      status = status_counts_in_run(run_id: scenario_run.id)
-      summary_class.new(run_id: scenario_run.id,
-                        run_dt_stamp: scenario_run.dt_stamp,
-                        authority_count: authorities_in_run(run_id: scenario_run.id).count,
-                        failing_authority_count: authorities_with_failures_in_run(run_id: scenario_run.id).count,
-                        passing_scenario_count: status['good'],
-                        failing_scenario_count: status['bad'] + status['unknown'])
+    # @param scenario_run [QaServer::ScenarioRunRegistry] the run on which to gather statistics
+    # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
+    # @returns [QaServer::ScenarioRunSummary] statistics on the requested run
+    # @example ScenarioRunSummary includes methods for accessing
+    #   * run_id: 14,
+    #   * run_dt_stamp:
+    #   * authority_count: 22,
+    #   * failing_authority_count: 1
+    #   * passing_scenario_count: 156,
+    #   * failing_scenario_count: 3,
+    #   * total_scenario_count: 159,
+    def self.run_summary(scenario_run:, force: false)
+      Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: force) do
+        Rails.logger.info("#{self.class}##{__method__} - creating summary of latest run - cache expired or refresh requested (#{force})")
+        status = status_counts_in_run(run_id: scenario_run.id)
+        summary_class.new(run_id: scenario_run.id,
+                          run_dt_stamp: scenario_run.dt_stamp,
+                          authority_count: authorities_in_run(run_id: scenario_run.id).count,
+                          failing_authority_count: authorities_with_failures_in_run(run_id: scenario_run.id).count,
+                          passing_scenario_count: status['good'],
+                          failing_scenario_count: status['bad'] + status['unknown'])
+      end
     end
 
     # Get set of all scenario results for a run.
@@ -85,6 +89,7 @@ module QaServer
     #       err_message: "Not enough search results returned",
     #       scenario_type: :connection
     #       run_time: 0.123 } ]
+    # @deprecated Not used anywhere. Being removed.
     def self.run_results(run_id:, authority_name: nil, status: nil, url: nil)
       return [] unless run_id
       where = {}
@@ -94,9 +99,11 @@ module QaServer
       where[:url] = url if url.present?
       QaServer::ScenarioRunHistory.where(where).to_a
     end
+    deprecation_deprecate run_results: "Not used anywhere. Being removed."
 
     # Get set of failures for a run, if any.
     # @param run_id [Integer] the run on which to gather statistics
+    # @param force [Boolean] if true, forces cache to regenerate; otherwise, returns value from cache unless expired
     # @returns [Array<Hash>] scenario details for any failing scenarios in the run
     # @example
     #   [ { status: :bad,
@@ -117,32 +124,43 @@ module QaServer
     #       err_message: "Not enough search results returned",
     #       scenario_type: :connection
     #       run_time: 0.123 } ]
-    def self.run_failures(run_id:)
+    def self.run_failures(run_id:, force: false)
       return [] unless run_id
-      QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: :good).to_a
+      Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: force) do
+        Rails.logger.info("#{self.class}##{__method__} - finding failures in latest run - cache expired or refresh requested (#{force})")
+        QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: :good).to_a
+      end
     end
 
     # Get a summary level of historical data
-    # @returns [Array<Hash>] scenario details for any failing scenarios in the run (auth_name, failing, passing)
-    # @example
+    # @returns [Array<Array>] summary of passing/failing tests for each authority
+    # @example [auth_name, failing, passing]
     #   [ [ 'agrovoc', 0, 24 ],
     #     [ 'geonames_ld4l_cache', 2, 22 ] ... ]
-    def self.historical_summary
-      runs = all_runs_per_authority
-      failures = failing_runs_per_authority
-      return [] unless runs.present?
-      data = []
-      runs.each do |auth_name, run_count|
-        auth_data = []
-        auth_data[0] = auth_name
-        failure_count = (failures.key? auth_name) ? failures[auth_name] : 0 # rubocop:disable Style/TernaryParentheses
-        auth_data[1] = failure_count
-        auth_data[2] = run_count - failure_count # passing
-        data << auth_data
+    def self.historical_summary(force: false)
+      Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour, force: force) do
+        Rails.logger.info("#{self.class}##{__method__} - calculating pass/fail per authority across all time - cache expired or refresh requested (#{force})")
+        runs = all_runs_per_authority
+        failures = failing_runs_per_authority
+        return [] unless runs.present?
+        data = []
+        runs.each do |auth_name, run_count|
+          data << pass_fail_stats_for_authority(failures, auth_name, run_count)
+        end
+        data
       end
-      data
     end
 
+    def self.pass_fail_stats_for_authority(failures, auth_name, run_count)
+      auth_data = []
+      auth_data[0] = auth_name
+      failure_count = failures.key?(auth_name) ? failures[auth_name] : 0
+      auth_data[1] = failure_count
+      auth_data[2] = run_count - failure_count # passing
+      auth_data
+    end
+    private_class_method :pass_fail_stats_for_authority
+
     def self.authorities_in_run(run_id:)
       QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).pluck(:authority_name).uniq
     end
@@ -153,6 +171,8 @@ module QaServer
     end
     private_class_method :authorities_with_failures_in_run
 
+    # @return [Hash] status counts across all authorities (used for current test summary)
+    # @example { "good" => 23, "bad" => 3, "unknown" => 0 }
     def self.status_counts_in_run(run_id:)
       status = QaServer::ScenarioRunHistory.group('status').where(scenario_run_registry_id: run_id).count
       status["good"] = 0 unless status.key? "good"

data/app/models/qa_server/scenario_run_registry.rb

@@ -5,7 +5,7 @@ module QaServer
     self.table_name = 'scenario_run_registry'
     has_many :scenario_run_history, foreign_key: :scenario_run_registry_id
 
-    # Get the latest saved run of scenarios.
+    # @return [ScenarioRunRegistry] registry data for latest run (e.g. id, dt_stamp)
     def self.latest_run
       return nil unless QaServer::ScenarioRunRegistry.last
       QaServer::ScenarioRunRegistry.last # Can we count on last to always be the one with the latest dt_stamp?
@@ -14,21 +14,27 @@ module QaServer
       # latest_run.id
     end
 
-    # Get the latest saved status.
+    # @return [Integer] id for latest test run
+    # @deprecated Not used anywhere. Being removed.
     def self.latest_run_id
       latest = latest_run
       return nil unless latest
       lastest.id
     end
+    deprecation_deprecate latest_run_id: "Not used anywhere. Being removed."
 
-    def self.save_run(scenarios_results:)
-      run = QaServer::ScenarioRunRegistry.create(dt_stamp: dt_stamp_now_et)
-      scenarios_results.each { |result| QaServer::ScenarioRunHistory.save_result(run_id: run.id, scenario_result: result) }
+    # @return [String] datetime stamp of first registered run
+    def self.first_run_dt
+      Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer.cache_expiry, race_condition_ttl: 1.hour) do
+        QaServer::ScenarioRunRegistry.first.dt_stamp.in_time_zone("Eastern Time (US & Canada)").strftime("%m/%d/%y - %I:%M %p")
+      end
     end
 
-    def self.dt_stamp_now_et
-      Time.now.in_time_zone("Eastern Time (US & Canada)")
+    # Register and save latest test run results
+    # @param scenarios_results [Array<Hash>] results of latest test run
+    def self.save_run(scenarios_results:)
+      run = QaServer::ScenarioRunRegistry.create(dt_stamp: QaServer.current_time)
+      scenarios_results.each { |result| QaServer::ScenarioRunHistory.save_result(run_id: run.id, scenario_result: result) }
     end
-    private_class_method :dt_stamp_now_et
   end
 end

data/app/models/qa_server/scenario_run_summary.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# Abstract class that parses the authority configuration from the yml file into the parts needed by inheriting scenario types.
+# Holds test run summary data providing methods for accessing each data point.
 module QaServer
   class ScenarioRunSummary
     # @return [Integer] the id of the scenario run being summarized

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 = Time.now.to_f
+    start_time_s = QaServer.current_time_s
 
     reader = RDF::Reader.open(real_url, { base_uri: real_url }.merge(options))
 
-    end_time_s = Time.now.to_f
+    end_time_s = QaServer.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 = Time.now.to_f
+    start_time_s = QaServer.current_time_s
 
     if graph_name
       statements = []
@@ -40,7 +40,7 @@ module PrependedRdf::RdfGraph
       nil
     end
 
-    end_time_s = Time.now.to_f
+    end_time_s = QaServer.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/qa_server/monitor_status/current_status_presenter.rb

@@ -16,7 +16,7 @@ module QaServer::MonitorStatus
 
     # @return [String] date of first recorded test run
     def first_updated
-      QaServer::ScenarioRunRegistry.first.dt_stamp.in_time_zone("Eastern Time (US & Canada)").strftime("%m/%d/%y - %I:%M %p")
+      QaServer::ScenarioRunRegistry.first_run_dt
     end
 
     # @return [Integer] number of loaded authorities

data/app/services/qa_server/performance_graph_data_service.rb

@@ -10,6 +10,9 @@ module QaServer
       self.performance_data_class = QaServer::PerformanceHistory
 
       # 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. }},
@@ -18,22 +21,19 @@ module QaServer
       #     ...,
       #     23: { hour: 'NOW', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #   }
-      def average_last_24_hours(authority_name: nil, action: nil)
-        start_hour = Time.now.getlocal.beginning_of_hour - 23.hours
-        avgs = {}
-        0.upto(23).each do |idx|
-          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
-          start_hour += 1.hour
+      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
-        avgs
       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. }},
@@ -42,22 +42,18 @@ module QaServer
       #     ...,
       #     29: { day: 'TODAY', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #   }
-      def average_last_30_days(authority_name: nil, action: nil)
-        start_day = Time.now.getlocal.beginning_of_day - 29.days
-        avgs = {}
-        0.upto(29).each do |idx|
-          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
-          start_day += 1.day
+      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)
         end
-        avgs
       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. }},
@@ -66,19 +62,12 @@ module QaServer
       #     ...,
       #     11: { month: '08-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #   }
-      def average_last_12_months(authority_name: nil, action: nil)
-        start_month = Time.now.getlocal.beginning_of_month - 11.months
-        avgs = {}
-        0.upto(11).each do |idx|
-          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
-          start_month += 1.month
+      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)
         end
-        avgs
       end
 
       private
@@ -109,6 +98,51 @@ module QaServer
             ""
           end
         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|
+            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
+            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|
+            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
+            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|
+            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
+            start_month += 1.month
+          end
+          avgs
+        end
     end
   end
 end

data/lib/generators/qa_server/templates/config/initializers/qa_server.rb

@@ -73,4 +73,9 @@ QaServer.config do |config|
   # impact and may need to be suppressed.  Performance stats will not be gathered when this config is true.
   # @param [Boolean] do not gather performance data when true (defaults to false for backward compatibitily)
   # config.suppress_performance_gathering = false
+
+  # Performance data is gathered on every incoming query.  Basic stats are logged from QA.  Full stats are logged
+  # by QaServer and can eat up logging realestate.  To suppress the logging of details, set this config to true.
+  # @param [Boolean] do not log performance data details when true (defaults to false for backward compatibitily)
+  # config.suppress_logging_performance_datails = false
 end

data/lib/qa_server/configuration.rb

@@ -179,6 +179,15 @@ module QaServer
       @suppress_performance_gathering ||= false
     end
 
+    # Performance data is gathered on every incoming query.  Basic stats are logged from QA.  Full stats are logged
+    # by QaServer and can eat up logging realestate.  To suppress the logging of details, set this config to true.
+    # @param [Boolean] do not log performance data details when true (defaults to false for backward compatibitily)
+    attr_writer :suppress_logging_performance_datails
+    def suppress_logging_performance_datails
+      @suppress_logging_performance_datails ||= false
+    end
+
+    # TODO: consider refactor performance caching to use Rails cache
     def performance_cache
       @performance_cache ||= QaServer::PerformanceCache.new
     end

data/lib/qa_server/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qa_server
 version: !ruby/object:Gem::Version
-  version: 5.4.0
+  version: 5.5.0
 platform: ruby
 authors:
 - E. Lynette Rayle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-07 00:00:00.000000000 Z
+date: 2020-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails