newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/noticeable_error.rb

@@ -0,0 +1,19 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    # This class is used for instrumentations that have exceptions or error classes
+    # not derived from Ruby's usual Exception or StandardError or in situations
+    # where we do not have such Exception object to work with.
+    class NoticeableError
+      attr_reader :class_name, :message
+
+      def initialize(class_name, message)
+        @class_name = class_name
+        @message = message
+      end
+    end
+  end
+end

data/lib/new_relic/agent/null_logger.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # A stub object that we can use in place of a real Logger instance when
 # the agent is disabled.
@@ -8,9 +8,13 @@ module NewRelic
   module Agent
     class NullLogger
       def fatal(*args); end
+
       def error(*args); end
-      def warn(*args);  end
-      def info(*args);  end
+
+      def warn(*args); end
+
+      def info(*args); end
+
       def debug(*args); end
 
       def method_missing(method, *args, &blk)

data/lib/new_relic/agent/obfuscator.rb

@@ -1,20 +1,19 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-#require 'base64'
+# require 'base64'
 
 module NewRelic
   module Agent
     class Obfuscator
-
       attr_reader :key_bytes
 
       EMPTY_KEY_BYTES = [0]
       PACK_FORMAT = 'm'
 
       # RUM uses a shortened key, so just trim it up front
-      def initialize(key, length=nil)
+      def initialize(key, length = nil)
         if key.nil? || key.empty?
           @key_bytes = EMPTY_KEY_BYTES
         else
@@ -24,26 +23,25 @@ module NewRelic
       end
 
       def obfuscate(text)
-        [ encode(text) ].pack(PACK_FORMAT).gsub(/\n/, '')
+        [encode(text)].pack(PACK_FORMAT).delete("\n")
       end
 
       def deobfuscate(text)
-        encode(text.unpack(PACK_FORMAT).first )
+        encode(text.unpack(PACK_FORMAT).first)
       end
 
       def encode(text)
         return text unless key_bytes
 
-        encoded = ""
-        encoded.force_encoding('binary') if encoded.respond_to?( :force_encoding )
+        encoded = String.new('')
+        encoded.force_encoding('binary') if encoded.respond_to?(:force_encoding)
         index = 0
         text.each_byte do |byte|
           encoded.concat((byte ^ key_bytes[index % key_bytes.length]))
-          index+=1
+          index += 1
         end
         encoded
       end
-
     end
   end
 end

data/lib/new_relic/agent/parameter_filtering.rb

@@ -1,29 +1,50 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module ParameterFiltering
       extend self
 
+      ACTION_DISPATCH_PARAMETER_FILTER ||= "action_dispatch.parameter_filter".freeze
+
+      if defined?(Rails) && Gem::Version.new(::Rails::VERSION::STRING) >= Gem::Version.new('5.0.0')
+        Rails.application.config.to_prepare do
+          RAILS_FILTER_CLASS ||= if defined?(ActiveSupport::ParameterFilter)
+            ActiveSupport::ParameterFilter
+          elsif defined?(ActionDispatch::Http::ParameterFilter)
+            ActionDispatch::Http::ParameterFilter
+          end
+        end
+      else
+        RAILS_FILTER_CLASS ||= if defined?(ActiveSupport::ParameterFilter)
+          ActiveSupport::ParameterFilter
+        elsif defined?(ActionDispatch::Http::ParameterFilter)
+          ActionDispatch::Http::ParameterFilter
+        end
+      end
+
       def apply_filters(env, params)
-        params = filter_using_rails(env, params)
+        if filters = env[ACTION_DISPATCH_PARAMETER_FILTER]
+          params = filter_using_rails(params, filters)
+        end
         params = filter_rack_file_data(env, params)
         params
       end
 
-      def filter_using_rails(env, params)
-        return params unless defined?(ActionDispatch::Http::ParameterFilter) && env.key?("action_dispatch.parameter_filter")
-        filters = env["action_dispatch.parameter_filter"]
-        ActionDispatch::Http::ParameterFilter.new(filters).filter(params)
+      def filter_using_rails(params, filters)
+        return params unless rails_filter_class?
+
+        pre_filtered_params = filter_rails_request_parameters(params)
+        RAILS_FILTER_CLASS.new(filters).filter(pre_filtered_params)
       end
 
       def filter_rack_file_data(env, params)
         content_type = env["CONTENT_TYPE"]
         multipart = content_type && content_type.start_with?("multipart")
 
-        params.inject({}) do |memo, (k,v)|
+        params.inject({}) do |memo, (k, v)|
           if multipart && v.is_a?(Hash) && v[:tempfile]
             memo[k] = "[FILE]"
           else
@@ -39,6 +60,12 @@ module NewRelic
         result.delete("action")
         result
       end
+
+      private
+
+      def rails_filter_class?
+        defined?(RAILS_FILTER_CLASS) && !RAILS_FILTER_CLASS.nil?
+      end
     end
   end
 end

data/lib/new_relic/agent/payload_metric_mapping.rb

@@ -1,12 +1,11 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module PayloadMetricMapping
-
       # this logic was extracted from TransactionEventAggregator for reuse by
       # the ErrorEventAggregator
 
@@ -28,7 +27,7 @@ module NewRelic
 
         private
 
-        def map_metric(metric_name, to_add={})
+        def map_metric(metric_name, to_add = {})
           to_add.values.each(&:freeze)
 
           mappings = SPEC_MAPPINGS.fetch(metric_name, {})
@@ -41,18 +40,18 @@ module NewRelic
       # All Transactions
       # Don't need to use the transaction-type specific metrics since this is
       # scoped to just one transaction, so Datastore/all has what we want.
-      map_metric('Datastore/all',         :total_call_time => 'databaseDuration')
-      map_metric('Datastore/all',         :call_count      => 'databaseCallCount')
-      map_metric('GC/Transaction/all',    :total_call_time => 'gcCumulative')
+      map_metric('Datastore/all', :total_call_time => 'databaseDuration')
+      map_metric('Datastore/all', :call_count => 'databaseCallCount')
+      map_metric('GC/Transaction/all', :total_call_time => 'gcCumulative')
 
       # Web Metrics
       map_metric('WebFrontend/QueueTime', :total_call_time => 'queueDuration')
-      map_metric('External/allWeb',       :total_call_time => 'externalDuration')
-      map_metric('External/allWeb',       :call_count      => 'externalCallCount')
+      map_metric('External/allWeb', :total_call_time => 'externalDuration')
+      map_metric('External/allWeb', :call_count => 'externalCallCount')
 
       # Background Metrics
-      map_metric('External/allOther',     :total_call_time => 'externalDuration')
-      map_metric('External/allOther',     :call_count      => 'externalCallCount')
+      map_metric('External/allOther', :total_call_time => 'externalDuration')
+      map_metric('External/allOther', :call_count => 'externalCallCount')
     end
   end
 end

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -1,12 +1,11 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'base64'
 
 module NewRelic
   module Agent
-
     #--
     # Manages the registering and servicing of pipes used by child
     # processes to report data to their parent, rather than directly
@@ -67,7 +66,7 @@ module NewRelic
           if defined?(::Encoding::ASCII_8BIT)
             @in.set_encoding(::Encoding::ASCII_8BIT)
           end
-          @last_read = Time.now
+          @last_read = Process.clock_gettime(Process::CLOCK_REALTIME)
           @parent_pid = $$
         end
 
@@ -92,7 +91,7 @@ module NewRelic
 
         def read
           @in.close unless @in.closed?
-          @last_read = Time.now
+          @last_read = Process.clock_gettime(Process::CLOCK_REALTIME)
           length_bytes = @out.read(NUM_LENGTH_BYTES)
           if length_bytes
             message_length = deserialize_message_length(length_bytes)
@@ -128,7 +127,7 @@ module NewRelic
       end
 
       class Listener
-        attr_reader   :thread
+        attr_reader :thread
 
         # This attr_accessor intentionally provides unsynchronized access to the
         # @pipes hash. It is used to look up the write end of the pipe from
@@ -161,6 +160,7 @@ module NewRelic
 
         def start
           return if @started == true
+
           @started = true
           @thread = NewRelic::Agent::Threading::AgentThread.create('Pipe Channel Manager') do
             now = nil
@@ -168,27 +168,36 @@ module NewRelic
               clean_up_pipes
 
               pipes_to_listen_to = @pipes_lock.synchronize do
-                @pipes.values.map{|pipe| pipe.out} + [wake.out]
+                @pipes.values.map { |pipe| pipe.out } + [wake.out]
               end
 
-              NewRelic::Agent.record_metric('Supportability/Listeners',
-                (Time.now - now).to_f) if now
+              if now
+                NewRelic::Agent.record_metric(
+                  'Supportability/Listeners',
+                  Process.clock_gettime(Process::CLOCK_REALTIME) - now
+                )
+              end
 
               if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout)
-                now = Time.now
+                now = Process.clock_gettime(Process::CLOCK_REALTIME)
 
                 ready_pipes = ready[0]
                 ready_pipes.each do |pipe|
                   merge_data_from_pipe(pipe) unless pipe == wake.out
                 end
 
-                wake.out.read(1) if ready_pipes.include?(wake.out)
+                begin
+                  wake.out.read_nonblock(1) if ready_pipes.include?(wake.out)
+                rescue IO::WaitReadable
+                  NewRelic::Agent.logger.error('Issue while reading from the ready pipe')
+                  NewRelic::Agent.logger.error("Ready pipes: #{ready_pipes.map(&:to_s)}, wake.out pipe: #{wake.out}")
+                end
               end
 
               break unless should_keep_listening?
             end
           end
-          sleep 0.001 # give time for the thread to spawn
+          sleep(0.001) # give time for the thread to spawn
         end
 
         def stop_listener_thread
@@ -199,6 +208,7 @@ module NewRelic
 
         def stop
           return unless @started == true
+
           stop_listener_thread
           close_all_pipes
           @wake.close
@@ -245,29 +255,29 @@ module NewRelic
         def unmarshal(data)
           Marshal.load(data)
         rescue StandardError => e
-          ::NewRelic::Agent.logger.error "Failure unmarshalling message from Resque child process", e
-          ::NewRelic::Agent.logger.debug Base64.encode64(data)
+          ::NewRelic::Agent.logger.error("Failure unmarshalling message from Resque child process", e)
+          ::NewRelic::Agent.logger.debug(Base64.encode64(data))
           nil
         end
 
         def should_keep_listening?
-          @started || @pipes_lock.synchronize { @pipes.values.find{|pipe| !pipe.in.closed?} }
+          @started || @pipes_lock.synchronize { @pipes.values.find { |pipe| !pipe.in.closed? } }
         end
 
         def clean_up_pipes
           @pipes_lock.synchronize do
             @pipes.values.each do |pipe|
-              if pipe.last_read.to_f + @timeout < Time.now.to_f
+              if pipe.last_read + @timeout < Process.clock_gettime(Process::CLOCK_REALTIME)
                 pipe.close unless pipe.closed?
               end
             end
-            @pipes.reject! {|id, pipe| pipe.out.closed? }
+            @pipes.reject! { |id, pipe| pipe.out.closed? }
           end
         end
 
         def find_pipe_for_handle(out_handle)
           @pipes_lock.synchronize do
-            @pipes.values.find{|pipe| pipe.out == out_handle }
+            @pipes.values.find { |pipe| pipe.out == out_handle }
           end
         end
       end

data/lib/new_relic/agent/pipe_service.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -10,8 +10,7 @@ module NewRelic
 
       def initialize(channel_id)
         @channel_id = channel_id
-        @collector = NewRelic::Control::Server.new(:name => 'parent',
-                                                   :port => 0)
+        @collector = NewRelic::Control::Server.new({name: 'parent', port: 0})
         @pipe = NewRelic::Agent::PipeChannelManager.channels[@channel_id]
         if @pipe && @pipe.parent_pid != $$
           @pipe.after_fork_in_child
@@ -25,7 +24,7 @@ module NewRelic
       end
 
       def get_agent_commands
-        []
+        NewRelic::EMPTY_ARRAY
       end
 
       def analytic_event_data(events)
@@ -61,7 +60,11 @@ module NewRelic
         write_to_pipe(:sql_trace_data, sql) if sql
       end
 
-      def shutdown(time)
+      def log_event_data(logs)
+        write_to_pipe(:log_event_data, logs) if logs
+      end
+
+      def shutdown
         @pipe.close if @pipe
       end
 

data/lib/new_relic/agent/prepend_supportability.rb

@@ -1,11 +1,11 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module PrependSupportability
-      def self.record_metrics_for *classes
+      def self.record_metrics_for(*classes)
         classes.each do |klass|
           count = klass.send(:ancestors).index(klass)
           ::NewRelic::Agent.record_metric("Supportability/PrependedModules/#{klass}", count) if count > 0

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/heap'
 require 'new_relic/agent/event_buffer'
@@ -15,29 +15,32 @@ module NewRelic
       def initialize(capacity)
         super
         @captured_lifetime = 0
-        @seen_lifetime     = 0
+        @seen_lifetime = 0
+      end
+
+      def heapify_items_array
+        if @items.is_a?(Array)
+          @items = Heap.new(@items) { |x| priority_for(x) }
+        end
       end
 
       # expects priority and a block, or an event as a hash with a `priority` key.
       def append(priority: nil, event: nil, &blk)
         increment_seen
 
-        if @seen == @capacity
-          @items = Heap.new(@items) { |x| priority_for(x) }
-        end
+        return if @capacity == 0
 
         if full?
           priority ||= priority_for(event)
           if priority_for(@items[0]) < priority
-            incoming = event || blk.call
+            heapify_items_array
+            incoming = event || yield
             @items[0] = incoming
             @items.fix(0)
             incoming
-          else
-            nil
           end
         else
-          @items << (event || blk.call)
+          @items << (event || yield)
           @captured_lifetime += 1
           @items[-1]
         end
@@ -48,17 +51,17 @@ module NewRelic
       def capacity=(new_capacity)
         @capacity = new_capacity
         old_items = @items.to_a
-        old_seen  = @seen
+        old_seen = @seen
         reset!
         old_items.each { |i| append(event: i) }
-        @seen     = old_seen
+        @seen = old_seen
       end
 
       def to_a
         @items.to_a.dup
       end
 
-      def decrement_lifetime_counts_by n
+      def decrement_lifetime_counts_by(n)
         @captured_lifetime -= n
         @seen_lifetime -= n
       end
@@ -87,4 +90,3 @@ module NewRelic
     end
   end
 end
-

data/lib/new_relic/agent/range_extensions.rb

@@ -1,45 +1,25 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module RangeExtensions
       module_function
 
-      def intersects? r1, r2
-        r1.include?(r2.begin) || r2.include?(r1.begin)
-      end
-
-      def merge r1, r2
-        return unless intersects? r1, r2
-        range_min = r1.begin < r2.begin ? r1.begin : r2.begin
-        range_max = r1.end > r2.end ? r1.end : r2.end
-        range_min..range_max
-      end
-
-      # Takes an array of ranges and a range which it will
-      # merge into an existing range if they intersect, otherwise
-      # it will append this range to the end the array.
-      def merge_or_append range, ranges
-        ranges.each_with_index do |r, i|
-          if merged = merge(r, range)
-            ranges[i] = merged
-            return ranges
-          end
-        end
-        ranges.push range
+      def intersects?(r1, r2)
+        r1.begin > r2.begin ? r2.cover?(r1.begin) : r1.cover?(r2.begin)
       end
 
       # Computes the amount of overlap between range and an array of ranges.
       # For efficiency, it assumes that range intersects with each of the
       # ranges in the ranges array.
-      def compute_overlap range, ranges
+      def compute_overlap(range, ranges)
         ranges.inject(0) do |memo, other|
-          next memo unless intersects? range, other
-          lower_bound = range.begin > other.begin ? range.begin : other.begin
-          upper_bound = range.end < other.end ? range.end : other.end
-          memo += upper_bound - lower_bound
+          next memo unless intersects?(range, other)
+
+          memo += ([range.end, other.end].min) -
+            ([range.begin, other.begin].max)
         end
       end
     end

data/lib/new_relic/agent/rules_engine/replacement_rule.rb

@@ -1,13 +1,13 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class RulesEngine
       class ReplacementRule
         attr_reader(:terminate_chain, :each_segment, :ignore, :replace_all, :eval_order,
-                    :match_expression, :replacement)
+          :match_expression, :replacement)
 
         def initialize(options)
           if !options['match_expression']
@@ -18,12 +18,12 @@ module NewRelic
           end
 
           @match_expression = Regexp.new(options['match_expression'], Regexp::IGNORECASE)
-          @replacement      = options['replacement']
-          @ignore           = options['ignore'] || false
-          @eval_order       = options['eval_order'] || 0
-          @replace_all      = options['replace_all'] || false
-          @each_segment     = options['each_segment'] || false
-          @terminate_chain  = options['terminate_chain'] || false
+          @replacement = options['replacement']
+          @ignore = options['ignore'] || false
+          @eval_order = options['eval_order'] || 0
+          @replace_all = options['replace_all'] || false
+          @each_segment = options['each_segment'] || false
+          @terminate_chain = options['terminate_chain'] || false
         end
 
         def terminal?
@@ -36,7 +36,7 @@ module NewRelic
               segment.match(@match_expression)
             end
           else
-            string.match @match_expression
+            string.match(@match_expression)
           end
         end
 
@@ -56,9 +56,9 @@ module NewRelic
         end
 
         def apply_to_each_segment(string)
-          string        = string.dup
+          string = string.dup
           leading_slash = string.slice!(LEADING_SLASH_REGEX)
-          segments      = string.split(SEGMENT_SEPARATOR)
+          segments = string.split(SEGMENT_SEPARATOR)
 
           segments.map! do |segment|
             apply_replacement(segment)

data/lib/new_relic/agent/rules_engine/segment_terms_rule.rb

@@ -1,24 +1,23 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class RulesEngine
       class SegmentTermsRule
-        PREFIX_KEY                        = 'prefix'.freeze
-        TERMS_KEY                         = 'terms'.freeze
-        SEGMENT_PLACEHOLDER               = '*'.freeze
-        ADJACENT_PLACEHOLDERS_REGEX       = %r{((?:^|/)\*)(?:/\*)*}.freeze
+        PREFIX_KEY = 'prefix'.freeze
+        TERMS_KEY = 'terms'.freeze
+        SEGMENT_PLACEHOLDER = '*'.freeze
+        ADJACENT_PLACEHOLDERS_REGEX = %r{((?:^|/)\*)(?:/\*)*}.freeze
         ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
-        VALID_PREFIX_SEGMENT_COUNT        = 2
 
         attr_reader :prefix, :terms
 
         def self.valid?(rule_spec)
           rule_spec[PREFIX_KEY].kind_of?(String) &&
-          rule_spec[TERMS_KEY].kind_of?(Array) &&
-          valid_prefix_segment_count?(rule_spec[PREFIX_KEY])
+            rule_spec[TERMS_KEY].kind_of?(Array) &&
+            valid_prefix_segment_count?(rule_spec[PREFIX_KEY])
         end
 
         def self.valid_prefix_segment_count?(prefix)
@@ -26,13 +25,13 @@ module NewRelic
           rindex = prefix.rindex(SEGMENT_SEPARATOR)
 
           (count == 2 && prefix[rindex + 1].nil?) ||
-          (count == 1 && !prefix[rindex + 1].nil?)
+            (count == 1 && !prefix[rindex + 1].nil?)
         end
 
         def initialize(options)
-          @prefix          = options[PREFIX_KEY]
-          @terms           = options[TERMS_KEY]
-          @trim_range      = (@prefix.size..-1)
+          @prefix = options[PREFIX_KEY]
+          @terms = options[TERMS_KEY]
+          @trim_range = (@prefix.size..-1)
         end
 
         def terminal?
@@ -50,7 +49,7 @@ module NewRelic
         end
 
         def apply(string)
-          rest          = string[@trim_range]
+          rest = string[@trim_range]
           leading_slash = rest.slice!(LEADING_SLASH_REGEX)
           segments = rest.split(SEGMENT_SEPARATOR, -1)
           segments.map! { |s| @terms.include?(s) ? s : SEGMENT_PLACEHOLDER }