qa_server 5.5.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 151dd2fd2491a1d6ea72b18356db77ec566bd513
-  data.tar.gz: a3f1e776af8ba78e91c754571cbed0c97ed3306e
+  metadata.gz: 860edda3341250dd5f1fc4db164b95f8f24bf832
+  data.tar.gz: 89cb1ccc0f86ef647d490dd416bf27b00f598d86
 SHA512:
-  metadata.gz: da0fe6ca4b13e58d7c263b585a391c9988786e06b16db3d3ed016c25db128f0e260a8fef17f774881f2037fe310a7eea1eb93c75a391ca5249b4a7437cc7a28a
-  data.tar.gz: c7d4b2bbc9532cce06f4ec96451780c0f5fffc04557cf82004796ac5247bb213390d7ca70f7fb5c35327075ae6c97f83557fa18652c323ff158d2dddd7c7ab84
+  metadata.gz: f43f63cbfda11c203e79fb8aeeb4a8f05dac3051ea4225593fe82244343d35b8076a3db11672c913bf80eb8df8cfd0216bc7a6218d296c9772b516e32edeb41f
+  data.tar.gz: 9192ba67322874947fc9f979d7545369de86d041a533361621ac091013cbb04230b0f756d2b6d570a0c5fc992dce27548d6b86dfd93ff95733c39a134b542546

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+### 6.0.0 (2020-02-13)
+
+* refactor generation of performance graphs to minimize db access and calculations
+* shorten race_condition times for caching
+* rename jobs_logger to be monitor_logger
+* run monitoring tests in background
+* move methods from QaServer to services
+* use presenter to get failure data
+* move controller validation code to module include
+* limit historical data to configurable time period
+* move time_period where clause construction to service
+
 ### 5.5.1 (2020-01-29)
 
 * fix - check for nil before calling .each

data/README.md

@@ -1,4 +1,5 @@
 # QaServer
+
 This rails engine can be installed into your app to serve as a Questioning Authority (QA) Server for accessing external authorities.  It is part of a larger architecture supporting linked data authority access.  From this engine, you can send a search query and get back multiple results OR you can fetch a single term.  The engine provides UI for monitoring connections to configured authorities and the ability to check the current status of a single authority to determine if it is up and running now. 
 
 ## Reference
@@ -25,6 +26,7 @@ Only required if you want to generate status charts.  Generated charts will be s
 `app/assets/images/qa_server/charts` directory.  By default status is displayed in a table.
 
 1. [ImageMagick](http://www.imagemagick.org/)
+2. job queue processor of your choice
 
 ### Installation Instructions
 
@@ -58,6 +60,57 @@ $ rake db:migrate
 
 If upgrading instead of installing, see the Release notes for steps you may need to take manually since you won't be running the installer.
 
+#### Setting up monitoring
+
+Monitoring runs once a day as a background job.  
+
+##### Configuring cache expiration
+
+There are several configurations that control when the monitoring job will execute.
+
+```
+    # Preferred time zone for reporting historical data and performance data
+    # @param [String] time zone name
+    # @see https://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html for possible values of TimeZone names
+    attr_writer :preferred_time_zone_name
+    def preferred_time_zone_name
+      @preferred_time_zone_name ||= 'Eastern Time (US & Canada)'
+    end
+
+    # Set preferred hour to expire caches related to slow running calculations (e.g. monitoring tests, performance data)
+    # @param [Integer] count of hours after midnight (0-23 with 0=midnight)
+    # @raise [ArgumentError] if offset is not between 0 and 23
+    # @example
+    #   For preferred_time_zone_name of 'Eastern Time (US & Canada)', use 3 for slow down at midnight PT/3am ET
+    #   For preferred_time_zone_name of 'Pacific Time (US & Canada)', use 0 for slow down at midnight PT/3am ET
+    def hour_offset_to_expire_cache=(offset)
+      raise ArgumentError, 'offset must be between 0 and 23' unless (0..23).cover? offset
+      @hour_offset_to_expire_cache = offset
+    end
+```
+
+With the default values set for the cache configurations, the cache will expire at midnight Pacific Time/3am Eastern Time.
+
+##### Process for updating monitoring tests
+
+Monitoring works in conjuction with the cache.  When the cache expires, the monitoring tests will run the next time the monitor status page is accessed.  When the monitor status page loads, it attempts to get the data for the page from the cache.  If the cache has expired, it will get the previous day's data and kick off a background job to run the tests and update the cache.
+
+##### Controlling when tests run
+
+Because this process is launched by access to the monitor status page, it will not by default run the monitoring tests everyday.  In our system, we set up Pingdom to access the monitor status page hourly around the clock.  If an error occurs during the latest testing, the monitor status page includes a CSS class `summary-status-bad` and displays error results.  Pingdom is configured to send a notification if the `summary-status-bad` CSS class is on the page, letting us know that we need to look into a problem with authority access.
+
+##### Setting up background jobs
+
+Reference: https://guides.rubyonrails.org/active_job_basics.html
+
+Since this job is not critical for end users, you can set up jobs to be processed by the ruby provided in-memory job queue.  The risk here is that if the server restarts or some other failure occurs, jobs in that queue are lost.  If this is unacceptable for your system, then you will want to setup a 3rd party job queue ([more info...](https://guides.rubyonrails.org/active_job_basics.html#starting-the-backend)).
+
+To configure in-memory job queue, add the following to config/environments/production.rb
+
+```
+  config.active_job.queue_adapter = :async # runs in-memory; a crash will lose the job
+```
+
 #### Test the install
 
 * Start rails server with `rails s`

data/app/controllers/{qa_server/authority_validation_controller.rb → concerns/qa_server/authority_validation_behavior.rb}

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 module QaServer
-  class AuthorityValidationController < ApplicationController
-    layout 'qa_server'
-
-    class_attribute :validator_class,
-                    :lister_class,
-                    :logger_class
-
-    self.validator_class = QaServer::AuthorityValidatorService
-    self.lister_class = QaServer::AuthorityListerService
-    self.logger_class = QaServer::ScenarioLogger
+  module AuthorityValidationBehavior
+    extend ActiveSupport::Concern
 
     VALIDATION_TYPE_PARAM = :validation_type
     VALIDATE_CONNECTIONS = 'connections'
     VALIDATE_ACCURACY = 'accuracy'
     ALL_VALIDATIONS = 'all_checks'
-    DEFAULT_VALIDATION_TYPE = validator_class::VALIDATE_CONNECTIONS
+    DEFAULT_VALIDATION_TYPE = QaServer::AuthorityValidatorService
+
+    included do
+      class_attribute :validator_class,
+                      :lister_class,
+                      :logger_class
+
+      self.validator_class = QaServer::AuthorityValidatorService
+      self.lister_class = QaServer::AuthorityListerService
+      self.logger_class = QaServer::ScenarioLogger
+    end
 
     private
 

data/app/controllers/qa_server/authority_list_controller.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 # Controller for Authorities header menu item
 module QaServer
-  class AuthorityListController < QaServer::AuthorityValidationController
+  class AuthorityListController < ApplicationController
+    layout 'qa_server'
+
+    include QaServer::AuthorityValidationBehavior
+
     class_attribute :presenter_class
     self.presenter_class = QaServer::AuthorityListPresenter
 

data/app/controllers/qa_server/check_status_controller.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 # Controller for Check Status header menu item
 module QaServer
-  class CheckStatusController < QaServer::AuthorityValidationController
+  class CheckStatusController < ApplicationController
+    layout 'qa_server'
+
+    include QaServer::AuthorityValidationBehavior
+
     ALL_AUTHORITIES = '__all__'
 
     class_attribute :presenter_class

data/app/controllers/qa_server/monitor_status_controller.rb

@@ -1,45 +1,58 @@
 # frozen_string_literal: true
 # Controller for Monitor Status header menu item
 module QaServer
-  class MonitorStatusController < QaServer::AuthorityValidationController
+  class MonitorStatusController < ApplicationController
+    layout 'qa_server'
+
+    include QaServer::AuthorityValidationBehavior
+
     class_attribute :presenter_class,
                     :scenario_run_registry_class,
                     :scenario_history_class,
-                    :performance_history_class
+                    :performance_history_class,
+                    :graphing_service_class
     self.presenter_class = QaServer::MonitorStatusPresenter
     self.scenario_run_registry_class = QaServer::ScenarioRunRegistry
     self.scenario_history_class = QaServer::ScenarioRunHistory
     self.performance_history_class = QaServer::PerformanceHistory
+    self.graphing_service_class = QaServer::PerformanceGraphingService
 
     # Sets up presenter with data to display in the UI
     def index
-      latest_run
+      log_header
+      latest_test_run
       @presenter = presenter_class.new(current_summary: latest_summary,
                                        current_failure_data: latest_failures,
                                        historical_summary_data: historical_data,
-                                       performance_data: performance_data)
+                                       performance_data: performance_table_data)
+      update_performance_graphs
       render 'index', status: :internal_server_error if latest_summary.failing_authority_count.positive?
     end
 
     private
 
-      # Sets @latest_run [QaServer::ScenarioRunRegistry]
-      def 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)
+      # Sets @latest_test_run [QaServer::ScenarioRunRegistry]
+      def latest_test_run
+        @latest_test_run ||= latest_test_run_from_cache
+      end
+
+      # cache of latest run; runs tests if cache is expired
+      # @see #latest_test_run_from_temp_cache
+      def latest_test_run_from_cache
+        Rails.cache.fetch("#{self.class}/#{__method__}", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 5.minutes, force: refresh_tests?) do
+          QaServer.config.monitor_logger.info("(#{self.class}##{__method__}) get latest run of monitoring tests - cache expired or refresh requested (force: #{refresh_tests?})")
+          QaServer::MonitorTestsJob.perform_later
           scenario_run_registry_class.latest_run
         end
       end
 
       # Sets @latest_summary [QaServer::ScenarioRunSummary]
       def latest_summary
-        scenario_history_class.run_summary(scenario_run: latest_run, force: refresh_tests?)
+        scenario_history_class.run_summary(scenario_run: latest_test_run, force: refresh_tests?)
       end
 
       def latest_failures
-        scenario_history_class.run_failures(run_id: latest_run.id, force: refresh_tests?)
+        scenario_history_class.run_failures(run_id: latest_test_run.id, force: refresh_tests?)
       end
 
       # Sets @historical_data [Array<Hash>]
@@ -47,16 +60,15 @@ module QaServer
         scenario_history_class.historical_summary(force: refresh_history?)
       end
 
-      # Sets @performance_data [Hash<Hash>]
-      def performance_data
-        performance_history_class.performance_data(datatype: performance_datatype, force: refresh_performance?)
+      # Sets @performance_table_data [Hash<Hash>]
+      def performance_table_data
+        display_performance_datatable? ? performance_history_class.performance_table_data(force: refresh_performance?) : {}
       end
 
-      def performance_datatype
-        return :all if display_performance_datatable? && display_performance_graph?
-        return :datatable if display_performance_datatable?
-        return :graph if display_performance_graph?
-        :none
+      def update_performance_graphs
+        return unless display_performance_graph?
+        data = performance_history_class.performance_graph_data(force: refresh_performance?)
+        graphing_service_class.create_performance_graphs(performance_data: data)
       end
 
       def display_performance_datatable?
@@ -67,14 +79,6 @@ module QaServer
         @display_performance_graph ||= QaServer.config.display_performance_graph?
       end
 
-      def refresh_history
-        historical_summary_data(refresh: refresh_history?)
-      end
-
-      def refresh_performance
-        performance_data(refresh: refresh_performance?)
-      end
-
       def refresh?
         params.key? :refresh
       end
@@ -98,5 +102,13 @@ module QaServer
         return false unless refresh?
         refresh_all? || params[:refresh].casecmp?('performance')
       end
+
+      def log_header
+        QaServer.config.monitor_logger.debug("----------------------------------------------------------------------")
+        QaServer.config.monitor_logger.debug("                         loading monitor status page")
+        QaServer.config.monitor_logger.debug("----------------------------------------------------------------------")
+        QaServer.config.monitor_logger.info("(#{self.class}##{__method__}) monitor status page request (refresh_tests? # #{refresh_tests?}, " \
+                                         "refresh_history? # #{refresh_history?}, refresh_performance? # #{refresh_performance?})")
+      end
   end
 end

data/app/jobs/qa_server/monitor_tests_job.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# Job to run monitoring tests
+module QaServer
+  class MonitorTestsJob < ApplicationJob
+    include QaServer::AuthorityValidationBehavior
+
+    queue_as :default
+
+    class_attribute :scenario_run_registry_class
+    self.scenario_run_registry_class = QaServer::ScenarioRunRegistry
+
+    # def perform(job_id:)
+    def perform
+      Rails.cache.fetch("QaServer::MonitorTestsController/latest_run", expires_in: QaServer::MonitorCacheService.cache_expiry, race_condition_ttl: 5.minutes, force: true) do
+        job_id = SecureRandom.uuid
+        monitor_tests_job_id = job_id unless monitor_tests_job_id
+        if monitor_tests_job_id == job_id # avoid race conditions
+          QaServer.config.monitor_logger.info("(#{self.class}##{__method__}-#{job_id}) RUNNING monitoring tests")
+          validate(authorities_list)
+          scenario_run_registry_class.save_run(scenarios_results: status_log.to_a)
+          QaServer.config.monitor_logger.info("(#{self.class}##{__method__}-#{job_id}) COMPLETED monitoring tests")
+          reset_monitor_tests_job_id
+        end
+        scenario_run_registry_class.latest_run
+      end
+    end
+
+    private
+
+      # @return [String, Boolean] Returns job id of the job currently running tests; otherwise, false if tests are not running
+      def monitor_tests_job_id
+        Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 5.minutes) { false }
+      end
+
+      # Set the id of the job that will run the tests.
+      # @param job_id [String] UUID for job running the tests
+      def monitor_tests_job_id=(job_id)
+        # check to see if there is a current job already running tests
+        current_job_id = Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 30.seconds) { job_id }
+
+        # current_job_id may be false meaning tests are not currently running; in which case, it is ok to force set job_id
+        Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 30.seconds, force: true) { job_id } unless current_job_id
+      end
+
+      # Set job id for monitor tests to false indicating that tests are not currently running
+      def reset_monitor_tests_job_id
+        Rails.cache.fetch("QaServer:monitor_tests-job_id", expires_in: 2.hours, race_condition_ttl: 30.seconds, force: true) { false }
+      end
+  end
+end

data/app/models/qa_server/performance_cache.rb

@@ -7,7 +7,7 @@ module QaServer
     end
 
     def new_entry(authority:, action:)
-      entry = { dt_stamp: QaServer.current_time,
+      entry = { dt_stamp: QaServer::TimeService.current_time,
                 authority: authority,
                 action: action }
       id = SecureRandom.uuid
@@ -36,8 +36,7 @@ module QaServer
                                             normalization_time_ms: entry[:normalization_time_ms])
         @cache.delete(id)
       end
-      Rails.logger.warn("0 of #{size_before} performance data records were saved") if size_before.positive? && (size_before == @cache.size)
-      Rails.logger.info("#{size_before - @cache.size} of #{size_before} performance data records were saved") if size_before.positive? && (size_before > @cache.size)
+      log_write_all("(#{self.class}##{__method__})", size_before, @cache.size)
     end
 
     def log(id:)
@@ -63,5 +62,14 @@ module QaServer
          :graph_load_time_ms,
          :normalization_time_ms]
       end
+
+      def log_write_all(prefix, size_before, cache_size)
+        if size_before.positive?
+          QaServer.config.monitor_logger.warn("#{prefix} 0 of #{size_before} performance data records were saved") if size_before == cache_size
+          QaServer.config.monitor_logger.info("#{prefix} #{size_before - cache_size} of #{size_before} performance data records were saved") if size_before > cache_size
+        else
+          QaServer.config.monitor_logger.info("#{prefix} 0 of 0 performance data records were saved")
+        end
+      end
   end
 end

data/app/models/qa_server/performance_history.rb

@@ -6,11 +6,9 @@ module QaServer
 
     enum action: [:fetch, :search]
 
-    class_attribute :stats_calculator_class, :graph_data_service_class, :graphing_service_class, :authority_list_class
-    self.stats_calculator_class = QaServer::PerformanceCalculatorService
+    class_attribute :datatable_data_service_class, :graph_data_service_class
+    self.datatable_data_service_class = QaServer::PerformanceDatatableService
     self.graph_data_service_class = QaServer::PerformanceGraphDataService
-    self.graphing_service_class = QaServer::PerformanceGraphingService
-    self.authority_list_class = QaServer::AuthorityListerService
 
     class << self
       include QaServer::PerformanceHistoryDataKeys
@@ -20,12 +18,30 @@ module QaServer
       # @param action [Symbol] type of action being evaluated (e.g. :fetch, :search)
       # @param dt_stamp [Time] defaults to current time in preferred time zone
       # @return ActveRecord::Base for the new performance history record
-      def create_record(authority:, action:, dt_stamp: QaServer.current_time)
+      def create_record(authority:, action:, dt_stamp: QaServer::TimeService.current_time)
         create(dt_stamp: dt_stamp,
                authority: authority,
                action: action)
       end
 
+      # Performance data for a day, a month, a year, and all time for each authority.
+      # @param datatype [Symbol] what type of data should be calculated (e.g. :datatable, :graph, :all)
+      # @returns [Hash] performance statistics for the past 24 hours
+      # @example
+      #   { all_authorities:
+      #     { search:
+      #       { 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 },
+      #       fetch: { ... # same data as for search_stats },
+      #       all: { ... # same data as for search_stats }
+      #     },
+      #     AGROVOC_LD4L_CACHE: { ... # same data for each authority  }
+      #   }
+      def performance_table_data(force: false)
+        datatable_data_service_class.calculate_datatable_data(force: force)
+      end
+
       # Performance data for a day, a month, a year, and all time for each authority.
       # @param datatype [Symbol] what type of data should be calculated (e.g. :datatable, :graph, :all)
       # @returns [Hash] performance statistics for the past 24 hours
@@ -33,10 +49,6 @@ module QaServer
       #   { all_authorities:
       #     { search:
       #       {
-      #         datatable_stats:
-      #           { 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 }
       #         day:
       #           { 0: { hour: '1400', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
       #             1: { hour: '1500', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }},
@@ -59,108 +71,14 @@ module QaServer
       #             11: { month: '08-2019', stats: { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5, etc. }}
       #           }
       #       },
-      #       fetch: { ... # same data as for search_stats }
+      #       fetch: { ... # same data as for search_stats },
       #       all: { ... # same data as for search_stats }
       #     },
       #     AGROVOC_LD4L_CACHE: { ... # same data for each authority  }
       #   }
-      def performance_data(datatype: :datatable, force: false)
-        return if datatype == :none
-        QaServer.config.performance_cache.write_all
-        data = calculate_data(datatype, force: force)
-        graphing_service_class.create_performance_graphs(performance_data: data) if calculate_graphdata? datatype
-        data
+      def performance_graph_data(force: false)
+        graph_data_service_class.calculate_graph_data(force: force)
       end
-
-      private
-
-        def calculate_datatable?(datatype)
-          datatype == :datatable || datatype == :all
-        end
-
-        def calculate_graphdata?(datatype)
-          datatype == :graph || datatype == :all
-        end
-
-        def calculate_data(datatype, force:)
-          data = {}
-          auths = authority_list_class.authorities_list
-          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:, force:)
-          action_data = {}
-          [:search, :fetch, :all_actions].each do |action|
-            data = {}
-            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, 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
-          action_data
-        end
-
-        # Get statistics for all available data.
-        # @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, 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
-          QaServer.config.performance_datatable_default_time_period
-        end
-
-        def records_for_last_24_hours(auth_name)
-          return unless expected_time_period == :day
-          end_hour = QaServer.current_time
-          start_hour = end_hour - 23.hours
-          where_clause = { dt_stamp: start_hour..end_hour }
-          records_for_authority(auth_name, where_clause)
-        end
-
-        def records_for_last_30_days(auth_name)
-          return unless expected_time_period == :month
-          end_day = QaServer.current_time
-          start_day = end_day - 29.days
-          where_clause = { dt_stamp: start_day..end_day }
-          records_for_authority(auth_name, where_clause)
-        end
-
-        def records_for_last_12_months(auth_name)
-          return unless expected_time_period == :year
-          end_month = QaServer.current_time
-          start_month = end_month - 11.months
-          where_clause = { dt_stamp: start_month..end_month }
-          records_for_authority(auth_name, where_clause)
-        end
-
-        def all_records(auth_name)
-          auth_name.nil? ? PerformanceHistory.all : where(authority: auth_name)
-        end
-
-        def records_for_authority(auth_name, where_clause)
-          where_clause[:authority] = auth_name unless auth_name.nil?
-          where(where_clause)
-        end
     end
   end
 end