contrast-agent 3.15.0 → 4.3.0

data/lib/contrast/components/settings.rb

@@ -55,23 +55,25 @@ module Contrast
         APPLICATION_STATE_ATTRS   = %i[modes_by_id exclusion_matchers disabled_assess_rules].cs__freeze
 
         # Meta-define an accessor for each state attribute.
-        begin
-          PROTECT_STATE_ATTRS.each do |attr|
-            define_method(attr) do
-              protect_state[attr]
-            end
+
+        PROTECT_STATE_ATTRS.each do |attr|
+          # TODO: RUBY-1052
+          define_method(attr) do # rubocop:disable Performance/Kernel/DefineMethod
+            protect_state[attr]
           end
+        end
 
-          ASSESS_STATE_ATTRS.each do |attr|
-            define_method(attr) do
-              assess_state[attr]
-            end
+        ASSESS_STATE_ATTRS.each do |attr|
+          # TODO: RUBY-1052
+          define_method(attr) do # rubocop:disable Performance/Kernel/DefineMethod
+            assess_state[attr]
           end
+        end
 
-          APPLICATION_STATE_ATTRS.each do |attr|
-            define_method(attr) do
-              application_state[attr]
-            end
+        APPLICATION_STATE_ATTRS.each do |attr|
+          # TODO: RUBY-1052
+          define_method(attr) do # rubocop:disable Performance/Kernel/DefineMethod
+            application_state[attr]
           end
         end
 
@@ -95,18 +97,16 @@ module Contrast
 
         def update_from_server_features server_features
           # protect
-          begin
-            @_protect_enabled = nil
-            protect_state[:enabled] = server_features.protect_enabled?
-          end
+
+          @_protect_enabled = nil
+          protect_state[:enabled] = server_features.protect_enabled?
 
           # assess
-          begin
-            @_assess_enabled = nil
-            assess_state[:enabled] = server_features.assess_enabled?
-            assess_state[:sampling_settings] = server_features.assess.sampling
-            Contrast::Utils::Assess::SamplingUtil.instance.update
-          end
+
+          @_assess_enabled = nil
+          assess_state[:enabled] = server_features.assess_enabled?
+          assess_state[:sampling_settings] = server_features.assess.sampling
+          Contrast::Utils::Assess::SamplingUtil.instance.update
         end
 
         def update_from_application_settings application_settings

data/lib/contrast/config/assess_configuration.rb

@@ -11,7 +11,8 @@ module Contrast
           enable: EMPTY_VALUE,
           enable_scan_response: Contrast::Config::DefaultValue.new('true'),
           sampling: Contrast::Config::SamplingConfiguration,
-          rules: Contrast::Config::AssessRulesConfiguration
+          rules: Contrast::Config::AssessRulesConfiguration,
+          stacktraces: Contrast::Config::DefaultValue.new('ALL')
       }.cs__freeze
 
       def initialize hsh

data/lib/contrast/config/inventory_configuration.rb

@@ -7,8 +7,8 @@ module Contrast
     # inventory functionality of the Agent.
     class InventoryConfiguration < BaseConfiguration
       KEYS = {
-          enable: EMPTY_VALUE,
-          record_used_classes: EMPTY_VALUE,
+          enable: Contrast::Config::DefaultValue.new(true),
+          analyze_libraries: Contrast::Config::DefaultValue.new(true),
           tags: EMPTY_VALUE
       }.cs__freeze
 

data/lib/contrast/config/service_configuration.rb

@@ -9,13 +9,15 @@ module Contrast
     # 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'
       DEFAULT_PORT       = '30555'
 
       KEYS = {
           enable: EMPTY_VALUE,
-          host: Contrast::Config::DefaultValue.new(DEFAULT_HOST),
-          port: Contrast::Config::DefaultValue.new(DEFAULT_PORT),
+          host: EMPTY_VALUE,
+          port: EMPTY_VALUE,
           socket: EMPTY_VALUE,
           logger: Contrast::Config::LoggerConfiguration
       }.cs__freeze

data/lib/contrast/configuration.rb

@@ -238,7 +238,7 @@ module Contrast
     # @return [Hash, Object] the leaf of each
     #   Contrast::Config::BaseConfiguration will be returned in the N > 0 steps
     #   the Hash will be returned at the end of the 0 level
-    def convert_to_hash convert=root, hash={}
+    def convert_to_hash convert = root, hash = {}
       case convert
       when Contrast::Config::BaseConfiguration
         convert.cs__class::KEYS.each_key do |key|

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

@@ -35,19 +35,21 @@ module Contrast
           # operation happens in C, we have to do it here rather than rely on the
           # patch of our String append or concat methods.
           def cs__track_join ary, separator, ret
-            return ret unless ary
+            return ret unless ary&.any? { |element| Contrast::Agent::Assess::Tracker.tracked?(element) }
             return ret if Contrast::Agent::Patching::Policy::Patch.skip_assess_analysis?
 
             with_contrast_scope do
-              properties = Contrast::Agent::Assess::Tracker.properties(ret)
-              return ret unless properties
+              return ret unless (properties = Contrast::Agent::Assess::Tracker.properties!(ret))
 
               shift = 0
               separator_length = separator.nil? ? 0 : separator.to_s.length
+              parent_events = []
               ary.each do |obj|
                 if obj # skip nil here
                   properties.copy_from(obj, ret, shift)
                   shift += obj.to_s.length
+                  parent_event = Contrast::Agent::Assess::Tracker.properties(obj)&.event
+                  parent_events << parent_event if parent_event
                 end
                 shift += separator_length
               end
@@ -60,15 +62,16 @@ module Contrast
                   ary,
                   ret,
                   [separator])
+              properties.event.instance_variable_set(:@_parent_events, parent_events)
               ret
             end
           end
 
           def instrument_array_track
             @_instrument_array_track ||= begin
-                                           require 'cs__assess_array/cs__assess_array'
-                                           true
-                                         end
+              require 'cs__assess_array/cs__assess_array'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading assess track patch', e)
             false

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

@@ -6,14 +6,13 @@ module ERBPropagator
   class << self
     def result_tagger patcher, preshift, ret, _block
       return unless preshift.args.length >= 1
-
-      properties = Contrast::Agent::Assess::Tracker.properties(ret)
-      return unless properties
+      return unless (properties = Contrast::Agent::Assess::Tracker.properties!(ret))
 
       used_binding = preshift.args[0]
       binding_variable_set = used_binding.local_variables
 
       erb_pre_result = preshift.object.src
+      parent_events = []
       binding_variable_set.each do |bound_var_symbol|
         bound_variable_value = used_binding.local_variable_get(bound_var_symbol)
         next unless Contrast::Agent::Assess::Tracker.tracked?(bound_variable_value)
@@ -23,6 +22,8 @@ module ERBPropagator
         next if start_index.nil?
 
         properties.copy_from(bound_variable_value, ret, start_index)
+        parent_event = Contrast::Agent::Assess::Tracker.properties(bound_variable_value)&.event
+        parent_events << parent_event if parent_event
       end
       properties.build_event(
           patcher,
@@ -31,6 +32,8 @@ module ERBPropagator
           ret,
           preshift.args,
           1)
+      properties.event.instance_variable_set(:@_parent_events, parent_events)
+
       ret
     end
   end

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

@@ -45,9 +45,9 @@ module Contrast
 
           def instrument_basic_object_track
             @_instrument_basic_object_track ||= begin
-                                               require 'cs__assess_basic_object/cs__assess_basic_object'
-                                               true
-                                             end
+              require 'cs__assess_basic_object/cs__assess_basic_object'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading basic object track patch', e)
             false
@@ -55,9 +55,9 @@ module Contrast
 
           def instrument_module_track
             @_instrument_module_track ||= begin
-                                               require 'cs__assess_module/cs__assess_module'
-                                               true
-                                             end
+              require 'cs__assess_module/cs__assess_module'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading module track patch', e)
             false

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

@@ -28,9 +28,6 @@ module Contrast
               Kernel,
               nil,
               source)
-          # Exec replaces the current process, if we occur in a forked process
-          # our appendage of this finding will not make it to TS
-          Contrast::Agent::AtExitHook.on_exit
         end
 
         private

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

@@ -61,8 +61,7 @@ module Contrast
 
             with_contrast_scope do
               results.each do |result|
-                result_properties = Contrast::Agent::Assess::Tracker.properties(result)
-                next unless result_properties
+                next unless (result_properties = Contrast::Agent::Assess::Tracker.properties!(result))
 
                 result_properties.splat_from(fiber, result)
                 result_properties.build_event(
@@ -82,7 +81,7 @@ module Contrast
             return unless underlying.is_a?(String) && !underlying.empty?
 
             with_contrast_scope do
-              properties = Contrast::Agent::Assess::Tracker.properties(fiber)
+              properties = Contrast::Agent::Assess::Tracker.properties!(fiber)
               return unless properties
 
               properties.splat_from(underlying, fiber)
@@ -99,9 +98,9 @@ module Contrast
 
           def instrument_fiber_track
             @_instrument_fiber_variables ||= begin
-                require 'cs__assess_fiber_track/cs__assess_fiber_track' if Funchook.available?
-                true
-              end
+              require 'cs__assess_fiber_track/cs__assess_fiber_track' if Funchook.available?
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading fiber track patch', e)
             false

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

@@ -17,18 +17,20 @@ module Contrast
             return object unless object.is_a?(String) && !object.cs__frozen?
             return object unless Contrast::Agent::Assess::Tracker.tracked?(object)
 
-            ret = Contrast::Agent::Assess::Tracker.duplicate(object)
-            ret.cs__freeze
+            # Copy the object, then freeze it, so that it looks the same
+            # externally, but will have our finalizer on it.
+            object.dup&.cs__freeze
           rescue StandardError
             # we'll rescue this error, but we can't log it here as that will
             # result in a seg fault
+            object
           end
 
           def instrument_hash_track
             @_instrument_hash_track ||= begin
-                                            require 'cs__assess_hash/cs__assess_hash'
-                                            true
-                                          end
+              require 'cs__assess_hash/cs__assess_hash'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading hash track patch', e)
             false

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

@@ -39,13 +39,13 @@ module Contrast
           # oh, and there's also %<name>type and %{name}... b/c of course there is
           # -HM
           def sprintf_tagger patcher, preshift, ret, _block
-            properties = Contrast::Agent::Assess::Tracker.properties(ret)
-            return unless properties
+            return unless (properties = Contrast::Agent::Assess::Tracker.properties!(ret))
 
             format_string = preshift.args[0]
             args = preshift.args[1]
 
-            track_sprintf(ret, format_string, args)
+            parent_events = []
+            track_sprintf(ret, format_string, args, parent_events)
 
             properties.build_event(
                 patcher,
@@ -54,32 +54,31 @@ module Contrast
                 ret,
                 preshift.args,
                 1)
+
+            properties.event.instance_variable_set(:@_parent_events, parent_events)
             ret
           end
 
-          def track_sprintf result, format_string, args
-            handle_sprintf_value(format_string, result)
+          def track_sprintf result, format_string, args, parent_events
+            handle_sprintf_value(format_string, result, parent_events)
             case args
             when String
-              handle_sprintf_value(args, result)
+              handle_sprintf_value(args, result, parent_events)
             when Hash
-              handle_sprintf_hash(args, result)
+              handle_sprintf_hash(args, result, parent_events)
             when Array
-              handle_sprintf_array args, result
+              handle_sprintf_array(args, result, parent_events)
             end
-
-            result
           rescue StandardError => e
             logger.error(
                 'Unable to track dataflow through sprintf', e)
-            result
           end
 
           def instrument_kernel_track
             @_instrument_fiber_variables ||= begin
-                                               require 'cs__assess_kernel/cs__assess_kernel'
-                                               true
-                                             end
+              require 'cs__assess_kernel/cs__assess_kernel'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading kernel track patch', e)
             false
@@ -87,28 +86,26 @@ module Contrast
 
           private
 
-          def handle_sprintf_value value, result
+          def handle_sprintf_value value, result, parent_events
             properties = Contrast::Agent::Assess::Tracker.properties(result)
             return unless properties
 
             value_properties = Contrast::Agent::Assess::Tracker.properties(value)
             return unless value_properties
 
-            value_properties.events.each do |event|
-              properties.events << event
-            end
+            parent_events << value_properties.event if value_properties.event
             properties.splat_from(value, result)
           end
 
-          def handle_sprintf_array args, result
+          def handle_sprintf_array args, result, parent_events
             args.each do |value|
-              handle_sprintf_value(value, result)
+              handle_sprintf_value(value, result, parent_events)
             end
           end
 
-          def handle_sprintf_hash args, result
+          def handle_sprintf_hash args, result, parent_events
             args.each_value do |value|
-              handle_sprintf_value(value, result)
+              handle_sprintf_value(value, result, parent_events)
             end
           end
         end

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

@@ -6,45 +6,57 @@ require 'contrast/components/interface'
 module Contrast
   module Extension
     module Assess
-      # This is our patch of the Array class required to handle propagation
+      # This is our patch of the Marshal class
       # Disclaimer: there may be a better way, but we're in a 'get it work' state.
       # Hopefully, we'll be in a 'get it right' state soon.
-      # This module is used for our Marshal#load patches
+      # This module is used for our Marshal.load patches
       class MarshalPropagator
         include Contrast::Components::Interface
 
-        access_component :logging
+        access_component :logging, :scope
 
         class << self
-          def cs__load_trigger_check source, ret
-            current_context = Contrast::Agent::REQUEST_TRACKER.current
-            return unless current_context
-
-            # Since we know this is the source of the trigger, we can do some
-            # optimization here and return when it is not tracked
-            return unless Contrast::Agent::Assess::Tracker.tracked?(source)
-
-            # source might not be all the args passed in, but it is the one we care
-            # about. we could pass in all the args in the last param here if it
-            # becomes an issue in rendering on TS
-            Contrast::Agent::Assess::Policy::TriggerMethod.build_finding(
-                current_context,
-                trigger_node('Marshal', :load),
-                source,
-                self,
-                ret,
-                source)
-            properties = Contrast::Agent::Assess::Tracker.properties(ret)
-            properties.copy_from(source, ret)
-          rescue StandardError => e
-            logger.error('Unable to determine if a trigger occurred in Marshal.load', e)
+          def cs__load_protect arg
+            return if in_contrast_scope?
+
+            with_contrast_scope do
+              Contrast::Agent::Protect::Policy::AppliesDeserializationRule.prepended_invoke(arg)
+            end
+            nil
+          end
+
+          def cs__load_assess source, ret
+            with_contrast_scope do
+              current_context = Contrast::Agent::REQUEST_TRACKER.current
+              return unless current_context
+
+              args = [source]
+              # source might not be all the args passed in, but it is the one we care
+              # about. we could pass in all the args in the last param here if it
+              # becomes an issue in rendering on TS
+              Contrast::Agent::Assess::Policy::TriggerMethod.build_finding(
+                  current_context,
+                  trigger_node('Marshal', :load),
+                  source,
+                  self,
+                  ret,
+                  *args)
+              return unless (properties = Contrast::Agent::Assess::Tracker.properties!(ret))
+
+              properties.copy_from(source, ret)
+
+              node = Contrast::Agent::Assess::Policy::Policy.instance.find_propagator_node('Marshal', :load, false)
+              properties.build_event(node, ret, self, ret, args)
+            rescue StandardError => e
+              logger.error('Unable to run Assess for Marshal.load', e)
+            end
           end
 
           def instrument_marshal_load
             @_instrument_marshal_load ||= begin
-                                            require 'cs__assess_marshal_module/cs__assess_marshal_module'
-                                            true
-                                          end
+              require 'cs__assess_marshal_module/cs__assess_marshal_module'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading marshal load patch', e)
             false