qa_server 5.5.1 → 6.0.0

data/app/services/qa_server/performance_graphing_service.rb

@@ -12,6 +12,7 @@ module QaServer
       # @param performance_data [Hash] hash of all performance data for all authorities
       # @see QaServer:PerformanceHistory
       def create_performance_graphs(performance_data:)
+        QaServer.config.monitor_logger.info("(QaServer::PerformanceGraphingService##{__method__}) - generating graphs")
         performance_data.each_key do |auth_name|
           create_graphs_for_authority(performance_data, auth_name.to_sym, :search)
           create_graphs_for_authority(performance_data, auth_name.to_sym, :fetch)
@@ -35,33 +36,35 @@ module QaServer
         end
 
         def create_performance_for_day_graph(performance_data, authority_name, action)
-          auth_data = authority_performance_data(performance_data, authority_name)
-          return unless auth_data
-          gruff_data = rework_performance_data_for_gruff(auth_data[action][FOR_DAY], BY_HOUR)
+          data = authority_performance_data(performance_data, authority_name, action, FOR_DAY)
+          return if data.empty?
+          gruff_data = rework_performance_data_for_gruff(data, BY_HOUR)
           create_gruff_graph(gruff_data,
                              performance_for_day_graph_full_path(authority_name, action),
                              I18n.t('qa_server.monitor_status.performance.x_axis_hour'))
         end
 
         def create_performance_for_month_graph(performance_data, authority_name, action)
-          auth_data = authority_performance_data(performance_data, authority_name)
-          gruff_data = rework_performance_data_for_gruff(auth_data[action][FOR_MONTH], BY_DAY)
+          data = authority_performance_data(performance_data, authority_name, action, FOR_MONTH)
+          return if data.empty?
+          gruff_data = rework_performance_data_for_gruff(data, BY_DAY)
           create_gruff_graph(gruff_data,
                              performance_for_month_graph_full_path(authority_name, action),
                              I18n.t('qa_server.monitor_status.performance.x_axis_day'))
         end
 
         def create_performance_for_year_graph(performance_data, authority_name, action)
-          auth_data = authority_performance_data(performance_data, authority_name)
-          gruff_data = rework_performance_data_for_gruff(auth_data[action][FOR_YEAR], BY_MONTH)
+          data = authority_performance_data(performance_data, authority_name, action, FOR_YEAR)
+          return if data.empty?
+          gruff_data = rework_performance_data_for_gruff(data, BY_MONTH)
           create_gruff_graph(gruff_data,
                              performance_for_year_graph_full_path(authority_name, action),
                              I18n.t('qa_server.monitor_status.performance.x_axis_month'))
         end
 
-        def authority_performance_data(data, authority_name)
+        def authority_performance_data(data, authority_name, action, time_period)
           auth_name = authority_name.nil? ? ALL_AUTH : authority_name
-          data[auth_name]
+          data[auth_name][action].key?(time_period) ? data[auth_name][action][time_period] : {}
         end
 
         def performance_for_day_graph_full_path(authority_name, action)
@@ -92,7 +95,7 @@ module QaServer
             graph_load_data << graph_load_time(data)
             normalization_data << data[STATS][AVG_NORM]
           end
-          [labels, normalization_data, graph_load_data, retrieve_data]
+          [labels, retrieve_data, graph_load_data, normalization_data]
         end
 
         def graph_load_time(data)
@@ -122,9 +125,9 @@ module QaServer
           g = Gruff::StackedBar.new
           performance_graph_theme(g, x_axis_label)
           g.labels = performance_data[0]
-          g.data(I18n.t('qa_server.monitor_status.performance.normalization_time_ms'), performance_data[1])
+          g.data(I18n.t('qa_server.monitor_status.performance.retrieve_time_ms'), performance_data[1])
           g.data(I18n.t('qa_server.monitor_status.performance.graph_load_time_ms'), performance_data[2])
-          g.data(I18n.t('qa_server.monitor_status.performance.retrieve_time_ms'), performance_data[3])
+          g.data(I18n.t('qa_server.monitor_status.performance.normalization_time_ms'), performance_data[3])
           g.write performance_graph_full_path
         end
     end

data/app/services/qa_server/time_period_service.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# Create where clauses for time periods and authorities.
+module QaServer
+  class TimePeriodService
+    class << self
+      # Construct a hash to pass to ActiveRecord where method limiting to last 24 hours and optionally an authority.
+      # @param auth_name [String] authority name if limiting to an authority; otherwise, nil
+      # @param auth_table [Symbol] name of the table holding the authority name; or nil if in same table
+      # @param dt_table [Symbol] name of the table holding the date-time stamp; or nil if in same table
+      # @return [Hash] a where clause for the last 24 hours for an authority
+      # @example returned where for join
+      #   { scenario_run_registry: { dt_stamp: start_hour..end_hour },
+      #     scenario_run_history: { authority: 'LOC_DIRECT' } }
+      # @example returned where for join with no authority
+      #   { scenario_run_registry: { dt_stamp: start_hour..end_hour } }
+      # @example returned where for same table
+      #   { dt_stamp: start_hour..end_hour, authority: 'LOC_DIRECT' }
+      # @example returned where when no authority
+      #   { dt_stamp: start_hour..end_hour }
+      def where_clause_for_last_24_hours(auth_name: nil, auth_table: nil, dt_table: nil)
+        validate_params(auth_name, auth_table, dt_table)
+        where_clause = where_for_dt_stamp(dt_table, 1.day)
+        where_with_authority(where_clause, auth_name, auth_table)
+      end
+
+      # Construct a hash to pass to ActiveRecord where method limiting to last 30 days and optionally an authority.
+      # @param auth_name [String] authority name if limiting to an authority; otherwise, nil
+      # @param auth_table [Symbol] name of the table holding the authority name; or nil if in same table
+      # @param dt_table [Symbol] name of the table holding the date-time stamp; or nil if in same table
+      # @return [Hash] a where clause for the last 30 days for an authority
+      # @example returned where for join
+      #   { scenario_run_registry: { dt_stamp: start_day..end_day },
+      #     scenario_run_history: { authority: 'LOC_DIRECT' } }
+      # @example returned where for join with no authority
+      #   { scenario_run_registry: { dt_stamp: start_day..end_day } }
+      # @example returned where for same table
+      #   { dt_stamp: start_day..end_day, authority: 'LOC_DIRECT' }
+      # @example returned where when no authority
+      #   { dt_stamp: start_day..end_day }
+      def where_clause_for_last_30_days(auth_name: nil, auth_table: nil, dt_table: nil)
+        validate_params(auth_name, auth_table, dt_table)
+        where_clause = where_for_dt_stamp(dt_table, 1.month)
+        where_with_authority(where_clause, auth_name, auth_table)
+      end
+
+      # Construct a hash to pass to ActiveRecord where method limiting to last 12 months and optionally an authority.
+      # @param auth_name [String] authority name if limiting to an authority; otherwise, nil
+      # @param auth_table [Symbol] name of the table holding the authority name; or nil if in same table
+      # @param dt_table [Symbol] name of the table holding the date-time stamp; or nil if in same table
+      # @return [Hash] a where clause for the last 12 months for an authority
+      # @example returned where for join
+      #   { scenario_run_registry: { dt_stamp: start_month..end_month },
+      #     scenario_run_history: { authority: 'LOC_DIRECT' } }
+      # @example returned where for join with no authority
+      #   { scenario_run_registry: { dt_stamp: start_month..end_month } }
+      # @example returned where for same table
+      #   { dt_stamp: start_month..end_month, authority: 'LOC_DIRECT' }
+      # @example returned where when no authority
+      #   { dt_stamp: start_month..end_month }
+      def where_clause_for_last_12_months(auth_name: nil, auth_table: nil, dt_table: nil)
+        validate_params(auth_name, auth_table, dt_table)
+        where_clause = where_for_dt_stamp(dt_table, 1.year)
+        where_with_authority(where_clause, auth_name, auth_table)
+      end
+
+      private
+
+        def where_for_dt_stamp(dt_table, time_period)
+          end_range = QaServer::TimeService.current_time
+          start_range = end_range - time_period
+          where_clause = { dt_stamp: start_range..end_range }
+          where_clause = { dt_table => where_clause } unless dt_table.nil?
+          where_clause
+        end
+
+        def where_with_authority(where_clause, auth_name, auth_table)
+          return where_clause if auth_name.nil?
+          if auth_table.nil?
+            where_clause[:authority] = auth_name
+          else
+            where_clause[auth_table] = { authority: auth_name }
+          end
+          where_clause
+        end
+
+        def validate_params(auth_name, auth_table, dt_table)
+          raise ArgumentError, "Do not specify auth_table when auth_name is not specified" if auth_table.present? && auth_name.nil?
+          return if auth_name.nil?
+          raise ArgumentError, "Either both table names need to be specified or neither" if auth_table.present? ^ dt_table.present?
+        end
+    end
+  end
+end

data/app/services/qa_server/time_service.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# Create where clauses for time periods and authorities.
+module QaServer
+  class TimeService
+    class << self
+      # @return [ActiveSupport::TimeWithZone] current DateTime in the configured preferred_time_zone_name
+      def current_time
+        Time.now.in_time_zone(QaServer.config.preferred_time_zone_name)
+      end
+
+      # @return [Float] current DateTime in seconds
+      def current_time_s
+        current_time.to_f
+      end
+
+      # @param dt [ActiveSupport::TimeWithZone] date time stamp
+      # @return [String] string version of date formatted with date and time (e.g. "02/01/2020 - 02:35 PM ET")
+      def pretty_time(dt)
+        dt.in_time_zone(QaServer.config.preferred_time_zone_name).strftime("%m/%d/%Y - %I:%M %p")
+      end
+
+      # @param dt [ActiveSupport::TimeWithZone] date time stamp
+      # @return [String] string version of date formatted with just date (e.g. "02/01/2020")
+      def pretty_date(dt)
+        dt.in_time_zone(QaServer.config.preferred_time_zone_name).strftime("%m/%d/%Y")
+      end
+    end
+  end
+end

data/app/validators/qa_server/scenario_validator.rb

@@ -59,15 +59,15 @@ module QaServer
       # Runs the test in the block passed by the specific scenario type.
       # @return [Symbol] :good (PASS) or :unknown (UNKNOWN) based on whether enough results were returned
       def test_connection(min_expected_size: MIN_EXPECTED_SIZE, scenario_type_name:)
-        dt_start = QaServer.current_time
+        dt_start = QaServer::TimeService.current_time
         results = yield if block_given?
-        dt_end = QaServer.current_time
+        dt_end = QaServer::TimeService.current_time
         actual_size = results.to_s.length
         status = actual_size > min_expected_size ? PASS : UNKNOWN
         errmsg = status == PASS ? '' : "#{scenario_type_name.capitalize} scenario unknown status; cause: Results actual size (#{actual_size} < expected size (#{min_expected_size})"
         log(status: status, error_message: errmsg, normalization_run_time: (dt_end - dt_start)) # TODO: need to get run times from results
       rescue Exception => e
-        dt_end = QaServer.current_time
+        dt_end = QaServer::TimeService.current_time
         log(status: FAIL, error_message: "Exception executing #{scenario_type_name} scenario; cause: #{e.message}", request_run_time: (dt_end - dt_start))
       end
 

data/app/validators/qa_server/search_scenario_validator.rb

@@ -40,9 +40,9 @@ module QaServer
 
       # Runs the accuracy test and log results
       def test_accuracy(subject_uri:, expected_by_position:)
-        dt_start = QaServer.current_time
+        dt_start = QaServer::TimeService.current_time
         results = yield if block_given?
-        dt_end = QaServer.current_time
+        dt_end = QaServer::TimeService.current_time
         if results.blank?
           log(status: UNKNOWN, errmsg: "Search position scenario failed; cause: no results found", expected: expected_by_position, target: subject_uri, request_run_time: (dt_end - dt_start))
           return
@@ -50,7 +50,7 @@ module QaServer
 
         check_position(results, subject_uri, expected_by_position, total_run_time: (dt_end - dt_start)) # TODO: need to get run times from results
       rescue Exception => e
-        dt_end = QaServer.current_time
+        dt_end = QaServer::TimeService.current_time
         log(status: FAIL, errmsg: "Exception executing search position scenario; cause: #{e.message}",
             expected: expected_by_position, target: subject_uri, request_run_time: (dt_end - dt_start))
       end

data/app/views/qa_server/monitor_status/_performance.html.erb

@@ -83,7 +83,8 @@
 
   <% if @presenter.display_performance_datatable? && !@presenter.performance_data.nil? %>
     <div id="performance-datatable-section">
-      <h4><%= @presenter.performance_table_description %></h4>
+      <h4><%= t('qa_server.monitor_status.performance.datatable_desc') %></h4>
+      <p class="status-update-dtstamp"><%= t('qa_server.monitor_status.performance.datarange', from: @presenter.performance_data_start, to: @presenter.performance_data_end) %></p>
       <table class="status">
         <tr>
           <th></th>

data/app/views/qa_server/monitor_status/_test_history.html.erb

@@ -1,8 +1,7 @@
   <% if @presenter.history? && @presenter.display_history_details?%>
       <div id="availability-history" class="status-section">
         <h3><%= t('qa_server.monitor_status.history.title') %></h3>
-        <p class="status-update-dtstamp"><%= t('qa_server.monitor_status.history.since', date: @presenter.first_updated) %></p>
-        <%#= column_chart @presenter.historical_summary, stacked: true, colors: ["green", "red"], xtitle: 'Authority', ytitle: 'Pass-Fail', legend: 'bottom' %>
+        <p class="status-update-dtstamp"><%= t('qa_server.monitor_status.history.range', from: @presenter.history_start, to: @presenter.history_end) %></p>
         <% if @presenter.display_historical_graph? %>
           <%= image_tag(@presenter.historical_graph, alt: 'History Graph Unavailable') %>
         <% end %>

data/app/views/qa_server/monitor_status/_test_summary.html.erb

@@ -19,7 +19,7 @@
   </table>
   <p class="status-update-dtstamp"><%= t('qa_server.monitor_status.summary.last_updated', date: @presenter.last_updated) %></p>
 
-  <% if @presenter.failures? & !@status_data.nil? %>
+  <% if @presenter.failures? & !@presenter.failures.nil? %>
     <div id="failures" class="status-section">
       <h4><%= t('qa_server.monitor_status.failures.title') %></h4>
 
@@ -33,7 +33,7 @@
           <th><%= t('qa_server.monitor_status.failures.errmsg') %></th>
         </tr>
         <% current_authority = nil %>
-        <% @status_data.each do |status| %>
+        <% @presenter.failures.each do |status| %>
           <% unless status[:authority_name] == current_authority %>
               <% current_authority = status[:authority_name] %>
               <tr>

data/config/locales/qa_server.en.yml

@@ -69,6 +69,7 @@ en:
       history:
         title:           Authority Connection History
         since:           'Since %{date} ET'
+        range:           'From %{from} to %{to}'
         authority:       Authority
         days_failing:    Days Failing
         days_passing:    Days Passing
@@ -95,10 +96,8 @@ en:
         y_axis_ms:       Milliseconds (ms)
         now:             NOW
         today:           TODAY
-        datatable_day_desc:   'Performance tabulated data for last 24 hours'
-        datatable_month_desc: 'Performance tabulated data for last 30 days'
-        datatable_year_desc:  'Performance tabulated data for one year'
-        datatable_all_desc:   'Performance tabulated data for all recorded data'
+        datatable_desc:       'Performance tabulated data'
+        datarange:            'From %{from} to %{to}'
         authority:            Authority
         average_times:        Average (ms)
         fastest_times:        10th percentile (ms)

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

@@ -20,6 +20,10 @@ QaServer.config do |config|
   # @param [Boolean] display history datatable when true
   # config.display_historical_datatable = true
 
+  # Historical datatable default time period.
+  # @param [Symbol] time period for calculating historical pass/fail (i.e., one of :month, :year, or :all)
+  # config.historical_datatable_default_time_period = :year
+
   # Displays a graph of performance test data when true
   # @param [Boolean] display performance graph when true
   # config.display_performance_graph = false

data/lib/qa_server.rb

@@ -27,29 +27,6 @@ module QaServer
     @config
   end
 
-  # @return [ActiveSupport::TimeWithZone] current DateTime in the configured preferred_time_zone_name
-  def self.current_time
-    Time.now.in_time_zone(QaServer.config.preferred_time_zone_name)
-  end
-
-  # @return [Float] current DateTime in seconds
-  def self.current_time_s
-    current_time.to_f
-  end
-
-  # @return [ActiveSupport::TimeWithZone] DateTime at which cache should expire
-  def self.monitoring_expires_at
-    offset = QaServer.config.hour_offset_to_expire_cache
-    offset_time = current_time
-    offset_time = offset_time.tomorrow unless (offset_time + 5.minutes).hour < offset
-    offset_time.beginning_of_day + offset.hours - 5.minutes
-  end
-
-  # @return [Float] number of seconds until cache should expire
-  def self.cache_expiry
-    monitoring_expires_at - current_time
-  end
-
   def self.log_agent_info(request)
     return if !Qa.config.respond_to?(:suppress_ip_data_from_log) || Qa.config.suppress_ip_data_from_log
     user_agent = request.respond_to?(:user_agent) && !request.user_agent.nil? ? ::UserAgent.parse(request.user_agent) : nil

data/lib/qa_server/configuration.rb

@@ -59,6 +59,20 @@ module QaServer
       @display_historical_datatable = true
     end
 
+    # Historical datatable default time period.
+    # @param [Symbol] time period for calculating historical pass/fail (i.e., one of :month, :year, or :all)
+    # @raise [ArgumentError] if time_period is not one of :month, :year, or :all
+    def historical_datatable_default_time_period=(time_period)
+      raise ArgumentError, 'time_period must be one of :day, :month, or :year' unless [:month, :year, :all].include? time_period
+      @historical_datatable_default_time_period = time_period
+    end
+
+    # Historical datatable default time period.
+    # @return [Symbol] time period for calculating historical pass/fail (i.e., one of :month, :year, or :all)
+    def historical_datatable_default_time_period
+      @historical_datatable_default_time_period ||= :year
+    end
+
     # Displays a graph of performance test data when true
     # @param [Boolean] display performance graph when true
     attr_writer :display_performance_graph
@@ -187,9 +201,15 @@ module QaServer
       @suppress_logging_performance_datails ||= false
     end
 
+    # For internal use only
     # TODO: consider refactor performance caching to use Rails cache
     def performance_cache
       @performance_cache ||= QaServer::PerformanceCache.new
     end
+
+    # For internal use only
+    def monitor_logger
+      @monitor_logger ||= Logger.new(ENV['MONITOR_LOG_PATH'] || File.join("log", "monitor.log"))
+    end
   end
 end

data/lib/qa_server/version.rb

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

data/spec/lib/qa_server_spec.rb

@@ -3,57 +3,6 @@ require 'spec_helper'
 
 RSpec.describe QaServer do
   # rubocop:disable RSpec/MessageChain
-  let(:timezone_name) { 'Eastern Time (US & Canada)' }
-  before { allow(described_class).to receive_message_chain(:config, :preferred_time_zone_name).and_return(timezone_name) }
-
-  describe '.current_time' do
-    before do
-      allow(Time).to receive(:now).and_return(DateTime.parse('2019-12-11 05:00:00 -0500').in_time_zone(timezone_name))
-    end
-
-    it 'returns the time in the preferred time zone' do
-      puts 'Running QaServer.current_time spec'
-      expect(described_class.current_time.zone).to eq 'EST'
-    end
-  end
-
-  describe '.monitoring_expires_at' do
-    before do
-      allow(described_class).to receive_message_chain(:config, :hour_offset_to_expire_cache).and_return(3)
-    end
-
-    context 'when current hour is before offset time' do
-      before do
-        allow(described_class).to receive(:current_time).and_return(DateTime.parse('2019-12-11 02:54:00 -0500').in_time_zone(timezone_name))
-      end
-
-      it 'returns expiration on current date at offset time' do
-        expect(described_class.monitoring_expires_at).to eq DateTime.parse('2019-12-11 02:55:00 -0500').in_time_zone(timezone_name)
-      end
-    end
-
-    context 'when current hour is after offset time' do
-      before do
-        allow(described_class).to receive(:current_time).and_return(DateTime.parse('2019-12-11 02:56:00 -0500').in_time_zone(timezone_name))
-      end
-
-      it 'returns expiration on previous date at offset time' do
-        expect(described_class.monitoring_expires_at).to eq DateTime.parse('2019-12-12 02:55:00 -0500').in_time_zone(timezone_name)
-      end
-    end
-  end
-
-  describe '.cache_expiry' do
-    before do
-      allow(described_class).to receive_message_chain(:config, :hour_offset_to_expire_cache).and_return(3)
-      allow(Time).to receive(:now).and_return(DateTime.parse('2019-12-11 02:54:59 -0500').in_time_zone(timezone_name))
-    end
-
-    it 'returns seconds until offset time (simulates 1 second before offset time)' do
-      expect(described_class.cache_expiry).to eq 1.second
-    end
-  end
-
   # rubocop:disable RSpec/MessageSpies
   describe '.log_agent_info' do
     let(:request) { double }

data/spec/services/qa_server/monitor_cache_service_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe QaServer::MonitorCacheService do
+  # rubocop:disable RSpec/MessageChain
+  let(:timezone_name) { 'Eastern Time (US & Canada)' }
+  before { allow(described_class).to receive_message_chain(:config, :preferred_time_zone_name).and_return(timezone_name) }
+
+  describe '.cache_expiry' do
+    before do
+      allow(described_class).to receive_message_chain(:config, :hour_offset_to_expire_cache).and_return(3)
+      allow(Time).to receive(:now).and_return(DateTime.parse('2019-12-11 02:54:59 -0500').in_time_zone(timezone_name))
+    end
+
+    it 'returns seconds until offset time (simulates 1 second before offset time)' do
+      expect(described_class.cache_expiry).to eq 1.second
+    end
+  end
+  # rubocop:enable RSpec/MessageChain
+end