contrast-agent 5.3.0 → 6.1.1

data/lib/contrast/utils/log_utils.rb

@@ -3,6 +3,7 @@
 
 require 'socket'
 require 'contrast/agent/version'
+require 'contrast/logger/aliased_logging'
 
 module Contrast
   module Utils
@@ -37,6 +38,7 @@ module Contrast
         logger.extend(Contrast::Logger::Application)
         logger.extend(Contrast::Logger::Request)
         logger.extend(Contrast::Logger::Time)
+        logger.extend(Contrast::Logger::AliasedLogging) if Contrast::Utils::Telemetry.exceptions_enabled?
       end
 
       # Determine the valid path to which to log, given the precedence of config > settings > default.
@@ -62,13 +64,13 @@ module Contrast
           # Log once when the path is invalid. We'll change to this path, so no
           # need to log again.
           if previous_path != DEFAULT_NAME
-            $stdout.puts "[!] Unable to write to '#{ path }'. Writing to default log '#{ DEFAULT_NAME }' instead."
+            $stdout.puts("[!] Unable to write to '#{ path }'. Writing to default log '#{ DEFAULT_NAME }' instead.")
           end
           DEFAULT_NAME
         else
           # Log once when the path is invalid. We'll change to this path, so no
           # need to log again.
-          $stdout.puts "[!] Unable to write to '#{ path }'. Writing to standard out instead."
+          $stdout.puts("[!] Unable to write to '#{ path }'. Writing to standard out instead.")
           STDOUT_STR
         end
       end
@@ -139,7 +141,7 @@ module Contrast
                  end
         logger.progname = PROGNAME
         logger.level = level_const
-        change_logger_formatter logger
+        change_logger_formatter(logger)
         logger
       end
 
@@ -160,7 +162,7 @@ module Contrast
           message << msg[0]
           message << severity
           message << extract_metadata(msg[1], msg[2])
-          message.join('|') + "\n"
+          "#{ message.join('|') }\n"
         end
       end
 
@@ -181,7 +183,7 @@ module Contrast
                            DEFAULT_METADATA
                          end
         app_name = ::Contrast::APP_CONTEXT.app_name
-        attach_request_and_sender_info message, sender_info
+        attach_request_and_sender_info(message, sender_info)
         message << "request=#{ context.request.url } "
         message << "requestMethod=#{ request_method } "
         message << "app=#{ app_name } "

data/lib/contrast/utils/lru_cache.rb

@@ -6,7 +6,7 @@ module Contrast
     # A LRU(Least Recently Used) Cache store.
     class LRUCache
       def initialize capacity = 500
-        raise StandardError 'Capacity must be bigger than 0' if capacity <= 0
+        raise(StandardError('Capacity must be bigger than 0')) if capacity <= 0
 
         @capacity = capacity
         @cache = {}

data/lib/contrast/utils/metrics_hash.rb

@@ -29,7 +29,7 @@ module Contrast
         value_val = value.dup
         key_val.strip! if key_val.cs__is_a?(String)
         value_val.strip! if value_val.cs__is_a?(String)
-        return unless valid_pair? key_val, value_val
+        return unless valid_pair?(key_val, value_val)
 
         key_val.downcase!
         key_val.strip!

data/lib/contrast/utils/middleware_utils.rb

@@ -8,6 +8,13 @@ module Contrast
     module MiddlewareUtils
       private
 
+      # TODO: RUBY-1609 update this part of the method for Ruby Version and Year
+      LANGUAGE_DEPRECATION_VERSION = '2.7'
+      LANGUAGE_DEPRECATION_YEAR = '2023'
+      LANGUAGE_DEPRECATION_WARNING =
+        "[Contrast Security] [DEPRECATION] Support for Ruby #{ LANGUAGE_DEPRECATION_VERSION } will be removed in "\
+        "April #{ LANGUAGE_DEPRECATION_YEAR }. Please contact Customer Support prior if you require continued support."
+
       def setup_agent
         ::Contrast::SETTINGS.reset_state
 
@@ -30,12 +37,12 @@ module Contrast
       def handle_exception exception
         if security_exception?(exception)
           exception_control = ::Contrast::AGENT.exception_control
-          raise exception unless exception_control[:enable]
+          raise(exception) unless exception_control[:enable]
 
           [exception_control[:status], {}, [exception_control[:message]]]
         else
           logger.debug('Re-throwing original error', exception)
-          raise exception
+          raise(exception)
         end
       end
 
@@ -51,25 +58,19 @@ module Contrast
       # deprecated and soon to be removed functionality. This method handles doing that by leveraging the standard
       # Kernel#warn approach
       def inform_deprecations
-        # Ruby 2.6 will be dropped in april of 2022. We'll begin the deprecation warnings
-        # now so that customers have time to reach out if they'll be impacted.
-        # TODO: RUBY-1188 remove this part of the method, leaving it empty if there are no other deprecations, when we
-        #   drop 2.6 support.
-        return unless RUBY_VERSION < '2.7.0'
-
-        Kernel.warn('[Contrast Security] [DEPRECATION] Support for Ruby 2.6 will be removed in April 2022. '\
-                    'Please contact Customer Support prior if you require continued support.')
+        # Warn customers that they're on a version that's losing support in the next year.
+        Kernel.warn(LANGUAGE_DEPRECATION_WARNING) if RUBY_VERSION.start_with?(LANGUAGE_DEPRECATION_VERSION)
       end
 
       # Displays Telemetry disclaimer if Telemetry is enabled.
       # if .telemetry file doesn't exist we create one and then show the disclaimer.
       # if the file already exists we do nothing.
       def telemetry_disclaimer
-        return unless Contrast::Agent::Telemetry.enabled?
+        return unless Contrast::Agent::Telemetry::Base.enabled?
         return unless Contrast::Utils::Telemetry.create_telemetry_file
 
-        logger.info Contrast::Utils::Telemetry.disclaimer
-        $stdout.print Contrast::Utils::Telemetry.disclaimer
+        logger.info(Contrast::Utils::Telemetry.disclaimer)
+        $stdout.print(Contrast::Utils::Telemetry.disclaimer)
         true
       end
 
@@ -79,7 +80,7 @@ module Contrast
         end
       rescue Contrast::SecurityException => e
         logger.trace('Security Exception raised during application lifecycle to prevent an attack', e)
-        raise e
+        raise(e)
       end
     end
   end

data/lib/contrast/utils/net_http_base.rb

@@ -22,7 +22,7 @@ module Contrast
       # @param use_custom_cert [Boolean] flag used to indicate whether the client is to use
       # self signed certificates provided by config [default = false]
       # @return [Net::HTTP, nil] Return open connection or nil
-      def initialize_connection service_name, url, use_proxy = false, use_custom_cert = false
+      def initialize_connection service_name, url, use_proxy: false, use_custom_cert: false
         return unless url
 
         addr = URI(url)
@@ -31,14 +31,14 @@ module Contrast
         return if addr.scheme != 'https' && !addr.host.to_s.include?('localhost') # TODO: RUBY-99999 allow http w/ localhost # rubocop:disable Layout/LineLength
 
         proxy_addr = URI(Contrast::API.proxy_url) if proxy_enabled?
-        net_http_client = initialize_client addr, proxy_addr, use_proxy, use_custom_cert
+        net_http_client = initialize_client(addr, proxy_addr, use_proxy, use_custom_cert)
         return if net_http_client.nil?
 
         net_http_client.start
         return unless net_http_client.started?
 
         logger.debug("Starting #{ service_name } connection test")
-        return unless connection_verified? net_http_client
+        return unless connection_verified?(net_http_client)
 
         logger.debug('Client verified', service: service_name, url: url)
         net_http_client
@@ -63,7 +63,7 @@ module Contrast
         response = client.request(Net::HTTP::Get.new(client.address))
         verify_cert = client.address.to_s.include?('localhost') ||
             OpenSSL::SSL.verify_certificate_identity(client.peer_cert, client.address)
-        resolved = resolved? client.address, ipaddr
+        resolved = resolved?(client.address, ipaddr)
         @_connection_verified = if resolved && response && verify_cert
                                   true
                                 else
@@ -91,7 +91,7 @@ module Contrast
       def resolved? address, ipaddr
         return @_resolved unless @_resolved.nil?
 
-        @_resolved = if (addresses = Resolv.getaddresses address)
+        @_resolved = if (addresses = Resolv.getaddresses(address))
                        addresses.any? { |addr| addr.include?(ipaddr) }
                      else
                        false

data/lib/contrast/utils/object_share.rb

@@ -23,6 +23,7 @@ module Contrast
       HTTPS_START =   'https:'
       NEW_LINE =      "\n"
       NIL_STRING =    'nil'
+      NIL_64_STRING = 'bmls'
       PERIOD =        '.'
       POUND_SIGN =    '#'
       QUESTION_MARK = '?'
@@ -38,6 +39,7 @@ module Contrast
       COLON_SLASH_SLASH = '://'
       DOLLAR_SIGN =    '$'
       CARROT =         '^'
+      BANG =           '!'
 
       WRITE_FLAG =    'w'
 
@@ -47,7 +49,6 @@ module Contrast
       CACHE = 'cache'
 
       CONTRAST_PATCHED_METHOD_START = 'cs__patched_'
-      DOUBLE_COLON = '::'
 
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze

data/lib/contrast/utils/os.rb

@@ -42,7 +42,7 @@ module Contrast
         end
 
         def mac?
-          @_mac = RUBY_PLATFORM.include? 'darwin' if @_mac.nil?
+          @_mac = RUBY_PLATFORM.include?('darwin') if @_mac.nil?
           @_mac
         end
 
@@ -53,11 +53,6 @@ module Contrast
         def linux?
           (unix? and !mac?)
         end
-
-        def jruby?
-          @_jruby = RUBY_ENGINE == 'jruby' if @_jruby.nil?
-          @_jruby
-        end
       end
     end
   end

data/lib/contrast/utils/patching/policy/patch_utils.rb

@@ -35,10 +35,9 @@ module Contrast
         # Given a method, return a symbol in the format
         # <method_start>_unbound_<method_name>
         def build_unbound_method_name patcher_method
-          (Contrast::Utils::ObjectShare::CONTRAST_PATCHED_METHOD_START +
-            'unbound' +
-            Contrast::Utils::ObjectShare::UNDERSCORE +
-            patcher_method.to_s).to_sym
+          "#{ Contrast::Utils::ObjectShare::CONTRAST_PATCHED_METHOD_START }unbound"\
+          "#{ Contrast::Utils::ObjectShare::UNDERSCORE }"\
+          "#{ patcher_method }".to_sym
         end
 
         # ===== PATCH APPLIERS =====
@@ -59,7 +58,7 @@ module Contrast
         rescue Contrast::SecurityException => e
           # We were told to block something, so we gotta. Don't catch this one, let it get back to our Middleware or
           # even all the way out to the framework
-          raise e
+          raise(e)
         rescue StandardError => e
           # Anything else was our bad and we gotta catch that to allow for normal application flow
           logger.error('Unable to apply pre patch to method.', e)
@@ -138,7 +137,7 @@ module Contrast
           if method_policy.source_node
             # If we were given a frozen return, and it was the target of a source, and we have frozen sources enabled,
             # we'll need to replace the return. Note, this is not the default case.
-            source_ret = Contrast::Agent::Assess::Policy::SourceMethod.source_patchers(method_policy, object, ret, args)
+            source_ret = Contrast::Agent::Assess::Policy::SourceMethod.apply_source(method_policy, object, ret, args)
           end
           if method_policy.propagation_node
             propagated_ret = Contrast::Agent::Assess::Policy::PropagationMethod.apply_propagation(
@@ -156,7 +155,7 @@ module Contrast
         rescue Exception => e # rubocop:disable Lint/RescueException
           logger.error('Unable to assess method call.', e)
           handle_return(propagated_ret, source_ret, ret)
-          raise e
+          raise(e)
         end
 
         # Generic invocation of the Inventory or Protect patch which apply to the given method.

data/lib/contrast/utils/request_utils.rb

@@ -31,7 +31,7 @@ module Contrast
             k = Contrast::Utils::StringUtils.force_utf8(k)
             nested_prefix = prefix.nil? ? k : "#{ prefix }[#{ k }]"
             hash[k] = Contrast::Utils::ObjectShare::EMPTY_STRING
-            hash.merge! normalize_params(v, prefix: nested_prefix)
+            hash.merge!(normalize_params(v, prefix: nested_prefix))
           end
           res[prefix] = Contrast::Utils::ObjectShare::EMPTY_STRING if prefix
           res
@@ -39,7 +39,7 @@ module Contrast
           idx = 0
           res = {}
           while idx < val.length
-            res.merge! normalize_params(val[idx], prefix: "#{ prefix }[#{ idx }]")
+            res.merge!(normalize_params(val[idx], prefix: "#{ prefix }[#{ idx }]"))
             idx += 1
           end
           res[prefix] = Contrast::Utils::ObjectShare::EMPTY_STRING if prefix

data/lib/contrast/utils/response_utils.rb

@@ -36,39 +36,24 @@ module Contrast
         return unless body
         return if defined?(Rack::File) && body.is_a?(Rack::File)
 
-        case body
-        when Rack::BodyProxy
-          handle_rack_body_proxy(body)
-        when ActionDispatch::Response::RackBody
-          extract_body(body.body) if defined?(ActionDispatch::Response::RackBody)
-        when Rack::Response
-          extract_body(body.body)
-        when Contrast::Utils::DuckUtils.quacks_to?(body, :each)
-          acc = []
-          body.each { |tmp| acc << read_or_string(tmp) }
-          acc.compact.join(Contrast::Utils::ObjectShare::NEW_LINE)
-        when ActionView::OutputBuffer
-          # https://stackoverflow.com/questions/15654676/how-to-convert-activesupportsafebuffer-to-string
-          body.to_str
-        else
-          read_or_string(body)
-        end
-        # if body.is_a?(Rack::BodyProxy)
-        #   handle_rack_body_proxy(body)
-        # elsif (defined?(ActionDispatch::Response::RackBody) && body.is_a?(ActionDispatch::Response::RackBody)) ||
-        #       body.is_a?(Rack::Response)
-        #
-        #   extract_body(body.body)
-        # elsif Contrast::Utils::DuckUtils.quacks_to?(body, :each)
-        #   acc = []
-        #   body.each { |tmp| acc << read_or_string(tmp) }
-        #   acc.compact.join(Contrast::Utils::ObjectShare::NEW_LINE)
-        # elsif ActionView::OutputBuffer
-        #   # https://stackoverflow.com/questions/15654676/how-to-convert-activesupportsafebuffer-to-string
-        #   body.to_str
-        # else
-        #   read_or_string(body)
-        # end
+        return handle_rack_body_proxy(body) if body.is_a?(Rack::BodyProxy)
+        return extract_body(body.body) if sub_extractable?(body)
+        return enumerable_text_from(body) if Contrast::Utils::DuckUtils.quacks_to?(body, :each)
+        # https://stackoverflow.com/questions/15654676/how-to-convert-activesupportsafebuffer-to-string
+        return body.to_str if body.is_a?(ActionView::OutputBuffer)
+
+        read_or_string(body)
+      end
+
+      def sub_extractable? body
+        (defined?(ActionDispatch::Response::RackBody) && body.is_a?(ActionDispatch::Response::RackBody)) ||
+            body.is_a?(Rack::Response)
+      end
+
+      def enumerable_text_from body
+        entries = body.map { |entry| read_or_string(entry) }
+        entries.compact!
+        entries.join(Contrast::Utils::ObjectShare::NEW_LINE)
       end
 
       def handle_rack_body_proxy body

data/lib/contrast/utils/sha256_builder.rb

@@ -9,16 +9,16 @@ module Contrast
     # Utility methods for building and caching hashes from strings
     class Sha256Builder
       include Singleton
+      # Return a list of "source" files. Ignore metadata files as well as files
+      # in the spec, test or exe directories. Could potentially miss important
+      # files but good enough for the time being.
+      PATHS = '{lib,bin,ext}/**/*.{rb,c,h,c++,cpp,java,rs}'
 
       def initialize
         @sha256_cache = {}
         @gem_hash_cache = {}
       end
 
-      # Return a list of "source" files. Ignore metadata files as well as files
-      # in the spec, test or exe directories. Could potentially miss important
-      # files but good enough for the time being.
-      PATHS = '{lib,bin,ext}/**/*.{rb,c,h,c++,cpp,java,rs}'
       def files path
         if Dir.exist?(path)
           Dir.glob(File.join(path, PATHS))

data/lib/contrast/utils/stack_trace_utils.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'contrast/utils/object_share'
+require 'contrast/agent/reporting/reporting_events/application_defend_attack_sample_stack'
 require 'contrast/api'
 
 module Contrast
@@ -35,21 +36,18 @@ module Contrast
         # StackTraceElement for TeamServer to display, excluding any Contrast
         # code found.
         #
-        # @return [Array<Contrast::Api::Dtm::StackTraceElement]
+        # @return [Array<Contrast::Api::Dtm::StackTraceElement>]
         def build_protect_stack_array
-          stack = caller(2, 20)
-          return [] unless stack
+          build_protect_stack(Contrast::Api::Dtm::StackTraceElement)
+        end
 
-          stack = reject_caller_entries(stack)
-          i = 0
-          stack.map! do |entry|
-            element = Contrast::Api::Dtm::StackTraceElement.new
-            element = fill_protect_element(element, entry, i)
-            i += 1
-            element
-          end
-          stack.compact!
-          stack
+        # Call and translate a caller_locations array to an array of
+        # StackTraceElement for TeamServer to display, excluding any Contrast
+        # code found.
+        #
+        # @return [Array<Contrast::Agent::Reporting::ApplicationDefendAttackSampleStack>]
+        def build_protect_report_stack_array
+          build_protect_stack(Contrast::Agent::Reporting::ApplicationDefendAttackSampleStack)
         end
 
         # Translate a caller array to an array of TraceStacks for TeamServer to
@@ -86,6 +84,26 @@ module Contrast
           end
         end
 
+        # @param clazz [Class] Contrast::Api::Dtm::StackTraceElement or
+        #   Contrast::Agent::Reporting::ApplicationDefendAttackSampleStack
+        # @return [Array<Contrast::Agent::Reporting::ApplicationDefendAttackSampleStack|
+        #   Contrast::Api::Dtm::StackTraceElement>]
+        def build_protect_stack clazz
+          stack = caller(3, 21)
+          return [] unless stack
+
+          stack = reject_caller_entries(stack)
+          i = 0
+          stack.map! do |entry|
+            element = clazz.new
+            element = fill_protect_element(element, entry, i)
+            i += 1
+            element
+          end
+          stack.compact!
+          stack
+        end
+
         # In Contrast UI - there are many ways to render the stacktraces. For
         # Protect, there are two ways we're concerned about, one for the first
         # element and then all others.

data/lib/contrast/utils/telemetry.rb

@@ -1,8 +1,9 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
-require 'contrast/agent/telemetry'
+require 'contrast/agent/telemetry/base'
 require 'contrast/utils/telemetry_identifier'
+require 'contrast/config/env_variables'
 
 module Contrast
   module Utils
@@ -30,14 +31,21 @@ module Contrast
       # @return[Boolean, nil] true if file is created, false if file already exist
       # and nil if Telemetry is disabled or on unsupported OS.
       def self.create_telemetry_file
-        write_mark_file DIR, FILE, CONFIG_DIR
+        write_mark_file(DIR, FILE, CONFIG_DIR)
       end
 
       def self.disclaimer
         @_disclaimer = MESSAGE[:disclaimer]
       end
 
+      def self.exceptions_enabled?
+        @_exceptions_enabled = telemetry_exceptions_enabled? if @_exceptions_enabled.nil?
+        @_exceptions_enabled
+      end
+
       class << self
+        include Contrast::Config::EnvVariables
+
         private
 
         # Create the mark file
@@ -48,7 +56,7 @@ module Contrast
         # @return[Boolean, nil] true if file is created, false if file already exist
         # and nil if Telemetry is disabled or on unsupported OS.
         def write_mark_file dir, file, config_dir
-          return unless Contrast::Agent::Telemetry.enabled?
+          return unless Contrast::Agent::Telemetry::Base.enabled?
           return if Contrast::Utils::OS.windows?
 
           @dir = dir
@@ -56,7 +64,7 @@ module Contrast
           # nor can we write to the "root" directory ( / ). This results in Errno::EROFS exception.
           # So for the MacOS we would use the config directory of the instrumented application.
           @dir = config_dir if Contrast::Utils::OS.mac?
-          return false if File.file? @dir + file
+          return false if File.file?(@dir + file)
           return true if touch_marker(@dir, file)
 
           # If we don't have permission to write to root directory use config instead
@@ -67,12 +75,19 @@ module Contrast
         #
         # @return[Boolean] true if success, false if fails
         def touch_marker dir, file
-          FileUtils.mkdir_p dir unless Dir.exist? dir
-          FileUtils.touch dir + file
-          File.file? dir + file
+          FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+          FileUtils.touch(dir + file)
+          File.file?(dir + file)
         rescue StandardError => _e
           false
         end
+
+        def telemetry_exceptions_enabled?
+          opts_out_telemetry = return_value(:telemetry_opt_outs).to_s
+          return false if opts_out_telemetry.casecmp?('true') || opts_out_telemetry == '1'
+
+          true
+        end
       end
     end
   end

data/lib/contrast/utils/telemetry_client.rb

@@ -12,9 +12,10 @@ module Contrast
   module Utils
     # This module creates a Net::HTTP client and initiates a connection to the provided result
     class TelemetryClient < NetHttpBase
+      include Contrast::Components::Logger::InstanceMethods
       ENDPOINT = 'api/v1/telemetry/metrics' # /TelemetryEvent.path
+      EXCEPTIONS = 'api/v1/telemetry/exceptions' # /TelemetryExceptions::Event.path
       SERVICE_NAME = 'Telemetry'
-      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.
@@ -22,36 +23,41 @@ module Contrast
       # @param url [String]
       # @return [Net::HTTP, nil] Return open connection or nil
       def initialize_connection url
-        super(SERVICE_NAME, url, false, false)
+        super(SERVICE_NAME, url, use_proxy: false, use_custom_cert: false)
       end
 
       # This method will be responsible for building the request. Because the telemetry collector expects to receive
       # multiple events in a single request, we must always wrap the event in an array, even if there is only one.
       #
-      # @param event [Contrast::Agent::TelemetryEvent,Contrast::Agent::StartupMetricsTelemetryEvent]
+      # @param event [Contrast::Agent::Telemetry::Event, Array<Contrast::Agent::Telemetry::TelemetryException::Event>]
       # @return [Net::HTTP::Post]
       def build_request event
-        return unless valid_event? event
+        return unless valid_event?(event)
+
+        string_body = if Array(event).all?(Contrast::Agent::Telemetry::TelemetryException::Event)
+                        event.map(&:to_controlled_hash).flatten!
+                      else
+                        [event.to_hash]
+                      end
 
-        string_body = [event.to_hash].to_json
         header = {
             'User-Agent' => "<#{ Contrast::Utils::ObjectShare::RUBY }>-<#{ Contrast::Agent::VERSION }>",
             'Content-Type' => 'application/json'
         }
-        request = Net::HTTP::Post.new(build_path(event.path), header)
-        request.body = string_body
+        request = Net::HTTP::Post.new(build_path(event), header)
+        request.body = string_body.to_json
         request
       end
 
       # This method will create the actual request and send it
-      # @param event[Contrast::Agent::TelemetryEvent]
+      # @param event[Contrast::Agent::Telemetry::Event]
       # @param connection[Net::HTTP]
       def send_request event, connection
         return if connection.nil? || event.nil?
-        return unless valid_event? event
+        return unless valid_event?(event)
 
-        req = build_request event
-        connection.request req
+        req = build_request(event)
+        connection.request(req)
       end
 
       # This method will handle the response from the tenant
@@ -68,10 +74,13 @@ module Contrast
       end
 
       # This method will be responsible for validating the event
-      # @param event[Contrast::Agent::TelemetryEvent,Contrast::Agent::StartupMetricsTelemetryEvent]
+      # @param event[Contrast::Agent::Telemetry::Event,Contrast::Agent::Telemetry::StartupMetricsEvent,
+      # array<Contrast::Agent::Telemetry::TelemetryException::Event>]
       def valid_event? event
-        return true if event.cs__is_a?(Contrast::Agent::TelemetryEvent)
-        return true if event.cs__is_a?(Contrast::Agent::StartupMetricsTelemetryEvent)
+        return true if event.cs__is_a?(Contrast::Agent::Telemetry::Event)
+        return true if event.cs__is_a?(Contrast::Agent::Telemetry::StartupMetricsEvent)
+        # Batch
+        return true if Array(event).all?(Contrast::Agent::Telemetry::TelemetryException::Event)
 
         false
       end
@@ -81,9 +90,12 @@ module Contrast
       # The telemetry instance accepts any path to #{ Contrast::Agent::Telemetry::URL }#{ ENDPOINT }, using the
       # remainder of the path to segregate messages.
       #
+      # @param event [Contrast::Agent::Telemetry::Event, Contrast::Agent::Telemetry::TelemetryException::Event]
       # @return [String] the fully qualified path to send the request
-      def build_path event_path
-        "#{ Contrast::Agent::Telemetry::URL }#{ ENDPOINT }#{ event_path }"
+      def build_path event
+        endpoint = Array(event).all?(Contrast::Agent::Telemetry::TelemetryException::Event) ? EXCEPTIONS : ENDPOINT
+        path = endpoint == EXCEPTIONS ? Contrast::Agent::Telemetry::TelemetryException::Event.path : event.path
+        "#{ Contrast::Agent::Telemetry::Base::URL }#{ endpoint }#{ path }"
       end
     end
   end

data/lib/contrast/utils/telemetry_hash.rb

@@ -0,0 +1,41 @@
+# 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'
+
+module Contrast
+  module Utils
+    # This is the TelemetryHash, which will take data type, so we can push freely, without worrying about
+    # validating the event before that
+    class TelemetryHash < Hash
+      include Contrast::Components::Logger::InstanceMethods
+
+      attr_reader :data_type
+
+      def initialize data_type, *_several_variants
+        super()
+        @data_type = data_type
+      end
+
+      def []= key, value
+        return unless valid_value?(value)
+
+        super(key, value)
+      end
+
+      def increment key
+        self[key].exceptions[0].increment_occurrences
+        :incremented!
+      end
+
+      def valid_value? value
+        unless value.cs__is_a?(data_type)
+          logger.debug('The following key will be omitted', value: value)
+          return false
+        end
+
+        true
+      end
+    end
+  end
+end