contrast-agent 6.0.0 → 6.1.2

data/lib/contrast/agent/reporting/reporting_utilities/response.rb

@@ -13,16 +13,26 @@ module Contrast
         # At least one, but not necessarily all, setting will differ from the agent's current set.
         # Agents are able to replace all application settings with those in this message.
         #
-        # @return application_settings [Contrast::Agent::Reporting::Settings::ApplicationSettings]
-        def application_settings
-          @_application_settings ||= Contrast::Agent::Reporting::Settings::ApplicationSettings.new
-        end
+        # @return [Contrast::Agent::Reporting::Settings::ApplicationSettings, nil]
+        attr_accessor :application_settings
 
         # All of the feature server_features
         #
-        # @return server_features [Contrast::Agent::Reporting::Settings::FeatureSettings]
-        def server_features
-          @_server_features ||= Contrast::Agent::Reporting::Settings::ServerFeatures.new
+        # @return [Contrast::Agent::Reporting::Settings::FeatureSettings, nil]
+        attr_accessor :server_features
+
+        class << self
+          def application_response
+            res = new
+            res.application_settings = Contrast::Agent::Reporting::Settings::ApplicationSettings.new
+            res
+          end
+
+          def server_response
+            res = new
+            res.server_features = Contrast::Agent::Reporting::Settings::ServerFeatures.new
+            res
+          end
         end
       end
     end

data/lib/contrast/agent/reporting/reporting_utilities/response_extractor.rb

@@ -15,7 +15,7 @@ module Contrast
           return unless assessments
 
           res.application_settings.assess.disabled_rules = assessments[:disabledRules]
-          res.application_settings.assess.session_id = assessments[:sessionId]
+          res.application_settings.assess.session_id = assessments[:session_id]
         end
 
         # @param response_data [Hash]
@@ -24,6 +24,7 @@ module Contrast
           protect = response_data[:settings][:defend]
           return unless protect
 
+          # TODO: RUBY-1636 should this be `:rules` or `:protectionRules`
           res.application_settings.protect.protection_rules = protect[:protectionRules]
           res.application_settings.protect.virtual_patches = protect[:virtualPatches]
         end
@@ -48,7 +49,7 @@ module Contrast
         # @param response_data [Hash]
         # @param res [Contrast::Agent::Reporting::Response]
         def extract_assess_server_features response_data, res
-          assess = response_data[:assessment]
+          assess = response_data[:features][:assessment]
           return unless assess
 
           res.server_features.assess.enabled = assess[:enabled]
@@ -60,18 +61,20 @@ module Contrast
         # @param response_data [Hash]
         # @param res [Contrast::Agent::Reporting::Response]
         def extract_protect_server_features response_data, res
-          protect = response_data[:defend]
+          protect = response_data[:features][:defend]
           return unless protect
 
           res.server_features.protect.enabled = protect[:enabled]
-          res.server_features.protect.bot_blocker = protect[:bot_blocker]
+          res.server_features.protect.bot_blocker = protect[:'bot-blocker']
+          # TODO: RUBY-1636 should this be `:rules` or `:protectionRules`
+          # process the botBlockers field
           res.server_features.protect.syslog = protect[:syslog]
         end
 
         # @param response_data [Hash]
         # @param res [Contrast::Agent::Reporting::Response]
         def extract_protect_lists response_data, res
-          protect = response_data[:defend]
+          protect = response_data[:features][:defend]
           return unless protect
 
           res.server_features.protect.ip_allowlist = protect[:ipAllowlist]
@@ -89,7 +92,7 @@ module Contrast
           sensitive_data = response_data[:settings][:sensitive_data_masking_policy]
           res.application_settings.sensitive_data_masking.mask_http_body = sensitive_data[:mask_http_body]
           res.application_settings.sensitive_data_masking.mask_attack_vector = sensitive_data[:mask_attack_vector]
-          res.application_settings.sensitive_data_masking.build_rules_form_settings sensitive_data[:rules]
+          res.application_settings.sensitive_data_masking.build_rules_form_settings(sensitive_data[:rules])
         end
       end
     end

data/lib/contrast/agent/reporting/reporting_utilities/response_handler.rb

@@ -14,7 +14,7 @@ module Contrast
   module Agent
     module Reporting
       # This class will facilitate the Response capture and analysis functionality.
-      class ResponseHandler < Contrast::Api::Communication::ResponseProcessor
+      class ResponseHandler
         include Contrast::Components::Logger::InstanceMethods
         include Contrast::Agent::Reporting::ResponseHandlerUtils
         # 15 min
@@ -26,19 +26,19 @@ module Contrast
         # @return response [Net::HTTP::Response, nil]
         def process response
           logger.debug('Reporter Received a response')
-          return unless analyze_response? response
+          return unless analyze_response?(response)
 
           # Handle the response body and obtain server_features or app_settings
-          report_response = convert_response response
-
+          report_response = convert_response(response)
           return unless report_response
 
-          update_agent_settings report_response
-          update_reaction report_response
-          # This one is called from super needs to be placed here after protobuf end of life.
-          update_features(report_response.server_features, report_response.application_settings)
-          logger.trace('Agent settings updated in response to Service', protect_on: ::Contrast::PROTECT.enabled?,
-                                                                        assess_on: ::Contrast::ASSESS.enabled?)
+          # Update Server Features and Application Settings to provide current agent settings
+          update_agent_settings(report_response)
+          # Process any reactions, including message logging and shutting down
+          update_reaction(report_response)
+          update_ruleset(report_response)
+          logger.trace('Agent settings updated in response to TeamServer', protect_on: ::Contrast::PROTECT.enabled?,
+                                                                           assess_on: ::Contrast::ASSESS.enabled?)
           response
         rescue StandardError => e
           logger.error('Unable to process response from TeamServer', e)
@@ -78,17 +78,17 @@ module Contrast
         def handle_error response
           case response&.code
           when ERROR_CODES[:message_not_sent]
-            handle_response_errors response, UNSUCCESSFULLY_RECEIVED_MSG, mode.running
+            handle_response_errors(response, UNSUCCESSFULLY_RECEIVED_MSG, mode.running)
           when ERROR_CODES[:access_forbidden]
-            handle_response_errors response, FORBIDDEN_MSG, mode.running
+            handle_response_errors(response, FORBIDDEN_MSG, mode.running)
           when ERROR_CODES[:access_forbidden_no_action]
-            handle_response_errors response, FORBIDDEN_NO_ACTION_MSG, mode.running
+            handle_response_errors(response, FORBIDDEN_NO_ACTION_MSG, mode.running)
           when ERROR_CODES[:application_do_not_exist]
-            handle_response_errors response, APP_NON_EXISTENT_MSG, mode.disabled
+            handle_response_errors(response, APP_NON_EXISTENT_MSG, mode.disabled)
           when ERROR_CODES[:unprocessable_entity]
-            handle_response_errors response, UNPROCESSABLE_ENTITY_MSG, mode.disabled
+            handle_response_errors(response, UNPROCESSABLE_ENTITY_MSG, mode.disabled)
           when ERROR_CODES[:too_many_requests]
-            handle_response_errors response, RETRY_AFTER_MSG, mode.resending
+            handle_response_errors(response, RETRY_AFTER_MSG, mode.resending)
           else
             logger.debug('Response Error code could not be processed')
           end
@@ -102,7 +102,7 @@ module Contrast
         # @param error_message [String, nil] Error message if any received.
         def suspend_reporting message, timeout, error_message
           @_timeout = timeout || Contrast::Agent::Reporting::ResponseHandler::TIMEOUT
-          log_debug_msg message, timeout: @_timeout, error_message: error_message || 'none'
+          log_debug_msg(message, timeout: @_timeout, error_message: error_message || 'none')
           @_sleep = true
         end
 

data/lib/contrast/agent/reporting/reporting_utilities/response_handler_utils.rb

@@ -78,9 +78,9 @@ module Contrast
           #                in the standard format per RFC 2616
           # used for in observed routes message.
           return false unless response && (response_code = response&.code)
-          return true if ANALYZE_WHEN.include? response_code
+          return true if ANALYZE_WHEN.include?(response_code)
 
-          handle_error response if ERROR_CODES.value?(response_code)
+          handle_error(response) if ERROR_CODES.value?(response_code)
           # There was error, so analyze the Error and nothing more.
           false
         end
@@ -95,16 +95,16 @@ module Contrast
         def handle_response_errors response, message, mode
           # Set the current mode status.
           @_mode.status = mode
-          ready_after, error_message, auth_error = extract_response_info response
+          ready_after, error_message, auth_error = extract_response_info(response)
           # log, suspend, disable:
           if mode == @_mode.running
-            log_debug_msg message,
+            log_debug_msg(message,
                           response: response.__id__,
                           request: Contrast::Agent::REQUEST_TRACKER.current&.request&.type,
                           error_message: error_message || 'none',
-                          auth_error: auth_error || 'none'
+                          auth_error: auth_error || 'none')
           end
-          suspend_reporting message, ready_after, error_message if mode == @_mode.resending
+          suspend_reporting(message, ready_after, error_message) if mode == @_mode.resending
           return unless mode == @_mode.disabled
 
           stop_reporting(message, application: Contrast::APP_CONTEXT.app_name, error_message: error_message)
@@ -142,8 +142,8 @@ module Contrast
         def update_agent_settings response
           return unless response
 
-          Contrast::SETTINGS.update_from_server_features(response) if response.server_features
-          Contrast::SETTINGS.update_from_application_settings(response) if response.application_settings
+          ::Contrast::SETTINGS.update_from_server_features(response) if response.server_features
+          ::Contrast::SETTINGS.update_from_application_settings(response) if response.application_settings
         end
 
         # Process the given Reactions from the application settings based on what
@@ -152,23 +152,18 @@ module Contrast
         #
         # @param response [Contrast::Agent::Reporting::Response]
         def update_reaction response
-          return unless response.application_settings.reactions&.any?
+          return unless response.application_settings&.reactions&.any?
 
           response.application_settings.reactions.each do |reaction|
             # The enums are all uppercase, we need to downcase them before attempting to log.
-            level = if reaction.level.nil?
-                      :error
-                    else
-                      reaction.level.downcase
-                    end
-
+            level = reaction.level.nil? ? :error : reaction.level.downcase
             logger.with_level(level, reaction.message) if reaction.message
 
             case reaction.operation
-            when Contrast::Agent::Reporting::Settings::Reaction::OPERATIONS.second
+            when Contrast::Agent::Reporting::Settings::Reaction::OPERATIONS[1]
               # DISABLED
-              Contrast::Agent::DisableReaction.run reaction, level
-            when Contrast::Agent::Reporting::Settings::Reaction::OPERATIONS.first
+              Contrast::Agent::DisableReaction.run(reaction, level)
+            when Contrast::Agent::Reporting::Settings::Reaction::OPERATIONS[0]
               # NOOP
             else
               logger.warn('ReactionProcessor received a reaction with an unknown operation',
@@ -177,6 +172,24 @@ module Contrast
           end
         end
 
+        # This can't go in the Settings component because protect and assess depend on settings
+        # I don't think it should go into contrast_service because that only handles connection specific data.
+        #
+        # @param response [Contrast::Agent::Reporting::Response]
+        def update_ruleset response
+          logger.info('Updating features from TeamServer')
+          return unless response&.server_features || response&.application_settings
+          return unless ::Contrast::AGENT.enabled?
+
+          logger.trace_with_time('Rebuilding rule modes from TeamServer') do
+            ::Contrast::SETTINGS.build_protect_rules if ::Contrast::PROTECT.enabled?
+            ::Contrast::AGENT.reset_ruleset
+            logger.info('Current rule settings:')
+            ::Contrast::PROTECT.rules.each { |k, v| logger.info('Protect Rule mode set', rule: k, mode: v.mode) }
+            logger.info('Disabled Assess Rules', rules: ::Contrast::ASSESS.disabled_rules)
+          end
+        end
+
         # Converts response from Net to Reporting Response object
         #
         # @param response [Net::HTTP::Response, nil]
@@ -192,12 +205,14 @@ module Contrast
           # check if response contains application settings or Feature settings
           if response_data[:settings]
             # the response contains ApplicationSettings
-            logger.trace('Agent: Received updated application settings')
-            build_application_settings response_data
+            app_settings = build_application_settings(response_data)
+            logger.trace('Agent: Received updated application settings', raw: response_data, processed: app_settings)
+            app_settings
           else
             # the response contains FeatureSettings
-            logger.trace('Agent: Received updated server features')
-            build_feature_settings response_data
+            server_features = build_feature_settings(response_data)
+            logger.trace('Agent: Received updated application settings', raw: response_data, processed: server_features)
+            server_features
           end
         rescue StandardError => e
           logger.error('Unable to convert response', e)
@@ -207,22 +222,22 @@ module Contrast
         # @param response_data [Hash]
         # @return res [Contrast::Agent::Reporting::Response]
         def build_application_settings response_data
-          res = Contrast::Agent::Reporting::Response.new
-          extract_assess response_data, res
-          extract_protect response_data, res
-          extract_exclusions response_data, res
-          extract_reactions response_data, res
-          extract_sensitive_data_policy response_data, res
+          res = Contrast::Agent::Reporting::Response.application_response
+          extract_assess(response_data, res)
+          extract_protect(response_data, res)
+          extract_exclusions(response_data, res)
+          extract_reactions(response_data, res)
+          extract_sensitive_data_policy(response_data, res)
           res
         end
 
         # @param response_data [Hash]
         # @return res [Contrast::Agent::Reporting::Response]
         def build_feature_settings response_data
-          res = Contrast::Agent::Reporting::Response.new
-          extract_assess_server_features response_data, res
-          extract_protect_server_features response_data, res
-          extract_protect_lists response_data, res
+          res = Contrast::Agent::Reporting::Response.server_response
+          extract_assess_server_features(response_data, res)
+          extract_protect_server_features(response_data, res)
+          extract_protect_lists(response_data, res)
           res.server_features.log_level = response_data[:logLevel]
           res.server_features.log_file = response_data[:logFile]
           res.server_features.telemetry = response_data[:telemetry]

data/lib/contrast/agent/reporting/settings/application_settings.rb

@@ -61,7 +61,7 @@ module Contrast
           #   operation [String] What to do in response to this reaction.[NOOP, DISABLE] }
           # @return [Array<Contrast::Agent::Reporting::Settings::Reaction>]
           def reactions= reactions
-            return unless reactions.is_a? Array
+            return unless reactions.is_a?(Array)
 
             @_reactions = []
             reactions.each do |r|

data/lib/contrast/agent/reporting/settings/assess.rb

@@ -12,7 +12,7 @@ module Contrast
         class Assess
           # Assess rules to disable for this application.
           #
-          # @return disabled_rules [Array<AssessRuleID>] Array with string rule_ids
+          # @return disabled_rules [Array<String>] Array with string rule_ids
           def disabled_rules
             @_disabled_rules ||= []
           end
@@ -20,15 +20,15 @@ module Contrast
           # @param disabled_rules [Array] with AssessRuleID strings
           # @return disabled_rules [Array<AssessRuleID>] Array with string rule_ids
           def disabled_rules= disabled_rules
-            @_disabled_rules = disabled_rules if disabled_rules.is_a? Array
+            @_disabled_rules = disabled_rules if disabled_rules.is_a?(Array)
           end
 
           # The id of a session on TeamServer under which this session of this application should report
           # Overrides that set by application.session_id (should match if provided).
           #
-          # @return session_id [String]
+          # @return session_id [String, nil]
           def session_id
-            @_session_id ||= Contrast::Utils::ObjectShare::EMPTY_STRING
+            @_session_id
           end
 
           # Set the session_id
@@ -36,7 +36,7 @@ module Contrast
           # @param session_id [String]
           # @return session_id [String]
           def session_id= session_id
-            @_session_id = session_id if session_id.is_a? String
+            @_session_id = session_id if session_id.is_a?(String) && !session_id.blank?
           end
         end
       end

data/lib/contrast/agent/reporting/settings/assess_server_feature.rb

@@ -47,7 +47,7 @@ module Contrast
           # }
           # @return [Contrast::Agent::Reporting::Settings::Sampling]
           def sampling= sampling
-            @_sampling = Contrast::Agent::Reporting::Settings::Sampling.new(sampling) if sampling.is_a? Hash
+            @_sampling = Contrast::Agent::Reporting::Settings::Sampling.new(sampling) if sampling.is_a?(Hash)
           end
 
           # The sanitizers defined by the user for use by the agent on this server for this organization.
@@ -72,7 +72,7 @@ module Contrast
           #   tags  [Array[String]]
           #   uuid  [String]
           def sanitizers= sanitizers
-            @_sanitizers = sanitizers if sanitizers.is_a? Array
+            @_sanitizers = sanitizers if sanitizers.is_a?(Array)
           end
 
           # The validators defined by the user for use by the agent on this server for this organization.
@@ -99,7 +99,7 @@ module Contrast
           #   uuid  [String]
           # }
           def validators= validators
-            @_validators = validators if validators.is_a? Array
+            @_validators = validators if validators.is_a?(Array)
           end
         end
       end

data/lib/contrast/agent/reporting/settings/exclusions.rb

@@ -36,7 +36,7 @@ module Contrast
           #   denylist     [String] The call, if in the stack, should result in the agent not taking action.
           # }
           def code_exclusions= code_exclusions
-            @_code_exclusions = code_exclusions if code_exclusions.is_a? Array
+            @_code_exclusions = code_exclusions if code_exclusions.is_a?(Array)
           end
 
           # Cases where rules should be excluded if violated from a given input.
@@ -75,7 +75,7 @@ module Contrast
           #   type           [String] The type of the input [COOKIE, PARAMETER, HEADER, BODY, QUERYSTRING]
           # }
           def input_exclusions= input_exclusions
-            @_input_exclusions = input_exclusions if input_exclusions.is_a? Array
+            @_input_exclusions = input_exclusions if input_exclusions.is_a?(Array)
           end
 
           # A case where rules should be excluded if violated during a call to a given URL.
@@ -114,7 +114,7 @@ module Contrast
           #   type           [String] The type of the input [COOKIE, PARAMETER, HEADER, BODY, QUERYSTRING]
           # }
           def url_exclusions= url_exclusions
-            @_url_exclusions = url_exclusions if url_exclusions.is_a? Array
+            @_url_exclusions = url_exclusions if url_exclusions.is_a?(Array)
           end
         end
       end

data/lib/contrast/agent/reporting/settings/protect.rb

@@ -11,7 +11,7 @@ module Contrast
         # Application level settings for the Protect featureset
         class Protect
           # block at perimeter needs to be check against the blockAtEntry boolean value
-          PROTECT_RULES_MODE = %w[OFF BLOCKING MONITORING].cs__freeze
+          PROTECT_RULES_MODE = %w[OFF MONITORING BLOCKING].cs__freeze
           # The settings for each protect rule for this application
           #
           # @return protection_rules [Array<protectRule>] protectRule: {
@@ -33,7 +33,7 @@ module Contrast
           #   id           [String] The id of a rule in Contrast.
           #   mode         [String] The mode that this rule should run in. [OFF, MONITORING, BLOCKING] }
           def protection_rules= protection_rules
-            @_protection_rules = protection_rules if protection_rules.is_a? Array
+            @_protection_rules = protection_rules if protection_rules.is_a?(Array)
           end
 
           # The virtual patches to apply for this application
@@ -66,19 +66,34 @@ module Contrast
           #   urls       [Array] The urls that must be present in the request to result in the request being blocked.
           #   uuids      [String] The UUID of the Virtual Patch }
           def virtual_patches= virtual_patches
-            @_virtual_patches = virtual_patches if virtual_patches.is_a? Array
+            @_virtual_patches = virtual_patches if virtual_patches.is_a?(Array)
           end
 
           # Converts settings into Agent Settings understandable hash {RULE_ID => MODE}
           #
           # @return rules [Hash<RULE_ID => MODE>, nil] Hash with rule_id as key and mode as value
           def protection_rules_to_settings_hash
-            return if protection_rules.empty?
+            return {} if protection_rules.empty?
 
             modes_by_id = {}
             protection_rules.each do |rule|
-              PROTECT_RULES_MODE.include? rule[:mode]
-              modes_by_id[rule[:id]] = rule[:mode]
+              setting_mode = rule[:mode]
+              next unless PROTECT_RULES_MODE.include?(setting_mode)
+
+              api_mode = case setting_mode
+                         when PROTECT_RULES_MODE[1]
+                           ::Contrast::Api::Settings::ProtectionRule::Mode::MONITORED
+                         when PROTECT_RULES_MODE[2]
+                           if rule[:blockAtEntry]
+                             ::Contrast::Api::Settings::ProtectionRule::Mode::BLOCK_AT_PERIMETER
+                           else
+                             ::Contrast::Api::Settings::ProtectionRule::Mode::BLOCKED
+                           end
+                         else
+                           ::Contrast::Api::Settings::ProtectionRule::Mode::NO_ACTION
+                         end
+
+              modes_by_id[rule[:id]] = api_mode
             end
             modes_by_id
           end

data/lib/contrast/agent/reporting/settings/protect_server_feature.rb

@@ -23,7 +23,7 @@ module Contrast
           # @param enabled [Boolean]
           # @return enabled [Boolean]
           def enabled= enabled
-            @_enabled = enabled if !!enabled == enabled
+            @_enabled = enabled
           end
 
           # Indicate if the bot protection feature set is enabled for this server or not.
@@ -66,7 +66,7 @@ module Contrast
           #   name    [String] The user defined name of the filter.
           #   uuid    [String] The identifier of the filter as defined by TeamServer.
           def ip_allowlist= allowlist
-            @_ip_allowlist = allowlist if allowlist.is_a? Array
+            @_ip_allowlist = allowlist if allowlist.is_a?(Array)
           end
 
           # The IP addresses for which to disable protection.
@@ -94,7 +94,7 @@ module Contrast
           #                     name    [String] The user defined name of the filter.
           #                     uuid    [String] The identifier of the filter as defined by TeamServer.
           def ip_denylist= denylist
-            @_ip_denylist = denylist if denylist.is_a? Array
+            @_ip_denylist = denylist if denylist.is_a?(Array)
           end
 
           # All of the apis to add new logging calls to the application at runtime.
@@ -134,7 +134,7 @@ module Contrast
           #    type    [String] The type of log message to tenerate. Audit as 0, Security as 2.
           #                     [ AUDIT, ERROR, SECURITY ]
           def log_enchancers= log_enchancers
-            @_log_enchancers = log_enchancers if log_enchancers.is_a? Array
+            @_log_enchancers = log_enchancers if log_enchancers.is_a?(Array)
           end
 
           # The keywords and patterns required for the input analysis of each rule with that capability.
@@ -191,7 +191,7 @@ module Contrast
           #                    value          [String] }
           # }
           def rule_definition_list= list
-            @_rule_definition_list = list if list.is_a? Array
+            @_rule_definition_list = list if list.is_a?(Array)
           end
 
           # Controls for the syslogging feature in the agent.
@@ -234,7 +234,7 @@ module Contrast
           #   syslogSeverityProbed    [String]
           #   syslogSeveritySuspicous [String]
           def syslog= log
-            @_syslog = log if log.is_a? Hash
+            @_syslog = log if log.is_a?(Hash)
           end
         end
       end

data/lib/contrast/agent/reporting/settings/reaction.rb

@@ -19,9 +19,9 @@ module Contrast
           # @param message [String] A message to log when receiving this reaction.
           # @param operation [String] What to do in response to this reaction.[NOOP, DISABLE]
           def initialize level, operation, message
-            @level = level if LEVELS.include? level
-            @operation = operation if OPERATIONS.include? operation
-            @message = message if message.is_a? String
+            @level = level if LEVELS.include?(level)
+            @operation = operation if OPERATIONS.include?(operation)
+            @message = message if message.is_a?(String)
           end
         end
       end

data/lib/contrast/agent/reporting/settings/sensitive_data_masking.rb

@@ -58,7 +58,7 @@ module Contrast
           # @param rules [Array<Contrast::Agent::Reporting::Settings::SensitiveDataMaskingRule>]
           # @return rules [Array<Contrast::Agent::Reporting::Settings::SensitiveDataMaskingRule>, []]
           def rules= rules
-            @_rules = rules if rules_array? rules
+            @_rules = rules if rules_array?(rules)
           end
 
           # Build rules from hash
@@ -99,7 +99,7 @@ module Contrast
           # @param item [Contrast::Agent::Reporting::Settings::SensitiveDataMaskingRule]
           # @return itself [Array<Contrast::Agent::Reporting::Settings::SensitiveDataMaskingRule>]
           def << item
-            return itself unless item.instance_of? Contrast::Agent::Reporting::Settings::SensitiveDataMaskingRule
+            return itself unless item.instance_of?(Contrast::Agent::Reporting::Settings::SensitiveDataMaskingRule)
 
             super
           end

data/lib/contrast/agent/reporting/settings/sensitive_data_masking_rule.rb

@@ -37,7 +37,7 @@ module Contrast
           # @param words_array [Array<String>]
           # @return keywords [Array<String>] set of keywords
           def keywords= words_array
-            @_keywords = words_array if string_array? words_array
+            @_keywords = words_array if string_array?(words_array)
           end
 
           private
@@ -49,7 +49,7 @@ module Contrast
           def string_array? array
             return false unless array.is_a?(Array) && array.any?
 
-            array.all? String
+            array.all?(String)
           end
         end
       end

data/lib/contrast/agent/reporting/settings/server_features.rb

@@ -27,7 +27,7 @@ module Contrast
           # @param log_level [String]
           # @return log_level [String] [ ERROR, WARN, INFO, DEBUG, TRACE ]
           def log_level= log_level
-            @_log_level = log_level if log_level.is_a? String
+            @_log_level = log_level if log_level.is_a?(String)
           end
 
           # Where to log the agent's log file, if set by the user. Overridden by agent.logger.path
@@ -43,7 +43,7 @@ module Contrast
           # @param log_file [String] path
           # @return log_file [String] path
           def log_file= log_file
-            @_log_file = log_file if log_file.is_a? String
+            @_log_file = log_file if log_file.is_a?(String)
           end
 
           # Controls for the reporting of telemetry events from the agent to TeamServer.

data/lib/contrast/agent/request.rb

@@ -34,12 +34,14 @@ module Contrast
       LAST_REST_TOKEN = %r{/\d+$}.cs__freeze
       INNER_NUMBER_MARKER = '/{n}/'
       LAST_NUMBER_MARKER = '/{n}'
+      STATIC_SUFFIXES = /\.(?:js|css|jpeg|jpg|gif|png|ico|woff|svg|pdf|eot|ttf|jar)$/i.cs__freeze
+      MEDIA_TYPE_MARKERS = %w[image/ text/css text/javascript].cs__freeze
 
       attr_reader :rack_request
       attr_accessor :route, :observed_route, :new_observed_route
 
       # Delegate calls to the following methods to the attribute @rack_request
-      def_delegators :@rack_request, :base_url, :content_type, :cookies, :env, :ip, :path, :port, :query_string,
+      def_delegators :@rack_request, :base_url, :cookies, :env, :ip, :media_type, :path, :port, :query_string,
                      :request_method, :scheme, :url, :user_agent
 
       # Initialize new Contrast Request
@@ -86,9 +88,9 @@ module Contrast
       #
       # @return type [Symbol<:XML, :JSON, :NORMAL>]
       def document_type
-        @_document_type ||= if /xml/i.match?(content_type) || body&.start_with?('<?xml')
+        @_document_type ||= if /xml/i.match?(media_type) || body&.start_with?('<?xml')
                               :XML
-                            elsif /json/i.match?(content_type) || body&.match?(/\s*[{\[]/)
+                            elsif /json/i.match?(media_type) || body&.match?(/\s*[{\[]/)
                               :JSON
                             else
                               :NORMAL
@@ -181,8 +183,6 @@ module Contrast
         @_hash_id ||= Contrast::Utils::HashDigest.generate_request_hash(self)
       end
 
-      STATIC_SUFFIXES = /\.(?:js|css|jpeg|jpg|gif|png|ico|woff|svg|pdf|eot|ttf|jar)$/i.cs__freeze
-      MEDIA_TYPE_MARKERS = %w[image/ text/css text/javascript].cs__freeze
       # Utility method for checking if a request is for a static resource.
       # @return [Boolean] true, if the request is for a well-known static
       #  type as determined by the request suffix or the accept header.