qa_server 5.5.1 → 6.0.0

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.
+# Provide access to the scenario_run_history database table which tracks scenario runs over time.
 module QaServer
-  class ScenarioRunHistory < ActiveRecord::Base # rubocop:disable Metrics/ClassLength
+  class ScenarioRunHistory < ActiveRecord::Base
     self.table_name = 'scenario_run_history'
     belongs_to :scenario_run_registry
     enum scenario_type: [:connection, :accuracy, :performance], _suffix: :type
@@ -15,195 +15,180 @@ module QaServer
 
     self.summary_class = QaServer::ScenarioRunSummary
 
-    # Save a scenario result
-    # @param run_id [Integer] the run on which to gather statistics
-    # @param result [Hash] the scenario result to be saved
-    def self.save_result(run_id:, scenario_result:)
-      QaServer::ScenarioRunHistory.create(scenario_run_registry_id: run_id,
-                                          status: scenario_result[:status],
-                                          authority_name: scenario_result[:authority_name],
-                                          subauthority_name: scenario_result[:subauthority_name],
-                                          service: scenario_result[:service],
-                                          action: scenario_result[:action],
-                                          url: scenario_result[:url],
-                                          err_message: scenario_result[:err_message],
-                                          run_time: scenario_result[:run_time])
-    end
+    class << self
+      # Save a scenario result
+      # @param run_id [Integer] the run on which to gather statistics
+      # @param result [Hash] the scenario result to be saved
+      def save_result(run_id:, scenario_result:)
+        QaServer::ScenarioRunHistory.create(scenario_run_registry_id: run_id,
+                                            status: scenario_result[:status],
+                                            authority_name: scenario_result[:authority_name],
+                                            subauthority_name: scenario_result[:subauthority_name],
+                                            service: scenario_result[:service],
+                                            action: scenario_result[:action],
+                                            url: scenario_result[:url],
+                                            err_message: scenario_result[:err_message],
+                                            run_time: scenario_result[:run_time])
+      end
 
-    # Get a summary of passing/failing tests for a run.
-    # @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'])
+      # Get a summary of passing/failing tests for a run.
+      # @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 run_summary(scenario_run:, force: false)
+        Rails.cache.fetch("QaServer::ScenarioRunHistory/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 1.minute, force: force) do
+          QaServer.config.monitor_logger.info("(QaServer::ScenarioRunHistory##{__method__}) - creating summary of latest run - cache expired or refresh requested (force: #{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
-    end
 
-    # Get set of all scenario results for a run.
-    # @param run_id [Integer] the run on which to gather statistics
-    # @param authority_name [String] limit results to those for the authority with this name
-    # @param status [Array<Symbol> | Symbol] :good, :bad, :unknown, or any of these in an array to select multiple status
-    # @param url [String] limit results to a specific scenario URL
-    # @returns [Array<ScenarioRunHistory>] scenario details for all 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: :good,
-    #       authority_name: "oclcfast_ld4l_cache",
-    #       subauthority_name: "Organization",
-    #       service: "ld4l_cache",
-    #       action: "search",
-    #       url: "/qa/search/linked_data/oclcfast_ld4l_cache/organization?q=mark twain&maxRecords=4",
-    #       err_message: "",
-    #       scenario_type: :connection
-    #       run_time: 0.131 },
-    #     { 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 } ]
-    # @deprecated Not used anywhere. Being removed.
-    def self.run_results(run_id:, authority_name: nil, status: nil, url: nil)
-      return [] unless run_id
-      where = {}
-      where[:scenario_run_registry_id] = run_id
-      where[:authority_name] = authority_name if authority_name.present?
-      where[:status] = status if status.present?
-      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 all scenario results for a run.
+      # @param run_id [Integer] the run on which to gather statistics
+      # @param authority_name [String] limit results to those for the authority with this name
+      # @param status [Array<Symbol> | Symbol] :good, :bad, :unknown, or any of these in an array to select multiple status
+      # @param url [String] limit results to a specific scenario URL
+      # @returns [Array<ScenarioRunHistory>] scenario details for all 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: :good,
+      #       authority_name: "oclcfast_ld4l_cache",
+      #       subauthority_name: "Organization",
+      #       service: "ld4l_cache",
+      #       action: "search",
+      #       url: "/qa/search/linked_data/oclcfast_ld4l_cache/organization?q=mark twain&maxRecords=4",
+      #       err_message: "",
+      #       scenario_type: :connection
+      #       run_time: 0.131 },
+      #     { 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 } ]
+      # @deprecated Not used anywhere. Being removed.
+      def run_results(run_id:, authority_name: nil, status: nil, url: nil)
+        return [] unless run_id
+        where = {}
+        where[:scenario_run_registry_id] = run_id
+        where[:authority_name] = authority_name if authority_name.present?
+        where[:status] = status if status.present?
+        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,
-    #       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 self.run_failures(run_id:, force: false)
-      return [] unless run_id
-      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
+      # 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,
+      #       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 run_failures(run_id:, force: false)
+        return [] unless run_id
+        Rails.cache.fetch("QaServer::ScenarioRunHistory/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 1.minute, force: force) do
+          QaServer.config.monitor_logger.info("(QaServer::ScenarioRunHistory##{__method__}) - finding failures in latest run - cache expired or refresh requested (force: #{force})")
+          QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: :good).to_a
+        end
       end
-    end
 
-    # Get a summary level of historical data
-    # @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(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)
+      # Get a summary level of historical data
+      # @returns [Array<Array>] summary of passing/failing tests for each authority
+      # @example [auth_name, failing, passing]
+      #   { 'agrovoc' => { "good" => 0, "bad" => 24 },
+      #     'geonames_ld4l_cache' => { "good" => 2, "bad" => 22 } }
+      def historical_summary(force: false)
+        Rails.cache.fetch("QaServer::ScenarioRunHistory/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 1.minute, force: force) do
+          runs_per_authority_for_time_period
         end
-        data
       end
-    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
+      private
 
-    def self.authorities_in_run(run_id:)
-      QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).pluck(:authority_name).uniq
-    end
-    private_class_method :authorities_in_run
+        def authorities_in_run(run_id:)
+          QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).pluck(:authority_name).uniq
+        end
 
-    def self.authorities_with_failures_in_run(run_id:)
-      QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: 'good').pluck('authority_name').uniq
-    end
-    private_class_method :authorities_with_failures_in_run
+        def authorities_with_failures_in_run(run_id:)
+          QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: 'good').pluck('authority_name').uniq
+        end
 
-    # @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"
-      status["bad"] = 0 unless status.key? "bad"
-      status["unknown"] = 0 unless status.key? "unknown"
-      status
-    end
-    private_class_method :status_counts_in_run
+        # @return [Hash] status counts across all authorities (used for current test summary)
+        # @example { "good" => 23, "bad" => 3, "unknown" => 0 }
+        def 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"
+          status["bad"] = 0 unless status.key? "bad"
+          status["unknown"] = 0 unless status.key? "unknown"
+          status
+        end
 
-    def self.all_runs_per_authority
-      # TODO: Really want to only get one run per day.  Preferably the first run of the day.
-      authority_runs = QaServer::ScenarioRunHistory.pluck(:authority_name, :scenario_run_registry_id).uniq # rubocop:disable Rails/UniqBeforePluck
-      runs_per_authority(authority_runs)
-    end
-    private_class_method :all_runs_per_authority
+        def runs_per_authority_for_time_period
+          status = QaServer::ScenarioRunHistory.joins(:scenario_run_registry).where(time_period_where).group('authority_name', 'status').count
+          status.each_with_object({}) do |(k, v), hash|
+            h = hash[k[0]] || { "good" => 0, "bad" => 0 } # initialize for an authority if it doesn't already exist
+            h[k[1]] = v
+            hash[k[0]] = h
+          end
+        end
 
-    def self.failing_runs_per_authority
-      failing_authority_runs = QaServer::ScenarioRunHistory.where.not(status: 'good').pluck(:authority_name, :scenario_run_registry_id).uniq
-      runs_per_authority(failing_authority_runs)
-    end
-    private_class_method :failing_runs_per_authority
+        def expected_time_period
+          QaServer.config.historical_datatable_default_time_period
+        end
 
-    def self.runs_per_authority(authority_runs)
-      runs_per_authority = {}
-      authority_runs.each do |auth_run|
-        auth_name = auth_run[0]
-        runs_per_authority[auth_name] = 0 unless runs_per_authority.key? auth_name
-        runs_per_authority[auth_name] += 1
-      end
-      runs_per_authority
+        def time_period_where
+          case expected_time_period
+          when :day
+            QaServer::TimePeriodService.where_clause_for_last_24_hours(dt_table: :scenario_run_registry)
+          when :month
+            QaServer::TimePeriodService.where_clause_for_last_30_days(dt_table: :scenario_run_registry)
+          when :year
+            QaServer::TimePeriodService.where_clause_for_last_12_months(dt_table: :scenario_run_registry)
+          else
+            all_records
+          end
+        end
     end
-    private_class_method :runs_per_authority
   end
 end

data/app/models/qa_server/scenario_run_registry.rb

@@ -23,17 +23,17 @@ module QaServer
     end
     deprecation_deprecate latest_run_id: "Not used anywhere. Being removed."
 
-    # @return [String] datetime stamp of first registered run
+    # @return [ActiveSupport::TimeWithZone] 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")
+      Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 30.seconds) do
+        QaServer::ScenarioRunRegistry.first.dt_stamp
       end
     end
 
     # 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)
+      run = QaServer::ScenarioRunRegistry.create(dt_stamp: QaServer::TimeService.current_time)
       scenarios_results.each { |result| QaServer::ScenarioRunHistory.save_result(run_id: run.id, scenario_result: result) }
     end
   end

data/app/prepends/prepended_linked_data/find_term.rb

@@ -21,7 +21,7 @@ module PrependedLinkedData::FindTerm
 
     def setup_find(request_header: {}, language: nil, replacements: {}, subauth: nil, format: nil, performance_data: false) # rubocop:disable Metrics/ParameterLists
       QaServer.log_agent_info(request_header[:request])
-      @start_time_s = QaServer.current_time_s
+      @start_time_s = QaServer::TimeService.current_time_s
       request_header = build_request_header(language: language, replacements: replacements, subauth: subauth, format: format, performance_data: performance_data) if request_header.empty?
       @saved_performance_data = performance_data || request_header[:performance_data]
       request_header[:performance_data] = true
@@ -30,7 +30,7 @@ module PrependedLinkedData::FindTerm
 
     def update_performance_history_record(full_results)
       return QaServer.config.performance_cache.destroy(@phid) unless full_results.is_a?(Hash) && full_results.key?(:performance)
-      updates = { action_time_ms: (QaServer.current_time_s - @start_time_s) * 1000,
+      updates = { action_time_ms: (QaServer::TimeService.current_time_s - @start_time_s) * 1000,
                   size_bytes: full_results[:performance][:fetched_bytes],
                   retrieve_plus_graph_load_time_ms: full_results[:performance][:fetch_time_s] * 1000,
                   normalization_time_ms: full_results[:performance][:normalization_time_s] * 1000 }
@@ -42,12 +42,12 @@ module PrependedLinkedData::FindTerm
     def load_graph(url:)
       return super if QaServer.config.suppress_performance_gathering
 
-      access_start_dt = QaServer.current_time
+      access_start_dt = QaServer::TimeService.current_time
 
       url += "&phid=#{@phid}"
       @full_graph = graph_service.load_graph(url: url)
 
-      access_end_dt = QaServer.current_time
+      access_end_dt = QaServer::TimeService.current_time
       @access_time_s = access_end_dt - access_start_dt
       @fetched_size = full_graph.triples.to_s.size if performance_data?
       Rails.logger.info("Time to receive data from authority: #{access_time_s}s")

data/app/prepends/prepended_linked_data/search_query.rb

@@ -21,7 +21,7 @@ module PrependedLinkedData::SearchQuery
 
     def setup_search(request_header: {}, language: nil, replacements: {}, subauth: nil, context: false, performance_data: false) # rubocop:disable Metrics/ParameterLists
       QaServer.log_agent_info(request_header[:request])
-      @start_time_s = QaServer.current_time_s
+      @start_time_s = QaServer::TimeService.current_time_s
       request_header = build_request_header(language: language, replacements: replacements, subauth: subauth, context: context, performance_data: performance_data) if request_header.empty?
       @saved_performance_data = performance_data || request_header[:performance_data]
       request_header[:performance_data] = true
@@ -30,7 +30,7 @@ module PrependedLinkedData::SearchQuery
 
     def update_performance_history_record(full_results)
       return QaServer.config.performance_cache.destroy(@phid) unless full_results.is_a?(Hash) && full_results.key?(:performance)
-      updates = { action_time_ms: (QaServer.current_time_s - @start_time_s) * 1000,
+      updates = { action_time_ms: (QaServer::TimeService.current_time_s - @start_time_s) * 1000,
                   size_bytes: full_results[:performance][:fetched_bytes],
                   retrieve_plus_graph_load_time_ms: full_results[:performance][:fetch_time_s] * 1000,
                   normalization_time_ms: full_results[:performance][:normalization_time_s] * 1000 }
@@ -42,12 +42,12 @@ module PrependedLinkedData::SearchQuery
     def load_graph(url:)
       return super if QaServer.config.suppress_performance_gathering
 
-      access_start_dt = QaServer.current_time
+      access_start_dt = QaServer::TimeService.current_time
 
       url += "&phid=#{@phid}"
       @full_graph = graph_service.load_graph(url: url)
 
-      access_end_dt = QaServer.current_time
+      access_end_dt = QaServer::TimeService.current_time
       @access_time_s = access_end_dt - access_start_dt
       @fetched_size = full_graph.triples.to_s.size if performance_data?
       Rails.logger.info("Time to receive data from authority: #{access_time_s}s")