contrast-agent 7.1.0 → 7.2.0

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

@@ -0,0 +1,144 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module Reporting
+      # Module to house the Resend logic, when there is no response from TS.
+      module Resend
+        # How manny times the client will try to rescue from above error before raising an
+        # error to reflect the events.
+        #
+        RESCUE_ATTEMPTS = 3
+        TIMEOUT = 5
+        RETRY_ERRORS = [
+          Net::OpenTimeout, Net::ReadTimeout, ArgumentError, EOFError, OpenSSL::SSL::SSLError, Resolv::ResolvError,
+          Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::ESHUTDOWN, Errno::EHOSTDOWN, NameError,
+          Errno::EHOSTUNREACH, Errno::EISCONN, Errno::ECONNABORTED, Errno::ENETRESET, Errno::ENETUNREACH, SocketError,
+          NameError, NoMethodError, Timeout::Error, RuntimeError
+        ].cs__freeze
+        RESENDING_MESSAGE = '[Reporter] Resending message...'
+        END_RESENDING_MESSAGE = '[Reporter] Reporter tried to resend event and received error:'
+
+        # This method is mainly used in inside error handling and startup mesasges sending.
+        #
+        # @param event [Contrast::Agent::Reporting::ReportingEvent] event to resend
+        # @param connection [Net::HTTP] open connection
+        # @param error [StandardError] error that was raised
+        # @return [Net::HTTPResponse, nil] response from TS
+        def try_resend event, connection, error
+          # The timeout for agent to sleep is set here, we don't need to raise an error,
+          # but also 15 min is a long time to wait for example if event is startup message.
+          # Override timeout
+          if Contrast::Agent::Reporting::ReporterClientUtils::STARTUP_EVENTS.include?(event.cs__class)
+            response_handler.suspend_reporting(RESENDING_MESSAGE,
+                                               TIMEOUT,
+                                               error,
+                                               event: event,
+                                               log_error: false,
+                                               startup: true)
+          end
+          mode.enter_resend_mode
+          handle_resend(event, connection)
+        end
+
+        # This method will handle the error and will decide if we need to resend the event
+        #
+        # @param event [Contrast::Agent::Reporting::ReportingEvent]
+        # @param connection [Net::HTTP] open connection
+        # @return [Net::HTTPResponse, nil] response from TS
+        def handle_resend event, connection
+          if sleep?
+            logger.debug("[Reporter] sleeping for #{ TIMEOUT } seconds before resending...")
+            Thread.current.send(:sleep, timeout)
+            wake_up
+          end
+          response = mode.status == mode.resending ? send_event(event, connection) : nil
+          response_success! if response
+          response
+        end
+
+        # Handles errors that occurs before the ResponseHandler do not have a response, or response
+        # code to hande. This Errors requires different handling, because most of errors here
+        # occurs when the response cannot be read, there is open ssl error, or a certain Timeout
+        # is reached.
+        #
+        # @param event [Contrast::Agent::Reporting::ReportingEvent]
+        #   One of the DTMs valid for the event field of Contrast::Api::Dtm::Message
+        # @param error [StandardError]
+        # @param connection [Net::HTTP] open connection
+        # @return nil [NilClass] to be passed as response
+        def handle_response_error event, connection, error
+          return end_of_rescue(event, error) if mode.resend.rescue_attempts >= RESCUE_ATTEMPTS
+
+          if RETRY_ERRORS.include?(error.cs__class)
+            mode.resend.increase_rescue_attempts
+            try_resend(event, connection, error)
+          else
+            end_of_rescue(event, error)
+          end
+        end
+
+        # End of rescue attempts.
+        #
+        # @param event [Contrast::Agent::Reporting::ReportingEvent]
+        # @param error [StandardError]
+        # @return [NilClass]
+        def end_of_rescue event, error
+          if Contrast::Agent::Reporting::ReporterClientUtils::STARTUP_EVENTS.include?(event.cs__class)
+            # Agent didn't send it's startup events, There will be reporting errors, disable reporting.
+            disable_reporting(event, error)
+          else
+            # There is an error in one of the reported messages, log that error and continue.
+            logger.error(END_RESENDING_MESSAGE,
+                         resend_attempts: Contrast::Agent::Reporting::Resend::RESCUE_ATTEMPTS,
+                         connection_error: error,
+                         client: Contrast::Agent::Reporting::ReporterClient::SERVICE_NAME,
+                         event_id: event&.__id__,
+                         event_type: event&.cs__class&.cs__name)
+          end
+        end
+
+        # Disable reporting when there is an error that cannot be handled.
+        #
+        # @param event [Contrast::Agent::Reporting::ReportingEvent]
+        # @param error [StandardError]
+        # @return [NilClass]
+        def disable_reporting event, error
+          logger.error('[Agent] Disabling Reporting...', error: error.message, event_type: event.cs__class&.cs__name)
+          Contrast::AGENT.disable!
+        end
+
+        # Methods that will initialize the resending state.
+        class Status
+          # RESEND_STARTUP_EVENTS = 4
+
+          def initialize
+            @_rescue_attempts = 0
+          end
+
+          # return how many times the client has tried to rescue from error.
+          #
+          # @return [Integer]
+          def rescue_attempts
+            @_rescue_attempts ||= 0
+          end
+
+          # Reset Error rescues attempts.
+          #
+          # @return [Integer]
+          def reset_rescue_attempts
+            @_rescue_attempts = 0
+          end
+
+          # Increase the Error rescues attempts.
+          #
+          # @return [Integer]
+          def increase_rescue_attempts
+            @_rescue_attempts += 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module Contrast
                                                                            assess_on: ::Contrast::ASSESS.enabled?)
           response
         rescue StandardError => e
-          logger.error('Unable to process response from TeamServer', e)
+          logger.error('[Reporter] Unable to process response from TeamServer', e)
           nil
         end
 
@@ -63,11 +63,45 @@ module Contrast
           @_mode ||= Contrast::Agent::Reporting::ResponseHandlerMode.new
         end
 
+        # Puts the reporting service to sleep
+        def put_to_sleep
+          @_sleep = true
+        end
+
         # Wakes the reporting service
         def wake_up
           @_sleep = false
         end
 
+        # Suspend the reporter and try again in time. If not set
+        # the timeout is set to 15 min As default:
+        #
+        # @param message [String] Message to log.
+        # @param timeout [Integer,nil] The timeout to wait and retry after.
+        # @param error_message [String, nil] Error message if any received.
+        # @param event [Contrast::Agent::Reporting::ReportingEvent, nil] The event sent to TeamServer if set
+        # @param log_error [Boolean] Whether to log the error or not.
+        # @param startup [Boolean] Whether this is a startup error or not.
+        def suspend_reporting message, timeout, error_message, event: nil, log_error: true, startup: false
+          @_timeout = timeout || Contrast::Agent::Reporting::ResponseHandler::TIMEOUT
+          if log_error
+            log_error_msg(message,
+                          timeout: @_timeout,
+                          error_message: error_message || 'none',
+                          event_id: event.nil? ? 'none' : event&.__id__,
+                          event_type: event.nil? ? 'none' : event&.cs__class&.cs__name)
+          end
+          if startup
+            logger.info(message,
+                        connection_error: error_message,
+                        client: Contrast::Agent::Reporting::ReporterClient::SERVICE_NAME,
+                        event_id: event&.__id__,
+                        timeout: timeout,
+                        event_type: event&.cs__class&.cs__name)
+          end
+          put_to_sleep
+        end
+
         private
 
         # Handles the errors code received from TS and takes appropriate action.
@@ -93,18 +127,6 @@ module Contrast
           end
         end
 
-        # Suspend the reporter and try again in time. If not set
-        # the timeout is set to 15 min As default:
-        #
-        # @param message [String] Message to log.
-        # @param timeout [Integer,nil] The timeout to wait and retry after.
-        # @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_error_msg(message, timeout: @_timeout, error_message: error_message || 'none')
-          @_sleep = true
-        end
-
         # Log what we've received.
         #
         # @param message [String] Message to log

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

@@ -1,6 +1,8 @@
 # Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/agent/reporting/reporting_utilities/resend'
+
 module Contrast
   module Agent
     module Reporting
@@ -44,6 +46,17 @@ module Contrast
           @_status ||= running
         end
 
+        # Resend Status tracker
+        #
+        # @return [Contrast::Agent::Reporting::Resend::Status]
+        def resend
+          @_resend ||= Contrast::Agent::Reporting::Resend::Status.new
+        end
+
+        def enter_resend_mode
+          @_status = resending
+        end
+
         # Set current mode.
         #
         # @return [Symbol] Reporter's client and Response Handler
@@ -54,7 +67,7 @@ module Contrast
 
         # Reset mode
         #
-        def reset_mode
+        def enter_run_mode
           @_status = running
         end
       end

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

@@ -54,6 +54,16 @@ module Contrast
           @_last_application_modified
         end
 
+        # Cease reporting about this application
+        #
+        # @param message [String] Message to log
+        # @param info_hash [Hash] information about the context to log.
+        def stop_reporting message, info_hash
+          Contrast::Agent.reporter&.stop!
+          log_error_msg(message, info_hash)
+          ::Contrast::AGENT.disable!
+        end
+
         private
 
         # check if response code is valid before analyze it
@@ -127,7 +137,7 @@ module Contrast
           # log, suspend, disable:
           if mode == @_mode.running
             log_error_msg(message,
-                          response: response.__id__,
+                          response_id: response.__id__,
                           request: Contrast::Agent::REQUEST_TRACKER.current&.request&.type,
                           error_message: error_message || 'none',
                           auth_error: auth_error || 'none')
@@ -176,16 +186,6 @@ module Contrast
           end
         end
 
-        # Cease reporting about this application
-        #
-        # @param message [String] Message to log
-        # @param info_hash [Hash] information about the context to log.
-        def stop_reporting message, info_hash
-          Contrast::Agent.reporter&.stop!
-          log_error_msg(message, info_hash)
-          ::Contrast::AGENT.disable!
-        end
-
         # Applies the settings from the TS response
         #
         # @param response [Contrast::Agent::Reporting::Response]

data/lib/contrast/agent/request/request.rb

@@ -10,6 +10,7 @@ require 'contrast/utils/hash_digest'
 require 'contrast/components/logger'
 require 'contrast/components/scope'
 require 'contrast/utils/request_utils'
+require 'contrast/utils/duck_utils'
 
 module Contrast
   module Agent
@@ -24,12 +25,7 @@ module Contrast
 
       extend Forwardable
 
-      INNER_REST_TOKEN = %r{/\d+/}.cs__freeze
-      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
+      EMPTY_PATH = '/'
 
       # @return [Rack::Request] The passed to the Agent RackRequest to be wrapped.
       attr_reader :rack_request
@@ -75,12 +71,31 @@ module Contrast
       def normalized_uri
         @_normalized_uri ||= begin
           path = rack_request.path_info || rack_request.path.to_s
-          path = '/' if path.empty?
-
-          uri = path.split(Contrast::Utils::ObjectShare::SEMICOLON)[0]    # remove ;jsessionid
-          uri = uri.split(Contrast::Utils::ObjectShare::QUESTION_MARK)[0] # remove ?query_string=
-          uri.gsub(INNER_REST_TOKEN, INNER_NUMBER_MARKER)                 # replace interior tokens
-          uri.gsub(LAST_REST_TOKEN, LAST_NUMBER_MARKER)                   # replace last token
+          path = EMPTY_PATH if Contrast::Utils::DuckUtils.empty_duck?(path)
+
+          # /foo/bar;jsessionid=123 => /foo/bar
+          uri = path.split(Contrast::Utils::ObjectShare::SEMICOLON)[0]
+          # /foo/bar?query_string=123 => /foo/bar
+          uri = uri.split(Contrast::Utils::ObjectShare::QUESTION_MARK)[0]
+
+          # Replace with tokens:
+          # NUM_ => '/{n}/'
+          # ID_ =>  '{ID}'
+          #
+          # replace UUIDs: /123e4567-e89b-42d3-a456-556642440000/ => /{ID}/
+          uri.gsub!(UUID_PATTERN, ID_)
+          # replace hash patterns: /6f1ed002ab5595859014ebf0951522d9/ => /{ID}/
+          uri.gsub!(HASH_PATTERN, ID_)
+          # replace windows SID: /S-1-5-21-1843332746-572796286-2118856591-1000/ => /{ID}/
+          uri.gsub!(WIN_PATTERN, ID_)
+          # replace interior number tokens: /123/ => /{n}/
+          uri.gsub!(NUM_PATTERN, NUM_)
+          # replace last number tokens: /123 => /{n}
+          uri.gsub!(END_PATTERN, NUM_[0..-2])
+          uri
+        rescue StandardError => e
+          logger.error('error normalizing uri', error: e, backtrace: e.backtrace)
+          EMPTY_PATH
         end
       end
 

data/lib/contrast/agent/telemetry/base.rb

@@ -8,6 +8,7 @@ require 'contrast/agent/thread/worker_thread'
 require 'contrast/agent/telemetry/telemetry'
 require 'contrast/agent/telemetry/exception'
 require 'contrast/utils/job_servers_running'
+require 'contrast/agent/reporting/client/interface'
 
 module Contrast
   module Agent
@@ -96,11 +97,7 @@ module Contrast
         end
 
         def client
-          @_client ||= Contrast::Agent::Telemetry::Client.new
-        end
-
-        def connection
-          @_connection ||= client.initialize_connection(URL)
+          @_client ||= Contrast::Agent::Reporting::Telemetry::Interface.new
         end
 
         def attempt_to_start?
@@ -148,16 +145,24 @@ module Contrast
           Contrast::TELEMETRY_EXCEPTIONS&.clear
         end
 
-        def request_with_response event
-          client.handle_response(client.send_request(event, connection))
-        end
-
         private
 
         def queue
           @_queue ||= Queue.new
         end
 
+        # Starts sending Telemetry messages.
+        def process_event event
+          logger.debug('[Telemetry] This is the current processed event', event)
+          if (sleep_time = client.request_with_response(event))
+            return sleep(sleep_time)
+          end
+
+          logger.debug('[Telemetry] Retrying to process event', event)
+          retry_sleep_time = client.request_with_response(event)
+          sleep(retry_sleep_time) unless retry_sleep_time.nil?
+        end
+
         # It is recommended that implementations send a single payload of general metrics every 3 hours, starting from
         # implementation startup. This returns a thread configured to do so.
         #
@@ -165,22 +170,16 @@ module Contrast
         def create_thread
           Contrast::Agent::Thread.new do
             loop do
-              next unless client && connection
+              next unless client.connected?
               break unless attempt_to_start?
 
               # Start pushing exceptions to queue for reporting.
-              Contrast::TELEMETRY_EXCEPTIONS.each_value { |value| queue << value }
-              Contrast::TELEMETRY_EXCEPTIONS.clear
+              Contrast::TELEMETRY_EXCEPTIONS&.each_value { |value| queue << value }
+              Contrast::TELEMETRY_EXCEPTIONS&.clear
               until queue.empty?
                 event = queue.pop
                 begin
-                  logger.debug('[Telemetry] This is the current processed event', event)
-                  if (sleep_time = request_with_response(event))
-                    sleep(sleep_time)
-                    logger.debug('[Telemetry] Retrying to process event', event)
-                    retry_sleep_time = request_with_response(event)
-                    sleep(retry_sleep_time) unless retry_sleep_time.nil?
-                  end
+                  process_event(event)
                 rescue StandardError => e
                   logger.error('[Telemetry] Could not send message to service from telemetry queue.', e)
                   stop!

data/lib/contrast/agent/telemetry/exception/obfuscate.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/duck_utils'
+require 'contrast/utils/object_share'
+
+module Contrast
+  module Agent
+    module Telemetry
+      module Exception
+        # Obfuscate sensitive user data before building exception.
+        module Obfuscate
+          CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'.cs__freeze
+          # This will generate different chars for each agent startup but will be constant
+          # for current run and will make identical obfuscation to be compared if given type
+          # is the same.
+          CYPHER = CHARS.chars.shuffle.join.cs__freeze
+          VERSION_MATCH = '[^0-9].-'
+
+          # List of known places after witch a user name might appear:
+          KNOWN_DIRS = %w[app application project projects git github users home user].cs__freeze
+
+          class << self
+            # Returns paths for known gems.
+            #
+            # @return [Array<Regexp>] known paths
+            def known_paths
+              @_known_paths ||= KNOWN_DIRS.map do |name|
+                to_regexp(name)
+              end
+            end
+
+            # Obfuscate a type and replace it with random characters.
+            #
+            # @param path [String] the StackFrame type to obfuscate
+            # @return [String] obfuscated type
+            def obfuscate_path path
+              return path if Contrast::Utils::DuckUtils.empty_duck?(path)
+
+              cypher(path)
+            end
+
+            private
+
+            # Transforms string to regexp
+            #
+            # @param string [String]
+            def to_regexp string
+              /#{ string }/
+            end
+
+            # Add cypher to path to make it obscure, but unique enough for
+            # comparisons. Mutates original or duplicate if frozen string.
+            #
+            # @param string [String] string to be transformed.
+            # @return [String]
+            def cypher string
+              cypher = string.cs__frozen? ? string.dup : string
+              dirs = cypher.split(Contrast::Utils::ObjectShare::SLASH)
+              return string unless dirs.cs__is_a?(Array)
+
+              dirs.each_with_index do |name, idx|
+                next if Contrast::Utils::DuckUtils.empty_duck?(name)
+                next unless match_known(known_paths,
+                                        name.tr(VERSION_MATCH, Contrast::Utils::ObjectShare::EMPTY_STRING).downcase)
+
+                obscure(name)
+                # obscure username (next dir in line)
+                obscure(dirs[idx + 1]) if dirs[idx + 1]
+              end
+              cypher = dirs.join(Contrast::Utils::ObjectShare::SLASH)
+              return cypher if cypher
+
+              Contrast::Utils::ObjectShare::EMPTY_STRING
+            rescue StandardError
+              Contrast::Utils::ObjectShare::EMPTY_STRING
+            end
+
+            # @param known [Array<Regexp>] Array of regexp to match against
+            # @param type [String] type to check
+            def match_known known, type
+              known.any? { |regexp| type =~ regexp }
+            end
+
+            # Replaces chars in name.
+            #
+            # @param [string] name
+            # @return [String, nil]
+            def obscure name
+              name.to_s.tr!(CHARS, CYPHER)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/exception.rb

@@ -17,3 +17,4 @@ require 'contrast/agent/telemetry/exception/stack_frame'
 require 'contrast/agent/telemetry/exception/message_exception'
 require 'contrast/agent/telemetry/exception/message'
 require 'contrast/agent/telemetry/exception/event'
+require 'contrast/agent/telemetry/exception/obfuscate'

data/lib/contrast/agent/version.rb

@@ -3,6 +3,6 @@
 
 module Contrast
   module Agent
-    VERSION = '7.1.0'
+    VERSION = '7.2.0'
   end
 end

data/lib/contrast/components/config/sources.rb

@@ -11,14 +11,15 @@ module Contrast
       # This component encapsulates storing the source for each entry in the config,
       # so that we can report on where the value was set from.
       class Sources
-        ENVIRONMENT_VARIABLE = 'ENV'
-        COMMAND_LINE = 'CLI'
-        CONTRAST_UI = 'ContrastUI'
-        DEFAULT_VALUE = 'Default'
+        ENVIRONMENT_VARIABLE = 'ENVIRONMENT_VARIABLE'
+        COMMAND_LINE = 'COMMAND_LINE'
+        CONTRAST_UI = 'CONTRAST_UI'
+        DEFAULT_VALUE = 'DEFAULT_VALUE'
+        APP_CONFIGURATION_FILE = 'USER_CONFIGURATION_FILE'
         # Order matters for the Configurations files. This is read when Agent starts up and will always go
         # through the YAML as priority.
         # Do not change the order!
-        APP_CONFIGURATION_FILE = %w[YAML YML].cs__freeze
+        APP_CONFIGURATION_EXTENSIONS = %w[yaml yml].cs__freeze
 
         # @return [Hash]
         attr_reader :data

data/lib/contrast/components/settings.rb

@@ -5,6 +5,7 @@ require 'contrast/agent/excluder/excluder'
 require 'contrast/agent/reporting/settings/sensitive_data_masking'
 require 'contrast/components/config'
 require 'contrast/components/logger'
+require 'contrast/utils/duck_utils'
 
 module Contrast
   module Components
@@ -219,6 +220,14 @@ module Contrast
           exclusions.input_exclusions.each do |exclusion|
             matchers << Contrast::Agent::ExclusionMatcher.new(exclusion)
           end
+          # Do not populate the matchers unless we have any. There are certain checks in
+          # SourceMethod that will safe-guard return if there are no exclusions received.
+          # The matching operation is expensive, and the excluder calls are made for each
+          # source, and we do not want to check for exclusions if they are empty. This is
+          # probably redundant as all exclusions default to empty, but will save useless
+          # new object creation at very least.
+          return if Contrast::Utils::DuckUtils.empty_duck?(matchers)
+
           @excluder = Contrast::Agent::Excluder.new(matchers)
         end
 

data/lib/contrast/config/diagnostics/source_config_value.rb

@@ -41,7 +41,11 @@ module Contrast
         # @param source [String] name of the source file yaml | yml
         # @return [Array<String>, nil]
         def assign_filename source
-          Contrast::Components::Config::Sources::APP_CONFIGURATION_FILE.each do |type|
+          Contrast::Components::Config::Sources::APP_CONFIGURATION_EXTENSIONS.each do |type|
+            # We use the source to transfer the file's name from the mapping of the extensions.
+            # This is done b/c the user_configuration file has a second field to be filled,
+            # and other sources don't. Transfer the source as filename and set the default value
+            # for it later when we find the sources.
             instance_variable_set(:@filename, source) if source.include?(".#{ type.downcase }")
           end
         end

data/lib/contrast/config/diagnostics/tools.rb

@@ -164,10 +164,10 @@ module Contrast
           # For files we keep the whole path as source.
           source = Contrast::CONFIG.sources.get(new_effective_value.canonical_name)
           new_effective_value.assign_filename(source)
-          new_source = if source.include?(Contrast::Config::LocalSourceValue::YAML_EXT)
-                         Contrast::Components::Config::Sources::APP_CONFIGURATION_FILE[0]
-                       elsif source.include?(Contrast::Config::LocalSourceValue::YML_EXT)
-                         Contrast::Components::Config::Sources::APP_CONFIGURATION_FILE[1]
+          new_source = if source.include?(Contrast::Config::LocalSourceValue::YAML_EXT) ||
+                source.include?(Contrast::Config::LocalSourceValue::YML_EXT)
+
+                         Contrast::Components::Config::Sources::APP_CONFIGURATION_FILE
                        else
                          Contrast::Components::Config::Sources::DEFAULT_VALUE
                        end

data/lib/contrast/config/validate.rb

@@ -108,9 +108,9 @@ module Contrast
 
       def test_connection reporter
         puts("  Connection failed #{ FAIL }") unless reporter
-        connection = reporter.connection
+        connection = reporter.client.send(:reporting_connection)
         abort("Failed to Initialize Connection please check error logs for details #{ FAIL } ") 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
         last_response = reporter.client.response_handler.last_response_code
         if last_response.include?('40')
           puts("  Last response code: #{ last_response  } #{ FAIL }")