foreman_rh_cloud 14.0.3 → 14.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f035b6029a915ea8c71037c73c528b8c26f3427c51af6a312ebd339c3ac960f
-  data.tar.gz: 277647650e9241e6ebe84d23cecf21fd93e61205f383ce118c3789b5eca97ad1
+  metadata.gz: ecc86813dfba949a2d7125c96245b767f5ecc4edee058828bac97042ce5d4ee0
+  data.tar.gz: e6d920065bbe1a0a560c49050614abbad1c72d4f4c5e1494edf390db0495833e
 SHA512:
-  metadata.gz: 6dcbc3ddf422874a3f167ce6a95cc5194564076fd8751d6f1f1c5dc7b24fc6f330905ddad78dc64081c2d31e17c6cb55aeb1e7dc906474cc3679fb78aaa6f20f
-  data.tar.gz: 76f670668addb23c1dd1229609436d9ae12343b21608ab4c006051d2296301166aea28466b875c02c166c60f330d9456d00758621353a4cbad9de45dfcfc68cb
+  metadata.gz: e672658acda2399401392268c238361a81720e58d6d5693e70b1195c8aaef4d22ee35918b1ee329fae40d03efb09ad77c5562e9d81a905bd9e3b86945ed5a7f7
+  data.tar.gz: 1ff3460a85b2a26b64de9a472dcaf864bcb9cdd71043736a94f7f0784eb48ed91dcee94c84ae7ad4ae3c10bd31df8addd89175cf7c9ff6b221b8fadbe5035391

data/app/controllers/concerns/insights_cloud/candlepin_proxies_extensions.rb

@@ -0,0 +1,23 @@
+module InsightsCloud
+  module CandlepinProxiesExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      # Update insights client status when hosts check in via subscription-manager facts upload
+      # rubocop:disable Rails/LexicallyScopedActionFilter
+      after_action :update_insights_client_status, only: [:facts]
+      # rubocop:enable Rails/LexicallyScopedActionFilter
+    end
+
+    def update_insights_client_status
+      # Update InsightsClientReportStatus whenever host checks in via subscription-manager
+      # This ensures USER_OMITTED status gets set even when insights-client isn't installed
+      # (parameter=false means insights-client won't be installed, so it won't hit MachineTelemetriesController)
+      hoststatus = @host.get_status(InsightsClientReportStatus)
+      Rails.logger.debug "Current status: #{hoststatus.to_label}"
+      @host.get_status(InsightsClientReportStatus).refresh!
+      @host.refresh_global_status!
+      Rails.logger.debug "New status: #{hoststatus.to_label}"
+    end
+  end
+end

data/app/controllers/concerns/insights_cloud/package_profile_upload_extensions.rb

@@ -6,6 +6,7 @@ module InsightsCloud
       # This method explicitly listens on Katello actions
       # rubocop:disable Rails/LexicallyScopedActionFilter
       after_action :generate_host_report, only: [:upload_package_profile, :upload_profiles]
+      after_action :update_insights_client_status, only: [:upload_package_profile, :upload_profiles]
       # rubocop:enable Rails/LexicallyScopedActionFilter
     end
 
@@ -31,5 +32,13 @@ module InsightsCloud
       insights_facet = @host.build_insights(uuid: @host.subscription_facet.uuid)
       insights_facet.save
     end
+
+    def update_insights_client_status
+      # Update InsightsClientReportStatus whenever host checks in via subscription-manager
+      # This ensures USER_OMITTED status gets set even when insights-client isn't installed
+      # (parameter=false means insights-client won't be installed, so it won't hit MachineTelemetriesController)
+      @host.get_status(InsightsClientReportStatus).refresh!
+      @host.refresh_global_status!
+    end
   end
 end

data/app/controllers/foreman_inventory_upload/accounts_controller.rb

@@ -47,7 +47,7 @@ module ForemanInventoryUpload
           resource_type: 'Organization',
           resource_id: org_id,
         })
-        .with_duration
+        .select_duration
         .order('started_at DESC')
         .first
     end

data/app/controllers/foreman_inventory_upload/api/tasks_controller.rb

@@ -15,7 +15,7 @@ module ForemanInventoryUpload
         tasks = ForemanTasks::Task
                 .active
                 .for_action_types(ACTION_TYPES)
-                .with_duration
+                .select_duration
 
         if organization_id.present?
           tasks = tasks.joins(:links)
@@ -40,7 +40,7 @@ module ForemanInventoryUpload
 
         tasks = ForemanTasks::Task
                 .for_action_types(ACTION_TYPES)
-                .with_duration
+                .select_duration
                 .order('started_at DESC')
                 .limit(limit)
 

data/app/controllers/insights_cloud/api/machine_telemetries_controller.rb

@@ -88,9 +88,16 @@ module InsightsCloud::Api
     private
 
     def ensure_telemetry_enabled_for_consumer
-      unless (config = telemetry_config(@host))
+      config = telemetry_config(@host)
+
+      # Always update the status based on current parameter value
+      # This will set USER_OMITTED if parameter is false, or REPORTING/NO_REPORT if true
+      @host.get_status(InsightsClientReportStatus).refresh!
+      @host.refresh_global_status!
+
+      unless config
         logger.debug("Rejected telemetry forwarding for host #{@host.name}, insights param is set to: #{config}")
-        render_message 'Telemetry is not enabled for this host', :status => 403
+        return render_message('Telemetry is not enabled for this host', :status => 403)
       end
       config
     end

data/app/models/concerns/rh_cloud_host.rb

@@ -15,13 +15,16 @@ module RhCloudHost
     has_one :insights_client_report_status_object, :class_name => '::InsightsClientReportStatus', :foreign_key => 'host_id'
     scoped_search :relation => :insights_client_report_status_object, :on => :status, :rename => :insights_client_report_status,
       :complete_value => { :reporting => ::InsightsClientReportStatus::REPORTING,
-                           :no_report => ::InsightsClientReportStatus::NO_REPORT }
+                           :no_report => ::InsightsClientReportStatus::NO_REPORT,
+                           :user_omitted => ::InsightsClientReportStatus::USER_OMITTED }
 
     has_one :inventory_sync_status_object, :class_name => '::InventorySync::InventoryStatus', :foreign_key => 'host_id'
     scoped_search :relation => :inventory_sync_status_object, :on => :status, :rename => :insights_inventory_sync_status,
       :complete_value => { :disconnect => ::InventorySync::InventoryStatus::DISCONNECT,
-                           :sync => ::InventorySync::InventoryStatus::SYNC }
-    scoped_search :relation => :insights, :on => :uuid, :only_explicit => true, :rename => :insights_uuid
+                           :sync => ::InventorySync::InventoryStatus::SYNC,
+                           :user_omitted => ::InventorySync::InventoryStatus::USER_OMITTED }
+    scoped_search :on => :id, :rename => :insights_uuid, :only_explicit => true,
+      :ext_method => :search_by_insights_uuid, :complete_value => false
 
     def insights_facet
       insights
@@ -41,4 +44,33 @@ module RhCloudHost
       insights_facet.update!(uuid: subscription_facet.uuid)
     end
   end
+
+  module ClassMethods
+    def search_by_insights_uuid(_key, operator, value)
+      # Determine which facet table to search based on IoP mode
+      facet_table = ForemanRhCloud.with_iop_smart_proxy? ? Katello::Host::SubscriptionFacet.table_name : InsightsFacet.table_name
+
+      # Build SQL condition
+      if ['IN', 'NOT IN'].include?(operator)
+        # For IN/NOT IN, value may be an array or comma-separated string
+        # Convert to array and build placeholders for each value
+        values = value.is_a?(Array) ? value : value.to_s.split(',').map(&:strip)
+        placeholders = (['?'] * values.size).join(',')
+        condition = sanitize_sql_for_conditions(
+          ["#{facet_table}.uuid #{operator} (#{placeholders})", *values]
+        )
+      else
+        # For other operators (=, !=, LIKE, etc.), use value_to_sql for proper SQL formatting
+        condition = sanitize_sql_for_conditions(
+          ["#{facet_table}.uuid #{operator} ?", value_to_sql(operator, value)]
+        )
+      end
+
+      # Return search parameters with LEFT JOIN to include hosts without facets
+      {
+        joins: "LEFT JOIN #{facet_table} ON #{facet_table}.host_id = #{Host::Managed.table_name}.id",
+        conditions: condition,
+      }
+    end
+  end
 end

data/app/models/insights_client_report_status.rb

@@ -3,8 +3,9 @@ class InsightsClientReportStatus < HostStatus::Status
 
   REPORTING             = 0
   NO_REPORT             = 1
+  USER_OMITTED          = 2
 
-  scope :stale, -> { where.not(reported_at: (Time.now - REPORT_INTERVAL)..Time.now) }
+  scope :stale, -> { where.not(status: USER_OMITTED).where.not(reported_at: (Time.now - REPORT_INTERVAL)..Time.now) }
   scope :reporting, -> { where(status: REPORTING) }
 
   def self.status_name
@@ -17,6 +18,8 @@ class InsightsClientReportStatus < HostStatus::Status
       N_('Reporting')
     when NO_REPORT
       N_('Not reporting')
+    when USER_OMITTED
+      N_('Not reporting because host_registration_insights parameter value is false')
     end
   end
 
@@ -26,10 +29,15 @@ class InsightsClientReportStatus < HostStatus::Status
       ::HostStatus::Global::OK
     when NO_REPORT
       ::HostStatus::Global::ERROR
+    when USER_OMITTED
+      ::HostStatus::Global::OK
     end
   end
 
   def to_status
+    excluded_by_host_param =
+      ::Foreman::Cast.to_bool(host.host_param('host_registration_insights')) == false
+    return USER_OMITTED if excluded_by_host_param
     in_interval? ? REPORTING : NO_REPORT
   end
 

data/app/models/inventory_sync/inventory_status.rb

@@ -2,6 +2,7 @@ module InventorySync
   class InventoryStatus < HostStatus::Status
     DISCONNECT = 0
     SYNC = 1
+    USER_OMITTED = 2
 
     def self.status_name
       N_('Inventory')
@@ -13,6 +14,8 @@ module InventorySync
         ::HostStatus::Global::WARN
       when SYNC
         ::HostStatus::Global::OK
+      when USER_OMITTED
+        ::HostStatus::Global::OK
       else
         ::HostStatus::Global::WARN
       end
@@ -21,16 +24,25 @@ module InventorySync
     def to_label
       case status
       when DISCONNECT
-        N_('Host was not uploaded to your RH cloud inventory')
+        N_('Host is not present on console.redhat.com Inventory service')
       when SYNC
-        N_('Successfully uploaded to your RH cloud inventory')
+        N_('Host is uploaded and present on console.redhat.com Inventory service')
+      when USER_OMITTED
+        N_('Host is excluded from upload to console.redhat.com Inventory service due to host parameter')
       end
     end
 
     def to_status(options = {})
-      # this method used to calculate status.
-      # Since the calculation is done externally we should return the previously calculated status
+      # Normally, this method is used to calculate status.
+      # In foreman_rh_cloud 'we do things a bit differently around here.'
+      # Calculation is done externally in InventorySync::Async::InventoryFullSync, so we simply return the previously calculated status.
       status
     end
+
+    def relevant?(_options = {})
+      # Inventory status is not relevant in IoP mode since we use single-host reports
+      # that don't sync with the cloud inventory service
+      !ForemanRhCloud.with_iop_smart_proxy?
+    end
   end
 end

data/lib/foreman_inventory_upload/async/create_missing_insights_facets.rb

@@ -7,9 +7,15 @@ module ForemanInventoryUpload
 
       def run
         organization = ::Organization.find(input[:organization_id])
-        hosts_without_facets = ::ForemanInventoryUpload::Generators::Queries.for_org(organization, hosts_query: 'null? insights_uuid')
+        # Find hosts with subscription facets but without insights facets
+        # Note: We can't use scoped_search 'null? insights_uuid' because the null? operator
+        # doesn't work with ext_methods - it would check hosts.id IS NULL instead of the facet
+        hosts_without_facets = ::ForemanInventoryUpload::Generators::Queries.for_org(organization, use_batches: false)
+                                                                            .left_outer_joins(:insights)
+                                                                            .where(insights_facets: { id: nil })
+
         facet_count = 0
-        hosts_without_facets.each do |batch|
+        hosts_without_facets.in_batches(of: ForemanInventoryUpload.slice_size) do |batch|
           facets = batch.pluck(:id, 'katello_subscription_facets.uuid').map do |host_id, uuid|
             {
               host_id: host_id,

data/lib/foreman_rh_cloud/engine.rb

@@ -40,6 +40,7 @@ module ForemanRhCloud
         ::Host::Managed.include RhCloudHost
 
         ::Katello::Api::Rhsm::CandlepinDynflowProxyController.include InsightsCloud::PackageProfileUploadExtensions
+        ::Katello::Api::Rhsm::CandlepinProxiesController.include InsightsCloud::CandlepinProxiesExtensions
         ::Katello::RegistrationManager.singleton_class.prepend ::ForemanRhCloud::RegistrationManagerExtensions
       end
     end

data/lib/foreman_rh_cloud/version.rb

@@ -1,3 +1,3 @@
 module ForemanRhCloud
-  VERSION = '14.0.3'.freeze
+  VERSION = '14.1.0'.freeze
 end

data/lib/insights_cloud/async/vmaas_reposcan_sync.rb

@@ -6,6 +6,8 @@ module InsightsCloud
     class VmaasReposcanSync < ::Actions::EntryAction
       include ::ForemanRhCloud::CertAuth
 
+      HTTP_TOO_MANY_REQUESTS = 429
+
       # Subscribe to Katello repository sync hook action, if available
       def self.subscribe
         'Actions::Katello::Repository::SyncHook'.constantize
@@ -49,15 +51,9 @@ module InsightsCloud
 
         response
       rescue RestClient::ExceptionWithResponse => e
-        message = "VMaaS reposcan sync failed: #{e.response&.code} - #{e.response&.body}"
-        logger.error(message)
-        output[:message] = message
-        raise
+        handle_rest_client_error(e)
       rescue StandardError => e
-        message = "Error triggering VMaaS reposcan sync: #{e.message}, response: #{e.respond_to?(:response) ? e.response : nil}"
-        logger.error(message)
-        output[:message] = message
-        raise
+        handle_standard_error(e)
       end
 
       def rescue_strategy_for_self
@@ -70,6 +66,25 @@ module InsightsCloud
 
       private
 
+      def handle_rest_client_error(exception)
+        if exception.response&.code == HTTP_TOO_MANY_REQUESTS
+          message = "VMaaS reposcan sync skipped: another sync already in progress (#{HTTP_TOO_MANY_REQUESTS})"
+          logger.warn(message)
+        else
+          message = "VMaaS reposcan sync failed: #{exception.response&.code} - #{exception.response&.body}"
+          logger.error(message)
+        end
+        output[:message] = message
+        # Do NOT raise - let rescue_strategy_for_self Skip handle this
+      end
+
+      def handle_standard_error(exception)
+        message = "Error triggering VMaaS reposcan sync: #{exception.message}"
+        logger.error(message)
+        output[:message] = message
+        # Do NOT raise - let rescue_strategy_for_self Skip handle this
+      end
+
       def logger
         action_logger
       end

data/lib/inventory_sync/async/inventory_full_sync.rb

@@ -15,16 +15,26 @@ module InventorySync
 
       def setup_statuses
         @subscribed_hosts_ids = Set.new(affected_host_ids)
+        @omitted_ids = Set.new(user_omitted_host_ids)
+
+        # Remove user-omitted hosts from subscribed set. In normal operation, affected_host_ids
+        # already excludes user-omitted hosts via for_slice, but this handles edge cases like
+        # a host transitioning from uploaded to user-omitted between syncs.
+        @subscribed_hosts_ids.subtract(@omitted_ids)
 
         InventorySync::InventoryStatus.transaction do
           InventorySync::InventoryStatus.where(host_id: @subscribed_hosts_ids).delete_all
+          InventorySync::InventoryStatus.where(host_id: @omitted_ids).delete_all
           yield
-          add_missing_hosts_statuses(@subscribed_hosts_ids)
+          add_missing_hosts_statuses(@subscribed_hosts_ids) # any remaining hosts after yield are disconnected
+          add_user_omitted_host_statuses(@omitted_ids)
           host_statuses[:disconnect] += @subscribed_hosts_ids.size
+          host_statuses[:user_omitted] += @omitted_ids.size
         end
 
-        logger.debug("Synced hosts amount: #{host_statuses[:sync]}")
-        logger.debug("Disconnected hosts amount: #{host_statuses[:disconnect]}")
+        logger.debug("Synced hosts count: #{host_statuses[:sync]}")
+        logger.debug("Disconnected hosts count: #{host_statuses[:disconnect]}")
+        logger.debug("User-omitted hosts count: #{host_statuses[:user_omitted]}")
         output[:host_statuses] = host_statuses
       end
 
@@ -44,6 +54,7 @@ module InventorySync
       private
 
       def update_hosts_status(status_hashes)
+        # create Inventory statuses
         InventorySync::InventoryStatus.create(status_hashes)
         updated_ids = status_hashes.map { |hash| hash[:host_id] }
         @subscribed_hosts_ids.subtract(updated_ids)
@@ -61,10 +72,23 @@ module InventorySync
         )
       end
 
+      def add_user_omitted_host_statuses(host_ids)
+        InventorySync::InventoryStatus.create(
+          host_ids.map do |host_id|
+            {
+              host_id: host_id,
+              status: InventorySync::InventoryStatus::USER_OMITTED,
+              reported_at: DateTime.current,
+            }
+          end
+        )
+      end
+
       def host_statuses
         @host_statuses ||= {
           sync: 0,
           disconnect: 0,
+          user_omitted: 0,
         }
       end
 
@@ -73,6 +97,18 @@ module InventorySync
           Host.unscoped.where(organization: organizations)
         ).pluck(:id)
       end
+
+      def user_omitted_host_ids
+        param_name = InsightsCloud.enable_client_param_inventory
+
+        # Use search_for to respect parameter inheritance (global, org, hostgroup, host)
+        # This matches the same logic used by for_slice, ensuring consistency
+        Host.unscoped
+            .where(organization: organizations)
+            .joins(:subscription_facet)
+            .search_for("params.#{param_name} = f")
+            .pluck(:id)
+      end
     end
   end
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foreman_rh_cloud",
-  "version": "14.0.3",
+  "version": "14.1.0",
   "description": "Inventory Upload =============",
   "main": "index.js",
   "scripts": {

data/test/controllers/insights_cloud/api/machine_telemetries_controller_test.rb

@@ -4,6 +4,7 @@ require 'rest-client'
 module InsightsCloud::Api
   class MachineTelemetriesControllerTest < ActionController::TestCase
     include KatelloCVEHelper
+    include CandlepinIsolation
 
     setup do
       FactoryBot.create(:common_parameter, name: InsightsCloud.enable_client_param, key_type: 'boolean', value: true)
@@ -170,6 +171,45 @@ module InsightsCloud::Api
 
         assert_not_nil InsightsFacet.find_by(host_id: @host.id)
       end
+
+      test "should update InsightsClientReportStatus when parameter is false and block request" do
+        # Remove the common parameter from setup and set it to false
+        CommonParameter.where(name: InsightsCloud.enable_client_param).delete_all
+        FactoryBot.create(:common_parameter, name: InsightsCloud.enable_client_param, key_type: 'boolean', value: false)
+
+        # Stub telemetry_config to return false (disabled)
+        InsightsCloud::Api::MachineTelemetriesController.any_instance.stubs(:telemetry_config).returns(false)
+
+        get :forward_request, params: { "path" => "platform/ingress/v1/upload" }
+
+        # Request should be blocked
+        assert_response 403
+        assert_equal 'Telemetry is not enabled for this host', JSON.parse(@response.body)['message']
+
+        # But status should be updated to USER_OMITTED
+        @host.reload
+        insights_status = @host.get_status(InsightsClientReportStatus)
+        assert insights_status.persisted?, 'InsightsClientReportStatus should be created'
+        assert_equal InsightsClientReportStatus::USER_OMITTED, insights_status.status
+      end
+
+      test "should update InsightsClientReportStatus on successful upload" do
+        # Stub telemetry_config to return true (enabled) - common param from setup works for this
+        InsightsCloud::Api::MachineTelemetriesController.any_instance.stubs(:telemetry_config).returns(true)
+
+        net_http_resp = Net::HTTPResponse.new(1.0, 200, "OK")
+        res = RestClient::Response.create('response body', net_http_resp, @http_req)
+        ::ForemanRhCloud::CloudRequestForwarder.any_instance.stubs(:forward_request).returns(res)
+
+        get :forward_request, params: { "path" => "/redhat_access/r/insights/uploads/" }
+
+        assert_response :success
+
+        # Status should have been refreshed during the request
+        @host.reload
+        insights_status = @host.get_status(InsightsClientReportStatus)
+        assert insights_status.persisted?, 'InsightsClientReportStatus should be created and persisted'
+      end
     end
 
     context '#branch_info' do

data/test/controllers/insights_cloud/candlepin_proxies_extensions_test.rb

@@ -0,0 +1,70 @@
+require 'test_plugin_helper'
+
+module InsightsCloud
+  class CandlepinProxiesExtensionsTest < ActiveSupport::TestCase
+    setup do
+      @organization = FactoryBot.create(:organization)
+      @host = FactoryBot.create(:host, :with_subscription, :managed, organization: @organization)
+    end
+
+    test 'updates InsightsClientReportStatus to USER_OMITTED when parameter is false' do
+      # Set parameter to false so status should be USER_OMITTED
+      FactoryBot.create(:common_parameter, name: 'host_registration_insights', key_type: 'boolean', value: false)
+
+      # Simulate what the callback does
+      @host.get_status(InsightsClientReportStatus).refresh!
+      @host.refresh_global_status!
+
+      # Verify the status was updated
+      @host.reload
+      insights_status = @host.get_status(InsightsClientReportStatus)
+      assert insights_status.persisted?, 'InsightsClientReportStatus should be persisted'
+      assert_equal InsightsClientReportStatus::USER_OMITTED, insights_status.status,
+        'Status should be USER_OMITTED when host_registration_insights=false'
+    end
+
+    test 'sets USER_OMITTED status when parameter is inherited from hostgroup' do
+      # Create hostgroup with parameter
+      hostgroup = FactoryBot.create(:hostgroup)
+      hostgroup.group_parameters << GroupParameter.create(
+        name: 'host_registration_insights',
+        value: 'false',
+        key_type: 'boolean'
+      )
+      hostgroup.save!
+
+      @host.hostgroup = hostgroup
+      @host.save!
+
+      # Simulate what the callback does
+      @host.get_status(InsightsClientReportStatus).refresh!
+      @host.refresh_global_status!
+
+      # Verify status respects inherited parameter
+      @host.reload
+      insights_status = @host.get_status(InsightsClientReportStatus)
+      assert_equal InsightsClientReportStatus::USER_OMITTED, insights_status.status,
+        'Status should be USER_OMITTED when host_registration_insights=false is inherited from hostgroup'
+    end
+
+    test 'refreshes global status' do
+      FactoryBot.create(:common_parameter, name: 'host_registration_insights', key_type: 'boolean', value: true)
+
+      # Simulate what the callback does
+      @host.get_status(InsightsClientReportStatus).refresh!
+      @host.refresh_global_status!
+
+      # Verify global status was updated
+      @host.reload
+      assert_not_nil @host.global_status, 'Global status should be set'
+    end
+
+    test 'CandlepinProxiesController includes the update_insights_client_status method' do
+      # Verify the concern is included and method is available
+      controller = Katello::Api::Rhsm::CandlepinProxiesController.new
+
+      assert_respond_to controller, :update_insights_client_status,
+        'CandlepinProxiesController should have update_insights_client_status method from concern'
+    end
+  end
+end

data/test/jobs/insights_client_status_aging_test.rb

@@ -31,4 +31,44 @@ class InsightsClientStatusAgingTest < ActiveSupport::TestCase
     assert_equal InsightsClientReportStatus::NO_REPORT, @host3.get_status(InsightsClientReportStatus).status
     assert_equal InsightsClientReportStatus::NO_REPORT, @host4.get_status(InsightsClientReportStatus).status
   end
+
+  test 'aging job does not affect USER_OMITTED hosts' do
+    # Host 1: USER_OMITTED with old reported_at (should stay USER_OMITTED)
+    InsightsClientReportStatus.find_or_initialize_by(host_id: @host1.id).update(
+      status: InsightsClientReportStatus::USER_OMITTED,
+      reported_at: Time.now - InsightsClientReportStatus::REPORT_INTERVAL - 1.day
+    )
+
+    # Host 2: REPORTING with old reported_at (should change to NO_REPORT)
+    InsightsClientReportStatus.find_or_initialize_by(host_id: @host2.id).update(
+      status: InsightsClientReportStatus::REPORTING,
+      reported_at: Time.now - InsightsClientReportStatus::REPORT_INTERVAL - 1.day
+    )
+
+    # Host 3: USER_OMITTED with recent reported_at (should stay USER_OMITTED)
+    InsightsClientReportStatus.find_or_initialize_by(host_id: @host3.id).update(
+      status: InsightsClientReportStatus::USER_OMITTED,
+      reported_at: Time.now - 1.day
+    )
+
+    # Host 4: REPORTING with recent reported_at (should stay REPORTING)
+    InsightsClientReportStatus.find_or_initialize_by(host_id: @host4.id).update(
+      status: InsightsClientReportStatus::REPORTING,
+      reported_at: Time.now - 1.day
+    )
+
+    action = create_and_plan_action(InsightsCloud::Async::InsightsClientStatusAging)
+    run_action(action)
+
+    @hosts.each(&:reload)
+
+    assert_equal InsightsClientReportStatus::USER_OMITTED, @host1.get_status(InsightsClientReportStatus).status,
+      'USER_OMITTED host with old report should stay USER_OMITTED'
+    assert_equal InsightsClientReportStatus::NO_REPORT, @host2.get_status(InsightsClientReportStatus).status,
+      'REPORTING host with old report should change to NO_REPORT'
+    assert_equal InsightsClientReportStatus::USER_OMITTED, @host3.get_status(InsightsClientReportStatus).status,
+      'USER_OMITTED host with recent report should stay USER_OMITTED'
+    assert_equal InsightsClientReportStatus::REPORTING, @host4.get_status(InsightsClientReportStatus).status,
+      'REPORTING host with recent report should stay REPORTING'
+  end
 end