Add maintenance window logic

config/locales/en.yml

@@ -67,3 +67,9 @@ en:
             return a boolean indicating whether the page is cached and will
             be served by rack middleware.
           default: proc { |_rack_env| false }
+        bigquery_maintenance_window:
+          description: |
+            Schedule a maintenance window during which no events are streamed to BigQuery
+            in the format of '22-01-2024 19:30..22-01-2024 20:30'.
+          default: ENV['BIGQUERY_MAINTENANCE_WINDOW']
+

lib/dfe/analytics.rb

@@ -63,6 +63,7 @@ def self.config
         pseudonymise_web_request_user_id
         entity_table_checks_enabled
         rack_page_cached
+        bigquery_maintenance_window
       ]
 
       @config ||= Struct.new(*configurables).new
@@ -86,6 +87,7 @@ def self.configure
       config.pseudonymise_web_request_user_id ||= false
       config.entity_table_checks_enabled      ||= false
       config.rack_page_cached                 ||= proc { |_rack_env| false }
+      config.bigquery_maintenance_window      ||= ENV.fetch('BIGQUERY_MAINTENANCE_WINDOW', nil)
     end
 
     def self.initialize!
@@ -244,5 +246,32 @@ def self.rack_page_cached?(rack_env)
     def self.entity_table_checks_enabled?
       config.entity_table_checks_enabled
     end
+
+    def self.parse_maintenance_window
+      return [nil, nil] unless config.bigquery_maintenance_window
+
+      start_str, end_str = config.bigquery_maintenance_window.split('..', 2).map(&:strip)
+      begin
+        start_time = DateTime.strptime(start_str, '%d-%m-%Y %H:%M')
+        end_time = DateTime.strptime(end_str, '%d-%m-%Y %H:%M')
+
+        if start_time > end_time
+          Rails.logger.info('Start time is after end time in maintenance window configuration')
+          return [nil, nil]
+        end
+
+        [start_time, end_time]
+      rescue ArgumentError => e
+        Rails.logger.info("DfE::Analytics: Unexpected error in maintenance window configuration: #{e.message}")
+        [nil, nil]
+      end
+    end
+
+    def self.within_maintenance_window?
+      start_time, end_time = parse_maintenance_window
+      return false unless start_time && end_time
+
+      DateTime.now.between?(start_time, end_time)
+    end
   end
 end

lib/dfe/analytics/send_events.rb

@@ -18,6 +18,12 @@ def self.do(events)
       end
 
       def perform(events)
+        if DfE::Analytics.within_maintenance_window?
+          # Delaying / Queueing events - the redis bit
+          Rails.logger.info('Within BigQuery maintenance window. Events will be queued for later processing.')
+          return
+        end
+
         if DfE::Analytics.log_only?
           # Use the Rails logger here as the job's logger is set to :warn by default
           Rails.logger.info("DfE::Analytics: #{events.inspect}")

spec/dfe/analytics/send_events_spec.rb

@@ -162,5 +162,41 @@
         end
       end
     end
+
+    context 'within the BigQuery maintenance window' do
+      before do
+        allow(DfE::Analytics).to receive(:within_maintenance_window?).and_return(true)
+      end
+
+      it 'logs that events will be queued for later processing and does not send events' do
+        expect(Rails.logger).to receive(:info).with('Within BigQuery maintenance window. Events will be queued for later processing.')
+
+        request = stub_analytics_event_submission
+        DfE::Analytics::Testing.webmock! do
+          described_class.new.perform([event.as_json])
+          expect(request).not_to have_been_made
+        end
+      end
+    end
+
+    context 'outside the BigQuery maintenance window' do
+      before do
+        allow(DfE::Analytics).to receive(:within_maintenance_window?).and_return(false)
+      end
+
+      it 'sends events to BigQuery' do
+        request = stub_analytics_event_submission
+
+        DfE::Analytics::Testing.webmock! do
+          described_class.new.perform([event.as_json])
+
+          expect(request.with do |req|
+            body = JSON.parse(req.body)
+            payload = body['rows'].first['json']
+            expect(payload.except('occurred_at', 'request_uuid')).to match(a_hash_including(event.deep_stringify_keys))
+          end).to have_been_made
+        end
+      end
+    end
   end
 end

spec/dfe/analytics_spec.rb

@@ -184,4 +184,67 @@
       end
     end
   end
+
+  describe '.parse_maintenance_window' do
+    context 'with a valid maintenance window' do
+      before do
+        allow(described_class.config).to receive(:bigquery_maintenance_window)
+          .and_return('01-01-2020 00:00..01-01-2020 23:59')
+      end
+
+      it 'returns the correct start and end times' do
+        start_time, end_time = described_class.parse_maintenance_window
+        expect(start_time).to eq(DateTime.new(2020, 1, 1, 0, 0))
+        expect(end_time).to eq(DateTime.new(2020, 1, 1, 23, 59))
+      end
+    end
+
+    context 'when start time is after end time' do
+      before do
+        allow(described_class.config).to receive(:bigquery_maintenance_window)
+          .and_return('01-01-2020 23:59..01-01-2020 00:00')
+      end
+
+      it 'logs an error and returns [nil, nil]' do
+        expect(Rails.logger).to receive(:info).with(/Start time is after end time/)
+        expect(described_class.parse_maintenance_window).to eq([nil, nil])
+      end
+    end
+
+    context 'with an invalid format' do
+      before do
+        allow(described_class.config).to receive(:bigquery_maintenance_window)
+          .and_return('invalid_format')
+      end
+
+      it 'logs an error and returns [nil, nil]' do
+        expect(Rails.logger).to receive(:info).with(/Unexpected error/)
+        expect(described_class.parse_maintenance_window).to eq([nil, nil])
+      end
+    end
+  end
+
+  describe '.within_maintenance_window?' do
+    context 'when the current time is within the maintenance window' do
+      before do
+        allow(described_class).to receive(:parse_maintenance_window)
+          .and_return([DateTime.now - 1.hour, DateTime.now + 1.hour])
+      end
+
+      it 'returns true' do
+        expect(described_class.within_maintenance_window?).to be true
+      end
+    end
+
+    context 'when the current time is outside the maintenance window' do
+      before do
+        allow(described_class).to receive(:parse_maintenance_window)
+          .and_return([DateTime.now - 2.days, DateTime.now - 1.day])
+      end
+
+      it 'returns false' do
+        expect(described_class.within_maintenance_window?).to be false
+      end
+    end
+  end
 end