Keep usage event records of running apps and services

AppUsageEvent and ServiceUsageEvent records can be used to track the lifecycle of apps and services in a foundation. However, if the start event is pruned before end event, the foundation no longer maintains an accurate state of its running apps and services. By holding on to the start events, consumers of these records are able to get an accurate picture of the current state whenever they choose to begin consuming usage event records.

Author: joyvuu-dave

app/repositories/app_usage_event_repository.rb

@@ -152,7 +152,7 @@ def purge_and_reseed_started_apps!
       end
 
       def delete_events_older_than(cutoff_age_in_days)
-        Database::OldRecordCleanup.new(AppUsageEvent, cutoff_age_in_days: cutoff_age_in_days, keep_at_least_one_record: true).delete
+        Database::OldRecordCleanup.new(AppUsageEvent, cutoff_age_in_days: cutoff_age_in_days, keep_at_least_one_record: true, keep_running_records: true).delete
       end
 
       private

app/repositories/service_usage_event_repository.rb

@@ -92,7 +92,7 @@ def purge_and_reseed_service_instances!
       end
 
       def delete_events_older_than(cutoff_age_in_days)
-        Database::OldRecordCleanup.new(ServiceUsageEvent, cutoff_age_in_days: cutoff_age_in_days, keep_at_least_one_record: true).delete
+        Database::OldRecordCleanup.new(ServiceUsageEvent, cutoff_age_in_days: cutoff_age_in_days, keep_at_least_one_record: true, keep_running_records: true).delete
       end
     end
   end

lib/database/old_record_cleanup.rb

@@ -3,12 +3,13 @@
 module Database
   class OldRecordCleanup
     class NoCurrentTimestampError < StandardError; end
-    attr_reader :model, :days_ago, :keep_at_least_one_record
+    attr_reader :model, :days_ago, :keep_at_least_one_record, :keep_running_records
 
-    def initialize(model, cutoff_age_in_days:, keep_at_least_one_record: false)
+    def initialize(model, cutoff_age_in_days:, keep_at_least_one_record: false, keep_running_records: false)
       @model = model
       @days_ago = cutoff_age_in_days
       @keep_at_least_one_record = keep_at_least_one_record
+      @keep_running_records = keep_running_records
     end
 
     def delete
@@ -21,6 +22,8 @@ def delete
       end
       logger.info("Cleaning up #{old_records.count} #{model.table_name} table rows")
 
+      old_records = exclude_running_records(old_records) if keep_running_records
+
       Database::BatchDelete.new(old_records, 1000).delete
     end
 
@@ -35,5 +38,55 @@ def current_timestamp_from_database
     def logger
       @logger ||= Steno.logger('cc.old_record_cleanup')
     end
+
+    def exclude_running_records(old_records)
+      return old_records unless has_duration?(model)
+
+      beginning_string = beginning_string(model)
+      ending_string = ending_string(model)
+      guid_symbol = guid_symbol(model)
+
+      raise "Invalid duration model: #{model}" if beginning_string.nil? || ending_string.nil? || guid_symbol.nil?
+
+      initial_records = old_records.where(state: beginning_string).from_self(alias: :initial_records)
+      final_records = old_records.where(state: ending_string).from_self(alias: :final_records)
+
+      exists_condition = final_records.where(Sequel[:final_records][guid_symbol] => Sequel[:initial_records][guid_symbol]).where do
+        Sequel[:final_records][:id] > Sequel[:initial_records][:id]
+      end.select(1).exists
+
+      prunable_initial_records = initial_records.where(exists_condition)
+      other_records = old_records.exclude(state: [beginning_string, ending_string])
+
+      prunable_initial_records.union(final_records, all: true).union(other_records, all: true)
+    end
+
+    def has_duration?(model)
+      return true if model == VCAP::CloudController::AppUsageEvent
+      return true if model == VCAP::CloudController::ServiceUsageEvent
+
+      false
+    end
+
+    def beginning_string(model)
+      return VCAP::CloudController::ProcessModel::STARTED if model == VCAP::CloudController::AppUsageEvent
+      return VCAP::CloudController::Repositories::ServiceUsageEventRepository::CREATED_EVENT_STATE if model == VCAP::CloudController::ServiceUsageEvent
+
+      nil
+    end
+
+    def ending_string(model)
+      return VCAP::CloudController::ProcessModel::STOPPED if model == VCAP::CloudController::AppUsageEvent
+      return VCAP::CloudController::Repositories::ServiceUsageEventRepository::DELETED_EVENT_STATE if model == VCAP::CloudController::ServiceUsageEvent
+
+      nil
+    end
+
+    def guid_symbol(model)
+      return :app_guid if model == VCAP::CloudController::AppUsageEvent
+      return :service_instance_guid if model == VCAP::CloudController::ServiceUsageEvent
+
+      nil
+    end
   end
 end

spec/unit/jobs/runtime/app_usage_events_cleanup_spec.rb

@@ -5,7 +5,7 @@ module Jobs::Runtime
     RSpec.describe AppUsageEventsCleanup, job_context: :worker do
       let(:cutoff_age_in_days) { 30 }
       let(:logger) { double(Steno::Logger, info: nil) }
-      let!(:event_before_threshold) { AppUsageEvent.make(created_at: (cutoff_age_in_days + 1).days.ago) }
+      let!(:event_before_threshold) { AppUsageEvent.make(created_at: (cutoff_age_in_days + 1).days.ago, state: 'STOPPED') }
       let!(:event_after_threshold) { AppUsageEvent.make(created_at: (cutoff_age_in_days - 1).days.ago) }
 
       subject(:job) do

spec/unit/jobs/services/service_usage_events_cleanup_spec.rb

@@ -5,7 +5,7 @@ module Jobs::Services
     RSpec.describe ServiceUsageEventsCleanup, job_context: :worker do
       let(:cutoff_age_in_days) { 30 }
       let(:logger) { double(Steno::Logger, info: nil) }
-      let!(:event_before_threshold) { ServiceUsageEvent.make(created_at: (cutoff_age_in_days + 1).days.ago) }
+      let!(:event_before_threshold) { ServiceUsageEvent.make(created_at: (cutoff_age_in_days + 1).days.ago, state: 'DELETED') }
       let!(:event_after_threshold) { ServiceUsageEvent.make(created_at: (cutoff_age_in_days - 1).days.ago) }
 
       subject(:job) do

spec/unit/lib/database/old_record_cleanup_spec.rb

@@ -3,12 +3,12 @@
 
 RSpec.describe Database::OldRecordCleanup do
   describe '#delete' do
-    let!(:stale_event1) { VCAP::CloudController::Event.make(created_at: 1.day.ago - 1.minute) }
-    let!(:stale_event2) { VCAP::CloudController::Event.make(created_at: 2.days.ago) }
+    it 'deletes records older than specified days' do
+      stale_event1 = VCAP::CloudController::Event.make(created_at: 1.day.ago - 1.minute)
+      stale_event2 = VCAP::CloudController::Event.make(created_at: 2.days.ago)
 
-    let!(:fresh_event) { VCAP::CloudController::Event.make(created_at: 1.day.ago + 1.minute) }
+      fresh_event = VCAP::CloudController::Event.make(created_at: 1.day.ago + 1.minute)
 
-    it 'deletes records older than specified days' do
       record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::Event, cutoff_age_in_days: 1)
 
       expect do
@@ -22,10 +22,10 @@
 
     context "when there are no records at all but you're trying to keep at least one" do
       it "doesn't keep one because there aren't any to keep" do
-        record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::ServiceUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: true)
+        record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::AppEvent, cutoff_age_in_days: 1, keep_at_least_one_record: true, keep_running_records: true)
 
         expect { record_cleanup.delete }.not_to raise_error
-        expect(VCAP::CloudController::ServiceUsageEvent.count).to eq(0)
+        expect(VCAP::CloudController::AppEvent.count).to eq(0)
       end
     end
 
@@ -36,7 +36,12 @@
     end
 
     it 'keeps the last row when :keep_at_least_one_record is true even if it is older than the cutoff date' do
-      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::Event, cutoff_age_in_days: 0, keep_at_least_one_record: true)
+      stale_event1 = VCAP::CloudController::Event.make(created_at: 1.day.ago - 1.minute)
+      stale_event2 = VCAP::CloudController::Event.make(created_at: 2.days.ago)
+
+      fresh_event = VCAP::CloudController::Event.make(created_at: 1.day.ago + 1.minute)
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::Event, cutoff_age_in_days: 0, keep_at_least_one_record: true, keep_running_records: true)
 
       expect do
         record_cleanup.delete
@@ -46,5 +51,62 @@
       expect { stale_event1.reload }.to raise_error(Sequel::NoExistingObject)
       expect { stale_event2.reload }.to raise_error(Sequel::NoExistingObject)
     end
+
+    # Testing keep_running_records feature
+    it 'keeps AppUsageEvent start record when there is no corresponding stop record' do
+      stale_app_usage_event_start = VCAP::CloudController::AppUsageEvent.make(created_at: 2.days.ago, state: 'STARTED', app_guid: 'guid1')
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::AppUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: false, keep_running_records: true)
+      record_cleanup.delete
+      expect(stale_app_usage_event_start.reload).to be_present
+    end
+
+    it 'keeps AppUsageEvent start record when stop record is fresh' do
+      stale_app_usage_event_start = VCAP::CloudController::AppUsageEvent.make(created_at: 2.days.ago, state: 'STARTED', app_guid: 'guid1')
+      fresh_app_usage_event_stop = VCAP::CloudController::AppUsageEvent.make(created_at: 1.day.ago + 1.minute, state: 'STOPPED', app_guid: 'guid1')
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::AppUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: false, keep_running_records: true)
+      record_cleanup.delete
+      expect(stale_app_usage_event_start.reload).to be_present
+      expect(fresh_app_usage_event_stop.reload).to be_present
+    end
+
+    it 'keeps AppUsageEvent start record when stop record is newer' do
+      stale_app_usage_event_stop = VCAP::CloudController::AppUsageEvent.make(created_at: 3.days.ago, state: 'STOPPED', app_guid: 'guid1')
+      stale_app_usage_event_start = VCAP::CloudController::AppUsageEvent.make(created_at: 2.days.ago, state: 'STARTED', app_guid: 'guid1')
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::AppUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: false, keep_running_records: true)
+      record_cleanup.delete
+      expect(stale_app_usage_event_start.reload).to be_present
+      expect { stale_app_usage_event_stop.reload }.to raise_error(Sequel::NoExistingObject)
+    end
+
+    it 'keeps ServiceUsageEvent create record when there is no corresponding delete record' do
+      stale_service_usage_event_create = VCAP::CloudController::ServiceUsageEvent.make(created_at: 2.days.ago, state: 'CREATED', service_instance_guid: 'guid1')
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::ServiceUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: false, keep_running_records: true)
+      record_cleanup.delete
+      expect(stale_service_usage_event_create.reload).to be_present
+    end
+
+    it 'keeps ServiceUsageEvent create record when delete record is fresh' do
+      stale_service_usage_event_create = VCAP::CloudController::ServiceUsageEvent.make(created_at: 2.days.ago, state: 'CREATED', service_instance_guid: 'guid1')
+      fresh_service_usage_event_delete = VCAP::CloudController::ServiceUsageEvent.make(created_at: 1.day.ago + 1.minute, state: 'DELETED', service_instance_guid: 'guid1')
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::ServiceUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: false, keep_running_records: true)
+      record_cleanup.delete
+      expect(stale_service_usage_event_create.reload).to be_present
+      expect(fresh_service_usage_event_delete.reload).to be_present
+    end
+
+    it 'keeps ServiceUsageEvent create record when delete record is newer' do
+      stale_service_usage_event_delete = VCAP::CloudController::ServiceUsageEvent.make(created_at: 3.days.ago, state: 'DELETED', service_instance_guid: 'guid1')
+      stale_service_usage_event_create = VCAP::CloudController::ServiceUsageEvent.make(created_at: 2.days.ago, state: 'CREATED', service_instance_guid: 'guid1')
+
+      record_cleanup = Database::OldRecordCleanup.new(VCAP::CloudController::ServiceUsageEvent, cutoff_age_in_days: 1, keep_at_least_one_record: false, keep_running_records: true)
+      record_cleanup.delete
+      expect(stale_service_usage_event_create.reload).to be_present
+      expect { stale_service_usage_event_delete.reload }.to raise_error(Sequel::NoExistingObject)
+    end
   end
 end