contrast-agent 6.3.0 → 6.5.1

data/lib/contrast/config/assess_configuration.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/sampling'
+
 module Contrast
   module Config
     # Common Configuration settings. Those in this section pertain to the
@@ -15,6 +17,10 @@ module Contrast
       attr_writer :enable_scan_response, :enable_dynamic_sources, :sampling, :rules, :stacktraces
 
       DEFAULT_STACKTRACES = 'ALL'
+      DEFAULT_MAX_SOURCE_EVENTS = 50_000
+      DEFAULT_MAX_PROPAGATION_EVENTS = 50_000
+      DEFAULT_MAX_RULE_REPORTED = 50_000
+      DEFAULT_MAX_RULE_TIME_THRESHOLD = 300_000
 
       def initialize hsh = {}
         return unless hsh
@@ -24,9 +30,13 @@ module Contrast
         @enable_scan_response = hsh[:enable_scan_response]
         @enable_dynamic_sources = hsh[:enable_dynamic_sources]
         @enable_original_object = hsh[:enable_original_object]
-        @sampling = Contrast::Config::SamplingConfiguration.new(hsh[:sampling])
+        @sampling = Contrast::Components::Sampling::Interface.new(hsh[:sampling])
         @rules = Contrast::Config::AssessRulesConfiguration.new(hsh[:rules])
         @stacktraces = hsh[:stacktraces]
+        @max_context_source_events = hsh[:max_context_source_events]
+        @max_propagation_events = hsh[:max_propagation_events]
+        @max_rule_reported = hsh[:max_rule_reported]
+        @time_limit_threshold = hsh[:time_limit_threshold]
       end
 
       # @return [Boolean, true]
@@ -44,9 +54,9 @@ module Contrast
         @enable_original_object.nil? ? true : @enable_original_object
       end
 
-      # @return [Contrast::Config::SamplingConfiguration]
+      # @return [Contrast::Components::Sampling::Interface]
       def sampling
-        @sampling ||= Contrast::Config::SamplingConfiguration.new
+        @sampling ||= Contrast::Components::Sampling::Interface.new
       end
 
       # @return [Contrast::Config::AssessRulesConfiguration]
@@ -58,6 +68,26 @@ module Contrast
       def stacktraces
         @stacktraces ||= DEFAULT_STACKTRACES
       end
+
+      # @return [int] max number of context source events in single request
+      def max_context_source_events
+        @max_context_source_events ||= DEFAULT_MAX_SOURCE_EVENTS
+      end
+
+      # @return [int] max number of propagation events in single request
+      def max_propagation_events
+        @max_propagation_events ||= DEFAULT_MAX_PROPAGATION_EVENTS
+      end
+
+      # @return [int] max number of rules reported within time_limit_threshold
+      def max_rule_reported
+        @max_rule_reported ||= DEFAULT_MAX_RULE_REPORTED
+      end
+
+      # @return [int] max ms threshold for reporting rules
+      def time_limit_threshold
+        @time_limit_threshold ||= DEFAULT_MAX_RULE_TIME_THRESHOLD
+      end
     end
   end
 end

data/lib/contrast/config/base_configuration.rb

@@ -10,12 +10,18 @@ module Contrast
     # Configuration settings to usable Ruby classes.
     module BaseConfiguration
       extend Forwardable
+      AT_UNDERSCORE = '@_'
 
       def to_hash
         hsh = {}
         instance_variables.each do |iv|
-          # strip the '@' to get the key
-          key = iv.to_s[1..]
+          # strip the '@' of '@_' to get the key
+          string_iv = iv.to_s
+          key = if string_iv.include?(AT_UNDERSCORE)
+                  string_iv[2..]
+                else
+                  string_iv[1..]
+                end
           hsh[key] = send(key.to_sym)
         end
         hsh

data/lib/contrast/config/root_configuration.rb

@@ -1,15 +1,18 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/agent'
+require 'contrast/components/inventory'
+require 'contrast/components/protect'
 module Contrast
   module Config
     # The base of the Common Configuration settings.
     class RootConfiguration
       include Contrast::Config::BaseConfiguration
 
-      # @return [Contrast::Config::ApiConfiguration]
+      # @return [Contrast::Components::Api::Interface]
       attr_writer :api
-      # @return [Contrast::Config::AgentConfiguration]
+      # @return [Contrast::Components::Agent::Interface]
       attr_writer :agent
       # @return [Contrast::Config::ApplicationConfiguration]
       attr_writer :application
@@ -17,9 +20,9 @@ module Contrast
       attr_writer :server
       # @return [Contrast::Config::AssessConfiguration]
       attr_writer :assess
-      # @return [Contrast::Config::InventoryConfiguration]
+      # @return [Contrast::Components::Inventory::Interface]
       attr_writer :inventory
-      # @return [Contrast::Config::ProtectConfiguration]
+      # @return [Contrast::Components::Protect::Interface]
       attr_writer :protect
       # @return [Contrast::Config::ServiceConfiguration]
       attr_writer :service
@@ -30,25 +33,25 @@ module Contrast
       def initialize hsh = {}
         raise(ArgumentError, 'Expected a hash') unless hsh.is_a?(Hash)
 
-        @api = Contrast::Config::ApiConfiguration.new(hsh[:api])
+        @api = Contrast::Components::Api::Interface.new(hsh[:api])
         @enable = hsh[:enable]
-        @agent = Contrast::Config::AgentConfiguration.new(hsh[:agent])
+        @agent = Contrast::Components::Agent::Interface.new(hsh[:agent])
         @application = Contrast::Config::ApplicationConfiguration.new(hsh[:application])
         @server = Contrast::Config::ServerConfiguration.new(hsh[:server])
         @assess = Contrast::Config::AssessConfiguration.new(hsh[:assess])
-        @inventory = Contrast::Config::InventoryConfiguration.new(hsh[:inventory])
-        @protect = Contrast::Config::ProtectConfiguration.new(hsh[:protect])
+        @inventory = Contrast::Components::Inventory::Interface.new(hsh[:inventory])
+        @protect = Contrast::Components::Protect::Interface.new(hsh[:protect])
         @service = Contrast::Config::ServiceConfiguration.new(hsh[:service])
       end
 
-      # @return [Contrast::Config::ApiConfiguration]
+      # @return [Contrast::Components::Api::Interface]
       def api
-        @api ||= Contrast::Config::ApiConfiguration.new
+        @api ||= Contrast::Components::Api::Interface.new
       end
 
-      # @return [Contrast::Config::AgentConfiguration]
+      # @return [Contrast::Components::Agent::Interface]
       def agent
-        @agent ||= Contrast::Config::AgentConfiguration.new
+        @agent ||= Contrast::Components::Agent::Interface.new
       end
 
       # @return [Contrast::Config::ApplicationConfiguration]
@@ -66,14 +69,14 @@ module Contrast
         @assess ||= Contrast::Config::AssessConfiguration.new
       end
 
-      # @return [Contrast::Config::InventoryConfiguration]
+      # @return [Contrast::Components::Inventory::Interface]
       def inventory
-        @inventory ||= Contrast::Config::InventoryConfiguration.new
+        @inventory ||= Contrast::Components::Inventory::Interface.new
       end
 
-      # @return [Contrast::Config::ProtectConfiguration]
+      # @return [Contrast::Components::Protect::Interface]
       def protect
-        @protect ||= Contrast::Config::ProtectConfiguration.new
+        @protect ||= Contrast::Components::Protect::Interface.new
       end
 
       # @return [Contrast::Config::ServiceConfiguration]

data/lib/contrast/config/service_configuration.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
-require 'contrast/config/logger_configuration'
+require 'contrast/components/logger'
 
 module Contrast
   module Config
@@ -31,13 +31,13 @@ module Contrast
         @host = hsh[:host]
         @port = hsh[:port]
         @socket = hsh[:socket]
-        @logger = Contrast::Config::LoggerConfiguration.new(hsh[:logger])
+        @logger = Contrast::Components::Logger::Interface.new(hsh[:logger])
         @bypass = hsh[:bypass]
       end
 
-      # @return [Contrast::Config::LoggerConfiguration]
+      # @return [Contrast::Components::Logger::Interface]
       def logger
-        @logger ||= Contrast::Config::LoggerConfiguration.new
+        @logger ||= Contrast::Components::Logger::Interface.new
       end
 
       # @return [Boolean, false]

data/lib/contrast/config.rb

@@ -11,23 +11,14 @@ module Contrast
 end
 
 require 'contrast/config/base_configuration'
-
-require 'contrast/config/logger_configuration'
-
-require 'contrast/config/heap_dump_configuration'
 require 'contrast/config/service_configuration'
 require 'contrast/config/exception_configuration'
 require 'contrast/config/assess_rules_configuration'
 require 'contrast/config/protect_rule_configuration'
 require 'contrast/config/protect_rules_configuration'
-require 'contrast/config/sampling_configuration'
 
 require 'contrast/config/ruby_configuration'
-require 'contrast/config/api_configuration'
-require 'contrast/config/agent_configuration'
 require 'contrast/config/application_configuration'
 require 'contrast/config/server_configuration'
 require 'contrast/config/assess_configuration'
-require 'contrast/config/inventory_configuration'
-require 'contrast/config/protect_configuration'
 require 'contrast/config/root_configuration'

data/lib/contrast/extension/object.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+# Some developers override various methods on Object, which can often involve
+# changing expected method parity/behavior which in turn prevents us from being
+# able to reliably use affected methods.
+# We alias these method so that we always have access to them.
+#
+# Because we use these methods in constructing classes (e.g., calling #freeze
+# on constants within class definitions) we do this aliasing ASAP.
+class Object
+  alias_method :cs__class, :class
+  alias_method :cs__freeze, :freeze
+  alias_method :cs__frozen?, :frozen?
+  alias_method :cs__is_a?, :is_a?
+  alias_method :cs__method, :method
+  alias_method :cs__respond_to?, :respond_to?
+  alias_method :cs__singleton_class, :singleton_class
+end

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

@@ -135,8 +135,11 @@ module Contrast
           # @return [bool] whether the router is an engine or not.
           def engine_route? route
             return false unless route&.app&.app
+            return false unless route.app.is_a?(::ActionDispatch::Routing::Mapper::Constraints) ||
+                route.app.is_a?(::ActionDispatch::Routing::RouteSet::Dispatcher)
 
-            route.app.is_a?(::ActionDispatch::Routing::Mapper::Constraints) && route.app.app < ::Rails::Engine
+            clazz = route.app.app.is_a?(Class) ? route.app.app : route.app.app.cs__class
+            clazz < ::Rails::Engine
           end
 
           # Recursively get final route traversing engines as required. Because this can only be called once, we store

data/lib/contrast/logger/log.rb

@@ -134,7 +134,8 @@ module Contrast
 
         enable_trace_timing if current_level_const == ::Ougai::Logging::TRACE
 
-        @_logger = build(path: current_path, level_const: current_level_const)
+        progname = Contrast::CONFIG.root.agent.logger.progname
+        @_logger = build(path: current_path, level_const: current_level_const, progname: progname)
         # If we're logging to a new path, then let's start it w/ our helpful
         # data gathering messages
         log_update if path_change

data/lib/contrast/utils/assess/event_limit_utils.rb

@@ -0,0 +1,96 @@
+# 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
+    module Assess
+      # EventLimitUtils is used to check and validate the number of source, propagation, or trigger events collected
+      # during the reporting time frame
+      module EventLimitUtils
+        include Contrast::Components::Logger::InstanceMethods
+        # Checks to see if the event limit for the policy type has been met or exceeded
+        # @param method_policy [Contrast::Agent::Patching::Policy::MethodPolicy] method to check for event limit
+        def event_limit? method_policy
+          return false unless (context = Contrast::Agent::REQUEST_TRACKER.current)
+
+          if method_policy.source_node
+            max =  (::Contrast::ASSESS.max_source_events ||
+              Contrast::Config::AssessConfiguration::DEFAULT_MAX_SOURCE_EVENTS)
+            return at_limit?(method_policy, context.source_event_count, max)
+
+          end
+          if method_policy.propagation_node
+            max = (::Contrast::ASSESS.max_propagation_events ||
+              Contrast::Config::AssessConfiguration::DEFAULT_MAX_PROPAGATION_EVENTS)
+            return at_limit?(method_policy, context.propagation_event_count, max)
+          end
+
+          false # policy does not have limit
+        end
+
+        def event_limit_for_rule? rule_id
+          if Contrast::Utils::Timer.now_ms > threshold_time_limit
+            @_rule_counts = nil
+            @_threshold_time_limit = nil
+            threshold_time_limit
+          end
+          rule_counts[rule_id] += 1
+          # TODO: RUBY-1680 remove default
+          rule_counts[rule_id] >=
+              (::Contrast::ASSESS.max_rule_reported || Contrast::Config::AssessConfiguration::DEFAULT_MAX_RULE_REPORTED)
+        end
+
+        # Increments the event count for the type of event that is being tracked
+        #
+        # @param node [Contrast::Agent::Assess::Policy::PolicyNode] policy to increment
+        def increment_event_count node
+          return unless (context = Contrast::Agent::REQUEST_TRACKER.current)
+
+          context.source_event_count += 1 if node.cs__is_a?(Contrast::Agent::Assess::Policy::SourceNode)
+          context.propagation_event_count += 1 if node.cs__is_a?(Contrast::Agent::Assess::Policy::PropagationNode)
+        end
+
+        private
+
+        # helper method to check limit and log when necessary
+        def at_limit? method_policy, current_count, event_max
+          if current_count == event_max
+            logger.warn('Event Limit Reached:',
+                        {
+                            count: current_count,
+                            max: event_max,
+                            policy: method_policy.method_name,
+                            node: method_policy
+                        })
+            # increment to be over count for logging purposes
+            increment_event_count(method_policy)
+            return true
+          elsif current_count > event_max
+            # increment to be over count for logging purposes
+            increment_event_count(method_policy)
+            logger.warn('Event Limit Exceeded:',
+                        {
+                            count: current_count,
+                            policy: method_policy.method_name,
+                            node: method_policy
+                        })
+            return true
+          end
+          false
+        end
+
+        def rule_counts
+          @_rule_counts ||= Hash.new { |h, k| h[k] = 0 }
+        end
+
+        # the time threshold for which to track rule counts resets when now >= threshold_time_limit
+        # @return [Integer]
+        def threshold_time_limit
+          @_threshold_time_limit ||= Contrast::Utils::Timer.now_ms + (::Contrast::ASSESS.time_limit_threshold || 0)
+        end
+      end
+    end
+  end
+end

data/lib/contrast/utils/assess/propagation_method_utils.rb

@@ -92,20 +92,24 @@ module Contrast
         # @param preshift [Contrast::Agent::Assess::PreShift] The capture of the state of the code just prior to
         #   the invocation of the patched method.
         # @param target [Object] the thing to which to propagate
+        # @param propagation_data [Contrast::Agent::Assess::Events::EventData] this will hold the
+        #                         object [Object] the Object on which the method was invoked
+        #                         args [Array<Object>] the Arguments with which the method was invoked
         # @return [Boolean]
-        def can_propagate? propagation_node, preshift, target
+        def can_propagate? propagation_node, preshift, target, propagation_data
           return false unless appropriate_target?(propagation_node, target)
           return true if Contrast::Utils::Assess::TrackingUtil.tracked?(target)
-          if propagation_node.use_original_object?
-            # return true since we don't have preshift while using the original object.
-            return true
-          end
-          return false unless preshift
+          return false unless appropriate_source?(propagation_node, propagation_data, preshift)
 
           propagation_node.sources.each do |source|
             case source
             when Contrast::Utils::ObjectShare::OBJECT_KEY
-              return true if Contrast::Utils::Assess::TrackingUtil.tracked?(preshift.object)
+              source_object = if propagation_node.use_original_object?
+                                propagation_data.object
+                              else
+                                preshift.object
+                              end
+              return true if Contrast::Utils::Assess::TrackingUtil.tracked?(source_object)
             else
               # has to be P, there's no ret source type (yet? ever?)
               return true if preshift.args && Contrast::Utils::Assess::TrackingUtil.tracked?(preshift.args[source])
@@ -129,6 +133,22 @@ module Contrast
 
           Contrast::Agent::Assess::Tracker.trackable?(target)
         end
+
+        # A source is appropriate if it is available for propagation
+        #
+        # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode] the node that governs this
+        #   propagation event.
+        # @param propagation_data [Contrast::Agent::Assess::Events::EventData] this will hold the
+        #                         object [Object] the Object on which the method was invoked
+        #                         args [Array<Object>] the Arguments with which the method was invoked
+        # @param preshift [Contrast::Agent::Assess::PreShift] The capture of the state of the code just prior to
+        #   the invocation of the patched method.
+        # @return [Boolean]
+        def appropriate_source? propagation_node, propagation_data, preshift
+          return true if preshift
+
+          propagation_node.use_original_object? && propagation_data&.object
+        end
       end
     end
   end

data/lib/contrast/utils/log_utils.rb

@@ -19,7 +19,7 @@ module Contrast
 
       private
 
-      def build path: STDOUT_STR, level_const: DEFAULT_LEVEL
+      def build path: STDOUT_STR, level_const: DEFAULT_LEVEL, progname: PROGNAME
         logger = case path
                  when STDOUT_STR, STDERR_STR
                    ::Ougai::Logger.new(Object.cs__const_get(path))
@@ -27,7 +27,7 @@ module Contrast
                    ::Ougai::Logger.new(path)
                  end
         add_contrast_loggers(logger)
-        logger.progname = PROGNAME
+        logger.progname = progname
         logger.level = level_const
         logger.formatter = Contrast::Logger::Format.new
         logger.formatter.datetime_format = DATE_TIME_FORMAT

data/lib/contrast/utils/net_http_base.rb

@@ -131,7 +131,7 @@ module Contrast
                             end
         return initialize_client if addr.host.to_s.include?('localhost') # TODO: RUBY-99999 allow http w/ localhost
 
-        assign_cert(initialize_client) if use_custom_cert && Contrast::API.certification_enabled?
+        assign_cert(initialize_client) if use_custom_cert && Contrast::API.certification_enable
         initialize_client.use_ssl = true
         initialize_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
         initialize_client.verify_depth = 5
@@ -150,7 +150,7 @@ module Contrast
       def proxy_enabled?
         return @_proxy_enabled unless @_proxy_enabled.nil?
 
-        @_proxy_enabled = Contrast::API.proxy_enabled? && !Contrast::API.proxy_url.nil?
+        @_proxy_enabled = Contrast::API.proxy_enable && !Contrast::API.proxy_url.nil?
       end
 
       # Retrieve the IP address from the client.

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

@@ -7,18 +7,6 @@ module Contrast
       # This module will include all methods for different patch applies from Patch module and some other module
       # methods from the same place, so we can ease the main module
       module PatchUtils
-        # Method to choose which replaced return from the post_patch to actually return.
-        #
-        # @param propagated_ret [Object, nil] The replaced return from the propagation patch.
-        # @param source_ret [Object, nil] The replaced return from the source patch.
-        # @param ret [Object, nil] The original return of the patched method.
-        # @return [Object, nil] The thing to return from the post patch.
-        def handle_return propagated_ret, source_ret, ret
-          safe_return = propagated_ret || source_ret || ret
-          safe_return.rewind if Contrast::Utils::IOUtil.should_rewind?(safe_return)
-          safe_return
-        end
-
         # Given a module and method, construct an expected name for the alias by which Contrast will reference the
         # original.
         #
@@ -107,7 +95,7 @@ module Contrast
         # @param object [Object] The object on which the method is invoked, typically what would be returned by self.
         # @param args [Array<Object>] The arguments passed to the method being invoked.
         def apply_inventory method_policy, method, exception, object, args
-          return unless ::Contrast::INVENTORY.enabled?
+          return unless ::Contrast::INVENTORY.enable
 
           apply_trigger_only(method_policy&.inventory_node, method, exception, object, args)
         end
@@ -123,8 +111,6 @@ module Contrast
         # @param args [Array<Object>] The arguments passed to the method being invoked.
         # @param block [Proc] The block passed to the method that was invoked.
         def apply_assess method_policy, preshift, object, ret, args, block
-          source_ret = nil
-          propagated_ret = nil
           return ret unless method_policy && ::Contrast::ASSESS.enabled?
 
           current_context = Contrast::Agent::REQUEST_TRACKER.current
@@ -135,27 +121,24 @@ module Contrast
             Contrast::Agent::Assess::Policy::TriggerMethod.apply_trigger_rule(trigger_node, object, ret, args)
           end
           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.apply_source(method_policy, object, ret, args)
+            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(
+            Contrast::Agent::Assess::Policy::PropagationMethod.apply_propagation(
                 method_policy,
                 preshift,
                 object,
-                source_ret || ret,
+                ret,
                 args,
                 block)
           end
-          handle_return(propagated_ret, source_ret, ret)
         rescue StandardError => e
           logger.error('Unable to assess method call.', e)
-          handle_return(propagated_ret, source_ret, ret)
         rescue Exception => e # rubocop:disable Lint/RescueException
           logger.error('Unable to assess method call.', e)
-          handle_return(propagated_ret, source_ret, ret)
           raise(e)
+        ensure
+          ret.rewind if Contrast::Utils::IOUtil.should_rewind?(ret)
         end
 
         # Generic invocation of the Inventory or Protect patch which apply to the given method.

data/lib/contrast.rb

@@ -4,21 +4,39 @@
 # Used to prevent deprecation warnings from flooding stdout
 ENV['PB_IGNORE_DEPRECATIONS'] = 'true'
 
-# Some developers override various methods on Object, which can often involve
-# changing expected method parity/behavior which in turn prevents us from being
-# able to reliably use affected methods.
-# We alias these method so that we always have access to them.
-#
-# Because we use these methods in constructing classes (e.g., calling #freeze
-# on constants within class definitions) we do this aliasing ASAP.
-class Object
-  alias_method :cs__class, :class
-  alias_method :cs__freeze, :freeze
-  alias_method :cs__frozen?, :frozen?
-  alias_method :cs__is_a?, :is_a?
-  alias_method :cs__method, :method
-  alias_method :cs__respond_to?, :respond_to?
-  alias_method :cs__singleton_class, :singleton_class
+require 'contrast/extension/object'
+
+# ActiveRecord gives access to the `String#blank?` method, which we've started using. We need to make sure that method
+# actually exists.
+# From https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/object/blank.rb
+class String
+  unless cs__respond_to?(:blank?)
+
+    CS__BLANK_RE = /\A[[:space:]]*\z/.cs__freeze
+    # A string is blank if it's empty or contains whitespaces only:
+    #
+    #   ''.blank?       # => true
+    #   '   '.blank?    # => true
+    #   "\t\n\r".blank? # => true
+    #   ' blah '.blank? # => false
+    #
+    # Unicode whitespace is supported:
+    #
+    #   "\u00a0".blank? # => true
+    #
+    # @return [true, false]
+    def blank?
+      # The regexp that matches blank strings is expensive. For the case of empty
+      # strings we can speed up this method (~3.5x) with an empty? call. The
+      # penalty for the rest of strings is marginal.
+      empty? ||
+          begin
+            CS__BLANK_RE.match?(self)
+          rescue Encoding::CompatibilityError
+            false
+          end
+    end
+  end
 end
 
 if RUBY_VERSION >= '3.0.0' && RUBY_VERSION < '3.1.0'
@@ -50,17 +68,18 @@ require 'contrast/components/settings'
 require 'contrast/utils/telemetry_hash'
 require 'contrast/utils/telemetry'
 require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_event'
+require 'protobuf' # TODO: RUBY-1438
 
 module Contrast
-  API = Contrast::Components::Api::Interface.new
-  SCOPE = Contrast::Components::Scope::Interface.new
   CONFIG = Contrast::Components::Config::Interface.new
+  SCOPE = Contrast::Components::Scope::Interface.new
+  API = CONFIG.root.api
   SETTINGS = Contrast::Components::Settings::Interface.new
   ASSESS = Contrast::Components::Assess::Interface.new
   PROTECT = Contrast::Components::Protect::Interface.new
-  INVENTORY = Contrast::Components::Inventory::Interface.new
-  LOGGER = Contrast::Components::Logger::Interface.new
-  AGENT = Contrast::Components::Agent::Interface.new
+  INVENTORY = CONFIG.root.inventory
+  AGENT = CONFIG.root.agent
+  LOGGER = AGENT.logger
   CONTRAST_SERVICE = Contrast::Components::ContrastService::Interface.new
   APP_CONTEXT = Contrast::Components::AppContext::Interface.new
 end