contrast-agent 4.13.1 → 5.1.0

data/lib/contrast/agent/inventory/database_config.rb

@@ -1,9 +1,10 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
-require 'contrast/utils/timer'
-require 'contrast/utils/object_share'
+require 'contrast/api/decorators/architecture_component'
 require 'contrast/components/logger'
+require 'contrast/utils/object_share'
+require 'contrast/utils/timer'
 
 module Contrast
   module Agent
@@ -13,9 +14,6 @@ module Contrast
       module DatabaseConfig
         extend Contrast::Components::Logger::InstanceMethods
 
-        # TeamServer only accepts certain values for ArchitectureComponents.
-        # DO NOT CHANGE THIS!
-        AC_TYPE_DB = 'db'
         # TeamServer only accepts certain values for FlowMap Services.
         # DO NOT CHANGE THIS
         ADAPTER = 'adapter'
@@ -25,91 +23,131 @@ module Contrast
         DEFAULT = 'default'
         LOCALHOST = 'localhost'
 
-        def self.active_record_config
-          return @_active_record_config if instance_variable_defined?(:@_active_record_config)
+        class << self
+          # Append the available database connection information to the message being sent to TeamServer. This message
+          # may be a Contrast::Api::Dtm::Activity or Contrast::Api::Dtm::ApplicationUpdate. Both report the same
+          # Contrast::Api::Dtm::ArchitectureComponent, but have different names for their fields.
+          #
+          # @param activity_or_update [Contrast::Api::Dtm::Activity, Contrast::Api::Dtm::ApplicationUpdate]
+          # @param hash_or_str [Hash, String] the database connection information
+          def append_db_config activity_or_update, hash_or_str = active_record_config
+            arr = build_from_db_config(hash_or_str)
+            return unless arr&.any?
+
+            arr.each do |a|
+              next unless a
+
+              if activity_or_update.is_a?(Contrast::Api::Dtm::Activity)
+                activity_or_update.architectures << a
+              else
+                activity_or_update.components << a
+              end
+            end
+          rescue StandardError => e
+            logger.error('Unable to append db config', e)
+            nil
+          end
 
-          @_active_record_config = ActiveRecord::Base.connection_config rescue nil # rubocop:disable Style/RescueModifier
-        end
+          private
 
-        def self.append_db_config(activity_or_update,
-                                  hash_or_str = Contrast::Agent::Inventory::DatabaseConfig.active_record_config)
-          arr = build_from_db_config(hash_or_str)
-          return unless arr&.any?
+          # We capture the active record configuration used by this application, as reported by
+          # ActiveRecord::Base.connection_config, so that we can record it once and report it as needed.
+          #
+          # @return [Hash]
+          def active_record_config
+            return @_active_record_config if instance_variable_defined?(:@_active_record_config)
 
-          arr.each do |a|
-            next unless a
+            @_active_record_config = ActiveRecord::Base.connection_config rescue nil # rubocop:disable Style/RescueModifier
+          end
 
-            if activity_or_update.is_a?(Contrast::Api::Dtm::Activity)
-              activity_or_update.architectures << a
+          # The classes we instrument in order to determine which, if any, database(s) an application connects to take
+          # either a Hash or a String as a parameter. We install this one patch into all of those methods, letting our
+          # code here, rather than at the patch level, make the determination of which path to call. We'll make that
+          # decision and then parse the given configuration to create a Contrast::Api::Dtm::ArchitectureComponent for
+          # reporting.
+          #
+          # @param hash_or_str [Hash, String]
+          # @return [Contrast::Api::Dtm::ArchitectureComponent]
+          def build_from_db_config hash_or_str
+            return unless hash_or_str
+
+            if hash_or_str.is_a?(Hash)
+              build_from_db_hash(hash_or_str)
             else
-              activity_or_update.components << a
+              build_from_db_string(hash_or_str.to_s)
             end
           end
-        rescue StandardError => e
-          logger.error('Unable to append db config', e)
-          nil
-        end
 
-        def self.build_from_db_config hash_or_str
-          return unless hash_or_str
-
-          if hash_or_str.is_a?(Hash)
-            build_from_db_hash(hash_or_str)
-          else
-            build_from_db_string(hash_or_str.to_s)
+          # Convert the Hash used to create a database connection into an Contrast::Api::Dtm::ArchitectureComponent
+          # understandable by TeamServer.
+          #
+          # @param hash [Hash] the information used to open a database connection
+          # @return [Contrast::Api::Dtm::ArchitectureComponent]
+          def build_from_db_hash hash
+            ac = Contrast::Api::Dtm::ArchitectureComponent.build_database
+            ac.vendor = hash[:adapter] || hash[ADAPTER] || Contrast::Utils::ObjectShare::EMPTY_STRING
+            ac.remote_host = host_from_hash(hash)
+            ac.remote_port = port_from_hash(hash)
+            ac.url = hash[:database] || hash[DATABASE] || DEFAULT
+            [ac]
           end
-        end
 
-        def self.build_from_db_hash hash
-          ac = Contrast::Api::Dtm::ArchitectureComponent.new
-          ac.vendor = hash[:adapter] || hash[ADAPTER] || Contrast::Utils::ObjectShare::EMPTY_STRING
-          ac.remote_host = host_from_hash(hash)
-          ac.remote_port = port_from_hash(hash)
-          ac.type = AC_TYPE_DB
-          ac.url = hash[:database] || hash[DATABASE] || DEFAULT
-          [ac]
-        end
-
-        def self.host_from_hash hash
-          hash[:host] || hash[HOST] || Contrast::Utils::ObjectShare::EMPTY_STRING
-        end
-
-        def self.port_from_hash hash
-          p = hash[:port] || hash[PORT] || Contrast::Utils::ObjectShare::EMPTY_STRING
-          p.to_i
-        end
+          # Retrieve the host from the given connection Hash
+          #
+          # @param hash [Hash]
+          # @return [String]
+          def host_from_hash hash
+            hash[:host] || hash[HOST] || Contrast::Utils::ObjectShare::EMPTY_STRING
+          end
 
-        # Examples:
-        # mongodb://[user:pass@]host1[:port1][,host2[:port2],[,hostN[:portN]]][/[database][?options]]
-        # postgresql://scott:tiger@localhost/mydatabase
-        # mysql+mysqlconnector://scott:tiger@localhost/foo
-        def self.build_from_db_string str
-          adapter, hosts, database = split_connection_str(str)
-          acs = []
-          hosts.split(Contrast::Utils::ObjectShare::COMMA).map do |s|
-            host, port = s.split(Contrast::Utils::ObjectShare::COLON)
-
-            ac = Contrast::Api::Dtm::ArchitectureComponent.new
-            ac.vendor = Contrast::Utils::StringUtils.force_utf8(adapter)
-            ac.remote_host = Contrast::Utils::StringUtils.force_utf8(host)
-            ac.remote_port = port.to_i
-            ac.type = AC_TYPE_DB
-            ac.url = Contrast::Utils::StringUtils.force_utf8(database)
-            acs << ac
+          # Retrieve the port from the given connection Hash
+          #
+          # @param hash [Hash]
+          # @return [integer]
+          def port_from_hash hash
+            p = hash[:port] || hash[PORT] || Contrast::Utils::ObjectShare::EMPTY_STRING
+            p.to_i
           end
-          acs
-        end
 
-        def self.split_connection_str str
-          adapter, str = str.split(Contrast::Utils::ObjectShare::COLON_SLASH_SLASH)
-          _auth, str = str.split(Contrast::Utils::ObjectShare::AT)
-          # Not currently used
-          # user, pass = auth.split(Contrast::Utils::ObjectShare::COLON)
-          hosts, db_and_options = str.split(Contrast::Utils::ObjectShare::SLASH)
-          hosts << LOCALHOST if hosts.empty?
-          database, _options = db_and_options.split(Contrast::Utils::ObjectShare::QUESTION_MARK)
+          # Examples:
+          # mongodb://[user:pass@]host1[:port1][,host2[:port2],[,hostN[:portN]]][/[database][?options]]
+          # postgresql://scott:tiger@localhost/mydatabase # pragma: allowlist secret
+          # mysql+mysqlconnector://scott:tiger@localhost/foo # pragma: allowlist secret
+          #
+          # @param str [String] the DB connection string
+          # @return [Contrast::Api::Dtm::ArchitectureComponent]
+          def build_from_db_string str
+            adapter, hosts, database = split_connection_str(str)
+            acs = []
+            hosts.split(Contrast::Utils::ObjectShare::COMMA).map do |s|
+              host, port = s.split(Contrast::Utils::ObjectShare::COLON)
+
+              ac = Contrast::Api::Dtm::ArchitectureComponent.build_database
+              ac.vendor = Contrast::Utils::StringUtils.force_utf8(adapter)
+              ac.remote_host = Contrast::Utils::StringUtils.force_utf8(host)
+              ac.remote_port = port.to_i
+              ac.url = Contrast::Utils::StringUtils.force_utf8(database)
+              acs << ac
+            end
+            acs
+          end
 
-          [adapter, hosts, database]
+          # Parse the given string used to connect to a database into its composite components, allowing for the
+          # generation of a Contrast::Api::Dtm::ArchitectureComponent
+          #
+          # @param str [String] the DB connection string
+          # @return [Array<String>] the adapter, hosts, and database
+          def split_connection_str str
+            adapter, str = str.split(Contrast::Utils::ObjectShare::COLON_SLASH_SLASH)
+            _auth, str = str.split(Contrast::Utils::ObjectShare::AT)
+            # Not currently used
+            # user, pass = auth.split(Contrast::Utils::ObjectShare::COLON)
+            hosts, db_and_options = str.split(Contrast::Utils::ObjectShare::SLASH)
+            hosts << LOCALHOST if hosts.empty?
+            database, _options = db_and_options.split(Contrast::Utils::ObjectShare::QUESTION_MARK)
+
+            [adapter, hosts, database]
+          end
         end
       end
     end

data/lib/contrast/agent/inventory/dependencies.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 module Contrast

data/lib/contrast/agent/inventory/dependency_analysis.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/agent/inventory/dependencies'

data/lib/contrast/agent/inventory/dependency_usage_analysis.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/agent/inventory/dependencies'
@@ -72,6 +72,7 @@ module Contrast
         # Populate the library_usages field of the Activity message using the data stored in the @gemdigest_cache.
         #
         # TODO: RUBY-1355
+        # TODO: RUBY-1438 -- change to just use EventMessage
         # @param activity [Contrast::Api::Dtm::Activity] the message to which to append the usage data
         def generate_library_usage activity
           return unless enabled?
@@ -84,7 +85,6 @@ module Contrast
             @gemdigest_cache = Hash.new { |hash, key| hash[key] = Set.new }
             hold
           end
-
           gem_spec_digest_to_files.each_pair do |digest, files|
             usage = Contrast::Api::Dtm::LibraryUsageUpdate.build(digest, files)
             activity.library_usages[usage.hash_code] = usage
@@ -97,7 +97,7 @@ module Contrast
 
         def adjust_path_for_spec_lookup path
           idx = path.index('/lib/')
-          path = path[(idx + 4)..-1] if idx
+          path = path[(idx + 4)..] if idx
           path
         end
 

data/lib/contrast/agent/inventory/policy/datastores.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# 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'

data/lib/contrast/agent/inventory/policy/policy.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/agent/inventory/policy/trigger_node'

data/lib/contrast/agent/inventory/policy/trigger_node.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/agent/patching/policy/trigger_node'

data/lib/contrast/agent/inventory.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 module Contrast

data/lib/contrast/agent/metric_telemetry_event.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/utils/metrics_hash'
@@ -15,10 +15,10 @@ module Contrast
       def initialize
         super
         @fields = MetricsHash.new(Numeric)
-        @fields['_filter'] = 0
+        @fields['_filler'] = 0
       end
 
-      def to_json **_args
+      def to_hash **_args
         super.merge!({ fields: @fields })
       end
     end

data/lib/contrast/agent/middleware.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'ipaddr'
@@ -14,6 +14,7 @@ require 'contrast/utils/telemetry'
 require 'contrast/agent/request_handler'
 require 'contrast/agent/static_analysis'
 require 'contrast/agent/startup_metrics_telemetry_event'
+require 'contrast/utils/middleware_utils'
 
 require 'contrast/utils/timer'
 
@@ -25,6 +26,7 @@ module Contrast
     class Middleware
       include Contrast::Components::Logger::InstanceMethods
       include Contrast::Components::Scope::InstanceMethods
+      include Contrast::Utils::MiddlewareUtils
 
       attr_reader :app
 
@@ -66,22 +68,6 @@ module Contrast
 
       private
 
-      def setup_agent
-        ::Contrast::SETTINGS.reset_state
-
-        inform_deprecations
-        telemetry_disclaimer
-
-        if ::Contrast::CONFIG.invalid?
-          ::Contrast::AGENT.disable!
-          logger.error('!!! CONFIG FILE IS INVALID - DISABLING CONTRAST AGENT !!!')
-        elsif ::Contrast::AGENT.disabled?
-          logger.warn('Contrast disabled by configuration. Continuing without instrumentation.')
-        else
-          ::Contrast::AGENT.enable!
-        end
-      end
-
       # Startup the Agent as part of the initialization process:
       # - start the service sending thread, responsible for sending and processing messages
       # - start the heartbeat thread, which triggers service startup
@@ -175,12 +161,16 @@ module Contrast
         with_contrast_scope do
           context.extract_after(response) # update context with final response information
 
+          # Build and report all collected findings prior response
+          Contrast::Agent::FINDINGS.report_collected_findings unless Contrast::Agent::FINDINGS.collection.empty?
+
           if Contrast::Agent.framework_manager.streaming?(env)
             context.reset_activity
             request_handler.stream_safe_postfilter
           else
             request_handler.ruleset.postfilter
-            request_handler.send_activity_messages
+            request_handler.report_activity
+            request_handler.send_activity_messages # TODO: RUBY-1438 -- remove
           end
         end
       rescue StandardError => e
@@ -188,65 +178,6 @@ module Contrast
 
         logger.error('Unable to execute agent post_call', e)
       end
-
-      def application_code env
-        logger.trace_with_time('application') do
-          app.call(env)
-        end
-      rescue Contrast::SecurityException => e
-        logger.trace('Security Exception raised during application lifecycle to prevent an attack', e)
-        raise e
-      end
-
-      SECURITY_EXCEPTION_MARKER = 'Contrast::SecurityException'
-      # We're only going to suppress SecurityExceptions indicating a blocked attack. And, only if the
-      # config.agent.ruby.exceptions.capture? is set
-      def handle_exception exception
-        if security_exception?(exception)
-          exception_control = ::Contrast::AGENT.exception_control
-          raise exception unless exception_control[:enable]
-
-          [exception_control[:status], {}, [exception_control[:message]]]
-        else
-          logger.debug('Re-throwing original error', exception)
-          raise exception
-        end
-      end
-
-      # Is the given exception one raised by our Protect code?
-      #
-      # @param exception [Exception]
-      # @return [Boolean]
-      def security_exception? exception
-        exception.is_a?(Contrast::SecurityException) || exception.message&.include?(SECURITY_EXCEPTION_MARKER)
-      end
-
-      # As we deprecate support to prepare to remove dead code, we need to inform our users still relying on the now
-      # deprecated and soon to be removed functionality. This method handles doing that by leveraging the standard
-      # Kernel#warn approach
-      def inform_deprecations
-        # Ruby 2.5 is currently in security maintenance, meaning int is only receiving updates for security issues. It
-        # will move to eol on 31 March 2021. As such, we can remove support for it in Q3. We'll begin the deprecation
-        # warnings now so that customers have time to reach out if they'll be impacted.
-        # TODO: RUBY-715 remove this part of the method, leaving it empty if there are no other deprecations, when we
-        #   drop 2.5 support.
-        return unless RUBY_VERSION < '2.6.0'
-
-        Kernel.warn('[Contrast Security] [DEPRECATION] Support for Ruby 2.5 will be removed in April 2021. '\
-                    'Please contact Customer Support prior if you require continued support.')
-      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::Utils::Telemetry.create_telemetry_file
-
-        logger.info Contrast::Utils::Telemetry.disclaimer
-        $stdout.print Contrast::Utils::Telemetry.disclaimer
-        true
-      end
     end
   end
 end

data/lib/contrast/agent/module_data.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 module Contrast

data/lib/contrast/agent/patching/policy/after_load_patch.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/components/scope'

data/lib/contrast/agent/patching/policy/after_load_patcher.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/agent/patching/policy/after_load_patch'

data/lib/contrast/agent/patching/policy/method_policy.rb

@@ -1,29 +1,45 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/agent/patching/policy/method_policy_extend'
+
 module Contrast
   module Agent
     module Patching
       module Policy
         # This class is used to map each method to the trigger node that applies to it
         class MethodPolicy
+          extend Contrast::Agent::Patching::Policy::MethodPolicyExtend
           attr_reader   :deadzone_node, :inventory_node, :propagation_node, :protect_node, :trigger_node
           attr_accessor :source_node, :method_name, :method_visibility, :instance_method
 
-          def initialize(source_node: nil, propagation_node: nil,
-                         trigger_node: nil, inventory_node: nil,
-                         protect_node: nil, deadzone_node: nil,
-                         method_name: nil, method_visibility: nil,
-                         instance_method: nil)
-            @method_name = method_name
-            @method_visibility = method_visibility
-            @instance_method = instance_method
-            @source_node = source_node
-            @propagation_node = propagation_node
-            @trigger_node = trigger_node
-            @inventory_node = inventory_node
-            @protect_node = protect_node
-            @deadzone_node = deadzone_node
+          # Initialize new method policy with:
+          #
+          # @param method_policy [Hash]
+          #  {
+          #   source_node       [ Contrast::Agent::Assesss::Policy::SourceNode      ]
+          #   propagation_node  [ Contrast::Agent::Assesss::Policy::PropagationNode ]
+          #   trigger_node      [ Contrast::Agent::Assesss::Policy::TriggerNode     ]
+          #   inventory_node    [ Contrast::Agent::Inventory::Policy::TriggerNode   ]
+          #   protect_node      [ Contrast::Agent::Protect::Policy::TriggerNode     ]
+          #   deadzone_node     [ Contrast::Agent::Deadzone::Policy::DeadzoneNode   ]
+          #   method_name       [ Symbol                                            ]
+          #                       the name of the method for this policy
+          #   method_visibility [ Symbol                                            ]
+          #                       Public, Private Protected
+          #   instance_method   [ Boolean                                           ]
+          #                       true if this method is an instance method
+          #  }
+          def initialize method_policy
+            @method_name = method_policy[:method_name]
+            @method_visibility = method_policy[:method_visibility]
+            @instance_method = method_policy[:instance_method]
+            @source_node = method_policy[:source_node]
+            @propagation_node = method_policy[:propagation_node]
+            @trigger_node = method_policy[:trigger_node]
+            @inventory_node = method_policy[:inventory_node]
+            @protect_node = method_policy[:protect_node]
+            @deadzone_node = method_policy[:deadzone_node]
           end
 
           def private_method?
@@ -60,95 +76,6 @@ module Contrast
             # defined by #nodes.
             @_method_scopes ||= nodes.flat_map(&:method_scope).tap(&:compact!).tap(&:uniq!)
           end
-
-          class << self
-            # Given a Contrast::Agent::Patching::Policy::ModulePolicy, parse
-            # out its information for the given method in order to construct a
-            # Contrast::Agent::Patching::Policy::MethodPolicy
-            #
-            # @param method_name [Symbol] the name of the method for this policy
-            # @param module_policy [Contrast::Agent::Patching::Policy::ModulePolicy]
-            #   the entire policy for this module
-            # @param instance_method [Boolean] true if this method is an
-            #   instance method
-            # @return [Contrast::Agent::Patching::Policy::MethodPolicy]
-            def build_method_policy method_name, module_policy, instance_method
-              source_node =      find_method_node(module_policy.source_nodes, method_name, instance_method)
-              propagation_node = find_method_node(module_policy.propagator_nodes, method_name, instance_method)
-              trigger_node =     find_method_node(module_policy.trigger_nodes, method_name, instance_method)
-              protect_node =     find_method_node(module_policy.protect_nodes, method_name, instance_method)
-              inventory_node =   find_method_node(module_policy.inventory_nodes, method_name, instance_method)
-              deadzone_node =    find_method_node(module_policy.deadzone_nodes, method_name, instance_method)
-              method_visibility = find_visibility(source_node, propagation_node, trigger_node, protect_node,
-                                                  inventory_node, deadzone_node)
-              method_policy = MethodPolicy.new(method_name: method_name,
-                                               method_visibility: method_visibility,
-                                               instance_method: instance_method,
-                                               source_node: source_node,
-                                               propagation_node: propagation_node,
-                                               trigger_node: trigger_node,
-                                               protect_node: protect_node,
-                                               inventory_node: inventory_node,
-                                               deadzone_node: deadzone_node)
-
-              return method_policy unless check_method_policy_nodes_empty? source_node, propagation_node, trigger_node,
-                                                                           protect_node, inventory_node, deadzone_node
-
-              create_new_node(module_policy, method_policy) if module_policy.deadzone_nodes&.any?
-              method_policy
-            end
-
-            def find_method_node nodes, method_name, is_instance_method
-              return unless nodes
-
-              nodes.find do |node|
-                node.instance_method? == is_instance_method && node.method_name == method_name
-              end
-            end
-
-            def find_visibility *nodes
-              nodes.find { |node| node }&.method_visibility
-            end
-
-            def check_method_policy_nodes_empty?(source_node, propagation_node, trigger_node, protect_node,
-                                                 inventory_node, deadzone_node)
-              return false unless source_node.nil? && propagation_node.nil? && trigger_node.nil? && protect_node.nil? &&
-                  inventory_node.nil? && deadzone_node.nil?
-
-              true
-            end
-
-            private
-
-            def create_new_node module_policy, method_policy
-              return if module_policy.deadzone_nodes.empty?
-
-              module_policy.deadzone_nodes.map do |node|
-                next unless node.method_name.nil?
-
-                klass = Module.cs__const_get(node.class_name)
-                next unless it_defined? klass, method_policy.method_name
-
-                new_node = {}
-                new_node['instance_method'] = method_policy.instance_method
-                new_node['method_visibility'] =
-                  klass.private_method_defined?(method_policy.method_name) ? 'private' : 'public'
-                new_node['method_name'] = method_policy.method_name
-                new_node['class_name'] = node.class_name
-                new_node = Contrast::Agent::Deadzone::Policy::DeadzoneNode.new(new_node)
-                method_policy.instance_variable_set(:@method_visibility, new_node.method_visibility)
-                method_policy.instance_variable_set(:@deadzone_node, new_node)
-                module_policy.deadzone_nodes << new_node
-                break unless method_policy.deadzone_node.nil?
-              end
-            end
-
-            def it_defined? klass, method_name
-              klass.instance_methods(false).include?(method_name) ||
-                  klass.private_instance_methods(false).include?(method_name) ||
-                  klass.singleton_methods(false).include?(method_name)
-            end
-          end
         end
       end
     end