newrelic_rpm 3.12.0.288 → 9.10.2

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,17 @@
-# 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.
-
-#require 'base64'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 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 +21,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 = +''
+        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,31 +1,52 @@
-# 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.
+# 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
     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")
+        content_type = env['CONTENT_TYPE']
+        multipart = 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]"
+            memo[k] = '[FILE]'
           else
             memo[k] = v
           end
@@ -35,10 +56,16 @@ module NewRelic
 
       def filter_rails_request_parameters(params)
         result = params.dup
-        result.delete("controller")
-        result.delete("action")
+        result.delete('controller')
+        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

@@ -0,0 +1,57 @@
+# -*- ruby -*-
+# 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
+    module PayloadMetricMapping
+      # this logic was extracted from TransactionEventAggregator for reuse by
+      # the ErrorEventAggregator
+
+      SPEC_MAPPINGS = {}
+
+      class << self
+        def append_mapped_metrics(txn_metrics, sample)
+          if txn_metrics
+            SPEC_MAPPINGS.each do |(name, extracted_values)|
+              if txn_metrics.has_key?(name)
+                stat = txn_metrics[name]
+                extracted_values.each do |value_name, key_name|
+                  sample[key_name] = stat.send(value_name)
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def map_metric(metric_name, to_add = {})
+          to_add.values.each(&:freeze)
+
+          mappings = SPEC_MAPPINGS.fetch(metric_name, {})
+          mappings.merge!(to_add)
+
+          SPEC_MAPPINGS[metric_name] = mappings
+        end
+      end
+
+      # 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')
+
+      # 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')
+
+      # Background Metrics
+      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'
+require 'new_relic/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
@@ -56,7 +55,7 @@ module NewRelic
       # 4 GB - much larger than we'd ever need or want for this application.
       #
       class Pipe
-        READY_MARKER = "READY"
+        READY_MARKER = 'READY'
         NUM_LENGTH_BYTES = 4
 
         attr_accessor :in, :out
@@ -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
 
@@ -77,11 +76,11 @@ module NewRelic
         end
 
         def serialize_message_length(data)
-          [data.bytesize].pack("L>")
+          [data.bytesize].pack('L>')
         end
 
         def deserialize_message_length(data)
-          data.unpack("L>").first
+          data.unpack('L>').first
         end
 
         def write(data)
@@ -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)
@@ -104,7 +103,7 @@ module NewRelic
               nil
             end
           else
-            NewRelic::Agent.logger.error("Failed to read bytes for length from pipe.")
+            NewRelic::Agent.logger.error('Failed to read bytes for length from pipe.')
             nil
           end
         end
@@ -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
@@ -139,6 +138,7 @@ module NewRelic
         attr_accessor :pipes, :timeout, :select_timeout
 
         def initialize
+          @started = nil
           @pipes = {}
           @pipes_lock = Mutex.new
 
@@ -160,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
@@ -167,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
@@ -198,6 +208,7 @@ module NewRelic
 
         def stop
           return unless @started == true
+
           stop_listener_thread
           close_all_pipes
           @wake.close
@@ -207,7 +218,8 @@ module NewRelic
         def close_all_pipes
           @pipes_lock.synchronize do
             @pipes.each do |id, pipe|
-              pipe.close if pipe
+              # Needs else branch coverage
+              pipe.close if pipe # rubocop:disable Style/SafeNavigation
             end
             @pipes = {}
           end
@@ -242,33 +254,31 @@ module NewRelic
         end
 
         def unmarshal(data)
-          NewRelic::LanguageSupport.with_cautious_gc do
-            Marshal.load(data)
-          end
+          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(NewRelic::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,13 +10,12 @@ 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
         else
-          NewRelic::Agent.logger.error("No communication channel to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.")
+          NewRelic::Agent.logger.error('No communication channel to parent process, please see https://docs.newrelic.com/docs/apm/agents/ruby-agent/background-jobs/resque-instrumentation/ for more information.')
         end
       end
 
@@ -25,7 +24,7 @@ module NewRelic
       end
 
       def get_agent_commands
-        []
+        NewRelic::EMPTY_ARRAY
       end
 
       def analytic_event_data(events)
@@ -49,12 +48,25 @@ module NewRelic
         write_to_pipe(:error_data, errors) if errors
       end
 
+      def error_event_data(events)
+        write_to_pipe(:error_event_data, events) if events
+      end
+
+      def span_event_data(events)
+        write_to_pipe(:span_event_data, events) if events
+      end
+
       def sql_trace_data(sql)
         write_to_pipe(:sql_trace_data, sql) if sql
       end
 
-      def shutdown(time)
-        @pipe.close if @pipe
+      def log_event_data(logs)
+        write_to_pipe(:log_event_data, logs) if logs
+      end
+
+      def shutdown
+        # no else branch coverage
+        @pipe.close if @pipe # rubocop:disable Style/SafeNavigation
       end
 
       # Invokes the block it is passed.  This is used to implement HTTP
@@ -64,20 +76,15 @@ module NewRelic
         yield
       end
 
-      def reset_metric_id_cache
-        # we don't cache metric IDs, so nothing to do
-      end
-
       private
 
       def marshal_payload(data)
-        NewRelic::LanguageSupport.with_cautious_gc do
-          Marshal.dump(data)
-        end
+        Marshal.dump(data)
       end
 
       def write_to_pipe(endpoint, data)
-        @pipe.write(marshal_payload([endpoint, data])) if @pipe
+        # the following line needs else branch coverage
+        @pipe.write(marshal_payload([endpoint, data])) if @pipe # rubocop:disable Style/SafeNavigation
       end
     end
   end

data/lib/new_relic/agent/prepend_supportability.rb

@@ -0,0 +1,16 @@
+# 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
+    module PrependSupportability
+      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
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -0,0 +1,92 @@
+# 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
+
+require 'new_relic/agent/heap'
+require 'new_relic/agent/event_buffer'
+
+module NewRelic
+  module Agent
+    class PrioritySampledBuffer < EventBuffer
+      PRIORITY_KEY = 'priority'.freeze
+
+      attr_reader :seen_lifetime, :captured_lifetime
+
+      def initialize(capacity)
+        super
+        @captured_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
+
+        return if @capacity == 0
+
+        if full?
+          priority ||= priority_for(event)
+          if priority_for(@items[0]) < priority
+            heapify_items_array
+            incoming = event || yield
+            @items[0] = incoming
+            @items.fix(0)
+            incoming
+          end
+        else
+          @items << (event || yield)
+          @captured_lifetime += 1
+          @items[-1]
+        end
+      end
+
+      alias_method :append_event, :append
+
+      def capacity=(new_capacity)
+        @capacity = new_capacity
+        old_items = @items.to_a
+        old_seen = @seen
+        reset!
+        old_items.each { |i| append(event: i) }
+        @seen = old_seen
+      end
+
+      def to_a
+        @items.to_a.dup
+      end
+
+      def decrement_lifetime_counts_by(n)
+        @captured_lifetime -= n
+        @seen_lifetime -= n
+      end
+
+      def sample_rate_lifetime
+        @captured_lifetime > 0 ? (@captured_lifetime.to_f / @seen_lifetime) : 0.0
+      end
+
+      def metadata
+        super.merge!(
+          :captured_lifetime => @captured_lifetime,
+          :seen_lifetime => @seen_lifetime
+        )
+      end
+
+      private
+
+      def increment_seen
+        @seen += 1
+        @seen_lifetime += 1
+      end
+
+      def priority_for(event)
+        event[0][PRIORITY_KEY]
+      end
+    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)