contrast-agent 6.3.0 → 6.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b7fbfe09d8f01268274ec60a3861fc4377278e0e33aafadd29a13aec59348bb
-  data.tar.gz: caf12a68dca338f4e1ed0e04483857cd7c55140d8698f1aa55b82c6f85d210c6
+  metadata.gz: d74206aa94d644cbe7c47523a69efdb9c0f27d59604125287fd98b123f0d20d6
+  data.tar.gz: d4c28074b8d3f11e968d9c3875bfd16d3de41bdd63452bec470cea65a6c83089
 SHA512:
-  metadata.gz: cd9eb2d8fd9faf79ad16e0d32889806c93178f696ad64aa58cdc046e46c1cb5e0ff463e54cf81e491518fd732a664f5838147f83c791c869d3689695b1255384
-  data.tar.gz: '097d53ac525825b0b3b305dafe1be2cc178f7198e057f292561e7ffa4801476dcf151d9a51d6277033dbaf149f6ed0d9b52606aebebeffc7636564eea59bbf74'
+  metadata.gz: 3dd36988b29722b7961e919d2685a8cafbf001917f54f5e43107cf51fddb7c105cfea368e04f819f01dc388dd75f5bf739f9bb0c58301784c90bf48188c43bd8
+  data.tar.gz: 18a2cbb1e4a4e56d64d3a3821c47ec3aca5709f64673ffb0024b26173de7d1ed4aa8213c851c202c1d30c118d73a4f373b14563d3aa3d9f017ea8caa24ead71d

data/.gitignore

@@ -56,8 +56,5 @@ contrast-agent-*.gem
 .ruby-gemset
 service_executables/*-*
 
-# Generated Protobuf files
-/lib/contrast/api/*.pb.rb
-
 # IDE stuff
 tags

data/.simplecov

@@ -4,5 +4,6 @@
 SimpleCov.minimum_coverage(line: 94)
 SimpleCov.start do
   add_filter '/spec/'
+  add_filter '/lib/protobuf/'
   enable_coverage :branch
 end

data/Rakefile

@@ -17,30 +17,3 @@ Dir['ext/cs__*'].each do |extension|
     ext.lib_dir = "lib/#{ name }"
   end
 end
-
-desc 'compile the protobuf files for the agent, translating them to .rb classes'
-task :contrast_pb_compile do
-  # do some stuff before compile
-
-  # Invoke the protobuf compile task with your sensible defaults
-  ::Rake::Task['protobuf:compile'].invoke('lib', './agent-service-api/protobuf ./agent-service-api/protobuf/dtm.proto',
-                                          'lib/contrast/api',
-                                          nil)
-
-  ::Rake::Task['protobuf:compile'].reenable
-
-  ::Rake::Task['protobuf:compile'].invoke('lib',
-                                          './agent-service-api/protobuf ./agent-service-api/protobuf/settings.proto',
-                                          'lib/contrast/api',
-                                          nil)
-
-  ['dtm.pb.rb', 'settings.pb.rb'].each do |target_file|
-    target_path = File.absolute_path(File.join(__dir__, "./lib/contrast/api/#{ target_file }"))
-    unless File.exist?(target_path)
-      puts "File not found #{ target_path }"
-      exit 1
-    end
-  end
-
-  puts 'Protobuf copied successfully'
-end

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

@@ -58,8 +58,6 @@ module Contrast
             #                         ret [Object] the Return of the invoked method
             #                         args [Array<Object>] the Arguments with which the method was invoked
             # @param block [Block] the Block passed to the original method
-            # @return [Object, nil] the tracked Return or nil if no changes were made; will replace the return of the
-            #   original function if not nil
             def apply_propagator propagation_node, preshift, target, propagation_data, block
               return unless propagation_possible?(propagation_node, target)
 

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

@@ -211,7 +211,7 @@ module Contrast
 
               build_events(finding, properties.event) if properties.event
 
-              # Google::Protobuf::Map doesn't support merge!, so we have to do this long form
+              # CSGoogle::Protobuf::Map doesn't support merge!, so we have to do this long form
               source_props = properties.properties
               return unless source_props
 

data/lib/contrast/agent/version.rb

@@ -3,6 +3,6 @@
 
 module Contrast
   module Agent
-    VERSION = '6.3.0'
+    VERSION = '6.4.0'
   end
 end

data/lib/contrast/api/dtm.pb.rb

@@ -8,7 +8,7 @@ require 'protobuf'
 module Contrast
   module Api
     module Dtm
-      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
+      ::Protobuf::Optionable.inject(self) { ::CSGoogle::Protobuf::FileOptions }
 
       ##
       # Message Classes

data/lib/contrast/api/settings.pb.rb

@@ -8,7 +8,7 @@ require 'protobuf'
 module Contrast
   module Api
     module Settings
-      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
+      ::Protobuf::Optionable.inject(self) { ::CSGoogle::Protobuf::FileOptions }
 
       ##
       # Enum Classes

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

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

data/lib/contrast.rb

@@ -21,6 +21,39 @@ class Object
   alias_method :cs__singleton_class, :singleton_class
 end
 
+# ActiveRecord gives access to the `String#blank?` method, which we've started using. We need to make sure that method
+# actually exists.
+# From https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/object/blank.rb
+class String
+  unless cs__respond_to?(:blank?)
+
+    CS__BLANK_RE = /\A[[:space:]]*\z/.cs__freeze
+    # A string is blank if it's empty or contains whitespaces only:
+    #
+    #   ''.blank?       # => true
+    #   '   '.blank?    # => true
+    #   "\t\n\r".blank? # => true
+    #   ' blah '.blank? # => false
+    #
+    # Unicode whitespace is supported:
+    #
+    #   "\u00a0".blank? # => true
+    #
+    # @return [true, false]
+    def blank?
+      # The regexp that matches blank strings is expensive. For the case of empty
+      # strings we can speed up this method (~3.5x) with an empty? call. The
+      # penalty for the rest of strings is marginal.
+      empty? ||
+          begin
+            CS__BLANK_RE.match?(self)
+          rescue Encoding::CompatibilityError
+            false
+          end
+    end
+  end
+end
+
 if RUBY_VERSION >= '3.0.0' && RUBY_VERSION < '3.1.0'
   # This fixes Ruby 3.0 issues with Module#(some instance method) patching by preventing the prepending of
   # a JSON helper on protobuf load. String.instance_method(:+) is one of the most noticeable.
@@ -50,6 +83,7 @@ require 'contrast/components/settings'
 require 'contrast/utils/telemetry_hash'
 require 'contrast/utils/telemetry'
 require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_event'
+require 'protobuf' # TODO: RUBY-1438
 
 module Contrast
   API = Contrast::Components::Api::Interface.new

data/lib/protobuf/code_generator.rb

@@ -0,0 +1,129 @@
+require 'active_support/core_ext/module/aliasing'
+require 'protobuf/generators/file_generator'
+
+module Protobuf
+  class CodeGenerator
+
+    CodeGeneratorFatalError = Class.new(RuntimeError)
+
+    def self.fatal(message)
+      fail CodeGeneratorFatalError, message
+    end
+
+    def self.print_tag_warning_suppress
+      STDERR.puts "Suppress tag warning output with PB_NO_TAG_WARNINGS=1."
+      def self.print_tag_warning_suppress; end # rubocop:disable Lint/DuplicateMethods, Lint/NestedMethodDefinition
+    end
+
+    def self.warn(message)
+      STDERR.puts("[WARN] #{message}")
+    end
+
+    private
+
+    attr_accessor :request
+
+    public
+
+    def initialize(request_bytes)
+      @request_bytes = request_bytes
+      self.request = ::CSGoogle::Protobuf::Compiler::CodeGeneratorRequest.decode(request_bytes)
+    end
+
+    def eval_unknown_extensions!
+      request.proto_file.each do |file_descriptor|
+        ::Protobuf::Generators::FileGenerator.new(file_descriptor).eval_unknown_extensions!
+      end
+      self.request = ::CSGoogle::Protobuf::Compiler::CodeGeneratorRequest.decode(@request_bytes)
+    end
+
+    def generate_file(file_descriptor)
+      ::Protobuf::Generators::FileGenerator.new(file_descriptor).generate_output_file
+    end
+
+    def response_bytes
+      generated_files = request.proto_file.map do |file_descriptor|
+        generate_file(file_descriptor)
+      end
+
+      ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse.encode(
+        :file => generated_files,
+        :supported_features => supported_features,
+      )
+    end
+
+    def supported_features
+      # The only available feature is proto3 with optional fields.
+      # This is backwards compatible with proto2 optional fields.
+      ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse::Feature::FEATURE_PROTO3_OPTIONAL.to_i
+    end
+
+    Protobuf::Field::BaseField.module_eval do
+      def define_set_method!
+      end
+
+      def set_without_options(message_instance, bytes)
+        return message_instance[name] = decode(bytes) unless repeated?
+
+        if map?
+          hash = message_instance[name]
+          entry = decode(bytes)
+          # decoded value could be nil for an
+          # enum value that is not recognized
+          hash[entry.key] = entry.value unless entry.value.nil?
+          return hash[entry.key]
+        end
+
+        return message_instance[name] << decode(bytes) unless packed?
+
+        array = message_instance[name]
+        stream = StringIO.new(bytes)
+
+        if wire_type == ::Protobuf::WireType::VARINT
+          array << decode(Varint.decode(stream)) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED64
+          array << decode(stream.read(8)) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED32
+          array << decode(stream.read(4)) until stream.eof?
+        end
+      end
+
+      # Sets a MessageField that is known to be an option.
+      # We must allow fields to be set one at a time, as option syntax allows us to
+      # set each field within the option using a separate "option" line.
+      def set_with_options(message_instance, bytes)
+        if message_instance[name].is_a?(::Protobuf::Message)
+          gp = CSGoogle::Protobuf
+          if message_instance.is_a?(gp::EnumOptions) || message_instance.is_a?(gp::EnumValueOptions) ||
+             message_instance.is_a?(gp::FieldOptions) || message_instance.is_a?(gp::FileOptions) ||
+             message_instance.is_a?(gp::MethodOptions) || message_instance.is_a?(gp::ServiceOptions) ||
+             message_instance.is_a?(gp::MessageOptions)
+
+            original_field = message_instance[name]
+            decoded_field = decode(bytes)
+            decoded_field.each_field do |subfield, subvalue|
+              option_set(original_field, subfield, subvalue) { decoded_field.field?(subfield.tag) }
+            end
+            return
+          end
+        end
+
+        set_without_options(message_instance, bytes)
+      end
+      alias_method :set, :set_with_options
+
+      def option_set(message_field, subfield, subvalue)
+        return unless yield
+        if subfield.repeated?
+          message_field[subfield.tag].concat(subvalue)
+        elsif message_field[subfield.tag] && subvalue.is_a?(::Protobuf::Message)
+          subvalue.each_field do |f, v|
+            option_set(message_field[subfield.tag], f, v) { subvalue.field?(f.tag) }
+          end
+        else
+          message_field[subfield.tag] = subvalue
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/decoder.rb

@@ -0,0 +1,28 @@
+module Protobuf
+  class Decoder
+
+    # Read bytes from +stream+ and pass to +message+ object.
+    def self.decode_each_field(stream)
+      until stream.eof?
+        bits = Varint.decode(stream)
+        wire_type = bits & 0x07
+        tag = bits >> 3
+
+        bytes = if wire_type == ::Protobuf::WireType::VARINT
+                  Varint.decode(stream)
+                elsif wire_type == ::Protobuf::WireType::LENGTH_DELIMITED
+                  value_length = Varint.decode(stream)
+                  stream.read(value_length)
+                elsif wire_type == ::Protobuf::WireType::FIXED64
+                  stream.read(8)
+                elsif wire_type == ::Protobuf::WireType::FIXED32
+                  stream.read(4)
+                else
+                  fail InvalidWireType, wire_type
+                end
+
+        yield(tag, bytes)
+      end
+    end
+  end
+end

data/lib/protobuf/deprecation.rb

@@ -0,0 +1,117 @@
+require 'active_support/deprecation'
+
+module Protobuf
+  if ::ActiveSupport::Deprecation.is_a?(Class)
+    class DeprecationBase < ::ActiveSupport::Deprecation
+      def deprecate_methods(*args)
+        deprecation_options = { :deprecator => self }
+
+        if args.last.is_a?(Hash)
+          args.last.merge!(deprecation_options)
+        else
+          args.push(deprecation_options)
+        end
+
+        super
+      end
+
+      def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
+        # This ensures ActiveSupport::Deprecation doesn't look for the caller, which is very costly.
+        super(deprecated_method_name, message, caller_backtrace) unless ENV.key?('PB_IGNORE_DEPRECATIONS')
+      end
+    end
+
+    class Deprecation < DeprecationBase
+      def define_deprecated_methods(target_module, method_hash)
+        target_module.module_eval do
+          method_hash.each do |old_method, new_method|
+            alias_method old_method, new_method
+          end
+        end
+
+        deprecate_methods(target_module, method_hash)
+      end
+    end
+
+    class FieldDeprecation < DeprecationBase
+      # this is a convenience deprecator for deprecated proto fields
+
+      def deprecate_method(target_module, method_name)
+        deprecate_methods(target_module, method_name => target_module)
+      end
+
+      private
+
+      def deprecated_method_warning(method_name, target_module)
+        "#{target_module.name}##{method_name} field usage is deprecated"
+      end
+    end
+  else
+    # TODO: remove this clause when Rails < 4 support is no longer needed
+    deprecator = ::ActiveSupport::Deprecation.clone
+    deprecator.instance_eval do
+      def new(deprecation_horizon = nil, *)
+        self.deprecation_horizon = deprecation_horizon if deprecation_horizon
+        self
+      end
+    end
+    Deprecation = deprecator.clone
+    FieldDeprecation = deprecator.clone
+
+    Deprecation.instance_eval do
+      def define_deprecated_methods(target_module, method_hash)
+        target_module.module_eval do
+          method_hash.each do |old_method, new_method|
+            alias_method old_method, new_method
+          end
+        end
+
+        deprecate_methods(target_module, method_hash)
+      end
+    end
+
+    FieldDeprecation.instance_eval do
+      def deprecate_method(target_module, method_name)
+        deprecate_methods(target_module, method_name => target_module)
+      end
+
+      private
+
+      def deprecated_method_warning(method_name, target_module)
+        "#{target_module.name}##{method_name} field usage is deprecated"
+      end
+    end
+  end
+
+  def self.deprecator
+    @deprecator ||= Deprecation.new('4.0', to_s).tap do |deprecation|
+      deprecation.silenced = ENV.key?('PB_IGNORE_DEPRECATIONS')
+      deprecation.behavior = :stderr
+    end
+  end
+
+  def self.field_deprecator
+    @field_deprecator ||= FieldDeprecation.new.tap do |deprecation|
+      deprecation.silenced = ENV.key?('PB_IGNORE_DEPRECATIONS')
+      deprecation.behavior = :stderr
+    end
+  end
+
+  # Print Deprecation Warnings
+  #
+  # Default: true
+  #
+  # Simple boolean to define whether we want field deprecation warnings to
+  # be printed to stderr or not. The rpc_server has an option to set this value
+  # explicitly, or you can turn this option off by setting
+  # ENV['PB_IGNORE_DEPRECATIONS'] to a non-empty value.
+  #
+  # The rpc_server option will override the ENV setting.
+  def self.print_deprecation_warnings?
+    !field_deprecator.silenced
+  end
+
+  def self.print_deprecation_warnings=(value)
+    field_deprecator.silenced = !value
+  end
+end

data/lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+
+##
+# Imports
+#
+require 'google/protobuf/descriptor.pb'
+
+module CSGoogle
+  module Protobuf
+    module Compiler
+      ::Protobuf::Optionable.inject(self) { ::CSGoogle::Protobuf::FileOptions }
+
+      ##
+      # Message Classes
+      #
+      class Version < ::Protobuf::Message; end
+      class CodeGeneratorRequest < ::Protobuf::Message; end
+      class CodeGeneratorResponse < ::Protobuf::Message
+        class Feature < ::Protobuf::Enum
+          define :FEATURE_NONE, 0
+          define :FEATURE_PROTO3_OPTIONAL, 1
+        end
+
+        class File < ::Protobuf::Message; end
+
+      end
+
+
+
+      ##
+      # File Options
+      #
+      set_option :java_package, "com.google.protobuf.compiler"
+      set_option :java_outer_classname, "PluginProtos"
+      set_option :go_package, "google.golang.org/protobuf/types/pluginpb"
+
+
+      ##
+      # Message Fields
+      #
+      class Version
+        optional :int32, :major, 1
+        optional :int32, :minor, 2
+        optional :int32, :patch, 3
+        optional :string, :suffix, 4
+      end
+
+      class CodeGeneratorRequest
+        repeated :string, :file_to_generate, 1
+        optional :string, :parameter, 2
+        repeated ::CSGoogle::Protobuf::FileDescriptorProto, :proto_file, 15
+        optional ::CSGoogle::Protobuf::Compiler::Version, :compiler_version, 3
+      end
+
+      class CodeGeneratorResponse
+        class File
+          optional :string, :name, 1
+          optional :string, :insertion_point, 2
+          optional :string, :content, 15
+          optional ::CSGoogle::Protobuf::GeneratedCodeInfo, :generated_code_info, 16
+        end
+
+        optional :string, :error, 1
+        optional :uint64, :supported_features, 2
+        repeated ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse::File, :file, 15
+      end
+
+    end
+
+  end
+
+end
+