contrast-agent 3.10.2 → 3.11.0

data/lib/contrast/agent/module_data.rb

@@ -6,7 +6,8 @@ module Contrast
     # A simple wrapper around a Module and a call to its name, used to avoid
     # calling the Module#name method and generating extra Strings
     class ModuleData
-      attr_accessor :mod, :name
+      attr_reader :mod, :name
+
       def initialize mod, name = nil
         @mod = mod
         @name = name || mod.cs__name

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

@@ -10,6 +10,7 @@ module Contrast
         # Used to handle tracking patches that need to apply special instrumentation when a module is loaded
         class AfterLoadPatch
           attr_reader :applied, :module_name, :instrumentation_file_path, :method_to_instrument
+
           def initialize module_name, instrumentation_file_path, method_to_instrument: nil
             @applied = false
             @module_name = module_name
@@ -18,7 +19,7 @@ module Contrast
           end
 
           def applied?
-            @applied
+            applied
           end
 
           # Modules can be re-opened, so the first load may not

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

@@ -12,7 +12,7 @@ module Contrast
         # after they've been loaded
         module AfterLoadPatcher
           include Contrast::Components::Interface
-          access_component :logging, :agent
+          access_component :agent, :logging
 
           AFTER_LOAD_PATCHES = Set.new([
                                          Contrast::Agent::Patching::Policy::AfterLoadPatch.new(
@@ -52,18 +52,36 @@ module Contrast
 
           # After initialization run a catchup check to instrument any already loaded modules we care about
           def catchup_after_load_patches
+            apply_direct_patches!
             applied = []
             AFTER_LOAD_PATCHES.each do |after_load_patch|
               next unless after_load_patch.target_defined?
               next if AGENT.skip_instrumentation?(after_load_patch.module_name)
 
-              logger.debug("Detected loading of #{ after_load_patch.module_name } - applying instrumentation")
+              logger.trace(
+                  'Catching up on already loaded afterload patch - applying instrumentation',
+                  module: after_load_patch.module_name)
               after_load_patch.instrument!
               applied << after_load_patch
             end
             AFTER_LOAD_PATCHES.subtract(applied)
           end
 
+          # These patches need to be applied directly, not from our policy, so
+          # do so and do so only once. This should be the new standard so that
+          # there are no require time side effects of loading our core
+          # extensions.
+          def apply_direct_patches!
+            @_apply_direct_patches ||= begin
+                                    Contrast::CoreExtensions::Assess::FiberPropagator.instrument_fiber_track
+                                    Contrast::CoreExtensions::Assess::HashPropagator.instrument_hash_track
+                                    Contrast::CoreExtensions::Assess::RegexpPropagator.instrument_regexp_track
+                                    Contrast::CoreExtensions::Assess::StringPropagator.instrument_string
+                                    Contrast::CoreExtensions::Assess::StringPropagator.instrument_string_interpolation
+                                    true
+                                  end
+          end
+
           # Use for any checks after we've initialized
           def load_patches_for_module module_name
             return if AFTER_LOAD_PATCHES.empty?
@@ -71,8 +89,7 @@ module Contrast
             patch = AFTER_LOAD_PATCHES.find { |after_load_patch| after_load_patch.applies?(module_name) }
             return unless patch
 
-            logger.debug("Detected loading of #{ module_name } - applying instrumentation")
-
+            logger.trace('Detected loading of afterload patch - applying instrumentation', module: module_name)
             patch.instrument!
             AFTER_LOAD_PATCHES.subtract([patch]) if patch.applied?
           end

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

@@ -7,9 +7,9 @@ module Contrast
       module Policy
         # This class is used to map each method to the trigger node that applies to it
         class MethodPolicy
-          attr_accessor :source_node, :propagation_node, :trigger_node,
-                        :inventory_node, :protect_node, :deadzone_node,
-                        :method_name, :method_visibility, :instance_method
+          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,

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

@@ -73,31 +73,6 @@ module Contrast
                                        end
           end
 
-          def collect_class_nodes nodes, clazz_name
-            return Contrast::Utils::ObjectShare::EMPTY_ARRAY unless nodes
-
-            nodes.select { |policy_node| clazz_name == policy_node.class_name }
-          end
-
-          def collect_method_nodes nodes, method, instance_method
-            return Contrast::Utils::ObjectShare::EMPTY_ARRAY unless nodes
-
-            nodes.select do |node|
-              node.instance_method? == instance_method && node.method_name == method
-            end
-          end
-
-          def create_method_policy_subset method, instance_method
-            method_policy = ModulePolicy.new
-            method_policy.source_nodes =     collect_method_nodes(source_nodes, method, instance_method)
-            method_policy.propagator_nodes = collect_method_nodes(propagator_nodes, method, instance_method)
-            method_policy.trigger_nodes =    collect_method_nodes(trigger_nodes, method, instance_method)
-            method_policy.inventory_nodes =  collect_method_nodes(inventory_nodes, method, instance_method)
-            method_policy.protect_nodes =    collect_method_nodes(protect_nodes, method, instance_method)
-            method_policy.deadzone_nodes =   collect_method_nodes(deadzone_nodes, method, instance_method)
-            method_policy
-          end
-
           private
 
           def sort_method_names nodes, instance_methods, singleton_methods

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

@@ -2,28 +2,25 @@
 # frozen_string_literal: true
 
 cs__scoped_require 'monitor'
-# base
-cs__scoped_require 'contrast/extensions/ruby_core/module'
+cs__scoped_require 'contrast/components/interface'
+
+cs__scoped_require 'contrast/agent'
+cs__scoped_require 'contrast/agent/logger'
 cs__scoped_require 'contrast/agent/patching/policy/method_policy'
 cs__scoped_require 'contrast/agent/patching/policy/patch_status'
 cs__scoped_require 'contrast/agent/patching/policy/trigger_node'
-cs__scoped_require 'contrast/components/interface'
 
 # assess
 cs__scoped_require 'contrast/agent/assess/policy/policy'
 cs__scoped_require 'contrast/agent/assess/policy/propagation_method'
 cs__scoped_require 'contrast/agent/assess/policy/source_method'
 cs__scoped_require 'contrast/agent/assess/policy/trigger_method'
-cs__scoped_require 'contrast/extensions/ruby_core/assess'
-
-# inventory
-cs__scoped_require 'contrast/agent/inventory/policy/policy'
-cs__scoped_require 'contrast/extensions/ruby_core/inventory'
 
 # protect
 cs__scoped_require 'contrast/agent/protect/policy/policy'
-cs__scoped_require 'contrast/extensions/ruby_core/protect'
-cs__scoped_require 'contrast/extensions/ruby_core/protect/kernel'
+
+# inventory
+cs__scoped_require 'contrast/agent/inventory/policy/policy'
 
 module Contrast
   module Agent
@@ -40,7 +37,7 @@ module Contrast
             include Contrast::Agent::Assess::Policy::TriggerMethod
 
             include Contrast::Components::Interface
-            access_component :logging, :analysis, :agent, :scope
+            access_component :agent, :analysis, :logging, :scope
 
             POLICIES = [
               Contrast::Agent::Assess::Policy::Policy,
@@ -86,7 +83,7 @@ module Contrast
             rescue StandardError => e
               # Anything else was our bad and we gotta catch that to allow for
               # normal application flow
-              logger.error(e, 'Unable to apply pre patch to method.')
+              logger.error('Unable to apply pre patch to method.', e)
             rescue Exception => e # rubocop:disable Lint/RescueException
               # This is something like NoMemoryError that we can't
               # hope to handle.  Nonetheless, shouldn't leak scope.
@@ -115,7 +112,7 @@ module Contrast
             def apply_post_patch method_policy, preshift, object, ret, args, block
               apply_assess(method_policy, preshift, object, ret, args, block)
             rescue StandardError => e
-              logger.error(e, 'Unable to apply post patch to method.')
+              logger.error('Unable to apply post patch to method.', e)
             end
 
             # Apply the Protect patch which applies to the given method.
@@ -184,14 +181,12 @@ module Contrast
 
               trigger_node = method_policy.trigger_node
               Contrast::Agent::Assess::Policy::TriggerMethod.apply_trigger_rule(trigger_node, object, ret, args) if trigger_node
-
               if method_policy.source_node
                 # If we were given a frozen return, and it was the target of a
                 # source, and we have frozen sources enabled, we'll need to
                 # replace the return. Note, this is not the default case.
                 source_ret = Contrast::Agent::Assess::Policy::SourceMethod.source_patchers(method_policy, object, ret, args)
               end
-
               if method_policy.propagation_node
                 propagated_ret = Contrast::Agent::Assess::Policy::PropagationMethod.apply_propagation(
                     method_policy,
@@ -201,13 +196,12 @@ module Contrast
                     args,
                     block)
               end
-
               handle_return(propagated_ret, source_ret, ret)
             rescue StandardError => e
-              logger.error(e, 'Unable to assess method call.')
+              logger.error('Unable to assess method call.', e)
               handle_return(propagated_ret, source_ret, ret)
             rescue Exception => e # rubocop:disable Lint/RescueException
-              logger.error(e, 'Unable to assess method call.')
+              logger.error('Unable to assess method call.', e)
               handle_return(propagated_ret, source_ret, ret)
               raise e
             end
@@ -237,7 +231,6 @@ module Contrast
               # resembling CUSTOM - they all have a common interface but their
               # own logic based on what's in the method(s) they've been patched
               # into.
-              applicator = trigger_node.applicator
               # Each patch also knows the method of its applicator. Some
               # things, like AppliesXxeRule, have different methods depending
               # on the library patched. This lets us handle the boilerplate of
@@ -247,7 +240,7 @@ module Contrast
               # By calling send like this, we can reuse all the patching.
               # We `send` to the given method of the given class
               # (applicator) since they all accept the same inputs
-              applicator.send(applicator_method, method, exception, trigger_node.properties, object, args)
+              trigger_node.applicator.send(applicator_method, method, exception, trigger_node.properties, object, args)
             end
 
             # Method to choose which replaced return from the post_patch to
@@ -279,6 +272,15 @@ module Contrast
                   patched_method.to_s).to_sym
             end
 
+            # Given a method, return a symbol in the format
+            # <method_start>_unbound_<method_name>
+            def build_unbound_method_name patcher_method
+              (Contrast::Utils::ObjectShare::CONTRAST_PATCHED_METHOD_START +
+                  'unbound' +
+                  Contrast::Utils::ObjectShare::UNDERSCORE +
+                  patcher_method.to_s).to_sym
+            end
+
             # @param mod [Module] the module in which the patch should be
             #   placed.
             # @param methods [Array(Symbol)] all the instance or singleton
@@ -297,10 +299,11 @@ module Contrast
               rescue NameError => e
                 # This shouldn't happen anymore, but just in case calling alias
                 # results in a NameError, we'll be safe here.
-                logger.debug(
+                logger.error(
+                    'Attempted to alias a method on a Module that doesn\'t respond to it.',
                     e,
-                    "The class #{ mod.cs__name } does not respond to the "\
-                    "method#{ method_policy.method_name }.")
+                    module: mod.cs__name,
+                    method: method_policy.method_name)
                 return false
               end
               true
@@ -316,9 +319,79 @@ module Contrast
               contrast_prepend_method(mod, method_policy)
             end
 
+            # @param unbound_method [UnboundMethod] An unbound method, that doesn't reference its binding.
+            #   This method executes C hooking code.
+            def register_c_hook unbound_method
+              # current binding is as meaningless as any other.  but we need something
+              unbound_method.bind_call(self)
+            end
+
+            # @param target_module_name [String] Fully-qualified module name, as string, to which the C patch applies.
+            # @param unbound_method [UnboundMethod] An unbound method, to be patched into target_module.
+            # @param impl [Symbol] Strategy for applying the patch: { :alias_instance, :alias_singleton, or :prepend }:
+            #   :alias_instance     -> alias instance method of module
+            #   :alias_singleton    -> alias instance method of singleton class of module
+            #                          (equivalent to :alias, where `module = module.singleton class`)
+            #                          (this is a.k.a. "class-method patch")
+            #   :prepend            -> prepend instance method of module
+            #   [prepending singleton is easily supported too, just not implemented yet.]
+            # @return [Symbol] new alias for the underlying method (presumably, so the patched method can call it)
+            def register_c_patch target_module_name, unbound_method, impl = :alias_instance
+              # These could be set as AfterLoadPatches.
+              method_name = unbound_method.name.to_sym
+              underlying_method_name = build_unbound_method_name(method_name).to_sym
+
+              target_module = Module.cs__const_get(target_module_name)
+
+              target_module = target_module.cs__singleton_class if %i[alias_singleton prepend].include? impl
+
+              visibility = if target_module.private_instance_methods(false).include?(method_name)
+                             :private
+                           elsif target_module.protected_instance_methods(false).include?(method_name)
+                             :protected
+                           elsif target_module.public_instance_methods(false).include?(method_name)
+                             :public
+                           else
+                             raise NotImplementedError,
+                                   <<~ERR
+                                     Tried to register a C-defined #{ impl } patch for \
+                                     #{ target_module_name }##{ method_name }, but can't find :#{ method_name }.
+                                   ERR
+                           end
+
+              case impl
+              when :alias_instance, :alias_singleton
+                unless target_module.instance_methods(false).include? underlying_method_name
+                  # alias_method may be private
+                  target_module.send(:alias_method, underlying_method_name, method_name)
+                  target_module.send(:define_method, method_name, unbound_method.bind(target_module))
+                end
+                target_module.send(visibility, method_name) # e.g., module.private(:my_method)
+              when :prepend
+                prepending_module = Module.new
+                prepending_module.send(:define_method, method_name, unbound_method.bind(target_module))
+                prepending_module.send(visibility, :method_name)
+                # This prepends to the singleton class (it patches a class method)
+                target_module.prepend prepending_module
+              end
+              # Ougai::Logger.create_item_with_2args calls Hash#[]=, so we
+              # can't invoke this logging method or we'll seg fault as we'd
+              # change the method definition mid-call
+              # if method_name != :[]=
+              #   logger.trace(
+              #       'Registered C-defined patch',
+              #       implementation: impl,
+              #       module: target_module_name,
+              #       method: method_name,
+              #       visibility: visibility)
+              # end
+              underlying_method_name.to_sym
+            end
+
             # @return [Boolean]
             def skip_contrast_analysis?
               return true if in_contrast_scope?
+              return true unless defined?(Contrast::Agent::REQUEST_TRACKER)
               return true unless Contrast::Agent::REQUEST_TRACKER.current&.analyze_request?
 
               false

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

@@ -44,14 +44,14 @@ module Contrast
           extend Contrast::Agent::Patching::Policy::AfterLoadPatcher
 
           include Contrast::Components::Interface
-          access_component :logging, :analysis, :agent, :scope
+          access_component :agent, :analysis, :logging, :scope
 
           class << self
             # Hook to install the Contrast changes needed to allow for the
             # instrumentation of the application - this only occurs once, during
             # startup to catchup on everything we didn't see get loaded
             def patch
-              logger.debug_with_time("\tPatching") do
+              logger.debug_with_time('Patching') do
                 catchup_after_load_patches
                 patch_methods
                 Contrast::Agent::Assess::Policy::RewriterPatch.rewrite_interpolations
@@ -91,7 +91,7 @@ module Contrast
               patch_into_module(module_data)
               all_module_names.delete(mod_name) if status_type.get_status(mod).patched?
             rescue StandardError => e
-              logger.error("Unable to patch into #{ mod_name }", e)
+              logger.error('Unable to patch module', e, module: mod_name)
             end
 
             # We did it, team. We found a patcher(s) that applies to the given
@@ -150,20 +150,20 @@ module Contrast
             # only be invoked by the patch_methods method above in order to
             # ensure it is wrapped in a synchronize call
             def synchronized_patch_methods
-              # logger.trace_with_time("\t\tRunning patching") do # TODO: RUBY-547
-              patched = []
-              all_module_names.each do |patchable_name|
-                next if AGENT.skip_instrumentation?(patchable_name)
+              logger.trace_with_time('Running patching') do
+                patched = []
+                all_module_names.each do |patchable_name|
+                  next if AGENT.skip_instrumentation?(patchable_name)
 
-                patchable_mod = patchable(patchable_name)
-                next unless patchable_mod
+                  patchable_mod = patchable(patchable_name)
+                  next unless patchable_mod
 
-                module_data = Contrast::Agent::ModuleData.new(patchable_mod, patchable_name)
-                patch_into_module(module_data)
-                patched << patchable_name if status_type.get_status(patchable_mod).patched?
+                  module_data = Contrast::Agent::ModuleData.new(patchable_mod, patchable_name)
+                  patch_into_module(module_data)
+                  patched << patchable_name if status_type.get_status(patchable_mod).patched?
+                end
+                all_module_names.subtract(patched)
               end
-              all_module_names.subtract(patched)
-              # end
             end
 
             # Given the patchers that apply to this class that may apply, patch
@@ -187,9 +187,6 @@ module Contrast
 
               clazz = module_data.mod
 
-              status = status_type.get_status(clazz)
-              return if (status.patched? || status.patching?) && !redo_patch
-
               status.patching!
               patched = include_module(module_data)
 
@@ -216,9 +213,12 @@ module Contrast
             rescue StandardError => e
               status ||= status_type.get_status(module_data.mod)
               status.failed_patch!
-              logger.warn(e, "Unable to patch into #{ module_data.name }")
+              logger.warn('Patching failed', e, module: module_data.name)
             ensure
-              logger.debug(nil, "Patching #{ module_data.name } resulted in #{ status_type.get_status(module_data.mod).patch_status }")
+              logger.trace('Patching complete',
+                           module: module_data.name,
+                           result: Contrast::Agent::Patching::Policy::PatchStatus.get_status(
+                               module_data.mod).patch_status)
             end
 
             # Includes the given module with the

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

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 cs__scoped_require 'json'
+cs__scoped_require 'singleton'
+
 cs__scoped_require 'contrast'
 cs__scoped_require 'contrast/components/interface'
 cs__scoped_require 'contrast/agent/patching/policy/module_policy'
@@ -33,10 +35,9 @@ module Contrast
             raise(NotImplementedError, 'specify the concrete node type for this poilcy')
           end
 
-          access_component :logging, :analysis
+          access_component :analysis, :logging
 
-          attr_accessor :providers, :tracked_classes
-          attr_reader :sources, :propagators, :triggers, :patched_names
+          attr_reader :sources, :propagators, :triggers, :providers, :tracked_classes
 
           SOURCES_KEY =          'sources'
           PROPAGATION_KEY =      'propagators'
@@ -54,7 +55,6 @@ module Contrast
             @triggers = []
             @providers = {}
             @tracked_classes = []
-            @patched_names = Set.new
 
             json = Contrast::Utils::ResourceLoader.load(cs__class.policy_json)
             from_hash_string(json)
@@ -85,14 +85,14 @@ module Contrast
 
           def add_node node, node_type = :trigger
             unless node
-              logger.error(nil, 'Node was nil when adding node to policy')
+              logger.error('Node was nil when adding node to policy')
               return
             end
 
             begin
               node.validate
             rescue ArgumentError => e
-              logger.error(e, e.message)
+              logger.error('Node failed validation', e)
               return
             end
 
@@ -107,7 +107,7 @@ module Contrast
               module_names << node.class_name
               @sources << node
             else
-              logger.error(nil, "Invalid node_type: #{ node_type } provided when adding node to policy")
+              logger.error('Invalid node_type provided when adding node to policy', node_type: node_type)
             end
           end