contrast-agent 5.3.0 → 6.1.1

data/lib/contrast/configuration.rb

@@ -7,7 +7,6 @@ require 'fileutils'
 require 'contrast/config'
 require 'contrast/utils/object_share'
 require 'contrast/components/scope'
-require 'contrast/utils/exclude_key'
 
 module Contrast
   # This is how we read in the local settings for the Agent, both ENV/ CMD line
@@ -27,15 +26,17 @@ module Contrast
     MILLISECOND_MARKER = '_ms'
     CONVERSION = { 'agent.service.enable' => 'agent.start_bundled_service' }.cs__freeze
     CONFIG_BASE_PATHS = ['', 'config/', '/etc/contrast/ruby/', '/etc/contrast/', '/etc/'].cs__freeze
+    KEYS_TO_REDACT = %i[api_key url service_key user_name].cs__freeze
+    REDACTED = '**REDACTED**'
 
     def initialize cli_options = nil, default_name = DEFAULT_YAML_PATH
       @default_name = default_name
 
       # Load config_kv from file
-      config_kv = deep_stringify_all_keys(load_config)
+      config_kv = deep_symbolize_all_keys(load_config)
 
       # Overlay CLI options - they take precedence over config file
-      cli_options = deep_stringify_all_keys(cli_options)
+      cli_options = deep_symbolize_all_keys(cli_options)
       config_kv = deep_merge(cli_options, config_kv) if cli_options
 
       # Some in-flight rewrites to maintain backwards compatibility
@@ -93,7 +94,7 @@ module Contrast
         rescue Psych::Exception => e
           log_yaml_parse_error(path, e)
         rescue RuntimeError => e
-          puts "WARN: Unable to load configuration. #{ e }; path: #{ path }, pwd: #{ Dir.pwd }"
+          puts("WARN: Unable to load configuration. #{ e }; path: #{ path }, pwd: #{ Dir.pwd }")
         end
       end
 
@@ -105,7 +106,7 @@ module Contrast
     def update_prop_keys config
       CONVERSION.each_pair do |old_method, new_method|
         # See if the old value was set and needs to be translated
-        deprecated_keys = old_method.split('.')
+        deprecated_keys = old_method.split('.').map(&:to_sym)
         old_value = config
         deprecated_keys.each do |key|
           old_value = old_value[key]
@@ -114,7 +115,7 @@ module Contrast
         next if old_value.nil? # have to account for literal false
 
         log_deprecated_property(old_method, new_method)
-        new_keys = new_method.split('.')
+        new_keys = new_method.split('.').map(&:to_sym)
         # We changed the seconds values into ms values. Multiply them accordingly
         old_value = old_value.to_i * 1000 if new_method.end_with?(MILLISECOND_MARKER)
         new_value = config
@@ -147,12 +148,12 @@ module Contrast
       end
     end
 
-    def deep_stringify_all_keys hash
+    def deep_symbolize_all_keys hash
       return if hash.nil?
 
       new_hash = {}
       hash.each do |key, value|
-        new_hash[key.to_s] = value.is_a?(Hash) ? deep_stringify_all_keys(value) : value
+        new_hash[key.to_sym] = value.is_a?(Hash) ? deep_symbolize_all_keys(value) : value
       end
       new_hash
     end
@@ -181,7 +182,7 @@ module Contrast
       if logger
         logger.warn('YAML validator found an error', hash)
       else
-        puts "CONTRAST - WARN: YAML validator found an error. #{ hash.inspect }"
+        puts("CONTRAST - WARN: YAML validator found an error. #{ hash.inspect }")
       end
     end
 
@@ -189,7 +190,7 @@ module Contrast
       if logger
         logger.warn('Configuration file is not readable by current user', path: path)
       else
-        puts "CONTRAST - WARN: Configuration file is not readable by current user; path: #{ path }"
+        puts("CONTRAST - WARN: Configuration file is not readable by current user; path: #{ path }")
       end
     end
 
@@ -197,7 +198,7 @@ module Contrast
       if logger
         logger.warn('Deprecated property in use', old_method: old_method, new_method: new_method)
       else
-        puts "CONTRAST - WARN: Deprecated property in use; old_method: #{ old_method }, new_method: #{ new_method }"
+        puts("CONTRAST - WARN: Deprecated property in use; old_method: #{ old_method }, new_method: #{ new_method }")
       end
     end
 
@@ -219,11 +220,9 @@ module Contrast
       when Contrast::Config::BaseConfiguration
         # to_hash returns @configuration_map
         convert.to_hash.each_key do |key|
-          next if Contrast::Utils::ExcludeKey.excludable?(key.to_s)
-
-          # keys can contain '-' but methods getters cannot
-          # clean_key = key.to_s.tr('-', '_')
-          hash[key] = convert_to_hash(convert.send(key.to_sym), {})
+          # change '-' to '_' for ProtectRulesConfiguration
+          hash[key] = convert_to_hash(convert.send(key.tr('-', '_').to_sym), {})
+          hash[key] = REDACTED if redactable?(key)
         end
         hash
       else
@@ -235,7 +234,7 @@ module Contrast
       idx = 0
       end_idx = new_keys.length - 1
       while idx < new_keys.length
-        new_key = new_keys[idx]
+        new_key = new_keys[idx].to_sym
         if idx == end_idx
           new_value[new_key] = old_value if new_value[new_key].nil?
         else
@@ -246,5 +245,14 @@ module Contrast
         idx += 1
       end
     end
+
+    # Check if keys with sensitive data needs to be
+    # redacted.
+    #
+    # @param key [Symbol] key to check
+    # @return[Boolean] true | false
+    def redactable? key
+      KEYS_TO_REDACT.include?(key.to_sym)
+    end
   end
 end

data/lib/contrast/extension/assess/array.rb

@@ -53,7 +53,7 @@ module Contrast
               return ret unless Contrast::Agent::Assess::Tracker.tracked?(ret)
 
               properties.cleanup_tags
-              event_data = Contrast::Agent::Assess::Events::EventData.new ARRAY_JOIN_NODE, ret, ary, ret, [separator]
+              event_data = Contrast::Agent::Assess::Events::EventData.new(ARRAY_JOIN_NODE, ret, ary, ret, [separator])
               properties.build_event(event_data)
               properties.event.instance_variable_set(:@_parent_events, parent_events)
               ret

data/lib/contrast/extension/assess/erb.rb

@@ -20,7 +20,7 @@ module ERBPropagator
 
       erb_pre_result = preshift.object.src
       parent_events = []
-      binding_variable_set binding_variable_set, used_binding, erb_pre_result, properties, parent_events, ret
+      binding_variable_set(binding_variable_set, used_binding, erb_pre_result, properties, parent_events, ret)
       properties.build_event(Contrast::Agent::Assess::Events::EventData.new(patcher,
                                                                             ret,
                                                                             preshift.object,

data/lib/contrast/extension/assess/marshal.rb

@@ -43,7 +43,7 @@ module Contrast
               properties.copy_from(source, ret)
 
               node = Contrast::Agent::Assess::Policy::Policy.instance.find_propagator_node('Marshal', :load, false)
-              event_data = Contrast::Agent::Assess::Events::EventData.new node, ret, self, ret, args
+              event_data = Contrast::Agent::Assess::Events::EventData.new(node, ret, self, ret, args)
               properties.build_event(event_data)
             rescue StandardError => e
               logger.error('Unable to run Assess for Marshal.load', e)

data/lib/contrast/extension/assess/string.rb

@@ -13,7 +13,7 @@ module Contrast
       # methods which are too complex to fit into one of the standard
       # Contrast::Agent::Assess::Policy::Propagator molds without cluttering up the
       # String Class or exposing our methods there.
-      class StringPropagator # rubocop:disable Style/StaticClass
+      class StringPropagator
         extend Contrast::Components::Logger::InstanceMethods
         extend Contrast::Components::Scope::InstanceMethods
 
@@ -43,6 +43,7 @@ module Contrast
               offset = 0
               inputs.each do |input|
                 properties.copy_from(input, result, offset)
+                add_dynamic_sources_info(input, result)
                 offset += input.length
                 parent_event = Contrast::Agent::Assess::Tracker.properties(input)&.event
                 parent_events << parent_event if parent_event
@@ -58,6 +59,24 @@ module Contrast
           rescue StandardError => e
             logger.error('Unable to track interpolation', e)
           end
+
+          private
+
+          # When there is a string interpolation on input coming from tainted database,
+          # the Contrast::Agent::Assess::Properties::Updated.copy_from method won't copy
+          # the dynamic source properties needed in the build findings from TS to display
+          # the column and Table information as database source information.
+          #
+          # @param source [Object] the source object with the required properties.
+          # @param target [Object] the result form the interpolation and the object
+          # that needs to keep the source properties, in order to be reporter on
+          # trigger event.
+          # @return updated_properties [Hash<DynamicSourceInfo>, nil]
+          def add_dynamic_sources_info source, target
+            return unless (dynamic_props = Contrast::Agent::Assess::Tracker.properties(source)&.properties)
+
+            Contrast::Agent::Assess::Tracker.properties(target)&.add_properties(dynamic_props)
+          end
         end
       end
     end

data/lib/contrast/extension/extension.rb

@@ -37,9 +37,9 @@ module Contrast
           def assign_value path
             case path
             when /fiber/, /interpolation26/
-              require path if Funchook.available?
+              require(path) if Funchook.available?
             else
-              require path
+              require(path)
             end
             true
           end

data/lib/contrast/extension/module.rb

@@ -13,5 +13,4 @@ class Module
   alias_method :cs__const_defined?, :const_defined?
   alias_method :cs__const_get, :const_get
   alias_method :cs__const_set, :const_set
-  alias_method :cs__autoload?, :autoload?
 end

data/lib/contrast/framework/base_support.rb

@@ -7,19 +7,19 @@ module Contrast
     module BaseSupport
       # The top level module name used by the framework
       def detection_class
-        raise NoMethodError('Subclasses of BaseSupport should implement this method')
+        raise(NoMethodError('Subclasses of BaseSupport should implement this method'))
       end
 
       def version
-        raise NoMethodError('Subclasses of BaseSupport should implement this method')
+        raise(NoMethodError('Subclasses of BaseSupport should implement this method'))
       end
 
       def application_name
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def server_type
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       # Find all the predefined routes for this application and append them to the
@@ -27,19 +27,19 @@ module Contrast
       # msg should be a Contrast::Api::Dtm::ApplicationUpdate or some other msg
       # that has a routes array consisting of Contrast::Api::Dtm::RouteCoverage
       def collect_routes
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def current_route_coverage
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def current_route
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       def retrieve_request _env
-        raise NoMethodError, 'Subclasses of BaseSupport should implement this method'
+        raise(NoMethodError, 'Subclasses of BaseSupport should implement this method')
       end
 
       # Some Frameworks require specific patching for their classes to handle

data/lib/contrast/framework/grape/support.rb

@@ -112,7 +112,7 @@ module Contrast
             full_route ||= request.env[::Rack::PATH_INFO]
 
             new_route_coverage = Contrast::Agent::Reporting::RouteCoverage.new
-            new_route_coverage.attach_rack_based_data final_controller, method, route_pattern, full_route
+            new_route_coverage.attach_rack_based_data(final_controller, method, route_pattern, full_route)
           end
 
           # Search object space for grape controllers--any class that subclasses ::Grape::API.
@@ -151,7 +151,7 @@ module Contrast
             # Grape controller actually has endpoints and each endpoint
             # has routes and that's why we need to do it that way
             controller = controllers.pop
-            return _route_recurse method, route, controllers unless controller
+            return _route_recurse(method, route, controllers) unless controller
 
             contr_routes = controller.endpoints&.map(&:routes)&.flatten || []
             route_pattern = contr_routes&.find do |r|
@@ -159,7 +159,7 @@ module Contrast
             end
             return controller, route_pattern unless route_pattern.nil?
 
-            _route_recurse method, route, controllers
+            _route_recurse(method, route, controllers)
           end
 
           # Get route and do some cleaning

data/lib/contrast/framework/manager.rb

@@ -64,25 +64,25 @@ module Contrast
       end
 
       def platform_version
-        framework_version = first_framework_result :version, ''
+        framework_version = first_framework_result(:version, '')
 
         Contrast::Framework::PlatformVersion.from_string(framework_version)
       end
 
       def platform_version_string
-        first_framework_result :version, ''
+        first_framework_result(:version, '')
       end
 
       def server_type
-        first_framework_result :server_type, 'rack'
+        first_framework_result(:server_type, 'rack')
       end
 
       def app_name
-        first_framework_result :application_name, 'root'
+        first_framework_result(:application_name, 'root')
       end
 
       def app_root
-        found = first_framework_result :application_root, nil
+        found = first_framework_result(:application_root, nil)
         found || ::Rack::Directory.new('').root
       end
 
@@ -125,7 +125,7 @@ module Contrast
       # @return [Contrast::Api::Dtm::RouteCoverage] the current route as a Dtm.
       def get_route_dtm request
         @_frameworks.lazy.map { |framework_support| framework_support.current_route(request) }.
-            reject(&:nil?).first
+            reject(&:nil?).first # rubocop:disable Style/CollectionCompact
       end
 
       # Iterate through current frameworks and return the current request's route. This will be the first non-nil
@@ -135,7 +135,7 @@ module Contrast
       # @return [Contrast::Agent::Reporting::RouteCoverage] the current route as a Dtm.
       def get_route_information request
         @_frameworks.lazy.map { |framework_support| framework_support.current_route_coverage(request) }.
-            reject(&:nil?).first
+            reject(&:nil?).first # rubocop:disable Style/CollectionCompact
       end
 
       # Sometimes the framework we want to instrument is loaded after our agent code. To catch that case, we'll detect

data/lib/contrast/framework/manager_extend.rb

@@ -21,7 +21,7 @@ module Contrast
       end
 
       def routes_for_all_frameworks
-        data_for_all_frameworks :collect_routes
+        data_for_all_frameworks(:collect_routes)
       end
 
       # This returns an array of all data from each framework in a flat, no-nil values array

data/lib/contrast/framework/rack/patch/session_cookie.rb

@@ -25,7 +25,7 @@ module Contrast
             def instrument
               @_instrument ||= begin
                 ::Rack::Session::Cookie.class_eval do
-                  alias_method :cs__patched_initialize, :initialize
+                  alias_method(:cs__patched_initialize, :initialize)
                   def initialize app, options = {} # rubocop:disable Style/OptionHash
                     Contrast::Framework::Rack::Patch::SessionCookie.analyze(options)
                     cs__patched_initialize(app, options)

data/lib/contrast/framework/rails/patch/action_controller_live_buffer.rb

@@ -16,8 +16,19 @@ module Contrast
             def send_messages
               return unless (context = Contrast::Agent::REQUEST_TRACKER.current)
 
-              [context.server_activity, context.activity, context.observed_route].each do |msg|
-                Contrast::Agent.messaging_queue.send_event_immediately(msg)
+              if Contrast::Agent::Reporter.enabled?
+                [
+                  context.new_observed_route,
+                  Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.server_activity),
+                  Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity.library_usages),
+                  Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity)
+                ].each do |event|
+                  Contrast::Agent.reporter&.send_event_immediately(event)
+                end
+              else
+                [context.server_activity, context.activity, context.observed_route].each do |msg|
+                  Contrast::Agent.messaging_queue&.send_event_immediately(msg)
+                end
               end
             end
 
@@ -27,7 +38,7 @@ module Contrast
                   # normally pre->in->post filters are applied however, in a streamed response we can run into a case
                   # where it's pre -> in -> post -> more infilters in order to submit anything found during the
                   # infilters after the response has been written we need to explicitly send them
-                  alias_method :cs__close, :close
+                  alias_method(:cs__close, :close)
                   def close
                     Contrast::Framework::Rails::Patch::ActionControllerLiveBuffer.send_messages
                     cs__close

data/lib/contrast/framework/rails/patch/assess_configuration.rb

@@ -49,7 +49,7 @@ module Contrast
             end
 
             def apply_session_timeout *args
-              return if ::Contrast::ASSESS.rule_disabled? CS__SESSION_TIMEOUT_NAME
+              return if ::Contrast::ASSESS.rule_disabled?(CS__SESSION_TIMEOUT_NAME)
               return unless vulnerable_setting?(:expire_after, SAFE_SESSION_TIMEOUT, args,
                                                 comparison_type: :greater_than, safe_default: false)
 
@@ -64,7 +64,7 @@ module Contrast
             end
 
             def apply_secure_cookie_disabled *args
-              return if ::Contrast::ASSESS.rule_disabled? CS__SECURE_RULE_NAME
+              return if ::Contrast::ASSESS.rule_disabled?(CS__SECURE_RULE_NAME)
               return unless vulnerable_setting?(:secure, true, args)
 
               rails_session_settings = args[1]
@@ -78,7 +78,7 @@ module Contrast
             end
 
             def apply_httponly_disabled *args
-              return if ::Contrast::ASSESS.rule_disabled? CS__HTTPONLY_RULE_NAME
+              return if ::Contrast::ASSESS.rule_disabled?(CS__HTTPONLY_RULE_NAME)
               return unless vulnerable_setting?(:httponly, true, args)
 
               rails_session_settings = args[1]

data/lib/contrast/framework/rails/patch/rails_application_configuration.rb

@@ -14,7 +14,7 @@ module Contrast
           def self.instrument
             @_instrument ||= begin
               ::Rails::Application::Configuration.class_eval do
-                alias_method :cs__patched_session_store, :session_store
+                alias_method(:cs__patched_session_store, :session_store)
                 def session_store *args, **kwargs
                   ret = cs__patched_session_store(*args, **kwargs)
                   Contrast::Framework::Rails::Patch::AssessConfiguration.analyze_session_store(*args, **kwargs)

data/lib/contrast/framework/rails/patch/support.rb

@@ -20,56 +20,24 @@ module Contrast
             # (i.e., where we normally patch) we will miss the configuration
             # and will never be able to report session misconfiguration rules.
             Contrast::Framework::Rails::Patch::RailsApplicationConfiguration.instrument
-            require 'contrast/framework/rails/railtie' if ::Rails::VERSION::MAJOR.to_i >= 3
+            require('contrast/framework/rails/railtie') if ::Rails::VERSION::MAJOR.to_i >= 3
           end
 
           # (See BaseSupport#after_load_patches)
           def after_load_patches
-            patches = Set.new([
-                                Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
-                                    'ActionController::Live::Buffer',
-                                    'contrast/framework/rails/patch/action_controller_live_buffer',
-                                    instrumenting_module:
-                                      'Contrast::Framework::Rails::Patch::ActionControllerLiveBuffer'),
-                                Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
-                                    'Rails::Application::Configuration',
-                                    'contrast/framework/rails/patch/rails_application_configuration',
-                                    method_to_instrument: :session_store,
-                                    instrumenting_module:
-                                      'Contrast::Framework::Rails::Patch::RailsApplicationConfiguration')
-                              ])
-            patches.merge(special_after_load_patches) if RUBY_VERSION < '2.6.0'
-            patches
-          end
-
-          def special_after_load_patches
-            [
-              # TODO: RUBY-714 remove w/ EOL of 2.5
-              #
-              # @deprecated  Everything past here is used for Rewriting and can
-              #   be removed once we no longer support 2.5.
-              Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
-                  'ActionController::Railties::Helper::ClassMethods',
-                  'contrast/framework/rails/rewrite/action_controller_railties_helper_inherited',
-                  method_to_instrument: :inherited,
-                  instrumenting_module:
-                    'Contrast::Framework::Rails::Rewrite::ActionControllerRailtiesHelperInherited'),
-              Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
-                  'ActiveRecord::AttributeMethods::Read::ClassMethods',
-                  'contrast/framework/rails/rewrite/active_record_attribute_methods_read',
-                  instrumenting_module:
-                    'Contrast::Framework::Rails::Rewrite::ActiveRecordAttributeMethodsRead'),
-              Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
-                  'ActiveRecord::Scoping::Named::ClassMethods',
-                  'contrast/framework/rails/rewrite/active_record_named',
-                  instrumenting_module: 'Contrast::Framework::Rails::Rewrite::ActiveRecordNamed'),
-              Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
-                  'ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods',
-                  'contrast/framework/rails/rewrite/active_record_time_zone_inherited',
-                  method_to_instrument: :inherited,
-                  instrumenting_module:
-                    'Contrast::Framework::Rails::Rewrite::ActiveRecordTimeZoneInherited')
-            ]
+            Set.new([
+                      Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
+                          'ActionController::Live::Buffer',
+                          'contrast/framework/rails/patch/action_controller_live_buffer',
+                          instrumenting_module:
+                            'Contrast::Framework::Rails::Patch::ActionControllerLiveBuffer'),
+                      Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
+                          'Rails::Application::Configuration',
+                          'contrast/framework/rails/patch/rails_application_configuration',
+                          method_to_instrument: :session_store,
+                          instrumenting_module:
+                            'Contrast::Framework::Rails::Patch::RailsApplicationConfiguration')
+                    ])
           end
         end
       end

data/lib/contrast/framework/rails/support.rb

@@ -104,7 +104,7 @@ module Contrast
             end
 
             new_route_coverage = Contrast::Agent::Reporting::RouteCoverage.new
-            new_route_coverage.attach_rails_data route, original_url
+            new_route_coverage.attach_rails_data(route, original_url)
           rescue StandardError => e
             logger.warn('Unable to determine the current route of this request', e)
             nil
@@ -153,7 +153,7 @@ module Contrast
             # If the current routing node points to a sub-app (::Rais::Engine), dive deeper.
             # Have sub-app route the remainder of the url.
             if engine_route?(route)
-              new_req = retrieve_request request.env
+              new_req = retrieve_request(request.env)
               new_req.path_info = new_req.path_info.gsub(match.to_s, '')
               get_full_route(new_req, route.app.app.routes.router, path << match.to_s)
             else

data/lib/contrast/framework/sinatra/support.rb

@@ -101,7 +101,7 @@ module Contrast
             full_route ||= request.env[::Rack::PATH_INFO]
 
             new_route_coverage = Contrast::Agent::Reporting::RouteCoverage.new
-            new_route_coverage.attach_rack_based_data final_controller, method, route_pattern, full_route
+            new_route_coverage.attach_rack_based_data(final_controller, method, route_pattern, full_route)
           end
 
           # Search object space for sinatra controllers--any class that subclasses ::Sinatra::Base.

data/lib/contrast/logger/aliased_logging.rb

@@ -0,0 +1,94 @@
+# 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/events/exceptions/telemetry_exceptions'
+require 'contrast/agent/telemetry/events/exceptions/obfuscate'
+
+module Contrast
+  module Logger
+    # Our decorator for the Ougai logger allowing for the catching, creating and saving Telemetry exceptions
+    module AliasedLogging
+      ALIASED_WARN = 'warn'.cs__freeze
+      ALIASED_ERROR = 'error'.cs__freeze
+      ALIASED_FATAL = 'fatal'.cs__freeze
+
+      # @param message [String] The message to log. Use default_message if not specified.
+      # @param exception [Exception] The exception or the error
+      # @param data [Object] Any structured data
+      def warn message = nil, exception = nil, data = nil, &block
+        # build Telemetry Exclusion
+        build_exclusion(ALIASED_WARN, message, exception, data)
+        super(message, exception, data, &block)
+      end
+
+      # @param message [String] The message to log. Use default_message if not specified.
+      # @param exception [Exception] The exception or the error
+      # @param data [Object] Any structured data
+      def error message = nil, exception = nil, data = nil, &block
+        # build Telemetry Exclusion
+        build_exclusion(ALIASED_ERROR, message, exception, data)
+        super(message, exception, data, &block)
+      end
+
+      # @param message [String] The message to log. Use default_message if not specified.
+      # @param exception [Exception] The exception or the error
+      # @param data [Object] Any structured data
+      def fatal message = nil, exception = nil, data = nil, &block
+        # build Telemetry Exclusion
+        build_exclusion(ALIASED_FATAL, message, exception, data)
+        super(message, exception, data, &block)
+      end
+
+      private
+
+      def build_exclusion _type, _message = nil, _exception = nil, _data = nil
+        # TODO: RUBY-1698
+        nil
+        #   start = caller_locations&.find_index { |stack| stack.to_s.include?(type) }
+        #   stack_trace = start ? caller_locations(start + 1, 20) : caller_locations(20, 20)
+        #   stack_frame_type = Contrast::Agent::Telemetry::TelemetryException::Obfuscate.obfuscate_type(
+        #       stack_trace[1].path.delete_prefix(Dir.pwd))
+        #   message_exception_type = Contrast::Agent::Telemetry::TelemetryException::Obfuscate.obfuscate_exception_type(
+        #       exception ? exception.cs__class.to_s : stack_frame_type.split('/').last)
+        #   stack_frame_function = stack_trace[1].label
+        #   key = "#{ stack_frame_type }|#{ stack_frame_function }|#{ message }"
+        #   if TELEMETRY_EXCEPTIONS[key]
+        #     TELEMETRY_EXCEPTIONS.increment(key)
+        #     return
+        #   end
+        #
+        #   event_message = create_message(stack_frame_function,
+        #                                  stack_frame_type, message_exception_type,
+        #                                  data, exception,
+        #                                  message)
+        #   TELEMETRY_EXCEPTIONS[key] = event_message
+        # rescue StandardError => e
+        #   debug('Unable to report exception to telemetry', e)
+      end
+
+      def create_message stack_frame_function, stack_frame_type, message_exception_type, data, exception, message
+        message_for_exception = if exception
+                                  exception.cs__respond_to?(:message) ? exception.message : exception
+                                else
+                                  message
+                                end
+        module_name = message_exception_type ? message_exception_type.split('::')[0] : nil
+        stack_frame = Contrast::Agent::Telemetry::TelemetryException::StackFrame.build(stack_frame_function,
+                                                                                       stack_frame_type,
+                                                                                       module_name)
+        message_exception = Contrast::Agent::Telemetry::TelemetryException::MessageException.build(
+            message_exception_type,
+            message_for_exception,
+            module_name,
+            stack_frame)
+        tags = if data
+                 data
+               else
+                 exception.cs__is_a?(Hash) ? exception : {}
+               end
+        message = Contrast::Agent::Telemetry::TelemetryException::Message.build(tags, [message_exception])
+        Contrast::Agent::Telemetry::TelemetryException::Event.new(message)
+      end
+    end
+  end
+end