contrast-agent 6.1.0 → 6.1.1

data/lib/contrast/configuration.rb

@@ -94,7 +94,7 @@ module Contrast
         rescue Psych::Exception => e
           log_yaml_parse_error(path, e)
         rescue RuntimeError => e
-          puts "WARN: Unable to load configuration. #{ e }; path: #{ path }, pwd: #{ Dir.pwd }"
+          puts("WARN: Unable to load configuration. #{ e }; path: #{ path }, pwd: #{ Dir.pwd }")
         end
       end
 
@@ -182,7 +182,7 @@ module Contrast
       if logger
         logger.warn('YAML validator found an error', hash)
       else
-        puts "CONTRAST - WARN: YAML validator found an error. #{ hash.inspect }"
+        puts("CONTRAST - WARN: YAML validator found an error. #{ hash.inspect }")
       end
     end
 
@@ -190,7 +190,7 @@ module Contrast
       if logger
         logger.warn('Configuration file is not readable by current user', path: path)
       else
-        puts "CONTRAST - WARN: Configuration file is not readable by current user; path: #{ path }"
+        puts("CONTRAST - WARN: Configuration file is not readable by current user; path: #{ path }")
       end
     end
 
@@ -198,7 +198,7 @@ module Contrast
       if logger
         logger.warn('Deprecated property in use', old_method: old_method, new_method: new_method)
       else
-        puts "CONTRAST - WARN: Deprecated property in use; old_method: #{ old_method }, new_method: #{ new_method }"
+        puts("CONTRAST - WARN: Deprecated property in use; old_method: #{ old_method }, new_method: #{ new_method }")
       end
     end
 

data/lib/contrast/extension/assess/array.rb

@@ -53,7 +53,7 @@ module Contrast
               return ret unless Contrast::Agent::Assess::Tracker.tracked?(ret)
 
               properties.cleanup_tags
-              event_data = Contrast::Agent::Assess::Events::EventData.new ARRAY_JOIN_NODE, ret, ary, ret, [separator]
+              event_data = Contrast::Agent::Assess::Events::EventData.new(ARRAY_JOIN_NODE, ret, ary, ret, [separator])
               properties.build_event(event_data)
               properties.event.instance_variable_set(:@_parent_events, parent_events)
               ret

data/lib/contrast/extension/assess/erb.rb

@@ -20,7 +20,7 @@ module ERBPropagator
 
       erb_pre_result = preshift.object.src
       parent_events = []
-      binding_variable_set binding_variable_set, used_binding, erb_pre_result, properties, parent_events, ret
+      binding_variable_set(binding_variable_set, used_binding, erb_pre_result, properties, parent_events, ret)
       properties.build_event(Contrast::Agent::Assess::Events::EventData.new(patcher,
                                                                             ret,
                                                                             preshift.object,

data/lib/contrast/extension/assess/marshal.rb

@@ -43,7 +43,7 @@ module Contrast
               properties.copy_from(source, ret)
 
               node = Contrast::Agent::Assess::Policy::Policy.instance.find_propagator_node('Marshal', :load, false)
-              event_data = Contrast::Agent::Assess::Events::EventData.new node, ret, self, ret, args
+              event_data = Contrast::Agent::Assess::Events::EventData.new(node, ret, self, ret, args)
               properties.build_event(event_data)
             rescue StandardError => e
               logger.error('Unable to run Assess for Marshal.load', e)

data/lib/contrast/extension/assess/string.rb

@@ -43,7 +43,7 @@ module Contrast
               offset = 0
               inputs.each do |input|
                 properties.copy_from(input, result, offset)
-                add_dynamic_sources_info input, result
+                add_dynamic_sources_info(input, result)
                 offset += input.length
                 parent_event = Contrast::Agent::Assess::Tracker.properties(input)&.event
                 parent_events << parent_event if parent_event

data/lib/contrast/extension/extension.rb

@@ -37,9 +37,9 @@ module Contrast
           def assign_value path
             case path
             when /fiber/, /interpolation26/
-              require path if Funchook.available?
+              require(path) if Funchook.available?
             else
-              require path
+              require(path)
             end
             true
           end

data/lib/contrast/framework/base_support.rb

@@ -7,19 +7,19 @@ module Contrast
     module BaseSupport
       # The top level module name used by the framework
       def detection_class
-        raise NoMethodError('Subclasses of BaseSupport should implement this method')
+        raise(NoMethodError('Subclasses of BaseSupport should implement this method'))
       end
 
       def version
-        raise NoMethodError('Subclasses of BaseSupport should implement this method')
+        raise(NoMethodError('Subclasses of BaseSupport should implement this method'))
       end
 
       def application_name
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def server_type
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       # Find all the predefined routes for this application and append them to the
@@ -27,19 +27,19 @@ module Contrast
       # msg should be a Contrast::Api::Dtm::ApplicationUpdate or some other msg
       # that has a routes array consisting of Contrast::Api::Dtm::RouteCoverage
       def collect_routes
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def current_route_coverage
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def current_route
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def retrieve_request _env
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       # Some Frameworks require specific patching for their classes to handle

data/lib/contrast/framework/grape/support.rb

@@ -112,7 +112,7 @@ module Contrast
             full_route ||= request.env[::Rack::PATH_INFO]
 
             new_route_coverage = Contrast::Agent::Reporting::RouteCoverage.new
-            new_route_coverage.attach_rack_based_data final_controller, method, route_pattern, full_route
+            new_route_coverage.attach_rack_based_data(final_controller, method, route_pattern, full_route)
           end
 
           # Search object space for grape controllers--any class that subclasses ::Grape::API.
@@ -151,7 +151,7 @@ module Contrast
             # Grape controller actually has endpoints and each endpoint
             # has routes and that's why we need to do it that way
             controller = controllers.pop
-            return _route_recurse method, route, controllers unless controller
+            return _route_recurse(method, route, controllers) unless controller
 
             contr_routes = controller.endpoints&.map(&:routes)&.flatten || []
             route_pattern = contr_routes&.find do |r|
@@ -159,7 +159,7 @@ module Contrast
             end
             return controller, route_pattern unless route_pattern.nil?
 
-            _route_recurse method, route, controllers
+            _route_recurse(method, route, controllers)
           end
 
           # Get route and do some cleaning

data/lib/contrast/framework/manager.rb

@@ -64,25 +64,25 @@ module Contrast
       end
 
       def platform_version
-        framework_version = first_framework_result :version, ''
+        framework_version = first_framework_result(:version, '')
 
         Contrast::Framework::PlatformVersion.from_string(framework_version)
       end
 
       def platform_version_string
-        first_framework_result :version, ''
+        first_framework_result(:version, '')
       end
 
       def server_type
-        first_framework_result :server_type, 'rack'
+        first_framework_result(:server_type, 'rack')
       end
 
       def app_name
-        first_framework_result :application_name, 'root'
+        first_framework_result(:application_name, 'root')
       end
 
       def app_root
-        found = first_framework_result :application_root, nil
+        found = first_framework_result(:application_root, nil)
         found || ::Rack::Directory.new('').root
       end
 

data/lib/contrast/framework/manager_extend.rb

@@ -21,7 +21,7 @@ module Contrast
       end
 
       def routes_for_all_frameworks
-        data_for_all_frameworks :collect_routes
+        data_for_all_frameworks(:collect_routes)
       end
 
       # This returns an array of all data from each framework in a flat, no-nil values array

data/lib/contrast/framework/rack/patch/session_cookie.rb

@@ -25,7 +25,7 @@ module Contrast
             def instrument
               @_instrument ||= begin
                 ::Rack::Session::Cookie.class_eval do
-                  alias_method :cs__patched_initialize, :initialize
+                  alias_method(:cs__patched_initialize, :initialize)
                   def initialize app, options = {} # rubocop:disable Style/OptionHash
                     Contrast::Framework::Rack::Patch::SessionCookie.analyze(options)
                     cs__patched_initialize(app, options)

data/lib/contrast/framework/rails/patch/action_controller_live_buffer.rb

@@ -16,8 +16,19 @@ module Contrast
             def send_messages
               return unless (context = Contrast::Agent::REQUEST_TRACKER.current)
 
-              [context.server_activity, context.activity, context.observed_route].each do |msg|
-                Contrast::Agent.messaging_queue.send_event_immediately(msg)
+              if Contrast::Agent::Reporter.enabled?
+                [
+                  context.new_observed_route,
+                  Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.server_activity),
+                  Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity.library_usages),
+                  Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity)
+                ].each do |event|
+                  Contrast::Agent.reporter&.send_event_immediately(event)
+                end
+              else
+                [context.server_activity, context.activity, context.observed_route].each do |msg|
+                  Contrast::Agent.messaging_queue&.send_event_immediately(msg)
+                end
               end
             end
 
@@ -27,7 +38,7 @@ module Contrast
                   # normally pre->in->post filters are applied however, in a streamed response we can run into a case
                   # where it's pre -> in -> post -> more infilters in order to submit anything found during the
                   # infilters after the response has been written we need to explicitly send them
-                  alias_method :cs__close, :close
+                  alias_method(:cs__close, :close)
                   def close
                     Contrast::Framework::Rails::Patch::ActionControllerLiveBuffer.send_messages
                     cs__close

data/lib/contrast/framework/rails/patch/assess_configuration.rb

@@ -49,7 +49,7 @@ module Contrast
             end
 
             def apply_session_timeout *args
-              return if ::Contrast::ASSESS.rule_disabled? CS__SESSION_TIMEOUT_NAME
+              return if ::Contrast::ASSESS.rule_disabled?(CS__SESSION_TIMEOUT_NAME)
               return unless vulnerable_setting?(:expire_after, SAFE_SESSION_TIMEOUT, args,
                                                 comparison_type: :greater_than, safe_default: false)
 
@@ -64,7 +64,7 @@ module Contrast
             end
 
             def apply_secure_cookie_disabled *args
-              return if ::Contrast::ASSESS.rule_disabled? CS__SECURE_RULE_NAME
+              return if ::Contrast::ASSESS.rule_disabled?(CS__SECURE_RULE_NAME)
               return unless vulnerable_setting?(:secure, true, args)
 
               rails_session_settings = args[1]
@@ -78,7 +78,7 @@ module Contrast
             end
 
             def apply_httponly_disabled *args
-              return if ::Contrast::ASSESS.rule_disabled? CS__HTTPONLY_RULE_NAME
+              return if ::Contrast::ASSESS.rule_disabled?(CS__HTTPONLY_RULE_NAME)
               return unless vulnerable_setting?(:httponly, true, args)
 
               rails_session_settings = args[1]

data/lib/contrast/framework/rails/patch/rails_application_configuration.rb

@@ -14,7 +14,7 @@ module Contrast
           def self.instrument
             @_instrument ||= begin
               ::Rails::Application::Configuration.class_eval do
-                alias_method :cs__patched_session_store, :session_store
+                alias_method(:cs__patched_session_store, :session_store)
                 def session_store *args, **kwargs
                   ret = cs__patched_session_store(*args, **kwargs)
                   Contrast::Framework::Rails::Patch::AssessConfiguration.analyze_session_store(*args, **kwargs)

data/lib/contrast/framework/rails/patch/support.rb

@@ -20,7 +20,7 @@ module Contrast
             # (i.e., where we normally patch) we will miss the configuration
             # and will never be able to report session misconfiguration rules.
             Contrast::Framework::Rails::Patch::RailsApplicationConfiguration.instrument
-            require 'contrast/framework/rails/railtie' if ::Rails::VERSION::MAJOR.to_i >= 3
+            require('contrast/framework/rails/railtie') if ::Rails::VERSION::MAJOR.to_i >= 3
           end
 
           # (See BaseSupport#after_load_patches)

data/lib/contrast/framework/rails/support.rb

@@ -104,7 +104,7 @@ module Contrast
             end
 
             new_route_coverage = Contrast::Agent::Reporting::RouteCoverage.new
-            new_route_coverage.attach_rails_data route, original_url
+            new_route_coverage.attach_rails_data(route, original_url)
           rescue StandardError => e
             logger.warn('Unable to determine the current route of this request', e)
             nil
@@ -153,7 +153,7 @@ module Contrast
             # If the current routing node points to a sub-app (::Rais::Engine), dive deeper.
             # Have sub-app route the remainder of the url.
             if engine_route?(route)
-              new_req = retrieve_request request.env
+              new_req = retrieve_request(request.env)
               new_req.path_info = new_req.path_info.gsub(match.to_s, '')
               get_full_route(new_req, route.app.app.routes.router, path << match.to_s)
             else

data/lib/contrast/framework/sinatra/support.rb

@@ -101,7 +101,7 @@ module Contrast
             full_route ||= request.env[::Rack::PATH_INFO]
 
             new_route_coverage = Contrast::Agent::Reporting::RouteCoverage.new
-            new_route_coverage.attach_rack_based_data final_controller, method, route_pattern, full_route
+            new_route_coverage.attach_rack_based_data(final_controller, method, route_pattern, full_route)
           end
 
           # Search object space for sinatra controllers--any class that subclasses ::Sinatra::Base.

data/lib/contrast/logger/aliased_logging.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'contrast/agent/telemetry/events/exceptions/telemetry_exceptions'
+require 'contrast/agent/telemetry/events/exceptions/obfuscate'
 
 module Contrast
   module Logger
@@ -40,23 +41,29 @@ module Contrast
 
       private
 
-      def build_exclusion type, message = nil, exception = nil, data = nil
-        start = caller_locations&.find_index { |stack| stack.to_s.include?(type) }
-        stack_trace = start ? caller_locations(start + 1, 20) : caller_locations(20, 20)
-        stack_frame_type = stack_trace[1].path.delete_prefix(Dir.pwd)
-        message_exception_type = exception ? exception.cs__class.to_s : stack_frame_type.split('/').last
-        stack_frame_function = stack_trace[1].label
-        key = "#{ stack_frame_type }|#{ stack_frame_function }|#{ message }"
-        if TELEMETRY_EXCEPTIONS[key]
-          TELEMETRY_EXCEPTIONS.increment key
-          return
-        end
-
-        event_message = create_message(stack_frame_function, stack_frame_type, message_exception_type, data, exception,
-                                       message)
-        TELEMETRY_EXCEPTIONS[key] = event_message
-      rescue StandardError => e
-        debug('Unable to report exception to telemetry', e)
+      def build_exclusion _type, _message = nil, _exception = nil, _data = nil
+        # TODO: RUBY-1698
+        nil
+        #   start = caller_locations&.find_index { |stack| stack.to_s.include?(type) }
+        #   stack_trace = start ? caller_locations(start + 1, 20) : caller_locations(20, 20)
+        #   stack_frame_type = Contrast::Agent::Telemetry::TelemetryException::Obfuscate.obfuscate_type(
+        #       stack_trace[1].path.delete_prefix(Dir.pwd))
+        #   message_exception_type = Contrast::Agent::Telemetry::TelemetryException::Obfuscate.obfuscate_exception_type(
+        #       exception ? exception.cs__class.to_s : stack_frame_type.split('/').last)
+        #   stack_frame_function = stack_trace[1].label
+        #   key = "#{ stack_frame_type }|#{ stack_frame_function }|#{ message }"
+        #   if TELEMETRY_EXCEPTIONS[key]
+        #     TELEMETRY_EXCEPTIONS.increment(key)
+        #     return
+        #   end
+        #
+        #   event_message = create_message(stack_frame_function,
+        #                                  stack_frame_type, message_exception_type,
+        #                                  data, exception,
+        #                                  message)
+        #   TELEMETRY_EXCEPTIONS[key] = event_message
+        # rescue StandardError => e
+        #   debug('Unable to report exception to telemetry', e)
       end
 
       def create_message stack_frame_function, stack_frame_type, message_exception_type, data, exception, message
@@ -65,10 +72,10 @@ module Contrast
                                 else
                                   message
                                 end
-        module_name = exception ? exception.cs__class.to_s.split('::').first : nil
-        stack_frame = Contrast::Agent::Telemetry::TelemetryException::StackFrame.build stack_frame_function,
+        module_name = message_exception_type ? message_exception_type.split('::')[0] : nil
+        stack_frame = Contrast::Agent::Telemetry::TelemetryException::StackFrame.build(stack_frame_function,
                                                                                        stack_frame_type,
-                                                                                       module_name
+                                                                                       module_name)
         message_exception = Contrast::Agent::Telemetry::TelemetryException::MessageException.build(
             message_exception_type,
             message_for_exception,
@@ -79,8 +86,8 @@ module Contrast
                else
                  exception.cs__is_a?(Hash) ? exception : {}
                end
-        message = Contrast::Agent::Telemetry::TelemetryException::Message.build tags, [message_exception]
-        Contrast::Agent::Telemetry::TelemetryException::Event.new message
+        message = Contrast::Agent::Telemetry::TelemetryException::Message.build(tags, [message_exception])
+        Contrast::Agent::Telemetry::TelemetryException::Event.new(message)
       end
     end
   end

data/lib/contrast/logger/cef_log.rb

@@ -30,7 +30,7 @@ module Contrast
           else
             cs__error(*args, **kwargs)
           end
-          args.each { |arg| raise arg if arg && arg.cs__class < Exception }
+          args.each { |arg| raise(arg) if arg && arg.cs__class < Exception }
         end
       end
     end
@@ -69,11 +69,11 @@ module Contrast
         if @_cef_logger
           @_cef_logger.error('Unable to process update to LoggerManager.', e)
         else
-          puts 'Unable to process update to LoggerManager.'
-          raise e if ENV['CONTRAST__AGENT__RUBY_MORE_COWBELL']
+          puts('Unable to process update to LoggerManager.')
+          raise(e) if ENV['CONTRAST__AGENT__RUBY_MORE_COWBELL']
 
-          puts e.message
-          puts e.backtrace.join("\n")
+          puts(e.message)
+          puts(e.backtrace.join("\n"))
         end
         # rubocop:enable Rails/Output
       end
@@ -99,28 +99,28 @@ module Contrast
 
       def virtual_patch_message patch, outcome
         message = "Virtual Patch #{ patch.fetch(:name, '') } - #{ patch[:uuid] } was triggered by this request."
-        log [message, patch, outcome], ::Logger::Severity::DEBUG
+        log([message, patch, outcome], ::Logger::Severity::DEBUG)
       end
 
       def bot_blocking_message matching_bot, outcome
         message = "User agent #{ matching_bot[:user_agent] } matched the disallowed value #{ matching_bot[:bot] }"
-        log [message, matching_bot, outcome], ::Logger::Severity::DEBUG
+        log([message, matching_bot, outcome], ::Logger::Severity::DEBUG)
       end
 
       def ip_denylisted_message remote_ip, block_entry, outcome
         message = "IP Address #{ remote_ip } matched the disallowed value" \
                   "#{ block_entry[:ip] } in the IP Blacklist #{ block_entry[:uuid] }"
-        log [message, block_entry, outcome], ::Logger::Severity::DEBUG
+        log([message, block_entry, outcome], ::Logger::Severity::DEBUG)
       end
 
       def successful_attack rule_id, outcome, input_type = nil, input_value = nil
         if input_type.present? && input_value.present?
           successful_attack_with_input = "#{ input_type } had a value that successfully exploited" \
                                          "#{ rule_id } - #{ input_value }"
-          log [successful_attack_with_input, rule_id, outcome], ::Logger::Severity::WARN
+          log([successful_attack_with_input, rule_id, outcome], ::Logger::Severity::WARN)
         else
           successful_attack_wo_input = "An effective attack was detected against #{ rule_id }"
-          log [successful_attack_wo_input, rule_id, outcome], ::Logger::Severity::WARN
+          log([successful_attack_wo_input, rule_id, outcome], ::Logger::Severity::WARN)
         end
       end
 
@@ -128,10 +128,10 @@ module Contrast
         if input_type.present? && input_value.present?
           ineffective_attack_with_input = "#{ input_type } had a value that matched a signature for, " \
                                           "but did not successfully exploit #{ rule_id } - #{ input_value }"
-          log [ineffective_attack_with_input, rule_id, outcome], ::Logger::Severity::WARN
+          log([ineffective_attack_with_input, rule_id, outcome], ::Logger::Severity::WARN)
         else
           ineffective_attack_wo_input = "An unsuccessful attack was detected against #{ rule_id }"
-          log [ineffective_attack_wo_input, rule_id, outcome], ::Logger::Severity::WARN
+          log([ineffective_attack_wo_input, rule_id, outcome], ::Logger::Severity::WARN)
         end
       end
 
@@ -140,10 +140,10 @@ module Contrast
         if input_type.present? && input_value.present?
           suspicious_attack_with = "#{ input_type } included a potential attack value that was detected" \
                                    "as suspicious using #{ rule_id } - #{ input_value }"
-          log [suspicious_attack_with, rule_id, outcome], ::Logger::WARN
+          log([suspicious_attack_with, rule_id, outcome], ::Logger::WARN)
         elsif input_value.present?
           suspicious_attack_without = "Suspicious activity indicates a potential attack using #{ rule_id }"
-          log [suspicious_attack_without, rule_id, outcome], ::Logger::WARN
+          log([suspicious_attack_without, rule_id, outcome], ::Logger::WARN)
         end
       end
     end

data/lib/contrast/logger/format.rb

@@ -10,6 +10,7 @@ module Contrast
     # Our format for the Ougai logger allowing for custom log format that
     # extends the behavior of the default Ougai logger
     class Format < Ougai::Formatters::Bunyan
+      NO_REQUEST_HASH = { request_id: -1 }.cs__freeze
       LOG_TRACKER = Contrast::Utils::ThreadTracker.new
       # Our override of the _call method to add in the extra data that we want,
       # based on
@@ -49,7 +50,6 @@ module Contrast
         hash
       end
 
-      NO_REQUEST_HASH = { request_id: -1 }.cs__freeze
       def request_hash
         @request_tracker_defined ||= defined?(Contrast::Agent) && defined?(Contrast::Agent::REQUEST_TRACKER)
         return NO_REQUEST_HASH unless @request_tracker_defined

data/lib/contrast/logger/log.rb

@@ -44,8 +44,8 @@ module Contrast
       untimed_func_symbol = "untimed_#{ meth_spec.method_name }".to_sym
       send_to = class_method ? meth_spec.clazz.cs__singleton_class : meth_spec.clazz
       meth_spec.clazz.class_eval do
-        include Contrast::Components::Logger::InstanceMethods
-        extend Contrast::Components::Logger::InstanceMethods
+        include(Contrast::Components::Logger::InstanceMethods)
+        extend(Contrast::Components::Logger::InstanceMethods)
 
         send_to.send(:alias_method, untimed_func_symbol, meth_spec.method_name)
         meth_spec.aliased = true
@@ -73,7 +73,7 @@ module Contrast
         next if meth_spec.aliased
 
         is_class_method = meth_spec.clazz.singleton_methods(false).include?(meth_spec.method_name)
-        trace_time_class_method meth_spec, is_class_method
+        trace_time_class_method(meth_spec, is_class_method)
       end
     end
   end
@@ -96,7 +96,7 @@ module Contrast
           else
             cs__error(*args, **kwargs)
           end
-          args.each { |arg| raise arg if arg && arg.cs__class < Exception }
+          args.each { |arg| raise(arg) if arg && arg.cs__class < Exception }
         end
       end
     end
@@ -142,11 +142,11 @@ module Contrast
         if logger
           logger.error('Unable to process update to LoggerManager.', e)
         else
-          puts 'Unable to process update to LoggerManager.'
-          raise e if ENV['CONTRAST__AGENT__RUBY_MORE_COWBELL']
+          puts('Unable to process update to LoggerManager.')
+          raise(e) if ENV['CONTRAST__AGENT__RUBY_MORE_COWBELL']
 
-          puts e.message
-          puts e.backtrace.join("\n")
+          puts(e.message)
+          puts(e.backtrace.join("\n"))
         end
       end
 

data/lib/contrast/tasks/config.rb

@@ -75,7 +75,7 @@ module Contrast
         missing = []
         api_hash = config.root.api.to_hash
         api_hash.each_key do |key|
-          value = mask_keys api_hash, key
+          value = mask_keys(api_hash, key)
           if value.is_a?(Contrast::Config::ApiProxyConfiguration)
             Contrast::Config.validate_proxy(value)
           elsif value.is_a?(Contrast::Config::CertificationConfiguration)
@@ -92,31 +92,31 @@ module Contrast
       end
 
       def self.validate_proxy config
-        puts "Proxy Enabled: #{ config.enable }"
+        puts("Proxy Enabled: #{ config.enable }")
         return unless config.enable
 
-        puts "Proxy URL: #{ config.url }"
+        puts("Proxy URL: #{ config.url }")
         abort('Proxy Enabled but no Proxy URL given') unless config.url
       end
 
       def self.validate_cert config
-        puts "Certification Enabled: #{ config.enable }"
+        puts("Certification Enabled: #{ config.enable }")
         return unless config.enable
 
-        puts "CA File: #{ config.ca_file }"
+        puts("CA File: #{ config.ca_file }")
         abort('CA file path not provided') unless config.ca_file
-        puts "Cert File: #{ config.cert_file }"
+        puts("Cert File: #{ config.cert_file }")
         abort('Cert file path not provided') unless config.cert_file
-        puts "Key File: #{ config.key_file }"
+        puts("Key File: #{ config.key_file }")
         abort('Key file path not provided') unless config.key_file
       end
 
       def self.validate_audit config
-        puts "Request Audit Enabled: #{ config.enable }"
+        puts("Request Audit Enabled: #{ config.enable }")
         return unless config.enable
 
         config.each do |k, v|
-          puts "#{ k }::#{ v }"
+          puts("#{ k }::#{ v }")
         end
       end
 
@@ -125,7 +125,7 @@ module Contrast
         reporter = Contrast::Agent::Reporter.new
         reporter_headers = reporter.client.headers.to_hash
         reporter_headers.each_key do |key|
-          value = mask_keys reporter_headers, key
+          value = mask_keys(reporter_headers, key)
           missing << key if value.nil?
         end
         abort("Missing required header values: #{ missing.join(', ') }") unless missing.empty?
@@ -135,13 +135,13 @@ module Contrast
       def self.test_connection reporter
         connection = reporter.connection
         abort('Failed to Initialize Connection please check error logs for details') unless connection
-        abort('Failed to Start Client please check error logs for details') unless reporter.client.startup! connection
+        abort('Failed to Start Client please check error logs for details') unless reporter.client.startup!(connection)
       end
 
       def self.mask_keys hash, key
         value = hash[key]
         redacted_value = Contrast::Configuration::REDACTED if SKIP_LOG.include?(key.to_s)
-        puts "#{ key }::#{ redacted_value || value }" unless value.is_a?(Contrast::Config::BaseConfiguration)
+        puts("#{ key }::#{ redacted_value || value }") unless value.is_a?(Contrast::Config::BaseConfiguration)
         value
       end
     end

data/lib/contrast/tasks/service.rb

@@ -11,7 +11,7 @@ module Contrast
     extend Rake::DSL
     # Start the service if it is not already running
     def self.start_service
-      puts 'Starting Contrast Service'
+      puts('Starting Contrast Service')
       service_log = ::Contrast::CONTRAST_SERVICE.logger_path
       if File.writable?(service_log)
         spawn('contrast_service', out: File::NULL, err: service_log)
@@ -23,7 +23,7 @@ module Contrast
         sleep(0.05) until Contrast::Utils::OS.running?
       end
       watcher.join(1)
-      puts Contrast::Utils::OS.running? ? 'Contrast Service started successfully.' : 'Contrast Service did not start.'
+      puts(Contrast::Utils::OS.running? ? 'Contrast Service started successfully.' : 'Contrast Service did not start.')
     end
 
     # Stop the service if it is running