qa_server 2.2.1 → 2.2.2

data/app/presenters/concerns/qa_server/monitor_status/performance_graph_behavior.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+# This module provides methods for creating and accessing performance graphs.
+module QaServer::MonitorStatus
+  module PerformanceGraphBehavior
+    include QaServer::PerformanceHistoryDataKeys
+    include QaServer::MonitorStatus::GruffGraph
+
+    def performance_graphs
+      auth_list = QaServer::AuthorityListerService.authorities_list
+      graphs = []
+      performance_graphs_for_authority(graphs, ALL_AUTH)
+      auth_list.each { |auth_name| performance_graphs_for_authority(graphs, auth_name) }
+      graphs
+    end
+
+    def performance_graph(graph_info)
+      graph_info[:graph]
+    end
+
+    def performance_graph_authority(graph_info)
+      graph_info[:authority_name]
+    end
+
+    def performance_graph_label(graph_info)
+      graph_info[:label]
+    end
+
+    def performance_default_graph_id
+      "performance-for-day-#{ALL_AUTH}"
+    end
+
+    def performance_graph_id(graph_info)
+      "#{graph_info[:base_id]}-during-#{graph_info[:time_period]}-chart"
+    end
+
+    def performance_graph_data_section_id(graph_info)
+      "#{graph_info[:base_id]}-during-#{graph_info[:time_period]}"
+    end
+
+    def performance_graph_data_section_base_id(graph_info)
+      graph_info[:base_id]
+    end
+
+    def performance_data_section_class(graph_info)
+      return 'performance-data-section-visible' if default_graph?(graph_info)
+      'performance-data-section-hidden'
+    end
+
+    def performance_day_graph_selected?(graph_info)
+      return true if graph_info[:time_period] == :day
+      false
+    end
+
+    def performance_month_graph_selected?(graph_info)
+      return true if graph_info[:time_period] == :month
+      false
+    end
+
+    def performance_year_graph_selected?(graph_info)
+      return true if graph_info[:time_period] == :year
+      false
+    end
+
+    private
+
+      def default_graph?(graph_info) # rubocop:disable Metrics/CyclomaticComplexity
+        return true if QaServer.config.performance_graph_default_time_period == :day && performance_day_graph_selected?(graph_info)
+        return true if QaServer.config.performance_graph_default_time_period == :month && performance_month_graph_selected?(graph_info)
+        return true if QaServer.config.performance_graph_default_time_period == :year && performance_year_graph_selected?(graph_info)
+        false
+      end
+
+      def performance_graphs_for_authority(graphs, auth_name)
+        graphs << performance_for_day_graph(auth_name)
+        graphs << performance_for_month_graph(auth_name)
+        graphs << performance_for_year_graph(auth_name)
+      end
+
+      def performance_for_day_graph(auth_name)
+        {
+          time_period: :day,
+          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, time_period: :day),
+          label: "Performance data for the last 24 hours.",
+          authority_name: auth_name,
+          base_id: "performance-for-#{auth_name}"
+        }
+      end
+
+      def performance_for_month_graph(auth_name)
+        {
+          time_period: :month,
+          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, time_period: :month),
+          label: "Performance data for the last 30 days.",
+          authority_name: auth_name,
+          base_id: "performance-for-#{auth_name}"
+        }
+      end
+
+      def performance_for_year_graph(auth_name)
+        {
+          time_period: :year,
+          graph: QaServer::PerformanceGraphingService.performance_graph_file(authority_name: auth_name, time_period: :year),
+          label: "Performance data for the last 12 months.",
+          authority_name: auth_name,
+          base_id: "performance-for-#{auth_name}"
+        }
+      end
+  end
+end

data/app/presenters/qa_server/monitor_status/performance_presenter.rb

@@ -1,35 +1,11 @@
 # frozen_string_literal: true
 # This presenter class provides performance data needed by the view that monitors status of authorities.
 module QaServer::MonitorStatus
-  class PerformancePresenter # rubocop:disable Metrics/ClassLength
-    class_attribute :performance_history_class
-    self.performance_history_class = QaServer::PerformanceHistory
-
+  class PerformancePresenter
     include QaServer::MonitorStatus::GruffGraph
-
-    ALL_AUTHS = performance_history_class::PERFORMANCE_ALL_KEY
-    STATS = performance_history_class::PERFORMANCE_STATS_KEY
-
-    FOR_LIFETIME = performance_history_class::PERFORMANCE_FOR_LIFETIME_KEY
-    FOR_DAY = performance_history_class::PERFORMANCE_FOR_DAY_KEY
-    BY_HOUR = performance_history_class::PERFORMANCE_BY_HOUR_KEY
-    FOR_MONTH = performance_history_class::PERFORMANCE_FOR_MONTH_KEY
-    BY_DAY = performance_history_class::PERFORMANCE_BY_DAY_KEY
-    FOR_YEAR = performance_history_class::PERFORMANCE_FOR_YEAR_KEY
-    BY_MONTH = performance_history_class::PERFORMANCE_BY_MONTH_KEY
-
-    SUM_LOAD = performance_history_class::SUM_LOAD_TIME_KEY
-    SUM_NORMALIZATION = performance_history_class::SUM_NORMALIZATION_TIME_KEY
-    SUM_FULL_REQUEST = performance_history_class::SUM_FULL_REQUEST_TIME_KEY
-    MIN_LOAD = performance_history_class::MIN_LOAD_TIME_KEY
-    MIN_NORMALIZATION = performance_history_class::MIN_NORMALIZATION_TIME_KEY
-    MIN_FULL_REQUEST = performance_history_class::MIN_FULL_REQUEST_TIME_KEY
-    MAX_LOAD = performance_history_class::MAX_LOAD_TIME_KEY
-    MAX_NORMALIZATION = performance_history_class::MAX_NORMALIZATION_TIME_KEY
-    MAX_FULL_REQUEST = performance_history_class::MAX_FULL_REQUEST_TIME_KEY
-    AVG_LOAD = performance_history_class::AVG_LOAD_TIME_KEY
-    AVG_NORMALIZATION = performance_history_class::AVG_NORMALIZATION_TIME_KEY
-    AVG_FULL_REQUEST = performance_history_class::AVG_FULL_REQUEST_TIME_KEY
+    include QaServer::MonitorStatus::PerformanceDatatableBehavior
+    include QaServer::MonitorStatus::PerformanceGraphBehavior
+    include QaServer::PerformanceHistoryDataKeys
 
     # @param performance_data [Hash<Hash>] performance data
     def initialize(performance_data:)
@@ -57,197 +33,5 @@ module QaServer::MonitorStatus
     def performance_data_authority_name(entry)
       entry.keys.first
     end
-
-    def performance_for_day_graph
-      performance_graph_file(rework_performance_data_for_gruff(all_authorities_performance_data[FOR_DAY], BY_HOUR),
-                             performance_for_day_graph_full_path,
-                             performance_for_day_graph_filename,
-                             I18n.t('qa_server.monitor_status.performance.x_axis_hour'))
-    end
-
-    def performance_for_month_graph
-      performance_graph_file(rework_performance_data_for_gruff(all_authorities_performance_data[FOR_MONTH], BY_DAY),
-                             performance_for_month_graph_full_path,
-                             performance_for_month_graph_filename,
-                             I18n.t('qa_server.monitor_status.performance.x_axis_day'))
-    end
-
-    def performance_for_year_graph
-      performance_graph_file(rework_performance_data_for_gruff(all_authorities_performance_data[FOR_YEAR], BY_MONTH),
-                             performance_for_year_graph_full_path,
-                             performance_for_year_graph_filename,
-                             I18n.t('qa_server.monitor_status.performance.x_axis_month'))
-    end
-
-    def lifetime_stats(authority_data)
-      authority_data[FOR_LIFETIME]
-    end
-
-    def min_load(stats)
-      format_stat stats[MIN_LOAD]
-    end
-
-    def min_normalization(stats)
-      format_stat stats[MIN_NORMALIZATION]
-    end
-
-    def min_full_request(stats)
-      format_stat stats[MIN_FULL_REQUEST]
-    end
-
-    def max_load(stats)
-      format_stat stats[MAX_LOAD]
-    end
-
-    def max_normalization(stats)
-      format_stat stats[MAX_NORMALIZATION]
-    end
-
-    def max_full_request(stats)
-      format_stat stats[MAX_FULL_REQUEST]
-    end
-
-    def avg_load(stats)
-      format_stat stats[AVG_LOAD]
-    end
-
-    def avg_normalization(stats)
-      format_stat stats[AVG_NORMALIZATION]
-    end
-
-    def avg_full_request(stats)
-      format_stat stats[AVG_FULL_REQUEST]
-    end
-
-    def min_load_style(stats)
-      performance_style_class(stats, MIN_LOAD)
-    end
-
-    def min_normalization_style(stats)
-      performance_style_class(stats, MIN_NORMALIZATION)
-    end
-
-    def min_full_request_style(stats)
-      performance_style_class(stats, MIN_FULL_REQUEST)
-    end
-
-    def max_load_style(stats)
-      performance_style_class(stats, MAX_LOAD)
-    end
-
-    def max_normalization_style(stats)
-      performance_style_class(stats, MAX_NORMALIZATION)
-    end
-
-    def max_full_request_style(stats)
-      performance_style_class(stats, MAX_FULL_REQUEST)
-    end
-
-    def avg_load_style(stats)
-      performance_style_class(stats, AVG_LOAD)
-    end
-
-    def avg_normalization_style(stats)
-      performance_style_class(stats, AVG_NORMALIZATION)
-    end
-
-    def avg_full_request_style(stats)
-      performance_style_class(stats, AVG_FULL_REQUEST)
-    end
-
-    private
-
-      def all_authorities_performance_data
-        performance_data[ALL_AUTHS]
-      end
-
-      def format_stat(stat)
-        format("%0.1f", stat)
-      end
-
-      def performance_style_class(stats, stat_key)
-        return "status-bad" if max_threshold_exceeded(stats, stat_key)
-        return "status-unknown" if min_threshold_not_met(stats, stat_key)
-        "status-neutral"
-      end
-
-      MAX_THRESHOLD = 1000 # ms
-      def max_threshold_exceeded(stats, stat_key)
-        return true if stats[stat_key] > MAX_THRESHOLD
-        false
-      end
-
-      MIN_THRESHOLD = 500 # ms
-      def min_threshold_not_met(stats, stat_key)
-        return true unless stats[stat_key] < MIN_THRESHOLD
-        false
-      end
-
-      def performance_graph_theme(g, x_axis_label)
-        g.theme_pastel
-        g.colors = ['#81adf4', '#8696b0', '#06578a']
-        g.marker_font_size = 12
-        g.x_axis_increment = 10
-        g.x_axis_label = x_axis_label
-        g.y_axis_label = I18n.t('qa_server.monitor_status.performance.y_axis_ms')
-        g.dot_radius = 3
-        g.line_width = 2
-        g.minimum_value = 0
-        g.maximum_value = 1000
-      end
-
-      def graph_filename(authority_name, time_period)
-        "performance_of_#{authority_name}_for_#{time_period}_graph.png"
-      end
-
-      def performance_for_day_graph_filename
-        graph_filename(ALL_AUTHS, :day)
-      end
-
-      def performance_for_day_graph_full_path
-        graph_full_path(performance_for_day_graph_filename)
-      end
-
-      def performance_for_month_graph_filename
-        graph_filename(ALL_AUTHS, :month)
-      end
-
-      def performance_for_month_graph_full_path
-        graph_full_path(performance_for_month_graph_filename)
-      end
-
-      def performance_for_year_graph_filename
-        graph_filename(ALL_AUTHS, :year)
-      end
-
-      def performance_for_year_graph_full_path
-        graph_full_path(performance_for_year_graph_filename)
-      end
-
-      def rework_performance_data_for_gruff(performance_data, label_key)
-        labels = {}
-        load_data = []
-        normalization_data = []
-        full_request_data = []
-        performance_data.each do |i, data|
-          labels[i] = data[label_key]
-          load_data << data[STATS][AVG_LOAD]
-          normalization_data << data[STATS][AVG_NORMALIZATION]
-          full_request_data << data[STATS][AVG_FULL_REQUEST]
-        end
-        [labels, load_data, normalization_data, full_request_data]
-      end
-
-      def performance_graph_file(performance_data, performance_graph_full_path, performance_graph_filename, x_axis_label)
-        g = Gruff::Line.new
-        performance_graph_theme(g, x_axis_label)
-        g.title = ''
-        g.labels = performance_data[0]
-        g.data(I18n.t('qa_server.monitor_status.performance.load_time_ms'), performance_data[1])
-        g.data(I18n.t('qa_server.monitor_status.performance.normalization_time_ms'), performance_data[2])
-        g.data(I18n.t('qa_server.monitor_status.performance.full_request_time_ms'), performance_data[3])
-        g.write performance_graph_full_path
-        File.join(graph_relative_path, performance_graph_filename)
-      end
   end
 end

data/app/presenters/qa_server/monitor_status_presenter.rb

@@ -25,10 +25,13 @@ module QaServer
 
     def_delegators :@performance_presenter, :performance_data, :performance_data?, :display_performance?, :display_performance_graph?,
                    :display_performance_datatable?, :performance_data_authority_name, :performance_for_day_graph, :performance_for_month_graph,
-                   :performance_for_year_graph, :lifetime_stats, :min_load, :min_normalization, :min_full_request, :max_load,
-                   :max_normalization, :max_full_request, :avg_load, :avg_normalization, :avg_full_request, :min_load_style,
-                   :min_normalization_style, :min_full_request_style, :max_load_style, :max_normalization_style, :max_full_request_style,
-                   :avg_load_style, :avg_normalization_style, :avg_full_request_style, :performance_style_class, :max_threshold_exceeded,
-                   :min_threshold_not_met
+                   :performance_for_year_graph, :datatable_stats, :low_load, :low_normalization, :low_full_request, :high_load,
+                   :high_normalization, :high_full_request, :avg_load, :avg_normalization, :avg_full_request, :low_load_style,
+                   :low_normalization_style, :low_full_request_style, :high_load_style, :high_normalization_style, :high_full_request_style,
+                   :avg_load_style, :avg_normalization_style, :avg_full_request_style, :performance_style_class, :high_threshold_exceeded,
+                   :low_threshold_not_met, :performance_graphs, :performance_graph, :performance_graph_authority, :performance_graph_label,
+                   :performance_default_graph_id, :performance_graph_id, :performance_graph_data_section_id, :performance_graph_data_section_base_id,
+                   :performance_data_section_class, :performance_day_graph_selected?, :performance_month_graph_selected?,
+                   :performance_year_graph_selected?, :performance_table_description
   end
 end

data/app/services/qa_server/performance_calculator_service.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+# This class calculates min, max, average stats for load, normalization, and full request times for a given set of performance records.
+require 'matrix'
+module QaServer
+  class PerformanceCalculatorService
+    include QaServer::PerformanceHistoryDataKeys
+
+    attr_reader :records
+    attr_reader :stats
+
+    # @param records [Array <Qa::PerformanceHistory>] set of records used to calculate the statistics
+    def initialize(records)
+      @records = records
+      @stats = {}
+    end
+
+    # Calculate performance statistics for a set of PerformanceHistory records.  Min is at the 10th percentile.  Max is at the 90th percentile.
+    # @return [Hash] hash of the statistics
+    # @example
+    # { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5,
+    #   load_min_ms: 12.3, normalization_min_ms: 4.2, full_request_min_ms: 16.5,
+    #   load_max_ms: 12.3, normalization_max_ms: 4.2, full_request_max_ms: 16.5 }
+    def calculate_stats(avg: false, low: false, high: false, load: true, norm: true, full: true) # rubocop:disable Metrics/ParameterLists
+      calculate_load_stats(avg, low, high) if load
+      calculate_norm_stats(avg, low, high) if norm
+      calculate_full_stats(avg, low, high) if full
+      stats
+    end
+
+    private
+
+      def calculate_load_stats(avg, low, high)
+        stats[AVG_LOAD] = calculate_average(load_times) if avg
+        stats[LOW_LOAD] = calculate_10th_percentile(load_times_sorted) if low
+        stats[HIGH_LOAD] = calculate_90th_percentile(load_times_sorted) if high
+      end
+
+      def calculate_norm_stats(avg, low, high)
+        stats[AVG_NORM] = calculate_average(norm_times) if avg
+        stats[LOW_NORM] = calculate_10th_percentile(norm_times_sorted) if low
+        stats[HIGH_NORM] = calculate_90th_percentile(norm_times_sorted) if high
+      end
+
+      def calculate_full_stats(avg, low, high)
+        stats[AVG_FULL] = calculate_average(full_times) if avg
+        stats[LOW_FULL] = calculate_10th_percentile(full_times_sorted) if low
+        stats[HIGH_FULL] = calculate_90th_percentile(full_times_sorted) if high
+      end
+
+      def count
+        @count ||= records.count
+      end
+
+      def tenth_percentile_count
+        return @tenth_percentile_count if @tenth_percentile_count.present?
+        percentile_count = (count * 0.1).round
+        percentile_count = 1 if percentile_count.zero? && count > 1
+        @tenth_percentile_count = percentile_count
+      end
+
+      def load_times
+        @load_times ||= records.pluck(:load_time_ms).to_a
+      end
+
+      def load_times_sorted
+        @load_times_sorted ||= load_times.sort
+      end
+
+      def norm_times
+        @norm_times ||= records.pluck(:normalization_time_ms).to_a
+      end
+
+      def norm_times_sorted
+        @norm_times_sorted ||= norm_times.sort
+      end
+
+      def full_times
+        @full_times ||= (Vector.elements(load_times) + Vector.elements(norm_times)).to_a
+      end
+
+      def full_times_sorted
+        @full_times_sorted ||= full_times.sort
+      end
+
+      def calculate_average(times)
+        return 0 if count.zero?
+        return times[0] if count == 1
+        times.inject(0.0) { |sum, el| sum + el } / count
+      end
+
+      def calculate_10th_percentile(sorted_times)
+        return 0 if count.zero?
+        return sorted_times[0] if count == 1
+        sorted_times[tenth_percentile_count - 1]
+      end
+
+      def calculate_90th_percentile(sorted_times)
+        return 0 if count.zero?
+        return sorted_times[0] if count == 1
+        sorted_times[count - tenth_percentile_count]
+      end
+  end
+end

data/app/services/qa_server/performance_graph_data_service.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+# This class sets performance stats for the last 24 hours, past 30 days, and the past 12 months.
+module QaServer
+  class PerformanceGraphDataService
+    class << self
+      include QaServer::PerformanceHistoryDataKeys
+
+      class_attribute :stats_calculator_class, :performance_data_class
+      self.stats_calculator_class = QaServer::PerformanceCalculatorService
+      self.performance_data_class = QaServer::PerformanceHistory
+
+      # Get hourly average for the past 24 hours.
+      # @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. }},
+      #     1: { hour: '1500', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #     2: { hour: '1600', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #     ...,
+      #     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(auth_name = nil)
+        start_hour = Time.now.getlocal.beginning_of_hour - 23.hours
+        avgs = {}
+        0.upto(23).each do |idx|
+          where_clause = { dt_stamp: start_hour..start_hour.end_of_hour }
+          where_clause[:authority] = auth_name unless auth_name.nil?
+          records = performance_data_class.where(where_clause)
+          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
+
+      # Get daily average for the past 30 days.
+      # @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. }},
+      #     1: { day: '07-16-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #     2: { day: '07-17-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #     ...,
+      #     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(auth_name = nil)
+        start_day = Time.now.getlocal.beginning_of_day - 29.days
+        avgs = {}
+        0.upto(29).each do |idx|
+          where_clause = { dt_stamp: start_day..start_day.end_of_day }
+          where_clause[:authority] = auth_name unless auth_name.nil?
+          records = performance_data_class.where(where_clause)
+          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
+
+      # Get daily average for the past 12 months.
+      # @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. }},
+      #     1: { month: '10-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #     2: { month: '11-2019', stats: { load_avg_ms: 12.3, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
+      #     ...,
+      #     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(auth_name = nil)
+        start_month = Time.now.getlocal.beginning_of_month - 11.months
+        avgs = {}
+        0.upto(11).each do |idx|
+          where_clause = { dt_stamp: start_month..start_month.end_of_month }
+          where_clause[:authority] = auth_name unless auth_name.nil?
+          records = performance_data_class.where(where_clause)
+          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
+
+      private
+
+        def performance_by_hour_label(idx, start_hour)
+          if idx == 23
+            I18n.t('qa_server.monitor_status.performance.now')
+          elsif ((idx + 1) % 2).zero?
+            (start_hour.hour * 100).to_s
+          else
+            ""
+          end
+        end
+
+        def performance_by_day_label(idx, start_day)
+          if idx == 29
+            I18n.t('qa_server.monitor_status.performance.today')
+          elsif ((idx + 1) % 5).zero?
+            start_day.strftime("%m-%d")
+          else
+            ""
+          end
+        end
+    end
+  end
+end