contrast-agent 4.12.0 → 4.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a0a50913c5c680462f9afd79070ca1f3d46d09d66ffdb943b1dc778f84830d6
-  data.tar.gz: bb3254c6a2cdc2b4add4e09b4bf1ed63c6a640f0dd82824db2769b911aacf96b
+  metadata.gz: 8ab9eae65aeefbeb3c12102f71287c60856783238067a7c461fcf534aaa65712
+  data.tar.gz: 1fe74d85374374f40a11c47e44ab0da1042a3f99d607fdfd697a45cc321b45b0
 SHA512:
-  metadata.gz: 78d5e66ee3ab7408e94348f6c2998e73cd78227a8b75cffa7add261b771092d470431ce8e44357dfb7d1a178e03e5033efc9f7a4c974a979f9dea88b2c55a3ec
-  data.tar.gz: d20f41b563778d84e63e4db7a9399e666a85fe1a2343772258f5248cd139f02e6a6bea33e51d9e5a0f954b1e2b4683ec08f3db7a52ab5a6990f7d725d2bc3dea
+  metadata.gz: df020b9d0ff09e61107e280f6e76411f9a9b75c1c94f7082ef52d487e5f88b940e75996dd869d648ac0af654f5f84e48b1f691fdcc9e5f294a565d2bb1a39b7d
+  data.tar.gz: 8bd869bfacbb82aea7b0cf55ff806fded4bae5c6b0454185c4c422bdd14ee07fd1edb3f4b843e702765a4693b51697a0497129d73d3d3652f32cc50056ed783b

data/.simplecov

@@ -4,5 +4,6 @@
 SimpleCov.minimum_coverage line: 94.75
 SimpleCov.start do
   add_filter '/spec/'
+  add_filter '/lib/contrast/extension/assess/erb.rb'
   enable_coverage :branch
 end

data/ext/cs__assess_module/cs__assess_module.c

@@ -57,6 +57,45 @@ contrast_assess_module_module_eval(const int argc, const VALUE *argv,
     return ret;
 }
 
+VALUE
+contrast_assess_module_prepend(const int argc, const VALUE *argv,
+                               const VALUE self) {
+
+    rb_prepend_module(self, argv[0]);
+
+    VALUE module_at;
+    VALUE rb_incl_in_mod_ary = rb_funcall(self, rb_intern("included_in"), 0);
+
+    if (RB_TYPE_P(rb_incl_in_mod_ary, T_ARRAY)) {
+       int i = 0;
+       int size = rb_funcall(rb_incl_in_mod_ary, rb_intern("length"), 0);
+       for (i = 0; i < size; ++i) {
+           module_at = rb_ary_entry(rb_incl_in_mod_ary, i);
+           if (RB_TYPE_P(module_at, T_MODULE)) {
+              rb_include_module(module_at, argv[0]);
+           }
+       }
+    }
+    return self;
+}
+
+VALUE
+contrast_assess_module_included(const int argc, const VALUE *argv,
+                               const VALUE self) {
+   VALUE frozen;
+   if (RB_TYPE_P(self, T_MODULE)) {
+       // check if frozen
+       frozen = rb_funcall(self, rb_intern("cs__frozen?"), 0);
+       if (frozen == Qfalse) {
+           VALUE ary = rb_funcall(self, rb_intern("included_in"), 0);
+           if (RB_TYPE_P(ary, T_ARRAY)) {
+              rb_ary_push(ary, argv[0]);
+           }
+       }
+   }
+   return self;
+}
+
 void Init_cs__assess_module(void) {
     module_eval_trigger =
         rb_define_class_under(core_assess, "EvalTrigger", rb_cObject);
@@ -76,4 +115,13 @@ void Init_cs__assess_module(void) {
 
     contrast_register_patch("Module", "module_eval",
                             contrast_assess_module_module_eval);
+   /*
+    * We patch these for better ancestors handling, and only for older ruby versions.
+    */
+  if (rb_ver_below_three()) {
+     contrast_register_patch("Module", "included",
+                             contrast_assess_module_included);
+     contrast_register_patch("Module", "prepend",
+                             contrast_assess_module_prepend);
+     }
 }

data/ext/cs__assess_module/cs__assess_module.h

@@ -24,5 +24,12 @@ contrast_assess_module_class_eval(const int argc, const VALUE *argv,
 VALUE
 contrast_assess_module_module_eval(const int argc, const VALUE *argv,
                                    const VALUE mod);
+VALUE
+contrast_assess_module_prepend(const int argc, const VALUE *argv,
+                               const VALUE self);
+
+VALUE
+contrast_assess_module_included(const int argc, const VALUE *argv,
+                               const VALUE mod);
 
 void Init_cs__assess_module(void);

data/ext/cs__common/cs__common.c

@@ -144,6 +144,11 @@ _contrast_register_patch(const char *module_name, const char *method_name,
     return SYM2ID(underlying_method_name);
 }
 
+int rb_ver_below_three() {
+  int ruby_version = FIX2INT(rb_funcall(rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")), rb_intern("to_i"), 0));
+  return ruby_version < 3;
+}
+
 void Init_cs__common(void) {
     cs__send_method = rb_intern("send");
     cs__alias_method_sym = ID2SYM(rb_intern("alias_method"));

data/ext/cs__common/cs__common.h

@@ -34,6 +34,14 @@ static VALUE rb_sym_alias_singleton;
 static VALUE rb_sym_prepend_instance;
 static VALUE rb_sym_prepend_singleton;
 
+/*
+ * Check if ruby version is < 3.0.0.
+ * We are using this for handling ancestors of included modules.
+ * Since this is fixed after Ruby 3.0.0 we should remove this after
+ * dropping support for older versions, as no longer needed.
+ */
+int rb_ver_below_three();
+
 void patch_via_funchook(void *original_function, void *hook_function);
 
 void contrast_alias_method(const VALUE target, const char *to,

data/ext/cs__contrast_patch/cs__contrast_patch.c

@@ -43,7 +43,7 @@ VALUE contrast_patch_call_original(const VALUE *args) {
         if (rb_block_given_p()) {
             return rb_funcall_with_block_kw(object, method_id, argc, params, rb_block_proc(), RB_PASS_CALLED_KEYWORDS);
         } else {
-            return rb_funcallv_kw(object, method_id, argc, params, RB_PASS_CALLED_KEYWORDS); 
+            return rb_funcallv_kw(object, method_id, argc, params, RB_PASS_CALLED_KEYWORDS);
         }
     /* Ruby < 2.7 */
     #else
@@ -448,6 +448,21 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
                                    -1);
     }
     rb_prepend_module(originalModule, module);
+
+    if (rb_ver_below_three()) {
+        VALUE module_at;
+        VALUE rb_incl_in_mod_ary = rb_funcall(originalModule, rb_intern("included_in"), 0);
+        if (RB_TYPE_P(rb_incl_in_mod_ary, T_ARRAY)) {
+            int i = 0;
+            int size = rb_funcall(rb_incl_in_mod_ary, rb_intern("length"), 0);
+            for (i = 0; i < size; ++i) {
+                module_at = rb_ary_entry(rb_incl_in_mod_ary, i);
+                if (RB_TYPE_P(module_at, T_MODULE)) {
+                    rb_include_module(module_at, module);
+                }
+            }
+        }
+   }
     return Qtrue;
 }
 

data/ext/cs__os_information/cs__os_information.c

@@ -0,0 +1,31 @@
+/* Copyright (c) 2021 Contrast Security, Inc.  See
+ * https://www.contrastsecurity.com/enduser-terms-0317a for more details. */
+
+#include "cs__os_information.h"
+#include <dlfcn.h>
+#include <ruby.h>
+#include <sys/utsname.h>
+
+VALUE contrast, utils, os;
+
+VALUE contrast_get_system_information()
+{
+    struct utsname uname_pointer;
+
+    uname (&uname_pointer);
+
+    VALUE rb_data_hash = rb_hash_new();
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_type"), rb_str_new2(uname_pointer.sysname));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_version"), rb_str_new2(uname_pointer.release));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_complete_version"), rb_str_new2(uname_pointer.version));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_arch"), rb_str_new2(uname_pointer.machine));
+    return rb_data_hash;
+}
+
+void Init_cs__os_information(void)
+{
+    contrast = rb_define_module("Contrast");
+    utils = rb_define_module_under(contrast, "Utils");
+    os = rb_define_module_under(utils, "OS");
+    rb_define_module_function(os, "get_system_information", contrast_get_system_information, 0);
+}

data/ext/cs__os_information/cs__os_information.h

@@ -0,0 +1,7 @@
+#include <ruby.h>
+
+extern VALUE contrast, utils, os;
+
+VALUE contrast_get_system_information();
+
+void Init_cs__os_information(void);

data/ext/cs__os_information/extconf.rb

@@ -0,0 +1,5 @@
+# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+$TO_MAKE = File.basename(__dir__)
+require_relative '../extconf_common'

data/lib/contrast/agent/assess/policy/policy_node.rb

@@ -135,14 +135,14 @@ module Contrast
 
             converted = []
             markers.split(Contrast::Utils::ObjectShare::COMMA).each do |t|
-              case t
-              when Contrast::Utils::ObjectShare::OBJECT_KEY,
+              converted << case t
+                           when Contrast::Utils::ObjectShare::OBJECT_KEY,
                    Contrast::Utils::ObjectShare::RETURN_KEY
 
-                converted << t
-              else
-                converted << Integer(t[1..-1])
-              end
+                             t
+                           else
+                             Integer(t[1..-1])
+                           end
             end
             converted
           end

data/lib/contrast/agent/assess/policy/policy_scanner.rb

@@ -32,8 +32,13 @@ module Contrast
               mod = trace_point.self
               return if mod.cs__frozen? || mod.singleton_class?
 
+              different_ruby_version trace_point, provider_values, mod
+            end
+
+            def different_ruby_version trace_point, provider_values, mod
               # TODO: RUBY-1014 - remove non-AST approach
               if RUBY_VERSION >= '2.6.0'
+                # TODO: RUBY-714 EOL 2.5. That check will be removed and the code will be brought back in here.
                 ast = RubyVM::AbstractSyntaxTree.parse_file(trace_point.path)
                 provider_values.each do |provider|
                   provider.parse(trace_point, ast)

data/lib/contrast/agent/assess/policy/propagation_method.rb

@@ -7,6 +7,7 @@ require 'contrast/agent/assess/policy/propagator'
 require 'contrast/components/logger'
 require 'contrast/utils/object_share'
 require 'contrast/utils/sha256_builder'
+require 'contrast/utils/assess/propagation_method_utils'
 
 module Contrast
   module Agent
@@ -16,35 +17,9 @@ module Contrast
         # untrusted value. In general, these methods work on the String class or a holder of Strings.
         module PropagationMethod
           extend Contrast::Components::Logger::InstanceMethods
-
-          APPEND_ACTION = 'APPEND'
-          CENTER_ACTION = 'CENTER'
-          INSERT_ACTION = 'INSERT'
-          KEEP_ACTION = 'KEEP'
-          NEXT_ACTION = 'NEXT'
-          NOOP_ACTION = 'NOOP'
-          PREPEND_ACTION = 'PREPEND'
-          REPLACE_ACTION = 'REPLACE'
-          REMOVE_ACTION = 'REMOVE'
-          REVERSE_ACTION = 'REVERSE'
-          SPLAT_ACTION = 'SPLAT'
-          SPLIT_ACTION = 'SPLIT'
-          DB_WRITE_ACTION = 'DB_WRITE'
-          CUSTOM_ACTION = 'CUSTOM'
+          extend Contrast::Utils::Assess::PropagationMethodUtils
 
           class << self
-            def determine_target propagation_node, ret, object, args
-              target = propagation_node.targets[0]
-              case target
-              when Contrast::Utils::ObjectShare::OBJECT_KEY
-                object
-              when Contrast::Utils::ObjectShare::RETURN_KEY
-                ret
-              else
-                args[target]
-              end
-            end
-
             # @param method_policy [Contrast::Agent::Patching::Policy::MethodPolicy] the policy that governs the
             #   patches to this method
             # @param preshift [Contrast::Agent::Assess::PreShift] The capture of the state of the code just prior to
@@ -65,21 +40,6 @@ module Contrast
               PropagationMethod.apply_propagator(propagation_node, preshift, target, object, ret, args, block)
             end
 
-            PROPAGATION_ACTIONS = {
-                APPEND_ACTION => Contrast::Agent::Assess::Policy::Propagator::Append,
-                CENTER_ACTION => Contrast::Agent::Assess::Policy::Propagator::Center,
-                INSERT_ACTION => Contrast::Agent::Assess::Policy::Propagator::Insert,
-                KEEP_ACTION => Contrast::Agent::Assess::Policy::Propagator::Keep,
-                NEXT_ACTION => Contrast::Agent::Assess::Policy::Propagator::Next,
-                NOOP_ACTION => nil,
-                PREPEND_ACTION => Contrast::Agent::Assess::Policy::Propagator::Prepend,
-                REPLACE_ACTION => Contrast::Agent::Assess::Policy::Propagator::Replace,
-                REMOVE_ACTION => Contrast::Agent::Assess::Policy::Propagator::Remove,
-                REVERSE_ACTION => Contrast::Agent::Assess::Policy::Propagator::Reverse,
-                SPLAT_ACTION => Contrast::Agent::Assess::Policy::Propagator::Splat,
-                SPLIT_ACTION => Contrast::Agent::Assess::Policy::Propagator::Split
-            }.cs__freeze
-
             # I lied above. We had to figure out what the target of the propagation was. Now that we know, we'll
             # actually do things to it. Note that the return of this method will replace the original return of the
             # patched function unless it is nil, so be sure you're returning what you intend.
@@ -116,80 +76,6 @@ module Contrast
               nil
             end
 
-            # Custom actions tend to be the more complex of our propagations. Often, the method has to make decisions
-            # about the target based on the context with which the method was called. As such, defer determining if the
-            # target is valid to that method.
-            #
-            # In all other cases, a target is valid for propagation if it is not nil
-            #
-            # @param target [Object] the thing to which to propagate
-            # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode] the node that governs this
-            #   propagation event.
-            # @return [Boolean]
-            def valid_target? target, propagation_node
-              return true if propagation_node.action == CUSTOM_ACTION
-
-              !!target
-            end
-
-            ZERO_LENGTH_ACTIONS = [DB_WRITE_ACTION, CUSTOM_ACTION, KEEP_ACTION, REPLACE_ACTION, SPLAT_ACTION].cs__freeze
-            # If the action required needs a length and the target does not have one, the length is not valid
-            #
-            # @param target [Object] the thing to which to propagate
-            # @param action [String] the name of the action taken during this propagation
-            # @return [Boolean]
-            def valid_length? target, action
-              return true if ZERO_LENGTH_ACTIONS.include?(action)
-
-              if Contrast::Utils::DuckUtils.quacks_to?(target, :length)
-                target.length != 0 # rubocop:disable Style/ZeroLengthPredicate
-              else
-                !target.to_s.empty?
-              end
-            end
-
-            # Before we do any work, we should check if we even need to. If the source and target of this patcher are
-            # not tracked, there's no need to do anything. A copy of nothing is still nothing.
-            #
-            # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode] the node that governs this
-            #   propagation event.
-            # @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
-            # @return [Boolean]
-            def can_propagate? propagation_node, preshift, target
-              return false unless appropriate_target?(propagation_node, target)
-              return true if Contrast::Utils::Assess::TrackingUtil.tracked?(target)
-              return false unless 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)
-                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])
-                end
-              end
-              false
-            end
-
-            # We cannot propagate to frozen things that have not been updated to work with our property tracking,
-            # unless they're duplicable and the return. We probably shouldn't propagate to frozen things at all, as
-            # they're supposed to be immutable, but third parties do jenky things, so allow it as long as it is safe to
-            # do.
-            #
-            # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode] the node that governs this
-            #   propagation event.
-            # @param target [Object] the Target to which to propagate.
-            # @return [Boolean] if the target can be propagated to
-            def appropriate_target? propagation_node, target
-              # special handle Returns b/c we can do unfreezing magic during propagation
-              return true if propagation_node.targets[0] == Contrast::Utils::ObjectShare::RETURN_KEY
-
-              Contrast::Agent::Assess::Tracker.trackable?(target)
-            end
-
             # If this patcher has tags, apply them to the entire target
             # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode] the node that governs this
             #   propagation event.

data/lib/contrast/agent/assess/policy/propagation_node.rb

@@ -95,8 +95,8 @@ module Contrast
 
           def needs_object?
             if @_needs_object.nil?
-              @_needs_object = action == Contrast::Agent::Assess::Policy::PropagationMethod::CUSTOM_ACTION ||
-                  action == Contrast::Agent::Assess::Policy::PropagationMethod::DB_WRITE_ACTION ||
+              @_needs_object = action == Contrast::Utils::Assess::PropagationMethodUtils::CUSTOM_ACTION ||
+                  action == Contrast::Utils::Assess::PropagationMethodUtils::DB_WRITE_ACTION ||
                   sources.any?(Contrast::Utils::ObjectShare::OBJECT_KEY) ||
                   targets.any?(Contrast::Utils::ObjectShare::OBJECT_KEY)
             end
@@ -105,8 +105,8 @@ module Contrast
 
           def needs_args?
             if @_needs_args.nil?
-              @_needs_args = action == Contrast::Agent::Assess::Policy::PropagationMethod::CUSTOM_ACTION ||
-                  action == Contrast::Agent::Assess::Policy::PropagationMethod::DB_WRITE_ACTION ||
+              @_needs_args = action == Contrast::Utils::Assess::PropagationMethodUtils::CUSTOM_ACTION ||
+                  action == Contrast::Utils::Assess::PropagationMethodUtils::DB_WRITE_ACTION ||
                   sources.any? { |source| source.is_a?(Integer) || source.is_a?(Symbol) } ||
                   targets.any? { |target| target.is_a?(Integer) || target.is_a?(Symbol) }
             end

data/lib/contrast/agent/assess/policy/propagator/center.rb

@@ -24,7 +24,7 @@ module Contrast
                 end
 
                 # find original in the target, copy tags to the new position in target
-                original_start_index = target[0..target.length / 2 + 1].rindex(source1)
+                original_start_index = target[0..(target.length / 2) + 1].rindex(source1)
                 original_start_index ||= 1
                 properties.copy_from(source1, target, original_start_index, propagation_node.untags)
 

data/lib/contrast/agent/assess/policy/propagator/substitution.rb

@@ -3,6 +3,7 @@
 
 require 'contrast/components/logger'
 require 'contrast/utils/duck_utils'
+require 'contrast/utils/substitution_utils'
 
 module Contrast
   module Agent
@@ -17,9 +18,7 @@ module Contrast
           class Substitution
             include Contrast::Components::Logger::InstanceMethods
             extend Contrast::Components::Logger::InstanceMethods
-
-            CAPTURE_GROUP_REGEXP = /\\[[:digit:]]/.cs__freeze
-            CAPTURE_NAME_REGEXP = /\\k<[[:alpha:]]/.cs__freeze
+            extend Contrast::Utils::SubstitutionUtils
 
             class << self
               # gsub is hard. there are four versions of this method
@@ -38,157 +37,6 @@ module Contrast
               def sub_tagger patcher, preshift, ret, block
                 substitution_tagger(patcher, preshift, ret, !block.nil?, false)
               end
-
-              private
-
-              def substitution_tagger patcher, preshift, ret, block, global = true
-                return ret unless ret
-
-                begin
-                  source = preshift.object
-                  self_tracked = Contrast::Agent::Assess::Tracker.tracked?(source)
-                  args = preshift.args[1]
-                  incoming_tracked = args && determine_tracked(args)
-                  return ret unless self_tracked || incoming_tracked
-
-                  parent_events = []
-                  if block
-                    block_sub(self_tracked, source, ret)
-                  elsif args.is_a?(String)
-                    string_sub(parent_events, self_tracked, preshift, ret, args, incoming_tracked, global)
-                  elsif args.is_a?(Hash)
-                    hash_sub(self_tracked, source, ret)
-                  else # Enumerator, only for gsub
-                    pattern_gsub(parent_events, preshift, ret)
-                  end
-
-                  if self_tracked
-                    source_properties = Contrast::Agent::Assess::Tracker.properties(source)
-                    parent_event = source_properties&.event
-                    parent_events.prepend(parent_event) if parent_event
-                  end
-                  string_build_event(parent_events, patcher, preshift, ret)
-                rescue StandardError => e
-                  logger.error('Unable to apply gsub propagator', e)
-                end
-                ret
-              end
-
-              def determine_tracked args
-                # if there's no arg, it can't be tracked
-                return false unless args
-
-                # if it's a string, just ask if it's tracked
-                case args
-                when String
-                  Contrast::Agent::Assess::Tracker.tracked?(args)
-                  # if it's a hash, ask if it has a tracked string
-                when Hash
-                  args.values.any? { |value| value.is_a?(String) && Contrast::Agent::Assess::Tracker.tracked?(value) }
-                  # this should never happen
-                else
-                  false
-                end
-              end
-
-              def string_sub parent_events, self_tracked, preshift, ret, incoming, incoming_tracked, global
-                return unless (properties = Contrast::Agent::Assess::Tracker.properties!(ret))
-
-                incoming_properties = Contrast::Agent::Assess::Tracker.properties(incoming)
-                parent_events << incoming_properties&.event if incoming_properties&.event
-
-                source = preshift.object
-
-                # We can't efficiently find the places that things were
-                # copied from regexp / captures. Trading accuracy for
-                # performance
-                if incoming.match?(CAPTURE_GROUP_REGEXP) || incoming.match?(CAPTURE_NAME_REGEXP)
-                  properties.splat_from(source, ret) if self_tracked
-                  return
-                end
-
-                # if it's just a straight insert, that we can do
-                # Copy the tags from us to the return
-                ranges = find_string_sub_insert(properties, preshift, incoming, ret, global)
-
-                properties.delete_tags_at_ranges(ranges)
-                properties.shift_tags(ranges)
-                return unless incoming_tracked
-                return unless incoming_properties
-
-                tags = incoming_properties.tag_keys
-                ranges.each do |range|
-                  tags.each do |tag|
-                    properties.add_tag(tag, range)
-                  end
-                end
-              end
-
-              # Find the points at which the new String was placed into the original
-              #
-              # @param properties [Contrast::Agent::Assess::Properties] the Properties of the ret
-              # @param preshift [Contrast::Agent::Assess::PreShift] the capture of the state of the code just prior to
-              #   the invocation of the patched method
-              # @param incoming [String] the new String going into the substitution
-              # @param ret [String] the result of the substitution
-              # @param global [Boolean] if this was a global or single substitution
-              # @return [Array<Range>] the Ranges where substitution occurred
-              def find_string_sub_insert properties, preshift, incoming, ret, global
-                pattern = preshift.args[0]
-                source = preshift.object
-
-                properties.copy_from(source, ret)
-                # Figure out where inserts occurred
-                last_idx = 0
-                ranges = []
-                # For each insert, move the tag ranges
-                while last_idx
-                  idx = source.index(pattern, last_idx)
-                  break unless idx
-
-                  last_idx = idx ? idx + 1 : nil
-                  start_index = idx
-                  end_index = idx + incoming.length
-                  ranges << (start_index...end_index)
-                  break unless global
-                end
-                ranges
-              end
-
-              def block_sub self_tracked, source, ret
-                return unless self_tracked
-
-                properties = Contrast::Agent::Assess::Tracker.properties!(ret)
-                properties&.splat_from(source, ret)
-              end
-
-              def hash_sub self_tracked, source, ret
-                return unless self_tracked
-
-                properties = Contrast::Agent::Assess::Tracker.properties!(ret)
-                properties&.splat_from(source, ret)
-              end
-
-              def pattern_gsub parent_events, preshift, ret
-                source = preshift.object
-                return unless (source_properties = Contrast::Agent::Assess::Tracker.properties(source))
-                return unless (properties = Contrast::Agent::Assess::Tracker.properties!(ret))
-
-                source_properties.tag_keys.each do |key|
-                  properties.add_tag(key, 0...1)
-                end
-                parent_event = source_properties.event
-                parent_events << parent_event if parent_event
-              end
-
-              def string_build_event parent_events, patcher, preshift, ret
-                return unless Contrast::Agent::Assess::Tracker.tracked?(ret)
-
-                properties = Contrast::Agent::Assess::Tracker.properties(ret)
-                args = preshift.args
-                properties.build_event(patcher, ret, preshift.object, ret, args, 2)
-                properties.event.instance_variable_set(:@_parent_events, parent_events)
-              end
             end
           end
         end