contrast-agent 4.14.0 → 5.2.0

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

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/components/logger'
@@ -22,18 +22,22 @@ module Contrast
         # This method will be handling the auditing of the requests and responses we send to SpeedRacer. If the audit
         # feature is enabled, we'll log to file the request and/or response protobuf objects.
         #
-        # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
-        #   Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
+        # @param event [Contrast::Api::Dtm|Contrast::Agent::Reporting::ReportingEvent] One of the DTMs valid for the
+        #   event field of Contrast::Api::Dtm::Message|Contrast::Agent::Reporting::ReportingEvent
         # @param response_data [Contrast::Api::Settings::AgentSettings,nil]
         def audit_event event, response_data = nil
-          return unless ::Contrast::API.request_audit_requests || ::Contrast::API.request_audit_responses
+          return unless ::Contrast::API.request_audit_requests? || ::Contrast::API.request_audit_responses?
 
           type = event.cs__respond_to?(:file_name) ? event.file_name : event.cs__class.cs__name.to_s.downcase
-          if ::Contrast::API.request_audit_requests
-            data = event.to_s
+          if ::Contrast::API.request_audit_requests?
+            data = if event.cs__class < Contrast::Agent::Reporting::ReportingEvent
+                     event.to_controlled_hash.to_json
+                   else # TODO: RUBY-1438 -- remove
+                     event.to_s
+                   end
             log_data :request, type, data if data
           end
-          return unless ::Contrast::API.request_audit_responses
+          return unless ::Contrast::API.request_audit_responses?
 
           data = response_data.to_s || event.http_response.try(:body) || 'There is no available response'
           log_data :response, type, data
@@ -63,24 +67,30 @@ module Contrast
           # destination. In that case, take no action
           return unless destination
 
-          filename = "#{ time }-#{ data_type.gsub('::', '_') }-teamserver.json"
+          filename = "#{ time }-#{ Thread.current.object_id }-#{ data_type.gsub('::', '_') }-teamserver.json"
           filepath = File.join(destination, filename)
           # Here is use append mode, because of a slightly possibility of overwriting an existing file
           File.open(filepath, 'a') do |f|
-            f.write({ data_type: Contrast::Utils::StringUtils.force_utf8(data) }.to_json)
+            if data_type.include?('reporting')
+              f.write(Contrast::Utils::StringUtils.force_utf8(data))
+            else
+              f.write({ data_type: Contrast::Utils::StringUtils.force_utf8(data) }.to_json)
+            end
           end
+        rescue StandardError => e
+          logger.warn('Saving audit failed', e: e)
         end
 
         # Here we will generate the directories for the requests and responses
         def generate_paths
           message_directories = File.expand_path(path_to_audits)
-          FileUtils.mkdir_p(message_directories) unless Dir.exist?(message_directories)
+          make_directory(message_directories) unless Dir.exist?(message_directories)
 
           requests_destination = File.expand_path(File.join(message_directories, '/requests'))
           responses_destination = File.expand_path(File.join(message_directories, '/responses'))
 
-          Dir.mkdir(requests_destination) if enabled_for_requests? && !Dir.exist?(requests_destination)
-          Dir.mkdir(responses_destination) if enabled_for_responses? && !Dir.exist?(responses_destination)
+          make_directory(requests_destination) if enabled_for_requests? && !Dir.exist?(requests_destination)
+          make_directory(responses_destination) if enabled_for_responses? && !Dir.exist?(responses_destination)
 
           @path_for_requests ||= requests_destination if enabled_for_requests?
           @path_for_responses ||= responses_destination if enabled_for_responses?
@@ -88,10 +98,17 @@ module Contrast
           logger.warn('Generating the paths failed with: ', e: e)
         end
 
+        # Make the directory provided, including any required intermediary directories.
+        # We do this here in order to make allow us to easily override directory
+        # creation while testing.
+        def make_directory directory
+          FileUtils.mkdir_p(directory)
+        end
+
         # Retrieves the configuration value if the request audit is enabled
         # @return [Boolean]
         def enabled?
-          ::Contrast::API.request_audit_enable
+          ::Contrast::API.request_audit_enable?
         end
 
         # The boolean values for the requests and the responses should be taken under
@@ -104,13 +121,13 @@ module Contrast
         # Retrieve the configuration value if the audit for requests is enabled
         # @return [Boolean]
         def enabled_for_requests?
-          ::Contrast::API.request_audit_requests
+          ::Contrast::API.request_audit_requests?
         end
 
         # Retrieve the configuration value if the audit for responses is enabled
         # @return [Boolean]
         def enabled_for_responses?
-          ::Contrast::API.request_audit_requests
+          ::Contrast::API.request_audit_requests?
         end
 
         # Retrieve the configuration value for the path of the audits

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

@@ -0,0 +1,67 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/reporting/reporting_events/server_activity'
+require 'contrast/api/dtm.pb'
+
+module Contrast
+  module Agent
+    module Reporting
+      # Util module for checking DTM message type. It temporarily allows for the conversion from a DTM to an
+      # EventReport.
+      # TODO: RUBY-1438 -- remove
+      module DtmMessage
+        class << self
+          # Checks if the message is of Contrast::Api::Dtm::ServerActivity class
+          #
+          # @param dtm [Contrast::Api::Dtm::ServerActivity, Object]
+          # @return [Boolean]
+          def server_activity? dtm
+            dtm.cs__is_a?(Contrast::Api::Dtm::ServerActivity)
+          end
+
+          # Checks if the message is a Hash of Contrast::Api::Dtm::LibraryUsageUpdate class
+          #
+          # @param message [Protobuf::Field::FieldHash<String,::Contrast::Api::Dtm::LibraryUsageUpdate>]
+          # @return [Boolean]
+          def library_usage? message
+            message.cs__is_a?(Protobuf::Field::FieldHash) &&
+                message.values[0].cs__is_a?(Contrast::Api::Dtm::LibraryUsageUpdate)
+          end
+
+          # Checks if the message is of Contrast::Api::Dtm::ApplicationUpdate class
+          #
+          # @param dtm [Contrast::Api::Dtm::ApplicationUpdate,Object]
+          # @return [Boolean]
+          def application_update? dtm
+            dtm.cs__is_a?(Contrast::Api::Dtm::ApplicationUpdate)
+          end
+
+          # @param dtm [Contrast::Api::Dtm::Finding,Object]
+          # @return [Boolean]
+          def finding? dtm
+            dtm.cs__is_a?(Contrast::Api::Dtm::Finding)
+          end
+
+          # Converts DTM message to Reporting Event for those messages that have conversion methods crated. We use this
+          # as we work to move away from requiring the Service.
+          #
+          # @param dtm [Contrast::Api::Dtm]
+          # @return event [Contrast::Agent::Reporting::ReportingEvent, nil]
+          def dtm_to_event dtm
+            # For the ServerActivity we need to create and send empty body only. This is done because we need the
+            # response from TS.
+            return Contrast::Agent::Reporting::ServerActivity.new if server_activity?(dtm)
+
+            # For the others, we convert them.
+            return Contrast::Agent::Reporting::ObservedLibraryUsage.convert(dtm) if library_usage?(dtm)
+            return Contrast::Agent::Reporting::ApplicationUpdate.convert(dtm) if application_update?(dtm)
+            return Contrast::Agent::Reporting::Finding.convert(dtm) if finding?(dtm)
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/components/logger'
+require 'contrast/utils/object_share'
+require 'base64'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This is the class which will hold up all the Endpoints we use for the direct report from the agent. It builds
+      # the full URLs needed for communication.
+      module Endpoints
+        extend Contrast::Components::Logger::InstanceMethods
+
+        APP_LANGUAGE = Contrast::Utils::ObjectShare::RUBY.upcase.cs__freeze
+        ENDPOINT_VERSION = '/v1.0'.cs__freeze
+        NG_ENDPOINTS = {
+            application_activity: "#{ Contrast::API.api_url }/api/ng/activity/application",
+            application_create: "#{ Contrast::API.api_url }/api/ng/applications/create",
+            agent_startup: "#{ Contrast::API.api_url }/api/ng/servers/"
+        }.cs__freeze
+
+        class << self
+          # @return [String,nil]
+          def application_startup
+            with_rescue do
+              "#{ application_endpoint }/startup".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def application_settings
+            with_rescue do
+              "#{ application_endpoint }/settings".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def application_inventory
+            with_rescue do
+              "#{ application_endpoint }/inventory".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def library_usage
+            with_rescue do
+              "#{ application_endpoint }/library-usage".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def heartbeat
+            with_rescue do
+              "#{ application_endpoint }/heartbeat".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def observed_route
+            with_rescue do
+              "#{ route_endpoint }/observed".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def trace_observed
+            with_rescue do
+              "#{ trace_endpoint }/observed".cs__freeze
+            end
+          end
+
+          private
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for application related information.
+          #
+          # @return [String]
+          def application_endpoint
+            @_application_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/applications"\
+                                       "#{ server_path_segment }#{ application_path_segment }"
+          end
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for route related information.
+          #
+          # @return [String]
+          def route_endpoint
+            @_route_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/routes"\
+                                 "#{ server_path_segment }#{ application_path_segment }"
+          end
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for server related information.
+          #
+          # @return [String]
+          def server_endpoint
+            @_server_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/servers"\
+                                  "#{ server_path_segment }"
+          end
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for trace/finding related information.
+          #
+          # @return [String]
+          def trace_endpoint
+            @_trace_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/traces"\
+                                 "#{ server_path_segment }#{ application_path_segment }"
+          end
+
+          # The server host, path, and type; required for endpoints that are server specific.
+          #
+          # @return [String]
+          def server_path_segment
+            @_server_path_segment ||= "/#{ Base64.urlsafe_encode64(server_host_name, padding: false) }"\
+                                      "/#{ Base64.urlsafe_encode64(server_path, padding: false) }"\
+                                      "/#{ Base64.urlsafe_encode64(server_type, padding: false) }"
+          end
+
+          # The application language and name; required for endpoints that are application specific.
+          #
+          # @return [String]
+          def application_path_segment
+            @_application_path_segment ||= "/#{ Base64.urlsafe_encode64(APP_LANGUAGE, padding: false) }"\
+                                           "/#{ Base64.urlsafe_encode64(app_name, padding: false) }"
+          end
+
+          # @return [String,nil]
+          def server_host_name
+            return @_server_host_name unless @_server_host_name.nil?
+
+            @_server_host_name = ::Contrast::APP_CONTEXT.server_name
+          end
+
+          # @return [String,nil]
+          def server_path
+            return @_server_path unless @_server_path.nil?
+
+            @_server_path = ::Contrast::APP_CONTEXT.server_path
+          end
+
+          # @return [String,nil]
+          def server_type
+            return @_server_type unless @_server_type.nil?
+
+            @_server_type = ::Contrast::APP_CONTEXT.server_type
+          end
+
+          # @return [String,nil]
+          def app_name
+            return @_app_name unless @_app_name.nil?
+
+            @_app_name = ::Contrast::APP_CONTEXT.app_name
+          end
+
+          # @return [String,nil]
+          def with_rescue
+            yield
+          rescue StandardError => e
+            logger.debug('Endpoint failed with the following error', e)
+            Contrast::Utils::ObjectShare::EMPTY_STRING
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/object_share'
+require 'contrast/agent/version'
+require 'base64'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This class will build the required headers for agent reporting to TS
+      class Headers
+        attr_reader :app_name, :api_key, :agent_version, :app_language, :app_path, :app_version, :authorization,
+                    :server_name, :server_path, :server_type, :content_type, :encoding
+
+        ENCODING = 'base64'
+        CONTENT_TYPE = 'application/json'
+
+        include Contrast::Utils::ObjectShare
+
+        def initialize
+          @app_name = Base64.strict_encode64(Contrast::APP_CONTEXT.app_name)
+          @api_key = Contrast::API.api_key
+          @agent_version = [RUBY, Contrast::Agent::VERSION].join(SPACE)
+          @app_language = RUBY
+          @app_path = Base64.strict_encode64(Contrast::APP_CONTEXT.path)
+          @app_version = Contrast::APP_CONTEXT.app_version
+          @authorization = Base64.strict_encode64("#{ Contrast::API.username }:#{ Contrast::API.service_key }")
+          @server_name = Base64.strict_encode64(Contrast::APP_CONTEXT.server_name)
+          @server_path = Base64.strict_encode64(Contrast::APP_CONTEXT.server_path)
+          @server_type = Base64.strict_encode64(Contrast::APP_CONTEXT.server_type)
+          @content_type = CONTENT_TYPE
+          @encoding = ENCODING
+        end
+
+        def to_hash
+          {
+              app_name: @app_name,
+              api_key: @api_key,
+              agent_version: @agent_version,
+              app_language: @app_language,
+              app_path: @app_path,
+              app_version: @app_version,
+              authorization: @authorization,
+              server_name: @server_name,
+              server_path: @server_path,
+              server_type: @server_type,
+              content_type: @content_type,
+              encoding: @encoding
+          }.cs__freeze
+        end
+      end
+    end
+  end
+end

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

@@ -1,167 +1,86 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'json'
 require 'net/http'
 require 'contrast/components/logger'
 require 'contrast/utils/net_http_base'
-require 'contrast/agent/reporting/reporting_events/finding'
-require 'contrast/agent/reporting/reporting_events/preflight_message'
-require 'contrast/agent/reporting/reporting_events/reporting_event'
+require 'contrast/api/communication/connection_status'
+require 'contrast/agent/reporting/reporting_utilities/response_handler'
+require 'contrast/agent/reporting/reporting_utilities/reporter_client_utils'
+require 'contrast/agent/reporting/reporting_utilities/endpoints'
+require 'contrast/agent/reporting/reporting_utilities/headers'
 
 module Contrast
-  module Utils
-    # This module creates a Net::HTTP client and initiates a connection to the provided result
-    class ReporterClient < NetHttpBase
-      include ObjectShare
-      SERVICE_NAME = 'Reporter'
-      ENDPOINTS = {
-          application_activity: '/api/ng/activity/application',
-          application_create: '/api/ng/applications/create',
-          agent_startup: '/api/ng/servers/',
-          preflight: '/api/ng/preflight/',
-          report_vulnerability: '/api/ng/traces',
-          server_activity: '/api/ng/servers/',
-          server_update: '/api/ng/update/application'
-      }.cs__freeze
-      # EVENT_TYPES = {
-      #     agent_startup: Contrast::Api::Dtm::AgentStartup,
-      #     report_vulnerability: Contrast::Agent::Reporting::Finding,
-      #     preflight: Contrast::Agent::Reporting::Preflight
-      # }.cs__freeze
-      include Contrast::Components::Logger::InstanceMethods
-      # This method initializes the Net::HTTP client we'll need. it will validate
-      # the connection and make the first request. If connection is valid and response
-      # is available then the open connection is returned.
-      #
-      # @return [Net::HTTP, nil] Return open connection or nil
-      def initialize_connection
-        # for this client we would use proxy and custom certificate file if available
-        super(SERVICE_NAME, Contrast::API.api_url, true, true)
-      end
-
-      # @param headers [Hash] all the headers needed for communication with TS
-      def initialize headers
-        @headers = headers
-        super()
-      end
-
-      # Send Agent Startup event
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
-      #   Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
-      # @param connection [Net::HTTP] open connection
-      # @return response [Net::HTTP::Response] response from TS
-      def send_agent_startup event, connection
-        logger.debug('Preparing to send startup messages')
-        request = build_request ENDPOINTS[:agent_startup], event
-        response = connection.request(request)
-        logger.debug('Successfully sent startup messages to service.') if response
-        response
-      end
-
-      # Check event type and send it to appropriate TS endpoint
-      #
-      # @param event [Contrast::Api::Dtm,Contrast::Agent::Reporting::ReportingEvent] One of the DTMs valid for the event
-      # field of Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
-      # @param connection [Net::HTTP] open connection
-      # @param send_immediately [Boolean] flag for the logger
-      # @return response [Net::HTTP::Response, nil] response from TS if no response
-      def send_event event, connection, send_immediately = false
-        event_type = symbolized_event_type event.event_type
-        @response = send_events event, event_type, connection
-        log_send_event event if send_immediately
-        @response
-      end
-
-      private
-
-      # This method will build headers of the request required for TS communication
-      #
-      # @param request [Net::HTTP::Post]
-      def build_headers request
-        @app_version = @headers[:app_version]
-        request['API-Key'] = @headers[:api_key]
-        request['Application-Language'] = @headers[:app_language]
-        request['Application-Name'] = @headers[:app_name]
-        request['Application-Path'] = @headers[:app_path]
-        request['Application-Version'] = @app_version if @app_version
-        request['Authorization'] = @headers[:authorization]
-        request['Content-Type'] = @headers[:content_type]
-        request['Server-Name'] = @headers[:server_name]
-        request['Server-Path'] = @headers[:server_path]
-        request['Server-Type'] = @headers[:server_type]
-        request['X-Contrast-Agent'] = @headers[:agent_version]
-        request['X-Contrast-Header-Encoding'] = @headers[:encoding]
-        request
-      end
-
-      # build the request headers and assign endpoint
-      #
-      # @param endpoint [String] endpoint to report to
-      # @param event [Contrast::Api::Dtm,Contrast::Agent::Reporting::ReportingEvent]
-      # One of the DTMs valid for the event field of Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
-      # @return [Net::HTTP::Post]
-      def build_request endpoint, event
-        @request = build_headers Net::HTTP::Post.new(endpoint)
-        @request.body = if event.cs__is_a?(Contrast::Agent::Reporting::ReportingEvent)
-                          event.to_controlled_hash.to_json
-                        else
-                          event.to_json
-                        end
-        @request
-      end
-
-      # log the event sent immediately
-      #
-      # @param event [Contrast::Api::Dtm,Contrast::Agent::Reporting::ReportingEvent] One of the DTMs valid for the
-      # event field of Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
-      def log_send_event event
-        logger.debug('Immediately sending event.', event_id: event.__id__, event_type: event.cs__class.cs__name)
-      end
-
-      # Sent different events to different endpoints
-      #
-      # @param event [Contrast::Api::Dtm,Contrast::Agent::Reporting::ReportingEvent] Main reporting event, all events
-      # inherit it
-      # @param event_type [Symbol] We'll use this symbol to match the urls
-      # @param connection [Net::HTTP] open connection
-      def send_events event, event_type, connection
-        logger.debug("Preparing to send #{ event_type.to_s.capitalize } messages")
-        request = build_request ENDPOINTS[event_type], event
-        response = connection.request(request)
-        logger.debug("Successfully sent #{ event_type.to_s.capitalize } messages to service.") if response
-        response
-      end
-
-      # Eventually here we'll handle more response types and etc
-
-      # @param event [Contrast::Agent::Reporting::Preflight] the preflight we handle here
-      # @param response [Net::HTTP::Response,nil] The response we handle and read from
-      # @param connection [Net::HTTP] open connection
-      def handle_response event, response, connection
-        return unless event || response || connection
-
-        preflight_message = event.messages[0]
-        event_type = symbolized_event_type preflight_message.event_type
-        return unless event_type == :preflight_message
-
-        # for handling multiple findings
-        # we'll only extract the indexes without *
-        # findings_to_return = response.body.split(',').delete_if { |el| el.include?('*') }
-        # after that we'll do some magic and return them the same way we do for corresponding_finding
-        corresponding_finding = Contrast::Agent::Reporting::ReportingStorage.delete(preflight_message.hash_code)
-        return unless corresponding_finding
-
-        send_event corresponding_finding, connection, true
-        nil
-      end
-
-      def symbolized_event_type event_type
-        return unless event_type
-        return event_type unless event_type.cs__is_a?(String)
-
-        event_type.downcase.to_sym
+  module Agent
+    module Reporting
+      # This class creates a Net::HTTP client and initiates a connection to the provided result
+      # @attr_reader headers [Contrast::Agent::Reporting::Headers]
+      class ReporterClient < Contrast::Utils::NetHttpBase
+        attr_reader :headers
+
+        include Contrast::Agent::Reporting::Endpoints
+        include Contrast::Agent::Reporting::ReporterClientUtils
+        SERVICE_NAME = 'Reporter'
+        include Contrast::Components::Logger::InstanceMethods
+        # This method initializes the Net::HTTP client we'll need. it will validate
+        # the connection and make the first request. If connection is valid and response
+        # is available then the open connection is returned.
+        #
+        # @return [Net::HTTP, nil] Return open connection or nil
+        def initialize_connection
+          # for this client we would use proxy and custom certificate file if available
+          super(SERVICE_NAME, Contrast::API.api_url, true, true)
+        end
+
+        def initialize
+          @headers = Contrast::Agent::Reporting::Headers.new
+          super()
+        end
+
+        # Start the client for first time and sent startup event
+        #
+        # @param connection [Net::HTTP] open connection
+        def startup! connection
+          return if status.startup_messages_sent?
+          return unless Contrast::Agent::Reporter.enabled?
+
+          send_agent_startup(connection)
+        end
+
+        # Check event type and send it to appropriate TS endpoint
+        #
+        # @param event [Contrast::Api::Dtm,Contrast::Agent::Reporting::ReportingEvent] One of the DTMs valid
+        # for the event field of Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
+        # @param connection [Net::HTTP] open connection
+        # @param send_immediately [Boolean] flag for the logger
+        # @return response [Net::HTTP::Response, nil] response from TS if no response
+        def send_event event, connection, send_immediately = false
+          return unless Contrast::Agent::Reporter.enabled?
+          return unless connection
+
+          response = send_events(event, connection)
+          log_send_event event if send_immediately
+          response
+        rescue StandardError => e
+          handle_error event, e
+        end
+
+        def status
+          @_status ||= Contrast::Api::Communication::ConnectionStatus.new
+        end
+
+        def response_handler
+          @_response_handler ||= Contrast::Agent::Reporting::ResponseHandler.new
+        end
+
+        def sleep?
+          response_handler.sleep?
+        end
+
+        def wake_up
+          response_handler.wake_up
+        end
       end
     end
   end