contrast-agent 6.2.0 → 6.3.0

data/lib/contrast/agent/reporting/reporting_events/route_discovery_observation.rb

@@ -3,6 +3,7 @@
 
 require 'contrast/api/dtm.pb'
 require 'contrast/utils/string_utils'
+require 'contrast/components/logger'
 
 module Contrast
   module Agent
@@ -16,6 +17,8 @@ module Contrast
       # @attr_reader verb [String] the HTTP Method requested to his this endpoint. Empty means all, so is allowed.
       #   for reporting.
       class RouteDiscoveryObservation
+        include Contrast::Components::Logger::InstanceMethods
+
         # required attributes
         attr_reader :url
         # optional attributes
@@ -47,10 +50,14 @@ module Contrast
         # @return [Hash]
         # @raise [ArgumentError]
         def to_controlled_hash
-          validate
-          hash = { url: url }
-          hash[:verb] = verb if verb
-          hash
+          begin
+            validate
+          rescue ArgumentError => e
+            logger.error('RouteDiscoveryObservation validation failed with: ', e)
+            return
+          end
+
+          { url: url, verb: verb }.compact
         end
 
         # Ensure the required fields are present.

data/lib/contrast/agent/reporting/reporting_events/server_activity.rb

@@ -12,14 +12,6 @@ module Contrast
       # for its response, which contains any updated server feature settings from TeamServer. The new Server Settings
       # endpoint should let us remove this.
       class ServerActivity < Contrast::Agent::Reporting::ServerReportingEvent
-        class << self
-          # @param _server_activity_dtm [Contrast::Api::Dtm::ServerActivity]
-          # @return [Contrast::Agent::Reporting::ServerActivity]
-          def convert _server_activity_dtm
-            new
-          end
-        end
-
         def initialize
           @event_method = :PUT
           @event_endpoint = "#{ Contrast::API.api_url }/api/ng/activity/server"

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

@@ -44,10 +44,7 @@ module Contrast
         # @param file_name[String] file_name to log
         # @param data[String] String representation if the logged data
         def log_data type, file_name, data = nil
-          return unless enabled?
-
-          logger.debug('logging to file', file_name: file_name) # TODO: RUBY-99999 DO NOT COMMIT THIS
-          write_to_file(type, file_name, data)
+          write_to_file(type, file_name, data) if enabled?
         end
 
         # This method will be actually writing to the file

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

@@ -1,7 +1,6 @@
 # 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/agent/reporting/reporting_events/application_activity'
 require 'contrast/api/dtm.pb'
 
@@ -13,22 +12,6 @@ module Contrast
       # 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 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
@@ -47,12 +30,7 @@ module Contrast
           # @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::ApplicationUpdate.convert(dtm) if application_update?(dtm)
             return Contrast::Agent::Reporting::Finding.convert(dtm) if finding?(dtm)
             return Contrast::Agent::Reporting::ApplicationActivity.convert(dtm) if activity?(dtm)
 

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

@@ -53,12 +53,10 @@ module Contrast
         # @param event [Contrast::Agent::Reporting::ReportingEvent] The event to send to TeamServer. Really a
         #   child of the ReportingEvent rather than a literal one.
         # @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
+        def send_event event, connection
           return unless connection
 
-          log_send_event(event) if send_immediately
           request = build_request(event)
           response = connection.request(request)
           audit&.audit_event(event, response) if ::Contrast::API.request_audit_enable?

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

@@ -39,7 +39,7 @@ module Contrast
 
           STARTUP_EVENTS.each do |event|
             startup_event = event.new
-            send_event(startup_event, connection, send_immediately: true)
+            send_event(startup_event, connection)
           rescue StandardError => e
             handle_error(startup_event, e)
           end
@@ -66,15 +66,6 @@ module Contrast
           request
         end
 
-        # log the event sent immediately
-        #
-        # @param event [Contrast::Agent::Reporting::ReportingEvent] The event to send to TeamServer. Really a
-        #   child of the ReportingEvent rather than a literal one.
-        def log_send_event event
-          logger.debug("#{ Contrast::Agent::Reporting::ReporterClient::SERVICE_NAME } immediately sending event.",
-                       event_id: event.__id__, event_type: event.cs__class.cs__name)
-        end
-
         # Handles standard error case, logs and set status for failure
         #
         # @param event [Contrast::Agent::Reporting::ReportingEvent]
@@ -96,7 +87,6 @@ module Contrast
         # @param response [Net::HTTP::Response]
         def process_settings_response response
           response_handler.process(response)
-          logger.debug('Successfully sent startup messages to TeamServer.')
           status.success!
         end
 

data/lib/contrast/agent/request.rb

@@ -17,12 +17,6 @@ module Contrast
     # provides access to the original Rack::Request object as well as extracts
     # data in a format that the Agent expects, caching those transformations in
     # order to avoid repeatedly creating Strings & thrashing GC.
-    #
-    # @attr_reader rack_request [Rack::Request] The passed to the Agent RackRequest to be wrapped.
-    # @attr_accessor route [Contrast::Api::Dtm::RouteCoverage] the route, used for findings, of this request
-    # @attr_accessor observed_route [Contrast::Api::Dtm::ObservedRoute] the route, used for coverage of this request
-    # @attr_accessor new_observed_route [Contrast::Agent::Reporting::ObservedRoute] the route, used for coverage, of
-    # this request
     class Request
       include Contrast::Utils::RequestUtils
       include Contrast::Components::Logger::InstanceMethods
@@ -37,8 +31,12 @@ module Contrast
       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
 
+      # @return [Rack::Request] The passed to the Agent RackRequest to be wrapped.
       attr_reader :rack_request
-      attr_accessor :route, :observed_route, :new_observed_route
+      # @return [Contrast::Api::Dtm::RouteCoverage] the route, used for findings, of this request
+      attr_accessor :route
+      # @return [Contrast::Agent::Reporting::ObservedRoute] the route, used for coverage, of this request
+      attr_accessor :observed_route
 
       # Delegate calls to the following methods to the attribute @rack_request
       def_delegators :@rack_request, :base_url, :cookies, :env, :ip, :media_type, :path, :port, :query_string,

data/lib/contrast/agent/request_context.rb

@@ -30,8 +30,6 @@ module Contrast
       # @return [Hash] context used to log the request
       attr_reader :logging_hash
       # @return [Contrast::Agent::Reporting::ObservedRoute] the route, used for coverage, of this request
-      attr_reader :new_observed_route
-      # @return [Contrast::Api::Dtm::ObservedRoute] the route, used for coverage, of this request
       attr_reader :observed_route
       # @return [Contrast::Agent::Request] our wrapper around the Rack::Request for this context
       attr_reader :request
@@ -40,15 +38,10 @@ module Contrast
       attr_reader :response
       # @return [Contrast::Api::Dtm::RouteCoverage] the route, used for findings, of this request
       attr_reader :route
-      # @return [Contrast::Api::Dtm::ServerActivity] the server activity found in this request
-      attr_reader :server_activity
       # @return [Contrast::Api::Settings::InputAnalysis] the protect input analysis of sources on this request
       attr_reader :speedracer_input_analysis
       # @return [Contrast::Utils::Timer] when the context was created
       attr_reader :timer
-      # @return [Contrast::Agent::Reporting::ObservedLibraryUsage] List of the libraries that have been observed to be
-      #   executed or to have something loaded. This here replaces part of the Activity Dtm
-      attr_reader :observed_library_usage
 
       def initialize rack_request, app_loaded: true
         with_contrast_scope do
@@ -62,9 +55,6 @@ module Contrast
           @activity = Contrast::Api::Dtm::Activity.new
           @activity.http_request = request.dtm
 
-          @server_activity = Contrast::Api::Dtm::ServerActivity.new
-          @observed_library_usage = Contrast::Agent::Reporting::ObservedLibraryUsage.new
-
           # build analyzer
           @do_not_track = false
           @speedracer_input_analysis = EMPTY_INPUT_ANALYSIS_PB
@@ -128,20 +118,21 @@ module Contrast
 
       def reset_activity
         @activity = Contrast::Api::Dtm::Activity.new(http_request: request.dtm)
-        @server_activity = Contrast::Api::Dtm::ServerActivity.new
-        @observed_route = Contrast::Api::Dtm::ObservedRoute.new # TODO: RUBY-1438 -- remove
-        @new_observed_route = Contrast::Agent::Reporting::ObservedRoute.new
+        @observed_route = Contrast::Agent::Reporting::ObservedRoute.new
       end
 
       private
 
       def handle_routes
-        @observed_route = Contrast::Api::Dtm::ObservedRoute.new # TODO: RUBY-1438 -- remove
-        @new_observed_route = Contrast::Agent::Reporting::ObservedRoute.new
+        @observed_route = Contrast::Agent::Reporting::ObservedRoute.new
+        # TODO: RUBY-1705 when we no longer need the DTM style, delete this method and use the get_route_information
+        #   instead.
         route_dtm = Contrast::Agent.framework_manager.get_route_dtm(@request)
-        new_route_coverage_dtm = Contrast::Agent.framework_manager.get_route_information(@request)
+        # new_route_coverage_dtm = Contrast::Agent.framework_manager.get_route_information(@request)
+        # TODO: RUBY-1705 -- delete append_route_coverage
         append_route_coverage(route_dtm)
-        append_to_new_observed_route(new_route_coverage_dtm)
+        # TODO: RUBY-1705 -- change to take [Contrast::Agent::Reporting::ObservedRoute]
+        append_to_observed_route(route_dtm)
       end
     end
   end

data/lib/contrast/agent/request_context_extend.rb

@@ -38,23 +38,20 @@ module Contrast
         @activity.routes << route
 
         # For TS routes
-        @observed_route.signature  = route.route
-        @observed_route.verb       = route.verb
-        @observed_route.url        = route.url if route.url
         @request.route = route
-        @request.observed_route = @observed_route
       end
 
       # Convert the discovered route for this request to appropriate forms and disseminate it to those locations
       # where it is necessary for our route coverage and finding vulnerability discovery features to function.
       #
-      def append_to_new_observed_route route
+      # @param route [Contrast::Api::Dtm::RouteCoverage]
+      def append_to_observed_route route
         return unless route
 
-        @new_observed_route.signature  = route.route
-        @new_observed_route.verb       = route.verb
-        @new_observed_route.url        = route.url if route.url
-        @request.new_observed_route = @new_observed_route
+        @observed_route.signature  = route.route
+        @observed_route.verb       = route.verb
+        @observed_route.url        = route.url if route.url
+        @request.observed_route    = @observed_route
       end
 
       # Collect the results for the given rule with the given action
@@ -71,6 +68,7 @@ module Contrast
         end
       end
 
+      # @raise [Contrast::SecurityException]
       def service_extract_request
         return false unless ::Contrast::AGENT.enabled?
         return false unless ::Contrast::PROTECT.enabled?
@@ -105,6 +103,7 @@ module Contrast
       # Normally these should be generated on Speedracer for any attacks detected during prefilter.
       #
       # @param agent_settings [Contrast::Api::Settings::AgentSettings]
+      # @raise[Contrast::SecurityException]
       def handle_protect_state agent_settings
         return unless agent_settings&.protect_state
 

data/lib/contrast/agent/request_handler.rb

@@ -22,56 +22,27 @@ module Contrast
         @ruleset = ::Contrast::AGENT.ruleset
       end
 
-      # Send Activities messages to TS [Contrast::Agent::Reporting::ServerActivity,
-      #                                 Contrast::Api::Dtm::ServerActivity,
-      #                                 Contrast::Api::Dtm::Activity,
-      #                                 Contrast::Api::Dtm::ObservedRoute]
-      # If bypass is enabled use the reporting service if not than the messages are
-      # send with speedracer
-      # TODO: RUBY-1355
-      # TODO: RUBY-1358
-      # TODO: RUBY-1438 -- remove
+      # Send Activities messages to TS [Contrast::Api::Dtm::Activity]
+      # TODO: RUBY-1704
+      # TODO: RUBY-1438
       def send_activity_messages
-        events = [context.activity]
-        unless Contrast::Agent::Reporter.enabled?
-          events << context.server_activity
-          events << context.observed_route
-        end
-        events.each do |message|
-          Contrast::Agent.messaging_queue&.send_event_eventually(message)
-        end
+        Contrast::Agent.messaging_queue&.send_event_eventually(context.activity)
       end
 
       # reports events[Contrast::Agent::Reporting::ReporterEvent] to TS
       # This method is used to send our JSON messages directly to TeamServer at the end of each request. As we move
       # more endpoints over, this method will take the messages originally sent by #send_actiivty_messages. At the end,
       # that method should be removed.
-      def report_activity # rubocop:disable Metrics/AbcSize
-        Contrast::Agent::Inventory::DependencyUsageAnalysis.instance.
-            generate_library_usage(context.observed_library_usage)
+      def report_activity
+        return unless (reporter = Contrast::Agent.reporter)
 
-        Contrast::Agent.reporter.send_event(context.observed_library_usage)
+        reporter.send_event(context.observed_route)
         return unless Contrast::Agent::Reporter.enabled?
 
-        reporter = Contrast::Agent.reporter
-        return unless reporter
-
         # Mask Sensitive Data
         Contrast::Agent::Reporting::Masker.mask(context.activity)
-
-        Contrast::Agent::Inventory::DependencyUsageAnalysis.instance.
-            generate_library_usage(context.observed_library_usage)
-        [
-          context.new_observed_route,
-          context.observed_library_usage,
-          Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.server_activity),
-          Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity)
-        ].each do |event|
-          reporter.send_event(event)
-        rescue StandardError => e
-          logger.warn('Unable to send Event Activity', e)
-        end
-        context.observed_library_usage.clear # TODO: RUBY-1355 remove when no longer using activity
+        event = Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity)
+        reporter.send_event(event)
       end
 
       # If the response is streaming, we should only perform filtering on our stream safe rules

data/lib/contrast/agent/rule_set.rb

@@ -14,6 +14,8 @@ module Contrast
       # The main action here is snapshotting the request as provided to the application from the
       # user before any application code has acted upon it. Additionally, this is where Protect will
       # terminate requests on attack detection if set to block at perimeter
+      #
+      # @raise [Contrast::SecurityException] raises error if security exception is thrown in prefilter
       def prefilter
         context = Contrast::Agent::REQUEST_TRACKER.current
         return unless context&.analyze_request?
@@ -30,6 +32,8 @@ module Contrast
 
       # The filtering that needs occur after the application has acted on the request and the response
       # has been created. The main actions here are analyzing the response for unsafe state or actions.
+      #
+      # @raise [Contrast::SecurityException] raises error if security exception is thrown in postfilter
       def postfilter
         context = Contrast::Agent::REQUEST_TRACKER.current
         return unless context&.analyze_response?

data/lib/contrast/agent/service_heartbeat.rb

@@ -22,7 +22,7 @@ module Contrast
         @_thread = Contrast::Agent::Thread.new do
           logger.info('Starting heartbeat thread.')
           loop do
-            Contrast::Agent.messaging_queue.send_event_eventually(poll_message)
+            Contrast::Agent.messaging_queue&.send_event_eventually(poll_message)
             sleep(REFRESH_INTERVAL_SEC)
           end
         end

data/lib/contrast/agent/static_analysis.rb

@@ -4,7 +4,6 @@
 require 'contrast/components/logger'
 require 'contrast/components/scope'
 require 'contrast/agent/reporting/reporting_events/application_update'
-require 'contrast/api/decorators/application_update'
 
 module Contrast
   module Agent
@@ -24,20 +23,16 @@ module Contrast
           end
         end
 
-        # TODO: RUBY-1703
         def send_inventory_message
           return unless ::Contrast::INVENTORY.enabled?
 
-          app_update_msg = Contrast::Api::Dtm::ApplicationUpdate.build
-          Contrast::Agent::Inventory::DatabaseConfig.append_db_config(app_update_msg)
-          # TODO: RUBY-1703 -- remove and build ReportingEvent directly
-          if Contrast::Agent::Reporter.enabled?
-            report = Contrast::Agent::Reporting::DtmMessage.dtm_to_event(app_update_msg)
-            Contrast::Agent.reporter.send_event(report)
-          else
-            Contrast::Agent.messaging_queue.send_event_eventually(app_update_msg, force: true)
+          report = Contrast::Agent::Reporting::ApplicationUpdate.new
+          # This convert here is left as it'll be easier to be replaced when the Library is being changed
+          report.libraries = Contrast::Agent::Inventory::DependencyAnalysis.instance.library_pb_list
+          Contrast::Agent::Inventory::DatabaseConfig.append_db_config(report)
+          [report, Contrast::Agent::Reporting::ApplicationInventory.new].each do |e|
+            Contrast::Agent.reporter.send_event(e)
           end
-          Contrast::Agent.reporter.send_event(Contrast::Agent::Reporting::ApplicationInventory.new)
         end
 
         private

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

@@ -7,7 +7,6 @@ require 'contrast/utils/telemetry_client'
 require 'contrast/agent/worker_thread'
 require 'contrast/utils/telemetry'
 require 'contrast/agent/telemetry/events/exceptions/telemetry_exceptions'
-require 'contrast/agent/telemetry/events/exceptions/telemetry_exceptions_report'
 
 module Contrast
   module Agent
@@ -15,7 +14,6 @@ module Contrast
       # This class will initialize and hold everything needed for the telemetry
       class Base < WorkerThread
         include Contrast::Components::Logger::InstanceMethods
-        include Contrast::Agent::Telemetry::TelemetryExceptionReport
 
         # this is where we will send the data from the agents
         URL = 'https://telemetry.ruby.contrastsecurity.com/'
@@ -66,10 +64,6 @@ module Contrast
           @_connection ||= client.initialize_connection(URL)
         end
 
-        def error_messages
-          @_error_messages ||= []
-        end
-
         def attempt_to_start?
           unless cs__class.enabled?
             logger.warn('Telemetry service is disabled!')
@@ -83,34 +77,8 @@ module Contrast
         def start_thread!
           return if running?
 
-          # It is recommended that implementations send a single payload of
-          # general metrics every 3 hours, starting from implementation startup.
-          @_thread = Contrast::Agent::Thread.new do
-            logger.debug('Starting background telemetry thread.')
-            loop do
-              next unless client && connection
-
-              # Start pushing exceptions to queue for reporting.
-              push_exceptions
-              until queue.empty?
-                event = queue.pop
-                begin
-                  logger.debug('This is the current processed event', event)
-                  sleep_time = request_with_response(event)
-                  if sleep_time
-                    sleep(sleep_time)
-                    logger.debug('Retrying to process event', event)
-                    retry_sleep_time = request_with_response(event)
-                    sleep(retry_sleep_time) unless retry_sleep_time.nil?
-                  end
-                rescue StandardError => e
-                  logger.error('Could not send message to service from telemetry queue.', e)
-                  stop!
-                end
-              end
-              sleep(SUGGESTED_TIMEOUT)
-            end
-          end
+          logger.debug('Starting background telemetry thread.')
+          @_thread = create_thread
         end
 
         def send_event event
@@ -126,7 +94,6 @@ module Contrast
         end
 
         def delete_queue!
-          @_queue&.clear
           @_queue&.close
           @_queue = nil
         end
@@ -149,6 +116,39 @@ module Contrast
         def queue
           @_queue ||= Queue.new
         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.
+        #
+        # @return [Contrast::Agent::Thread]
+        def create_thread
+          Contrast::Agent::Thread.new do
+            loop do
+              next unless client && connection
+
+              # Start pushing exceptions to queue for reporting.
+              Contrast::TELEMETRY_EXCEPTIONS.each_value { |value| queue << value }
+              Contrast::TELEMETRY_EXCEPTIONS.clear
+              until queue.empty?
+                event = queue.pop
+                begin
+                  logger.debug('This is the current processed event', event)
+                  sleep_time = request_with_response(event)
+                  if sleep_time
+                    sleep(sleep_time)
+                    logger.debug('Retrying to process event', event)
+                    retry_sleep_time = request_with_response(event)
+                    sleep(retry_sleep_time) unless retry_sleep_time.nil?
+                  end
+                rescue StandardError => e
+                  logger.error('Could not send message to service from telemetry queue.', e)
+                  stop!
+                end
+              end
+              sleep(SUGGESTED_TIMEOUT)
+            end
+          end
+        end
       end
     end
   end

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

@@ -28,6 +28,7 @@ module Contrast
           #
           # @param validation_pair [Hash] Validation hash to use
           # @param key[String] The key to check in VALIDATIONS
+          # @raise [ArgumentError]
           def validate_field validation_pair, key
             value_to_validate = send(key.to_sym)
             validate_class(value_to_validate, validation_pair[:class], key) if validation_pair.key?(:class)
@@ -48,6 +49,7 @@ module Contrast
           # @param message [Object] The message we want to check the class of
           # @param klass [Class] The klass we want to check the message with
           # @param field [Object] The field with the error
+          # @raise [ArgumentError]
           def validate_class message, klass, field
             message = message[0] if message.cs__is_a?(Array)
             raise(ArgumentError, "The provided value for #{ field } is of wrong class") unless message.cs__is_a?(klass)

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

@@ -18,6 +18,7 @@ module Contrast
           # to be created
           #
           # @param message [Contrast::Agent::Telemetry::TelemetryException::Message]
+          # @raise[ArgumentError]
           def initialize message
             super()
             validate_class(message, Contrast::Agent::Telemetry::TelemetryException::Message, 'exception_message')
@@ -25,6 +26,7 @@ module Contrast
           end
 
           # @param message [Contrast::Agent::Telemetry::TelemetryException::Message]
+          # @raise[ArgumentError]
           def push message
             validate_class(message, Contrast::Agent::Telemetry::TelemetryException::Message, 'exception_message')
             @exceptions << message

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

@@ -50,6 +50,7 @@ module Contrast
           # @return [String | nil] A string message to provide additional context to the errors.
           attr_reader :message
 
+          # @raise[ArgumentError]
           def initialize instance, tags, exceptions
             super()
             @tags = tags
@@ -63,17 +64,19 @@ module Contrast
           # Optional parameters will be set separately from the required
           #
           # @param logger[String]
+          # @raise[ArgumentError]
           def logger= logger
-            validate_field(VALIDATIONS[:logger], 'logger')
             @logger = logger
+            validate_field(VALIDATIONS[:logger], 'logger')
           end
 
           # Optional parameters will be set separately from the required
           #
           # @param message[String]
+          # @raise[ArgumentError]
           def message= message
-            validate_field(VALIDATIONS[:message], 'message')
             @message = message
+            validate_field(VALIDATIONS[:message], 'message')
           end
 
           # Optional parameters will be set separately from the required

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

@@ -43,16 +43,19 @@ module Contrast
           end
 
           # @param stack_frame [Contrast::Agent::Telemetry::TelemetryException::StackFrame]
+          # @raise[ArgumentError]
           def push stack_frame
             validate_class(stack_frame, Contrast::Agent::Telemetry::TelemetryException::StackFrame, 'stack_frame')
             @stack_frames << stack_frame
           end
 
+          # @raise[ArgumentError]
           def module_name= module_name
             @module_name = module_name
             validate_field(VALIDATIONS[:module_name], 'module_name')
           end
 
+          # @raise[ArgumentError]
           def value= value
             @value = value
             validate_field(VALIDATIONS[:value], 'value')

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

@@ -28,6 +28,7 @@ module Contrast
           # @return [String]
           attr_reader :module_name
 
+          # @raise [ArgumentError]
           def initialize function, type
             super()
             @function = function
@@ -36,11 +37,13 @@ module Contrast
             validate(VALIDATIONS)
           end
 
+          # @raise [ArgumentError]
           def module_name= module_name
             @module_name = module_name
             validate_field(VALIDATIONS[:module_name], 'module_name')
           end
 
+          # @raise [ArgumentError]
           def to_controlled_hash
             super
             { function: function, type: type, module: module_name, inContrast: in_contrast }.compact

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

@@ -17,4 +17,3 @@ require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_stack_fr
 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'