contrast-agent 5.2.0 → 6.1.0

data/lib/contrast/config/ruby_configuration.rb

@@ -3,9 +3,10 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # specific settings that apply to Ruby
-    class RubyConfiguration < BaseConfiguration
+    # Common Configuration settings. Those in this section pertain to the specific settings that apply to Ruby
+    class RubyConfiguration
+      include Contrast::Config::BaseConfiguration
+
       DISABLED_RAKE_TASK_LIST = %w[
         about assets:clean assets:clobber assets:environment
         assets:precompile assets:precompile:all db:create db:drop db:fixtures:load db:migrate
@@ -23,16 +24,16 @@ module Contrast
                   :track_frozen_sources, :non_request_tracking, :uninstrument_namespace
 
       def initialize hsh = {}
-        @disabled_agent_rake_tasks = traverse_config(hsh, :disabled_agent_rake_tasks)
-        @exceptions = Contrast::Config::ExceptionConfiguration.new(traverse_config(hsh, :exceptions))
-        @interpolate = traverse_config(hsh, :interpolate)
-        @propagate_yield = traverse_config(hsh, :propagate_yield)
-        @require_scan = traverse_config(hsh, :require_scan)
-        @track_frozen_sources = traverse_config(hsh, :track_frozen_sources)
-        @non_request_tracking = traverse_config(hsh, :non_request_tracking)
-        @uninstrument_namespace = traverse_config(hsh, :uninstrument_namespace)
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @disabled_agent_rake_tasks = hsh[:disabled_agent_rake_tasks]
+        @exceptions = Contrast::Config::ExceptionConfiguration.new(hsh[:exceptions])
+        @interpolate = hsh[:interpolate]
+        @propagate_yield = hsh[:propagate_yield]
+        @require_scan = hsh[:require_scan]
+        @track_frozen_sources = hsh[:track_frozen_sources]
+        @non_request_tracking = hsh[:non_request_tracking]
+        @uninstrument_namespace = hsh[:uninstrument_namespace]
       end
 
       # These commands being detected will result the agent disabling instrumentation, generally any command
@@ -82,40 +83,6 @@ module Contrast
       def uninstrument_namespace
         @uninstrument_namespace.nil? ? DEFAULT_UNINSTRUMENTED_NAMESPACES : @uninstrument_namespace
       end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
-      end
     end
   end
 end

data/lib/contrast/config/sampling_configuration.rb

@@ -3,9 +3,10 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # sampling functionality of the Agent.
-    class SamplingConfiguration < BaseConfiguration
+    # Common Configuration settings. Those in this section pertain to the sampling functionality of the Agent.
+    class SamplingConfiguration
+      include Contrast::Config::BaseConfiguration
+
       # @return [Integer, nil]
       attr_reader :baseline
       # @return [Integer, nil]
@@ -16,72 +17,18 @@ module Contrast
       attr_reader :window_ms
 
       def initialize hsh = {}
-        @enable = traverse_config(hsh, :enable)
-        @baseline = traverse_config(hsh, :baseline)
-        @request_frequency = traverse_config(hsh, :request_frequency)
-        @response_frequency = traverse_config(hsh, :response_frequency)
-        @window_ms = traverse_config(hsh, :window_ms)
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @enable = hsh[:enable]
+        @baseline = hsh[:baseline]
+        @request_frequency = hsh[:request_frequency]
+        @response_frequency = hsh[:response_frequency]
+        @window_ms = hsh[:window_ms]
       end
 
       # @return [Boolean, false]
       def enable
-        @enable.nil? ? false : @enable
-      end
-
-      def enable= value
-        self['enable'] = value
-      end
-
-      def baseline= value
-        self['baseline'] = value
-      end
-
-      def request_frequency= value
-        self['request_frequency'] = value
-      end
-
-      def response_frequency= value
-        self['response_frequency'] = value
-      end
-
-      def window_ms= value
-        self['window_ms'] = value
-      end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
+        !!@enable
       end
     end
   end

data/lib/contrast/config/server_configuration.rb

@@ -3,9 +3,11 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # server identification functionality of the Agent.
-    class ServerConfiguration < BaseConfiguration
+    # Common Configuration settings. Those in this section pertain to the server identification functionality of the
+    # Agent.
+    class ServerConfiguration
+      include Contrast::Config::BaseConfiguration
+
       # @return [String, nil]
       attr_accessor :name
       # @return [String, nil]
@@ -20,48 +22,14 @@ module Contrast
       attr_accessor :version
 
       def initialize hsh = {}
-        @path = traverse_config(hsh, :path)
-        @name = traverse_config(hsh, :name)
-        @type = traverse_config(hsh, :type)
-        @tags = traverse_config(hsh, :tags)
-        @environment = traverse_config(hsh, :environment)
-        @version = traverse_config(hsh, :version)
-        @configuration_map = {}
-        build_configuration_map
-      end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
+        return unless hsh
+
+        @path = hsh[:path]
+        @name = hsh[:name]
+        @type = hsh[:type]
+        @tags = hsh[:tags]
+        @environment = hsh[:environment]
+        @version = hsh[:version]
       end
     end
   end

data/lib/contrast/config/service_configuration.rb

@@ -5,25 +5,44 @@ require 'contrast/config/logger_configuration'
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # communication between the Agent & the Service.
-    class ServiceConfiguration < BaseConfiguration
-      # We don't set these b/c we've been asked to handle the default values of
-      # these settings differently, logging when we have to use them.
-      DEFAULT_HOST       = '127.0.0.1'
+    # Common Configuration settings. Those in this section pertain to the communication between the Agent & the Service
+    class ServiceConfiguration
+      include Contrast::Config::BaseConfiguration
+
+      # We don't set these b/c we've been asked to handle the default values of these settings differently, logging
+      # when we have to use them.
+      DEFAULT_HOST       = '127.0.0.1' # rubocop:disable Style/IpAddresses
       DEFAULT_PORT       = '30555'
 
-      KEYS = {
-          enable: EMPTY_VALUE,
-          host: EMPTY_VALUE,
-          port: EMPTY_VALUE,
-          socket: EMPTY_VALUE,
-          logger: Contrast::Config::LoggerConfiguration,
-          bypass: false
-      }.cs__freeze
-
-      def initialize hsh
-        super(hsh, KEYS)
+      attr_writer :logger, :bypass
+      # @return [String, nil]
+      attr_accessor :socket
+      # @return [String, nil]
+      attr_accessor :port
+      # @return [String, nil]
+      attr_accessor :host
+      # @return [Boolean, nil]
+      attr_accessor :enable
+
+      def initialize hsh = {}
+        return unless hsh
+
+        @enable = hsh[:enable]
+        @host = hsh[:host]
+        @port = hsh[:port]
+        @socket = hsh[:socket]
+        @logger = Contrast::Config::LoggerConfiguration.new(hsh[:logger])
+        @bypass = hsh[:bypass]
+      end
+
+      # @return [Contrast::Config::LoggerConfiguration]
+      def logger
+        @logger ||= Contrast::Config::LoggerConfiguration.new
+      end
+
+      # @return [Boolean, false]
+      def bypass
+        @bypass.nil? ? false : @bypass
       end
     end
   end

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
@@ -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
@@ -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/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/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/manager.rb

@@ -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/rails/patch/support.rb

@@ -25,51 +25,19 @@ module Contrast
 
           # (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/logger/aliased_logging.rb

@@ -0,0 +1,87 @@
+# 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'
+
+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
+        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 = stack_trace[1].path.delete_prefix(Dir.pwd)
+        message_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 = exception ? exception.cs__class.to_s.split('::').first : 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

data/lib/contrast/logger/application.rb

@@ -1,8 +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/utils/exclude_key'
-
 module Contrast
   module Logger
     # Our decorator for the Ougai logger allowing for the logging of the
@@ -19,7 +17,7 @@ module Contrast
           env_key = env_key.to_s
           next unless ENV_KEYS.include?(env_key) ||
               (env_key.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER) &&
-                  !env_key.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER + 'API'))
+                  !env_key.start_with?("#{ Contrast::Components::Config::CONTRAST_ENV_MARKER }API"))
 
           info('Environment settings', key: env_key, value: env_value)
         end
@@ -31,8 +29,6 @@ module Contrast
         loggable = ::Contrast::CONFIG.loggable
         info('Current configuration', configuration: loggable)
         env_keys = ENV.keys.select do |env_key|
-          next if Contrast::Utils::ExcludeKey.excludable? env_key.to_s
-
           env_key&.to_s&.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER)
         end
         env_items = env_keys.map { |env_key| Contrast::Utils::EnvConfigurationItem.new(env_key, nil) }

data/lib/contrast/logger/cef_log.rb

@@ -142,7 +142,7 @@ module Contrast
                                    "as suspicious using #{ rule_id } - #{ input_value }"
           log [suspicious_attack_with, rule_id, outcome], ::Logger::WARN
         elsif input_value.present?
-          suspicious_attack_without = 'Suspicious activity indicates a potential attack using ' + rule_id.to_s
+          suspicious_attack_without = "Suspicious activity indicates a potential attack using #{ rule_id }"
           log [suspicious_attack_without, rule_id, outcome], ::Logger::WARN
         end
       end