contrast-agent 6.1.2 → 6.4.0

data/lib/contrast/utils/thread_tracker.rb

@@ -3,36 +3,53 @@
 
 module Contrast
   module Utils
-    # ThreadTracker allows tracking of singleton objects across threads
+    # ThreadTracker allows tracking of singleton objects across threads. It acts on Thread#[] as that call is
+    # fiber-local where as Thread#thread_variables is not.
     class ThreadTracker
-      def initialize; end
-
-      # Note about Ruby -- thread#[] is fiber-local,
-      # #thread_variables is not.
-
+      # Get the given key to given value in Thread#[] or return default.
+      #
+      # @param key [Object] key used to reference the value
+      # @param default [Object] value to return if not present in Thread#[]
+      # @return [Object]
       def get key, default = nil
         Thread.current[key] || default
       end
 
+      # Set the given key to given value in Thread#[].
+      #
+      # @param key [Object] key used to reference the value
+      # @param value [Object] value to store
       def set key, value
         Thread.current[key] = value
       end
 
+      # Remove the given key from the current Thread#[] by setting it to nil.
+      #
+      # @param key [Object] key of the value to delete
       def delete key
         Thread.current[key] = nil
       end
 
-      def lifespan obj
-        set(:current_context, obj)
-        response = yield(obj)
+      # Wrap the block given with a RequestContext by setting it beforehand and deleting it after.
+      #
+      # @param context [Contrast::Agent::RequestContext]
+      def lifespan context
+        set(:current_context, context)
+        response = yield(context)
         delete(:current_context)
         response
       end
 
+      # Retrieve the Thread#[] RequestContext
+      #
+      # @return [Contrast::Agent::RequestContext]
       def current
         get(:current_context)
       end
 
+      # Set the Thread#[] context to the one provided.
+      #
+      # @param context [Contrast::Agent::RequestContext]
       def update_current_context context
         set(:current_context, context)
       end

data/lib/contrast/utils/timer.rb

@@ -6,14 +6,19 @@ module Contrast
     # Timer is class that can track state about when an event starts and how long it takes
     # Also contains utility methods to get time values in milliseconds
     class Timer
-      attr_reader :start_ms, :events
+      # @return [Integer] the ms of the Time that this instance represents
+      attr_reader :start_ms
 
+      # Create a wrapper for the current time
+      #
+      # @param time [Time]
       def initialize time = Time.now
         @start_at = time
         @start_ms = (@start_at.to_f * 1000).to_i
         @events = {}
       end
 
+      # @return [Integer] time, in ms
       def self.now_ms
         (Time.now.to_f * 1000).to_i
       end

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
@@ -66,9 +100,7 @@ module Contrast
 end
 
 module Contrast
-  TELEMETRY_EXCEPTIONS = if Contrast::Utils::Telemetry.exceptions_enabled?
-                           Contrast::Utils::TelemetryHash.new(Contrast::Agent::Telemetry::TelemetryException::Event)
-                         end
+  TELEMETRY_EXCEPTIONS = (Contrast::Utils::TelemetryHash.new if Contrast::Utils::Telemetry.exceptions_enabled?)
 end
 
 # This needs to be required very early, after component interfaces, and before instrumentation attempts

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
+