Recognize WAS_RUNNING as a beginning state in keep-running cleanup

Extend usage_lifecycle.beginning_state on AppUsageEvent and
ServiceUsageEvent to be an array containing both the existing
state (STARTED / CREATED) and WAS_RUNNING. Update OldRecordCleanup
so the "other states" exclusion flattens the begin states correctly.

Without this, synthetic WAS_RUNNING rows (added in a follow-up
migration) would be pruned at 31 days even when their resource is
still running.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: joyvuu-dave

app/models/runtime/app_usage_event.rb

@@ -12,7 +12,7 @@ class AppUsageEvent < Sequel::Model
 
     def self.usage_lifecycle
       {
-        beginning_state: ProcessModel::STARTED,
+        beginning_state: [ProcessModel::STARTED, Repositories::AppUsageEventRepository::WAS_RUNNING_STATE],
         ending_state: ProcessModel::STOPPED,
         guid_column: :app_guid
       }.freeze

app/models/services/service_usage_event.rb

@@ -10,7 +10,8 @@ class ServiceUsageEvent < Sequel::Model
 
     def self.usage_lifecycle
       {
-        beginning_state: Repositories::ServiceUsageEventRepository::CREATED_EVENT_STATE,
+        beginning_state: [Repositories::ServiceUsageEventRepository::CREATED_EVENT_STATE,
+                          Repositories::ServiceUsageEventRepository::WAS_RUNNING_EVENT_STATE],
         ending_state: Repositories::ServiceUsageEventRepository::DELETED_EVENT_STATE,
         guid_column: :service_instance_guid
       }.freeze

lib/database/old_record_cleanup.rb

@@ -60,8 +60,9 @@ def exclude_running_records(old_records)
 
       prunable_initial_records = initial_records.where(exists_condition)
 
-      # Include records with states other than START/STOP
-      other_records = old_records.exclude(state: [beginning_state, ending_state])
+      # Include records with states other than START/STOP. beginning_state may be a
+      # scalar or an array; flatten so the exclude clause produces a flat list of states.
+      other_records = old_records.exclude(state: Array(beginning_state) + [ending_state])
 
       # Return the UNION of:
       # 1. START records that have a matching STOP (safe to delete)

spec/unit/lib/database/old_record_cleanup_spec.rb

@@ -108,6 +108,54 @@
       expect(VCAP::CloudController::AppUsageEvent.count).to eq(0)
     end
 
+    it 'keeps AppUsageEvent WAS_RUNNING record when there is no corresponding stop record' do
+      stale_was_running = VCAP::CloudController::AppUsageEvent.make(created_at: 2.days.ago, state: 'WAS_RUNNING', 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_was_running.reload).to be_present
+      expect(VCAP::CloudController::AppUsageEvent.count).to eq(1)
+    end
+
+    it 'deletes AppUsageEvent WAS_RUNNING record when there is a corresponding stop record' do
+      app_guid = 'stopped-app'
+      stale_was_running = VCAP::CloudController::AppUsageEvent.make(created_at: 5.days.ago, state: 'WAS_RUNNING', app_guid: app_guid)
+      stale_stop = VCAP::CloudController::AppUsageEvent.make(created_at: 4.days.ago, state: 'STOPPED', app_guid: app_guid)
+
+      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_was_running.reload }.to raise_error(Sequel::NoExistingObject)
+      expect { stale_stop.reload }.to raise_error(Sequel::NoExistingObject)
+    end
+
+    it 'keeps both STARTED and WAS_RUNNING records for the same app while it is running' do
+      app_guid = 'running-app'
+      stale_started = VCAP::CloudController::AppUsageEvent.make(created_at: 10.days.ago, state: 'STARTED', app_guid: app_guid)
+      stale_was_running = VCAP::CloudController::AppUsageEvent.make(created_at: 5.days.ago, state: 'WAS_RUNNING', app_guid: app_guid)
+
+      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_started.reload).to be_present
+      expect(stale_was_running.reload).to be_present
+    end
+
+    it 'deletes both STARTED and WAS_RUNNING records when a STOPPED record exists' do
+      app_guid = 'restarted-app'
+      stale_started = VCAP::CloudController::AppUsageEvent.make(created_at: 10.days.ago, state: 'STARTED', app_guid: app_guid)
+      stale_was_running = VCAP::CloudController::AppUsageEvent.make(created_at: 8.days.ago, state: 'WAS_RUNNING', app_guid: app_guid)
+      stale_stop = VCAP::CloudController::AppUsageEvent.make(created_at: 5.days.ago, state: 'STOPPED', app_guid: app_guid)
+
+      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_started.reload }.to raise_error(Sequel::NoExistingObject)
+      expect { stale_was_running.reload }.to raise_error(Sequel::NoExistingObject)
+      expect { stale_stop.reload }.to raise_error(Sequel::NoExistingObject)
+    end
+
     # ==================== KEEP_RUNNING_RECORDS: ServiceUsageEvent ====================
 
     it 'keeps ServiceUsageEvent create record when there is no corresponding delete record' do
@@ -177,6 +225,40 @@
       expect { orphan_delete.reload }.to raise_error(Sequel::NoExistingObject)
     end
 
+    it 'keeps ServiceUsageEvent WAS_RUNNING record when there is no corresponding delete record' do
+      stale_was_running = VCAP::CloudController::ServiceUsageEvent.make(created_at: 2.days.ago, state: 'WAS_RUNNING', 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_was_running.reload).to be_present
+      expect(VCAP::CloudController::ServiceUsageEvent.count).to eq(1)
+    end
+
+    it 'deletes ServiceUsageEvent WAS_RUNNING record when there is a corresponding delete record' do
+      service_guid = 'deleted-instance'
+      stale_was_running = VCAP::CloudController::ServiceUsageEvent.make(created_at: 5.days.ago, state: 'WAS_RUNNING', service_instance_guid: service_guid)
+      stale_delete = VCAP::CloudController::ServiceUsageEvent.make(created_at: 4.days.ago, state: 'DELETED', service_instance_guid: service_guid)
+
+      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_was_running.reload }.to raise_error(Sequel::NoExistingObject)
+      expect { stale_delete.reload }.to raise_error(Sequel::NoExistingObject)
+    end
+
+    it 'keeps both CREATED and WAS_RUNNING records for the same service instance while it exists' do
+      service_guid = 'running-service'
+      stale_created = VCAP::CloudController::ServiceUsageEvent.make(created_at: 10.days.ago, state: 'CREATED', service_instance_guid: service_guid)
+      stale_was_running = VCAP::CloudController::ServiceUsageEvent.make(created_at: 5.days.ago, state: 'WAS_RUNNING', service_instance_guid: service_guid)
+
+      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_created.reload).to be_present
+      expect(stale_was_running.reload).to be_present
+    end
+
     # ==================== EDGE CASES & DATA INTEGRITY ====================
 
     it 'deletes records with non-lifecycle states when keep_running_records is true' do