foreman_rh_cloud 13.2.8 → 13.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04c6a1daea1675deb081565cf7d9e83e669a3fd01a577a032c9d7d5ba825cbce
-  data.tar.gz: 5172a5c764d0dbcb71cf47e19e423f0eae01db27636be594320dece4c6364719
+  metadata.gz: 4301f698357e719f6ba5d08677bdeaf3ccefb995835dcf86f3e253cb0c01d599
+  data.tar.gz: 77f3bc1ef3e85cc1d8988a53f2cd5fdcd65b99a9fb6d6da1cc5f366bbfebc6d3
 SHA512:
-  metadata.gz: 15b24817679825c5e60bc0e0ca0b33c18eadae7277483155c641f3d3d140bd911c0c7ad7dca15c40e3d63f9a8e354acfcd5789048658fd2888a33fa4b9741d0d
-  data.tar.gz: 0cfe77f01b645de55c8e3e41ac4411201c5ec4819e5926d3054bac08b551e12dc923dffa6b1503956cb1075c688a5a3d94e5a63a8c4e332414e10f78054d3954
+  metadata.gz: 000fad5efc5a8bd42e03045e33bc10795a5d658aa3ef1098e6f95fa2a0476630cc85fe6b7b40929e817a4ca0d166fd88c8073b4faa972b72a84d0a146eb7aa70
+  data.tar.gz: 06fe93496e585831f593b8d31223577eb236adf7d1e4d90342cd203ddc9fbf9a80e9b58636b033fa04adefc806885feba8326a4e34dc38844bbaacd083df9c91

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/insights_cloud/api/machine_telemetries_controller.rb

@@ -32,14 +32,10 @@ module InsightsCloud::Api
       rescue RestClient::ExceptionWithResponse => e
         response_obj = e.response.presence || e.exception
         code = response_obj.try(:code) || response_obj.try(:http_code) || 500
-        message = 'Cloud request failed'
-
-        return render json: {
-          :message => message,
-          :error => response_obj.to_s,
-          :headers => {},
-          :response => response_obj,
-        }, status: code
+        upstream_content_type = response_obj.try(:headers)&.[](:content_type)
+        content_type = upstream_content_type&.match?(/json/) ? upstream_content_type : 'application/json'
+
+        return render body: response_obj.to_s, status: code, content_type: content_type
       rescue StandardError => e
         # Catch any other exceptions here, such as Errno::ECONNREFUSED
         logger.warn("Cloud request failed with exception: #{e}")
@@ -88,9 +84,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/controllers/insights_cloud/ui_requests_controller.rb

@@ -36,14 +36,10 @@ module InsightsCloud
       rescue RestClient::ExceptionWithResponse => e
         response_obj = e.response.presence || e.exception
         code = response_obj.try(:code) || response_obj.try(:http_code) || 500
-        message = 'Cloud request failed'
+        upstream_content_type = response_obj.try(:headers)&.[](:content_type)
+        content_type = upstream_content_type&.match?(/json/) ? upstream_content_type : 'application/json'
 
-        return render json: {
-          :message => message,
-          :error => response_obj.to_s,
-          :headers => {},
-          :response => response_obj,
-        }, status: code
+        return render body: response_obj.to_s, status: code, content_type: content_type
       rescue StandardError => e
         # Catch any other exceptions here, such as Errno::ECONNREFUSED
         logger.warn("Cloud request failed with exception: #{e}")

data/app/models/concerns/rh_cloud_host.rb

@@ -15,12 +15,14 @@ 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 }
+                           :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
 

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/generators/fact_helpers.rb

@@ -114,6 +114,7 @@ module ForemanInventoryUpload
 
       def host_ips(host)
         # Determines and returns the IP addresses associated with a host, applying obfuscation if enabled.
+        return {} if host.nil?
 
         # If IP obfuscation is enabled for the host return a representation of obfuscated IP addresses.
         return obfuscated_ips(host) if obfuscate_ips?(host)
@@ -163,10 +164,29 @@ module ForemanInventoryUpload
 
       def hostname_match
         bash_hostname = `uname -n`.chomp
-        foreman_hostname = ForemanRhCloud.foreman_host&.name
-        if bash_hostname == foreman_hostname
-          fqdn(ForemanRhCloud.foreman_host)
-        elsif Setting[:obfuscate_inventory_hostnames]
+        foreman_host = ForemanRhCloud.foreman_host
+
+        # If bash hostname matches foreman_host, use fqdn
+        if foreman_host && bash_hostname == foreman_host.name
+          return fqdn(foreman_host)
+        end
+
+        # If no foreman_host, try foreman_host_name from Setting[:foreman_url]
+        unless foreman_host
+          foreman_hostname_from_setting = ForemanRhCloud.foreman_host_name
+          if foreman_hostname_from_setting
+            # Apply obfuscation if enabled
+            return obfuscate_fqdn(foreman_hostname_from_setting) if Setting[:obfuscate_inventory_hostnames]
+
+            return foreman_hostname_from_setting
+          end
+          # Otherwise fall through to bash_hostname below
+          # NOTE: Containerized foremanctl setups must configure Setting[:foreman_url]
+          # as bash hostname may not be available or meaningful in containers
+        end
+
+        # Fallback to bash hostname (with obfuscation if enabled)
+        if Setting[:obfuscate_inventory_hostnames]
           obfuscate_fqdn(bash_hostname)
         else
           bash_hostname
@@ -174,6 +194,8 @@ module ForemanInventoryUpload
       end
 
       def bios_uuid(host)
+        return nil if host.nil?
+
         value = fact_value(host, 'dmi::system::uuid') || ''
         uuid_value(value)
       end

data/lib/foreman_inventory_upload.rb

@@ -96,7 +96,14 @@ module ForemanInventoryUpload
   end
 
   def self.inventory_self_url
-    inventory_base_url + "?hostname_or_id=#{ForemanRhCloud.foreman_host.fqdn}"
+    host = ForemanRhCloud.foreman_host
+    hostname = host ? host.fqdn : ForemanRhCloud.foreman_host_name
+    if hostname.nil?
+      Rails.logger.warn("Cannot determine Foreman hostname for inventory sync. " \
+                        "Please configure Setting[:foreman_url]. " \
+                        "Containerized setups must explicitly set this.")
+    end
+    inventory_base_url + "?hostname_or_id=#{hostname}"
   end
 
   def self.host_by_id_url(host_uuid)

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 = '13.2.8'.freeze
+  VERSION = '13.2.10'.freeze
 end

data/lib/foreman_rh_cloud.rb

@@ -84,23 +84,50 @@ module ForemanRhCloud
 
   # For testing purposes we can override the default hostname with an environment variable SATELLITE_RH_CLOUD_FOREMAN_HOST
   def self.foreman_host
-    @foreman_host ||= begin
-      fullname = foreman_host_name
-      ::Host.unscoped.friendly.find(fullname)
-    rescue ActiveRecord::RecordNotFound
-      # fullname didn't work. Let's try shortname
+    return @foreman_host if defined?(@foreman_host)
+
+    fullname = foreman_host_name
+    return @foreman_host = nil unless fullname
+
+    # Try fullname first
+    host = ::Host.unscoped.friendly.where(name: fullname).first
+
+    # If not found, try shortname
+    if host.nil?
       shortname = /(?<shortname>[^\.]*)\.?.*/.match(fullname)[:shortname]
-      ::Host.unscoped.friendly.find(shortname)
+      host = ::Host.unscoped.friendly.where(name: shortname).first
     end
+
+    @foreman_host = host
   end
 
   def self.foreman_host_name
-    ENV['SATELLITE_RH_CLOUD_FOREMAN_HOST'] || marked_foreman_host&.name || ::SmartProxy.default_capsule.name
+    ENV['SATELLITE_RH_CLOUD_FOREMAN_HOST'] || marked_foreman_host&.name || foreman_url_hostname
+  end
+
+  def self.foreman_url_hostname
+    return nil unless Setting[:foreman_url]
+
+    begin
+      # Ensure setting is a string to avoid TypeError from URI.parse
+      url = Setting[:foreman_url].to_s
+      URI.parse(url).host
+    rescue URI::InvalidURIError, ArgumentError, TypeError => e
+      Rails.logger.warn("Invalid foreman_url setting: #{e.message}")
+      nil
+    end
   end
 
   def self.marked_foreman_host
-    ::Host.unscoped.search_for('infrastructure_facet.foreman = true').first
-  rescue ScopedSearch::QueryNotSupported
+    # Find host with infrastructure_facet.foreman_instance = true
+    # Facets use a special mechanism in Foreman, so we query the facet table directly
+    return nil unless defined?(HostFacets::InfrastructureFacet)
+
+    facet = HostFacets::InfrastructureFacet.find_by(foreman_instance: true)
+    facet&.host
+  rescue ActiveRecord::StatementInvalid => e
+    # Table might not exist yet during migrations
+    Rails.logger.debug("Could not query marked foreman host: #{e.message}")
     nil
   end
 

data/lib/insights_cloud/async/insights_generate_notifications.rb

@@ -13,7 +13,16 @@ module InsightsCloud
       end
 
       def add_satellite_notifications
-        hits_count = InsightsHit.where(host_id: foreman_host.id).count
+        host = foreman_host
+
+        # Skip if no Foreman host record exists
+        unless host
+          logger.debug("Skipping Insights notifications: no Foreman host record found")
+          blueprint&.notifications&.destroy_all
+          return
+        end
+
+        hits_count = InsightsHit.where(host_id: host.id).count
 
         # Remove stale notifications
         blueprint.notifications.destroy_all

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/lib/inventory_sync/async/inventory_self_host_sync.rb

@@ -4,7 +4,14 @@ module InventorySync
       set_callback :step, :around, :create_facets
 
       def plan
-        super(ForemanRhCloud.foreman_host.organization)
+        host = ForemanRhCloud.foreman_host
+
+        if host.nil?
+          logger.warn("Skipping self-host inventory sync: no Foreman host record found.")
+          return
+        end
+
+        super(host.organization)
       end
 
       def create_facets
@@ -22,7 +29,10 @@ module InventorySync
       private
 
       def add_missing_insights_facet(uuids_hash)
-        facet = InsightsFacet.find_or_create_by(host_id: ForemanRhCloud.foreman_host.id) do |facet|
+        host = ForemanRhCloud.foreman_host
+        return unless host # Guard against nil
+
+        facet = InsightsFacet.find_or_create_by(host_id: host.id) do |facet|
           facet.uuid = uuids_hash.values.first
         end
 

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foreman_rh_cloud",
-  "version": "13.2.7",
+  "version": "13.2.10",
   "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)
@@ -153,8 +154,22 @@ module InsightsCloud::Api
 
         get :forward_request, params: { "path" => "platform/module-update-router/v1/channel" }
         assert_equal 500, @response.status
-        assert_equal 'Cloud request failed', JSON.parse(@response.body)['message']
-        assert_match /#{@body}/, JSON.parse(@response.body)['response']
+        assert_equal @body, @response.body
+      end
+
+      test "should forward JSON error responses without double-escaping" do
+        json_error = { errors: [{ detail: 'inventory_id must exist', status: '404' }] }.to_json
+        net_http_resp = Net::HTTPResponse.new(1.0, 404, "Not Found")
+        net_http_resp['content-type'] = 'application/json'
+        res = RestClient::Response.create(json_error, net_http_resp, @http_req)
+        ::ForemanRhCloud::CloudRequestForwarder.any_instance.stubs(:execute_cloud_request).raises(RestClient::NotFound.new(res))
+
+        get :forward_request, params: { "path" => "api/vulnerability/v1/systems/00000000-0000-0000-0000-000000000000" }
+        assert_equal 404, @response.status
+        assert_includes @response.content_type, 'application/json'
+        assert_equal json_error, @response.body
+        parsed = JSON.parse(@response.body)
+        assert_equal 'inventory_id must exist', parsed['errors'][0]['detail']
       end
 
       test "should create insights facet" do
@@ -170,6 +185,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