contrast-agent 6.8.0 → 6.10.0

data/lib/contrast/components/polling.rb

@@ -0,0 +1,39 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/components/base'
+
+module Contrast
+  module Components
+    module Polling
+      # A wrapper build around the agent.polling config
+      class Interface
+        include Contrast::Components::ComponentBase
+
+        # @return [Integer, nil]
+        attr_reader :server_settings_ms
+        # @return [Integer, nil]
+        attr_reader :app_settings_ms
+        # @return [String]
+        attr_reader :canon_name
+        # @return [Array]
+        attr_reader :config_values
+        # @return [Integer, nil]
+        attr_reader :batch_reporting_interval_ms
+
+        CANON_NAME = 'agent.polling'
+        CONFIG_VALUES = %w[server_settings_ms app_settings_ms batch_reporting_interval_ms].cs__freeze
+
+        def initialize hsh = {}
+          @config_values = CONFIG_VALUES
+          @canon_name = CANON_NAME
+          return unless hsh
+
+          @server_settings_ms = hsh[:server_settings_ms]
+          @batch_reporting_interval_ms = hsh[:batch_reporting_interval_ms]
+          @app_settings_ms = hsh[:app_settings_ms]
+        end
+      end
+    end
+  end
+end

data/lib/contrast/components/protect.rb

@@ -14,12 +14,23 @@ module Contrast
         include Contrast::Components::ComponentBase
         include Contrast::Config::BaseConfiguration
 
+        CANON_NAME = 'protect'
+        CONFIG_VALUES = %w[enabled?].cs__freeze
+        RULES = 'rules'
+        MODE = 'mode'
+
         # @return [Boolean, nil]
         attr_accessor :enable
+        # @return [String]
+        attr_reader :canon_name
+        # @return [Array]
+        attr_reader :config_values
         # @return [Boolean, nil]
         attr_accessor :agent_lib
 
         def initialize hsh = {}
+          @config_values = CONFIG_VALUES
+          @canon_name = CANON_NAME
           return unless hsh
 
           @_exceptions = Contrast::Config::ExceptionConfiguration.new(hsh[:exceptions])
@@ -57,6 +68,9 @@ module Contrast
           ::Contrast::SETTINGS.protect_state.enabled == true
         end
 
+        # Current Configuration for the protect rules
+        #
+        # @return [Contrast::Config::ProtectRulesConfiguration]
         def rule_config
           ::Contrast::CONFIG.protect.rules
         end
@@ -65,11 +79,17 @@ module Contrast
         # protect rules.
         #
         # @return defend_rules[Hash<Contrast::SETTINGS.protect_state.rules>]
-        #
         def defend_rules
           ::Contrast::SETTINGS.protect_state.rules
         end
 
+        # The Contrast::CONFIG.protect.rules is object so we need to check it's
+        # corresponding method call for each rule of interest. If there is no
+        # status available we search for any Settings available received form
+        # TS response.
+        #
+        # @param rule_id [String]
+        # @return mode [Symbol]
         def rule_mode rule_id
           str = rule_id.tr('-', '_')
           ::Contrast::CONFIG.protect.rules[str]&.applicable_mode ||
@@ -77,6 +97,9 @@ module Contrast
               :NO_ACTION
         end
 
+        # Name of the protect rule
+        #
+        # @return [String]
         def rule name
           ::Contrast::SETTINGS.protect_state.rules[name]
         end
@@ -104,8 +127,32 @@ module Contrast
           @_forcibly_disabled = false?(::Contrast::CONFIG.protect.enable)
         end
 
+        # Converts current configuration to effective config values class and appends them to
+        # EffectiveConfig class.
+        #
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        def to_effective_config effective_config
+          super
+          protect_rules_to_effective_config(effective_config)
+        end
+
         private
 
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        def protect_rules_to_effective_config effective_config
+          return unless defend_rules
+
+          defend_rules.each do |key, value|
+            next unless key && value
+
+            config_prefix = "#{ CANON_NAME }.#{ RULES }.#{ key }"
+            name_prefix = "#{ CONTRAST }.#{ CANON_NAME }.#{ RULES }.#{ key }"
+            add_single_effective_value(effective_config, ENABLE, value.enabled?, config_prefix, name_prefix)
+            # Get the mode by checking Current Configs or Settings received:
+            add_single_effective_value(effective_config, MODE, rule_mode(key), config_prefix, name_prefix)
+          end
+        end
+
         def forcibly_enabled?
           return @_forcibly_enabled unless @_forcibly_enabled.nil?
 

data/lib/contrast/components/ruby_component.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Components
     module Ruby
@@ -23,11 +25,24 @@ module Contrast
         ].cs__freeze
 
         DEFAULT_UNINSTRUMENTED_NAMESPACES = %w[FactoryGirl FactoryBot].cs__freeze
+        CANON_NAME = 'agent.ruby'
+        CONFIG_VALUES = %w[
+          disabled_agent_rake_tasks
+          propagate_yield require_scan
+          non_request_tracking
+          uninstrument_namespace
+        ].cs__freeze
 
         attr_writer :disabled_agent_rake_tasks, :exceptions, :propagate_yield, :require_scan,
                     :non_request_tracking, :uninstrument_namespace
+        # @return [String]
+        attr_reader :canon_name
+        # @return [Array]
+        attr_reader :config_values
 
         def initialize hsh = {}
+          @config_values = CONFIG_VALUES
+          @canon_name = CANON_NAME
           return unless hsh
 
           @disabled_agent_rake_tasks = hsh[:disabled_agent_rake_tasks]

data/lib/contrast/components/sampling.rb

@@ -28,10 +28,10 @@ module Contrast
             settings = ::Contrast::SETTINGS&.assess_state&.sampling_settings
             {
                 enabled: enabled?(config_settings, settings),
-                baseline: baseline(config_settings, settings),
-                request_frequency: request_frequency(config_settings, settings),
-                response_frequency: response_frequency(config_settings, settings),
-                window: window(config_settings, settings)
+                baseline: check_baseline(config_settings, settings),
+                request_frequency: check_request_frequency(config_settings, settings),
+                response_frequency: check_response_frequency(config_settings, settings),
+                window: check_window(config_settings, settings)
             }
           end
         end
@@ -45,7 +45,8 @@ module Contrast
 
         # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
         #   local user input
-        # @param settings [Contrast::Api::Settings::Sampling] the Sampling settings as provided by TeamServer
+        # @param settings [Contrast::Agent::Reporting::Settings::Sampling, nil] the Sampling settings as provided by
+        # TeamServer
         # @return [Boolean] the resolution of the config_settings, settings, and default value
         def enabled? config_settings, settings
           true?([config_settings&.enable, settings&.enabled, DEFAULT_SAMPLING_ENABLED].compact[0])
@@ -53,35 +54,39 @@ module Contrast
 
         # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
         #   local user input
-        # @param settings [Contrast::Api::Settings::Sampling] the Sampling settings as provided by TeamServer
+        # @param settings [Contrast::Agent::Reporting::Settings::Sampling] the Sampling settings as provided by
+        # TeamServer
         # @return [Integer] the resolution of the config_settings, settings, and default value
-        def baseline config_settings, settings
+        def check_baseline config_settings, settings
           [config_settings&.baseline, settings&.baseline].map(&:to_i).find(&:positive?) || DEFAULT_SAMPLING_BASELINE
         end
 
         # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
         #   local user input
-        # @param settings [Contrast::Api::Settings::Sampling] the Sampling settings as provided by TeamServer
+        # @param settings [Contrast::Agent::Reporting::Settings::Sampling] the Sampling settings as provided by
+        # TeamServer
         # @return [Integer] the resolution of the config_settings, settings, and default value
-        def request_frequency config_settings, settings
+        def check_request_frequency config_settings, settings
           [config_settings&.request_frequency, settings&.request_frequency].map(&:to_i).find(&:positive?) ||
               DEFAULT_SAMPLING_REQUEST_FREQUENCY
         end
 
         # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
         #   local user input
-        # @param settings [Contrast::Api::Settings::Sampling] the Sampling settings as provided by TeamServer
+        # @param settings [Contrast::Agent::Reporting::Settings::Sampling] the Sampling settings as provided by
+        # TeamServer
         # @return [Integer] the resolution of the config_settings, settings, and default value
-        def response_frequency config_settings, settings
+        def check_response_frequency config_settings, settings
           [config_settings&.response_frequency, settings&.response_frequency].map(&:to_i).find(&:positive?) ||
               DEFAULT_SAMPLING_RESPONSE_FREQUENCY
         end
 
         # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
         #   local user input
-        # @param settings [Contrast::Api::Settings::Sampling] the Sampling settings as provided by TeamServer
+        # @param settings [Contrast::Agent::Reporting::Settings::Sampling] the Sampling settings as provided by
+        # TeamServer
         # @return [Integer] the resolution of the config_settings, settings, and default value
-        def window config_settings, settings
+        def check_window config_settings, settings
           [config_settings&.window_ms, settings&.window_ms].map(&:to_i).find(&:positive?) || DEFAULT_SAMPLING_WINDOW_MS
         end
       end
@@ -94,8 +99,13 @@ module Contrast
 
       class Interface # :nodoc:
         include InstanceMethods
+        extend ClassMethods
         include Contrast::Config::BaseConfiguration
 
+        CANON_NAME = 'assess.sampling'
+        NAME_PREFIX = "#{ CONTRAST }.#{ CANON_NAME }"
+        CONFIG_VALUES = %w[enable baseline request_frequency response_frequency window_ms].cs__freeze
+
         # @return [Integer, nil]
         attr_reader :baseline
         # @return [Integer, nil]
@@ -104,8 +114,11 @@ module Contrast
         attr_reader :response_frequency
         # @return [Integer, nil]
         attr_reader :window_ms
+        # @return [String]
+        attr_reader :canon_name
 
         def initialize hsh = {}
+          @canon_name = CANON_NAME
           return unless hsh
 
           @enable = hsh[:enable]
@@ -119,6 +132,50 @@ module Contrast
         def enable
           !!@enable
         end
+
+        # Converts current configuration to effective config values class and appends them to
+        # EffectiveConfig class.
+        #
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        def to_effective_config effective_config
+          confirm_sources
+
+          add_single_effective_value(effective_config, 'enable', sampling_control[:enabled], canon_name, NAME_PREFIX)
+          add_single_effective_value(effective_config, 'baseline', sampling_control[:baseline], canon_name, NAME_PREFIX)
+          add_single_effective_value(effective_config, 'window_ms', sampling_control[:window], canon_name, NAME_PREFIX)
+          add_single_effective_value(effective_config,
+                                     'request_frequency',
+                                     sampling_control[:request_frequency],
+                                     canon_name,
+                                     NAME_PREFIX)
+          add_single_effective_value(effective_config,
+                                     'response_frequency',
+                                     sampling_control[:response_frequency],
+                                     canon_name,
+                                     NAME_PREFIX)
+        end
+
+        private
+
+        # Confirm the sources for the sample entries to ensure that we use 'Default' if we've fallen
+        # back to the default values.
+        def confirm_sources
+          if sampling_control[:enabled] == DEFAULT_SAMPLING_ENABLED
+            Contrast::CONFIG.sources.set('assess.sampling.enable', Contrast::Components::Config::Sources::DEFAULT)
+          end
+          if sampling_control[:window] == DEFAULT_SAMPLING_WINDOW_MS
+            Contrast::CONFIG.sources.set('assess.sampling.window_ms', Contrast::Components::Config::Sources::DEFAULT)
+          end
+          {
+              'baseline' => :baseline,
+              'request_frequency' => :request_frequency,
+              'response_frequency' => :response_frequency
+          }.each do |k, v|
+            if sampling_control[v] == cs__class.cs__const_get("DEFAULT_SAMPLING_#{ v.upcase }")
+              Contrast::CONFIG.sources.set("assess.sampling.#{ k }", Contrast::Components::Config::Sources::DEFAULT)
+            end
+          end
+        end
       end
     end
   end

data/lib/contrast/components/security_logger.rb

@@ -1,17 +1,30 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Components
     module SecurityLogger
       # Here we will read and store the setting for the CEF Logging functionality
       class Interface
+        include Contrast::Components::ComponentBase
+
+        CANON_NAME = 'agent.security_logger'
+        CONFIG_VALUES = %w[path level].cs__freeze
+
         # @return [String, nil]
         attr_accessor :path
         # @return [String, nil]
         attr_accessor :level
+        # @return [String]
+        attr_reader :canon_name
+        # @return [Array]
+        attr_reader :config_values
 
         def initialize hsh = {}
+          @config_values = CONFIG_VALUES
+          @canon_name = CANON_NAME
           return unless hsh
 
           @path = hsh[:path]

data/lib/contrast/components/settings.rb

@@ -4,6 +4,7 @@
 require 'contrast/agent/excluder'
 require 'contrast/agent/reporting/settings/sensitive_data_masking'
 require 'contrast/components/config'
+require 'contrast/components/logger'
 
 module Contrast
   module Components
@@ -24,7 +25,8 @@ module Contrast
       SENSITIVE_DATA_MASKING_BASE = Contrast::Agent::Reporting::Settings::SensitiveDataMasking.new
 
       # This is a class.
-      class Interface
+      class Interface # rubocop:disable Metrics/ClassLength
+        include Contrast::Components::Logger::InstanceMethods
         extend Contrast::Components::Config
 
         # tainted_columns are database columns that receive unsanitized input.
@@ -68,6 +70,16 @@ module Contrast
         attr_reader :last_server_update_ms
         # @return [Contrast::Agent::Excluder] a wrapper around the exclusion rules for the application
         attr_reader :excluder
+        # @return [String] The last update but in string format used to build request header.
+        # This value should be sent be TS in the Last-Modified header to sync and save resources if the
+        # two dates are the same.
+        # format: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT
+        attr_reader :server_settings_last_httpdate
+        # @return [String] The last update but in string format used to build request header.
+        # This value should be sent be TS in the Last-Modified header to sync and save resources if the
+        # two dates are the same.
+        # format: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT
+        attr_reader :app_settings_last_httpdate
 
         def initialize
           reset_state
@@ -78,16 +90,69 @@ module Contrast
         end
 
         # @param features_response [Contrast::Agent::Reporting::Response]
-        def update_from_server_features features_response
+        def update_from_server_features features_response # rubocop:disable Metrics/AbcSize
           return unless (server_features = features_response&.server_features)
 
           log_file = server_features.log_file
           log_level = server_features.log_level
+          # Update logger:
           Contrast::Logger::Log.instance.update(log_file, log_level) if log_file || log_level
-          @protect_state.enabled = server_features.protect.enabled?
-          @assess_state.enabled = server_features.assess.enabled?
-          @assess_state.sampling_settings = server_features.assess.sampling
+          # Update AgentLib Logger
+          update_agent_lib_log(log_level.to_s)
+          # Update CEFlogger:
+          unless server_features.security_logger.settings_blank?
+            cef_logger.build_logger(server_features.security_logger.log_level, server_features.security_logger.log_file)
+          end
+          # TODO: RUBY-99999 Update Bot-Blocker from server settings - check enable value.
+          # For now all protection rules are rebuild on Application update. Bot blocker uses the default
+          # enable from the base rule, and update it's mode on app settings update.
+          # Here we receive also bots for that rule.
+          unless settings_empty?(server_features.protect.enabled?)
+            @protect_state.enabled = server_features.protect.enabled?
+            store_in_config(%i[protect enable], server_features.protect.enabled?)
+          end
+          update_assess_server_features(server_features.assess)
           @last_server_update_ms = Contrast::Utils::Timer.now_ms
+          # update via response header. We receive header from TS with last update info, setting the
+          # next request's header with the same time will save needless update of settings if there
+          # are no new server features updates after the said time.
+          @server_settings_last_httpdate = header_last_update
+        rescue StandardError => e
+          logger.warn('The following error occurred from server update: ', e: e)
+        end
+
+        # Update AgentLib log level
+        def update_agent_lib_log new_log_level
+          agent_lib_log_level = Contrast::AgentLib::InterfaceBase::LOG_LEVEL[0] if new_log_level.empty?
+          agent_lib_log_level ||= Contrast::AgentLib::InterfaceBase::LOG_LEVEL.key(new_log_level.upcase)
+
+          # detect if the provided level is invalid and log if it is
+          # by default if we pass invalid log level - it will leave the last active
+          unless Contrast::AgentLib::InterfaceBase::LOG_LEVEL.value?(new_log_level.upcase)
+            cur_active = Contrast::AGENT_LIB.log_level
+            logger.debug('The provided level was invalid, so the logger stays to the last active: ',
+                         active: cur_active,
+                         provided_level: new_log_level)
+          end
+
+          Contrast::AGENT_LIB.change_log_options(true, agent_lib_log_level)
+        end
+
+        # Update Assess server features
+        #
+        # @param assess [Contrast::Agent::Reporting::Settings::AssessServerFeature]
+        def update_assess_server_features assess
+          return if settings_empty?(assess.enabled?)
+
+          @assess_state.enabled = assess.enabled?
+          store_in_config(%i[assess enable], assess.enabled?)
+          @assess_state.sampling_settings = assess.sampling
+
+          Contrast::Components::Sampling::Interface::CONFIG_VALUES.each do |field|
+            lookup_field = field == 'enable' ? :enabled : field.to_sym
+            store_in_config(Contrast::Components::Sampling::Interface::CANON_NAME.split('.') + [field.to_sym],
+                            assess.sampling.send(lookup_field))
+          end
         end
 
         # @param settings_response [Contrast::Agent::Reporting::Response]
@@ -96,34 +161,54 @@ module Contrast
 
           @application_state.modes_by_id = app_settings.protect.protection_rules_to_settings_hash
           update_exclusion_matchers(app_settings.exclusions)
+          app_settings.protect.virtual_patches = app_settings.protect.virtual_patches unless
+            settings_empty?(app_settings.protect.virtual_patches)
           update_sensitive_data_policy(app_settings.sensitive_data_masking)
           @assess_state.disabled_assess_rules = app_settings.assess.disabled_rules
           new_session_id = app_settings.assess.session_id
           @assess_state.session_id = new_session_id if new_session_id && !new_session_id.blank?
           @last_app_update_ms = Contrast::Utils::Timer.now_ms
+          @app_settings_last_httpdate = header_last_update
         end
 
         # Wipe state to zero.
         def reset_state
           @protect_state = PROTECT_STATE_BASE.dup
-          @assess_state = ASSESS_STATE_BASE.dup
+          update_assess_state
           @application_state = APPLICATION_STATE_BASE.dup
           @tainted_columns = {}
           @sensitive_data_masking = SENSITIVE_DATA_MASKING_BASE.dup
           @excluder = Contrast::Agent::Excluder.new
         end
 
+        # We save the session_id, reset and set it again if available.
+        # This done so that reporting between updates won't trigger argument error
+        # for missing session_id given one is already set and used with the first application
+        # create response received from TS.
+        #
+        # @return [Struct]
+        def update_assess_state
+          current_session_id = @assess_state&.session_id
+          @assess_state = ASSESS_STATE_BASE.dup
+          # There is application settings update for the session id if new is received.
+          # Here we make sure not to delete the already set one.
+          @assess_state&.session_id = current_session_id unless current_session_id&.empty?
+          @assess_state
+        end
+
         def build_protect_rules
           @protect_state.rules = {}
 
           # Rules. They add themselves on initialize.
           Contrast::Agent::Protect::Rule::BotBlocker.new
-          Contrast::Agent::Protect::Rule::CmdInjection.new
+          cmdi = Contrast::Agent::Protect::Rule::CmdInjection.new
+          cmdi.sub_rules
           Contrast::Agent::Protect::Rule::Deserialization.new
-          Contrast::Agent::Protect::Rule::HttpMethodTampering.new
           Contrast::Agent::Protect::Rule::NoSqli.new
-          Contrast::Agent::Protect::Rule::PathTraversal.new
-          Contrast::Agent::Protect::Rule::Sqli.new
+          path = Contrast::Agent::Protect::Rule::PathTraversal.new
+          path.sub_rules
+          sqli = Contrast::Agent::Protect::Rule::Sqli.new
+          sqli.sub_rules
           Contrast::Agent::Protect::Rule::UnsafeFileUpload.new
           Contrast::Agent::Protect::Rule::Xss.new
           Contrast::Agent::Protect::Rule::Xxe.new
@@ -174,6 +259,31 @@ module Contrast
 
           false
         end
+
+        # update via response header.
+        # Used to build the next request header.
+        #
+        # @return [String]
+        def header_last_update
+          Contrast::Agent.reporter.client.response_handler.last_server_modified
+        end
+
+        # Update the stored config values to ensure that we know about the correct values,
+        # and that the sources are correct for entries updated from the UI.
+        #
+        # @param parts [Array] the path to the setting in config
+        # @param value [String, Integer, Array, nil] the value for the configuration setting
+        def store_in_config parts, value
+          level = Contrast::CONFIG.config.loaded_config
+          parts[0...-1].each do |segment|
+            level[segment] ||= {}
+            level = level[segment]
+          end
+          return unless level.cs__is_a?(Hash)
+
+          level[parts[-1]] = value
+          Contrast::CONFIG.sources.set(parts.join('.'), Contrast::Components::Config::Sources::CONTRASTUI)
+        end
       end
     end
   end

data/lib/contrast/config/certification_configuration.rb

@@ -1,11 +1,17 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # Certificate Configuration
     class CertificationConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
+
+      CANON_NAME = 'api.certification'
+      CONFIG_VALUES = %w[ca_file cert_file key_file enable].cs__freeze
 
       # @return [String] path to CA Cert file
       attr_accessor :ca_file
@@ -28,6 +34,14 @@ module Contrast
       def enable
         @enable.nil? ? false : @enable
       end
+
+      # Converts current configuration to effective config values class and appends them to
+      # EffectiveConfig class.
+      #
+      # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+      def to_effective_config effective_config
+        add_effective_config_values(effective_config, CONFIG_VALUES, CANON_NAME, CONTRAST)
+      end
     end
   end
 end

data/lib/contrast/config/config.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/config/effective_config'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # This class is responsible for logging to file the effective Agent configurations after startup.
+      class Config
+        attr_reader :effective_config
+
+        MESSAGE_FAIL = 'Unable to connect to Contrast, configuration details from the Contrast UI will not be included.'
+        MESSAGE_SUCCESSFUL = 'Connected to Contrast.'
+        CONN_STATUS_MSG_FAILURE = 'Unable to connect to Contrast, insufficient connection properties provided.'
+
+        def initialize
+          @effective_config = Contrast::Agent::DiagnosticsConfig::EffectiveConfig.new
+          @config_status = Contrast::Utils::ObjectShare::EMPTY_STRING
+        end
+
+        # This method will set the status from the request/response cycles
+        #
+        # @param response [Contrast::Agent::Reporting::Response]
+        def determine_config_status response
+          return unless response
+          # If we encounter for some of the startup events failure - always return failure
+          return if [MESSAGE_FAIL, CONN_STATUS_MSG_FAILURE].include?(@config_status)
+
+          response_code = response.code.to_s
+          @config_status = response_code.start_with?('2') ? MESSAGE_SUCCESSFUL : MESSAGE_FAIL
+          nil
+        end
+
+        # This method will set the status message from the config validation
+        def populate_fail_connection
+          @config_status = CONN_STATUS_MSG_FAILURE
+        end
+
+        def to_controlled_hash
+          @effective_config.to_controlled_hash.merge({ Status: @config_status })
+        end
+      end
+    end
+  end
+end