contrast-agent 5.3.0 → 6.1.1

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exceptions.rb

@@ -0,0 +1,20 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This is the module that will include every information created and stored for the
+      # Telemetry Exceptions
+      module TelemetryException
+      end
+    end
+  end
+end
+
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_base'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_stack_frame'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_message_exception'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_message'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_event'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exceptions_report'

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exceptions_report.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This module will handle the reporting of the TelemetryExceptionHash
+      module TelemetryExceptionReport
+        # Here we will send any exceptions gathered. The telemetry_hash is split into batches of 256
+        # and then added to the telemetry queue. Since this method is called before entering the
+        # until queue loop any updates after clearing the Contrast::TELEMETRY_EXCEPTIONS would have
+        # to wait for the sending process to be completed, so accumulating new batches.
+        # This methods expects queue and error_messages methods from Contrast::Agent::Telemetry::Base
+        def push_exceptions
+          return unless Contrast::TELEMETRY_EXCEPTIONS&.any?
+
+          Contrast::TELEMETRY_EXCEPTIONS.values.each_slice(256) { |tuple| error_messages.push(tuple) }
+          # Clear the hash. All exceptions now live in @_error_messages instance variable. and we will
+          # add them to the queue. Clearing would make the hash available to be populated again while the
+          # sending is proceeding.
+          Contrast::TELEMETRY_EXCEPTIONS.clear
+          # Add batch to queue. We need to shift here, because we want to report from the oldest batch to
+          # the newest. And even if somehow the array is filled during sending the new messages would stay
+          # and wait their turn.
+          queue << error_messages.shift until error_messages.empty?
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/events/metric_event.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/metrics_hash'
+require 'contrast/agent/telemetry/events/event'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This class will hold the basic information for a Telemetry Event
+      class MetricEvent < Contrast::Agent::Telemetry::Event
+        include Contrast::Utils
+
+        attr_reader :fields
+
+        def initialize
+          super
+          @fields = MetricsHash.new(Numeric)
+          @fields['_filler'] = 0
+        end
+
+        def to_hash **_args
+          super.merge!({ fields: @fields })
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/events/startup_metrics_event.rb

@@ -0,0 +1,123 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/metrics_hash'
+require 'contrast/agent/telemetry/events/metric_event'
+require 'contrast/agent/version'
+require 'contrast/utils/os'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This class will hold the Startup Metrics Telemetry Event
+      # The class will include initialization of the agent version, language version
+      # os type, arch and version
+      # application framework and version and server framework
+      # It will be initialized and send in Middleware#agent_startup_routine
+      class StartupMetricsEvent < Contrast::Agent::Telemetry::MetricEvent
+        include Contrast::Utils::OS
+
+        APP_AND_SERVER_DATA = ::Contrast::APP_CONTEXT.app_and_server_information.cs__freeze
+        # Multi-tenant Production Environments
+        SAAS_DEFAULT = { addr: 'app.contrastsecurity.com', type: 'SAAS_DEFAULT' }.cs__freeze
+        SAAS_CS = { addr: /cs[[:digit:]]+\.contrastsecurity\.com/, type: 'SAAS_DEFAULT' }.cs__freeze
+        SAAS_JP = { addr: 'app.contrastsecurity.jp', type: 'SAAS_DEFAULT' }.cs__freeze
+        SAAS_CE = { addr: 'ce.contrastsecurity.com', type: 'SAAS_CE' }.cs__freeze
+        # Multi-tenant Demo Environments
+        SAAS_DEMO = { addr: 'apptwo.contrastsecurity.com', type: 'SAAS_DEMO' }.cs__freeze
+        SAAS_POV = { addr: 'eval.contrastsecurity.com', type: 'SAAS_POV' }.cs__freeze
+        # Multi-tenant Testing Environment
+        SAAS_RESEARCH = { addr: 'security-research.contrastsecurity.com', type: 'SAAS_RESEARCH' }.cs__freeze
+        SAAS_ALPHA = { addr: 'alpha.contrastsecurity.com', type: 'SAAS_ALPHA' }.cs__freeze
+        SAAS_STAGING = { addr: 'teamserver-staging.contsec.com', type: 'SAAS_TESTING' }.cs__freeze
+        SAAS_STAGING_TOKYO = { addr: 'teamserver-staging.contsec.jp', type: 'SAAS_TESTING' }.cs__freeze
+        SAAS_TESTING = { addr: 'teamserver-darpa.contsec.com', type: 'SAAS_TESTING' }.cs__freeze
+        SAAS_OPS_TESTING = { addr: 'teamserver-ops.contsec.com', type: 'SAAS_TESTING' }.cs__freeze
+        # Fallback for Single-tenant Production Environments
+        SAAS_CUSTOM = { addr: 'contrastsecurity.com', type: 'SAAS_CUSTOM' }.cs__freeze
+        SAAS_CUSTOM_JP = { addr: 'contrastsecurity.jp', type: 'SAAS_CUSTOM' }.cs__freeze
+
+        SINGLE_MAP_TENANTS = [
+          SAAS_DEFAULT, SAAS_JP, SAAS_CE, SAAS_DEMO, SAAS_POV, SAAS_RESEARCH, SAAS_ALPHA,
+          SAAS_STAGING, SAAS_STAGING_TOKYO, SAAS_TESTING, SAAS_OPS_TESTING
+        ].cs__freeze
+        REGEXP_MAP_TENANTS = [SAAS_CS].cs__freeze
+        FALLBACK_TENANTS = [SAAS_CUSTOM, SAAS_CUSTOM_JP].cs__freeze
+        # Fallback for Custom, most likely self-hosted, Environments
+        EOP = 'EOP'
+        REJECTED_VALUES = [nil, 'NEEDS_TO_BE_SET', Contrast::Utils::ObjectShare::EMPTY_STRING].cs__freeze
+
+        def initialize
+          super
+          @settings = []
+          add_config_keys(::Contrast::CONFIG.root, 'root')
+          @settings << ENV.keys.select { |v| v.starts_with?('CONTRAST') }
+          @settings.flatten
+          add_tags
+        end
+
+        def path
+          '/startup'
+        end
+
+        def add_tags
+          add_system_tags
+          @tags['app_framework_and_version'] = APP_AND_SERVER_DATA[:application_info].to_s
+          @tags['server_framework_and_version'] = APP_AND_SERVER_DATA[:server_info].to_s
+          @tags['ASSESS'] = Contrast::ASSESS.enabled?.to_s
+          @tags['PROTECT'] = Contrast::PROTECT.enabled?.to_s
+          @tags['settings'] = @settings.join(',')
+        end
+
+        def add_config_keys config, nested_key
+          config.to_hash.reject! { |_k, v| REJECTED_VALUES.include?(v) }
+
+          config.to_hash.each do |k, v|
+            unless v.cs__class <= Contrast::Config::BaseConfiguration
+              @settings << "#{ nested_key }.#{ k }"
+              next
+            end
+
+            add_config_keys(v, "#{ nested_key }.#{ k }")
+          end
+        end
+
+        def sys_info
+          @sys_info ||= get_system_information if @sys_info.nil?
+          @sys_info
+        end
+
+        private
+
+        # Here we extract the TeamServer url type
+        #
+        # @return [String] the type of TeamServer environment to which we're connecting
+        def teamserver_type
+          @_teamserver_type ||= begin
+            url = Contrast::API.api_url
+            if (single = SINGLE_MAP_TENANTS.find { |tenant| url.include?(tenant[:addr]) })
+              single[:type]
+            elsif (regexp = REGEXP_MAP_TENANTS.find { |tenant| tenant[:addr].match?(url) })
+              regexp[:type]
+            elsif (fallback = FALLBACK_TENANTS.find { |tenant| url.include?(tenant[:addr]) })
+              fallback[:type]
+            else
+              EOP
+            end
+          end
+        end
+
+        # Here we attach the key-value pairs of the system
+        #
+        def add_system_tags
+          @tags['teamserver'] = teamserver_type
+          @tags['agent_version'] = VERSION
+          @tags['ruby_version'] = RUBY_VERSION
+          @tags['os_type'] = sys_info['os_type'] == 'Darwin' ? 'MacOS' : 'Linux'
+          @tags['os_arch'] = sys_info['os_arch']
+          @tags['os_version'] = sys_info['os_version']
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/thread_watcher.rb

@@ -5,46 +5,58 @@ require 'contrast/components/logger'
 require 'contrast/agent/service_heartbeat'
 require 'contrast/api/communication/messaging_queue'
 require 'contrast/agent/reporting/report'
-require 'contrast/agent/telemetry'
+require 'contrast/agent/reporting/reporter_heartbeat'
+require 'contrast/agent/telemetry/base'
 
 module Contrast
   module Agent
     # This class used to ensure that our worker threads are running in multi-process environments
-    #
-    # @attr_reader heapdump_util [Contrast::Utils::HeapDumpUtil]
-    # @attr_reader heartbeat [Contrast::Agent::ServiceHeartbeat]
-    # @attr_reader messaging_queue [Contrast::Api::Communication::MessagingQueue]
     class ThreadWatcher
       include Contrast::Components::Logger::InstanceMethods
 
-      attr_reader :heapdump_util, :heartbeat, :messaging_queue
+      # @return [Contrast::Utils::HeapDumpUtil]
+      attr_reader :heapdump_util
+      # @return [Contrast::Agent::ServiceHeartbeat, nil]
+      attr_reader :heartbeat
+      # @return [Contrast::Api::Communication::MessagingQueue, nil]
+      attr_reader :messaging_queue
+      # @return [Contrast::Agent::Reporter]
+      attr_reader :reporter
+      # @return [Contrast::Agent::ReporterHeartbeat]
+      attr_reader :reporter_heartbeat
 
       def initialize
         @pids = {}
         @heapdump_util = Contrast::Utils::HeapDumpUtil.new
-        @heartbeat = Contrast::Agent::ServiceHeartbeat.new
-        @messaging_queue = Contrast::Api::Communication::MessagingQueue.new
-        @telemetry = Contrast::Agent::Telemetry.new if Contrast::Agent::Telemetry.enabled?
-        @reporter = Contrast::Agent::Reporter.new if Contrast::Agent::Reporter.enabled?
+        unless ::Contrast::CONTRAST_SERVICE.unnecessary?
+          @heartbeat = Contrast::Agent::ServiceHeartbeat.new
+          @messaging_queue = Contrast::Api::Communication::MessagingQueue.new
+        end
+        if Contrast::Agent::Reporter.enabled?
+          @reporter = Contrast::Agent::Reporter.new
+          @reporter_heartbeat = Contrast::Agent::ReporterHeartbeat.new
+        end
+        @telemetry = Contrast::Agent::Telemetry::Base.new if Contrast::Agent::Telemetry::Base.enabled?
       end
 
+      # @return [Hash, nil] map of process to thread startup status
       def startup!
         return unless ::Contrast::AGENT.enabled?
 
-        telemetry_status = telemetry_thread_init
-        heartbeat_status = heartbeat_thread_init
-        messaging_status = messaging_thread_init
-        reporter_status = reporter_thread_init
-
         logger.debug('ThreadWatcher started threads')
-
+        heartbeat_status = init_thread(heartbeat)
+        messaging_status = init_thread(messaging_queue)
         @pids[Process.pid] = messaging_status && heartbeat_status
-        return @pids unless Contrast::Agent::Telemetry.enabled?
-
-        @pids[Process.pid] = @pids[Process.pid] && telemetry_status
+        if Contrast::Agent::Telemetry::Base.enabled?
+          telemetry_status = init_thread(telemetry_queue)
+          @pids[Process.pid] = @pids[Process.pid] && telemetry_status
+        end
         return @pids unless Contrast::Agent::Reporter.enabled?
 
-        @pids[Process.pid] = @pids[Process.pid] && reporter_status
+        reporter_status = init_thread(reporter)
+        reporter_heartbeat_status = init_thread(reporter_heartbeat)
+        @pids[Process.pid] = @pids[Process.pid] && reporter_status && reporter_heartbeat_status
+        @pids
       end
 
       def ensure_running?
@@ -55,63 +67,35 @@ module Contrast
       end
 
       def shutdown!
-        heartbeat.stop!
-        messaging_queue.stop!
-        heapdump_util.stop!
+        heartbeat&.stop!
+        messaging_queue&.stop!
+        heapdump_util&.stop!
         telemetry_queue&.stop!
         reporter&.stop!
+        reporter_heartbeat&.stop!
       end
 
-      def heartbeat_thread_init
-        unless heartbeat.running?
-          logger.debug('Attempting to start heartbeat thread')
-          heartbeat.start_thread!
-        end
-        heartbeat_result = heartbeat.running?
-        logger.debug('Heartbeat thread status', alive: heartbeat_result)
-        heartbeat_result
-      end
-
-      def telemetry_thread_init
-        @telemetry.start_thread! if @telemetry&.attempt_to_start?
-        telemetry_result = @telemetry&.running?
-        logger.debug('Telemetry thread status', alive: telemetry_result)
-        telemetry_result
-      end
-
-      def messaging_thread_init
-        unless messaging_queue.running?
-          logger.debug('Attempting to start messaging queue thread')
-          messaging_queue.start_thread!
-        end
-        messaging_result = messaging_queue.running?
-        logger.debug('Messaging thread status', alive: messaging_result)
-        messaging_result
-      end
-
-      def reporter_thread_init
-        @reporter.start_thread! if @reporter&.attempt_to_start?
-        unless @reporter&.running?
-          logger.debug('Attempting to start reporter thread')
-          @reporter&.start_thread!
-        end
-        reporter_result = @reporter&.running?
-        logger.debug('Reporter thread status', alive: reporter_result)
-        reporter_result
-      end
-
-      # @return [Contrast::Agent::Telemetry]
+      # @return [Contrast::Agent::Telemetry::Base]
       def telemetry_queue
-        return if @telemetry.nil?
-
         @telemetry
       end
 
-      # @return [Contrast::Agent::Reporter]
-      def reporter
-        return if @reporter.nil?
+      private
 
-        @reporter
+      # Start the thread governed by the given watcher
+      #
+      # @param watcher [Contrast::Agent::ThreadWatcher]
+      # @return [Boolean] if the watched thread started successfully
+      def init_thread watcher
+        return unless watcher&.attempt_to_start?
+
+        unless watcher.running?
+          logger.debug('Attempting to start thread', type: watcher.to_s)
+          watcher.start_thread!
+        end
+        result = watcher.running?
+        logger.debug('Thread status', type: watcher.to_s, alive: result)
+        result
       end
     end
   end

data/lib/contrast/agent/version.rb

@@ -3,6 +3,6 @@
 
 module Contrast
   module Agent
-    VERSION = '5.3.0'
+    VERSION = '6.1.1'
   end
 end

data/lib/contrast/agent/worker_thread.rb

@@ -15,10 +15,18 @@ module Contrast
 
       def stop!
         return unless running?
+        return unless @_thread
 
         Thread.kill(@_thread)
         @_thread = nil
       end
+
+      # Most threads, we always want to start. Some may be controlled by feature guards though, so we need to check.
+      #
+      # @return [Boolean]
+      def attempt_to_start?
+        true
+      end
     end
   end
 end

data/lib/contrast/agent.rb

@@ -32,6 +32,8 @@ require 'contrast/utils/invalid_configuration_util'
 # Collect findings
 require 'contrast/utils/findings'
 
+# Collect Exploites and Attacks
+require 'contrast/agent/protect/exploitable_collection'
 # scoping
 require 'contrast/agent/scope'
 
@@ -52,6 +54,7 @@ module Contrast
     # build a map for tracking the context of the current request
     REQUEST_TRACKER = Contrast::Utils::ThreadTracker.new
     FINDINGS = Contrast::Utils::Findings.new
+    EXPLOITS = Contrast::Agent::Protect::ExploitableCollection.new
 
     # @return [Contrast::Framework::Manager]
     def self.framework_manager
@@ -68,10 +71,8 @@ module Contrast
       thread_watcher.messaging_queue
     end
 
-    # @return [nil, Contrast::Agent::Telemetry]
+    # @return [nil, Contrast::Agent::Telemetry::Base]
     def self.telemetry_queue
-      return unless thread_watcher.telemetry_queue
-
       thread_watcher.telemetry_queue
     end
 

data/lib/contrast/api/communication/messaging_queue.rb

@@ -2,8 +2,10 @@
 # frozen_string_literal: true
 
 require 'contrast/components/logger'
+require 'contrast/agent/assess/policy/trigger_method'
 require 'contrast/agent/worker_thread'
 require 'contrast/agent/reporting/reporting_utilities/audit'
+require 'contrast/api/dtm.pb'
 
 module Contrast
   module Api
@@ -12,11 +14,13 @@ module Contrast
       class MessagingQueue < Contrast::Agent::WorkerThread
         include Contrast::Components::Logger::InstanceMethods
 
+        # @return [Contrast::Api::Communication::Speedracer, nil]
         attr_reader :speedracer
 
         def initialize
+          return if ::Contrast::CONTRAST_SERVICE.unnecessary?
+
           @speedracer = Contrast::Api::Communication::Speedracer.new
-          @audit = Contrast::Agent::Reporting::Audit.new if ::Contrast::API.request_audit_enable?
           super
         end
 
@@ -33,18 +37,18 @@ module Contrast
             logger.warn('Attempted to send event immediately with Agent disabled', caller: caller, event: event)
             return
           end
-          response_data = speedracer.return_response(event)
-          return response_data unless ::Contrast::API.request_audit_enable?
+          return if ::Contrast::CONTRAST_SERVICE.unnecessary?
 
-          @audit&.audit_event(event, response_data)
-          response_data
+          speedracer.return_response(event)
         end
 
         # A simple Queue used to hold messages that are ready to be sent to SpeedRacer but for which we do not need an
         # immediate response
         #
-        # @return [Queue]
+        # @return [Queue, nil]
         def queue
+          return if ::Contrast::CONTRAST_SERVICE.unnecessary?
+
           @_queue ||= Queue.new
         end
 
@@ -54,31 +58,44 @@ module Contrast
         # application to our post-filter operations as well as those that don't alter the application's execution (i.e.
         # Assess' vulnerability reporting).
         #
-        # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
+        # @param event [Contrast::Api::Dtm, Contrast::Api::Dtm::Poll] One of the DTMs valid for the event field of
         #   Contrast::Api::Dtm::Message|Contrast::Api::Dtm::Activity
-        def send_event_eventually event
+        # @param force [Boolean] if we should always queue this event, even if the service isn't running, in case the
+        #   message may be ready before the service has initiated. usually for those events which happen in a separate
+        #   thread or which may occur during initialization.
+        def send_event_eventually event, force: false
           if ::Contrast::AGENT.disabled?
             logger.warn('Attempted to queue event with Agent disabled', caller: caller, event: event)
             return
           end
+          return if ::Contrast::CONTRAST_SERVICE.unnecessary?
+          # If we're unable to start the Service, then we cannot afford to queue messages as this creates the potential
+          # for a memory leak, especially if the thread responsible for de-queueing the messages is dead.
+          return if !force && !(speedracer.status.connected? && running?)
+
+          # If we're in direct communication mode, the only message we should queue is the heartbeat to keep the
+          # service alive during Protect activities. All other messages should go through direct reporting.
+          if ::Contrast::CONTRAST_SERVICE.use_agent_communication?
+            return unless ::Contrast::PROTECT.enabled?
+            return unless event.cs__is_a?(Contrast::Api::Dtm::Poll)
+          end
+
           logger.debug('Enqueued event for sending', event_type: event.cs__class)
           queue << event if event
-          return unless ::Contrast::API.request_audit_enable?
-
-          @audit&.audit_event(event)
         end
 
         # Create the reporting thread, which will pull from the queue in order to send messages to SpeedRacer. If
         # SpeedRacer is not running and should be, meaning the Agent is configured to control it, then we will also
         # try to start that process.
         def start_thread!
+          return if ::Contrast::CONTRAST_SERVICE.unnecessary?
+
           speedracer.ensure_startup!
           return if running?
 
           @_thread = Contrast::Agent::Thread.new do
             loop do
               event = queue.pop
-
               begin
                 logger.debug('Dequeued event for sending', event_type: event.cs__class)
                 speedracer.process_internally(event)

data/lib/contrast/api/communication/response_processor.rb

@@ -8,12 +8,8 @@ module Contrast
   module Api
     module Communication
       # Handles processing deferred messages sent to SpeedRacer.
-      #
-      # @attr_reader last_app_update_ms [Integer] the time, in ms, that application settings last changed
-      # @attr_reader last_server_update_ms [Integer] the time, in ms, that server settings last changed
       class ResponseProcessor
         include Contrast::Components::Logger::InstanceMethods
-        attr_reader :last_app_update_ms, :last_server_update_ms
 
         # Use the given response to update the Agent's server features and application settings, allowing it to reflect
         # the latest options configured by the user in TeamServer
@@ -48,7 +44,6 @@ module Contrast
           logger.trace('Agent: Received updated server features')
 
           ::Contrast::SETTINGS.update_from_server_features(server_features)
-          @last_server_update_ms = Contrast::Utils::Timer.now_ms
           server_features
         end
 
@@ -58,22 +53,24 @@ module Contrast
         # @param response [Contrast::Api::Settings::AgentSettings]
         # @return [Contrast::Api::Settings::ApplicationSettings]
         def process_application_response response
+          logger.debug('[!] process_application_response', response: response)
           app_settings = response&.application_settings
           return unless app_settings
 
-          logger.debug('Agent: Received updated application settings')
-
+          logger.debug('[!] Agent: Received updated application settings', settings: app_settings)
           ::Contrast::SETTINGS.update_from_application_settings(app_settings)
-          @last_app_update_ms = Contrast::Utils::Timer.now_ms
           app_settings
         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 server_features [Contrast::Api::Settings::AgentSettings, Array]
-        # @param app_settings [Contrast::Api::Settings::ApplicationSettings, Array]
+        # @param server_features
+        #   [Contrast::Api::Settings::AgentSettings, Contrast::Agent::Reporting::Settings::FeatureSettings]
+        # @param app_settings
+        #   [Contrast::Api::Settings::ApplicationSettings, Contrast::Agent::Reporting::Settings::ApplicationSettings]
         def update_features server_features, app_settings
+          logger.info('Updating features')
           return unless !!(server_features || app_settings)
           return unless ::Contrast::AGENT.enabled?
 

data/lib/contrast/api/communication/service_lifecycle.rb

@@ -55,7 +55,7 @@ module Contrast
         def spawn_service
           options = determine_startup_options
           logger.debug('Spawning service')
-          spawn 'contrast_service', options
+          spawn('contrast_service', options)
         end
 
         # Create a thread to start the SpeedRacer, making calls to spawn until one starts successfully. As soon as the

data/lib/contrast/api/communication/socket.rb

@@ -35,7 +35,7 @@ module Contrast
 
         # Override this method to return a socket. Should be interface compatible with TCPSocket, UNIXSocket, etc.
         def new_socket
-          raise NoMethodError, 'This is abstract, override it.'
+          raise(NoMethodError, 'This is abstract, override it.')
         end
       end
     end

data/lib/contrast/api/communication/socket_client.rb

@@ -114,7 +114,7 @@ module Contrast
         rescue StandardError => e
           logger.error('Sending failed for message.', e, msg_id: msg.__id__, p_id: msg.pid,
                                                          msg_count: msg.message_count, response_id: response&.__id__)
-          raise e # reraise to let SpeedRacer manage the connection
+          raise(e) # reraise to let SpeedRacer manage the connection
         end
 
         # Send the marshaled Contrast::Api::Dtm::Message across the socket used to talk to SpeedRacer

data/lib/contrast/api/communication/speedracer.rb

@@ -42,7 +42,7 @@ module Contrast
                 return
               end
             end
-            unless status.startup_messages_sent?
+            unless status.startup_messages_sent? || Contrast::CONTRAST_SERVICE.unnecessary?
               startup_responses = send_initialization_messages
               return false unless startup_responses
 
@@ -87,9 +87,9 @@ module Contrast
           ensure_startup!
 
           logger.debug_with_time(event.cs__class.cs__name) do
-            response = socket_client.send_one event
+            response = socket_client.send_one(event)
             status.success!
-            yield response
+            yield(response)
           end
         rescue StandardError => e
           status.failure!

data/lib/contrast/api/decorators/activity.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/string_utils'
+
+module Contrast
+  module Api
+    module Decorators
+      # Used to decorate the {Contrast::Api::Dtm::Activity} protobuf model
+      # to handle conversion between framework route classes and the dtm.
+      module Activity
+        def self.included klass
+          klass.extend(ClassMethods)
+        end
+
+        # Class methods for Activity
+        module ClassMethods
+          def source_or_string obj
+            if obj.cs__is_a?(Regexp)
+              obj.source
+            elsif obj.cs__respond_to?(:safe_string)
+              obj.safe_string
+            else
+              obj.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Contrast::Api::Dtm::Activity.include(Contrast::Api::Decorators::Activity)