newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/error_filter.rb

@@ -0,0 +1,174 @@
+# 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
+    # Handles loading of ignored and expected errors from the agent configuration, and
+    # determining at runtime whether an exception is ignored or expected.
+    class ErrorFilter
+      def initialize
+        reset
+      end
+
+      def reset
+        @ignore_classes, @expected_classes = [], []
+        @ignore_messages, @expected_messages = {}, {}
+        @ignore_status_codes, @expected_status_codes = [], []
+      end
+
+      def load_all
+        %i[
+          ignore_classes ignore_messages ignore_status_codes
+          expected_classes expected_messages expected_status_codes
+        ].each { |setting| load_from_config(setting) }
+      end
+
+      def load_from_config(setting, value = nil)
+        errors = nil
+        new_value = value || fetch_agent_config(setting.to_sym)
+
+        return if new_value.nil? || (new_value.respond_to?(:empty?) && new_value.empty?)
+
+        case setting.to_sym
+        when :ignore_classes
+          new_value = new_value.split(',').map!(&:strip) if new_value.is_a?(String)
+          errors = @ignore_classes = new_value
+        when :ignore_messages
+          errors = @ignore_messages = new_value || {}
+        when :ignore_status_codes
+          errors = @ignore_status_codes = parse_status_codes(new_value) || []
+        when :expected_classes
+          errors = @expected_classes = new_value || []
+        when :expected_messages
+          errors = @expected_messages = new_value || {}
+        when :expected_status_codes
+          errors = @expected_status_codes = parse_status_codes(new_value) || []
+        end
+        log_filter(setting, errors) if errors
+      end
+
+      def ignore?(ex, status_code = nil)
+        @ignore_classes.include?(ex.class.name) ||
+          (@ignore_messages.key?(ex.class.name) &&
+          @ignore_messages[ex.class.name].any? { |m| ex.message.include?(m) }) ||
+          @ignore_status_codes.include?(status_code.to_i)
+      end
+
+      def expected?(ex, status_code = nil)
+        @expected_classes.include?(ex.class.name) ||
+          (@expected_messages.key?(ex.class.name) &&
+          @expected_messages[ex.class.name].any? { |m| ex.message.include?(m) }) ||
+          @expected_status_codes.include?(status_code.to_i)
+      end
+
+      def fetch_agent_config(cfg)
+        NewRelic::Agent.config[:"error_collector.#{cfg}"]
+      end
+
+      # A generic method for adding ignore filters manually. This is kept for compatibility
+      # with the previous ErrorCollector#ignore method, and adds some flexibility for adding
+      # different ignore/expected error types by examining each argument.
+      def ignore(*args)
+        args.each do |errors|
+          case errors
+          when Array
+            errors.each { |e| ignore(e) }
+          when Integer
+            @ignore_status_codes << errors
+          when Hash
+            @ignore_messages.update(errors)
+            log_filter(:ignore_messages, errors)
+          when String
+            if errors =~ /^[\d\,\-]+$/
+              @ignore_status_codes |= parse_status_codes(errors)
+              log_filter(:ignore_status_codes, errors)
+            else
+              new_ignore_classes = errors.split(',').map!(&:strip)
+              @ignore_classes |= new_ignore_classes
+              log_filter(:ignore_classes, new_ignore_classes)
+            end
+          end
+        end
+      end
+
+      # See #ignore above.
+      def expect(*args)
+        args.each do |errors|
+          case errors
+          when Array
+            errors.each { |e| expect(e) }
+          when Integer
+            @expected_status_codes << errors
+          when Hash
+            @expected_messages.update(errors)
+            log_filter(:expected_messages, errors)
+          when String
+            if errors =~ /^[\d\,\-]+$/
+              @expected_status_codes |= parse_status_codes(errors)
+              log_filter(:expected_status_codes, errors)
+            else
+              new_expected_classes = errors.split(',').map!(&:strip)
+              @expected_classes |= new_expected_classes
+              log_filter(:expected_classes, new_expected_classes)
+            end
+          end
+        end
+      end
+
+      private
+
+      def log_filter(setting, errors)
+        case setting
+        when :ignore_classes
+          errors.each do |error|
+            ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}'")
+          end
+        when :ignore_messages
+          errors.each do |error, messages|
+            ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}' with messages: #{messages.join(',')}")
+          end
+        when :ignore_status_codes
+          ::NewRelic::Agent.logger.debug("Ignoring errors associated with status codes: #{errors}")
+        when :expected_classes
+          errors.each do |error|
+            ::NewRelic::Agent.logger.debug("Expecting errors of type '#{error}'")
+          end
+        when :expected_messages
+          errors.each do |error, messages|
+            ::NewRelic::Agent.logger.debug("Expecting errors of type '#{error}' with messages: #{messages.join(',')}")
+          end
+        when :expected_status_codes
+          ::NewRelic::Agent.logger.debug("Expecting errors associated with status codes: #{errors}")
+        end
+      end
+
+      def parse_status_codes(codes)
+        code_list = case codes
+          when String
+            codes.split(',')
+          when Integer
+            [codes]
+          else
+            codes
+        end
+        result = []
+        code_list.each do |code|
+          result << code && next if code.is_a?(Integer)
+
+          m = code.match(/(\d{3})(-\d{3})?/)
+          if m.nil? || m[1].nil?
+            ::NewRelic::Agent.logger.warn("Invalid HTTP status code: '#{code}'; ignoring config")
+            next
+          end
+          if m[2]
+            result += (m[1]..m[2].tr('-', '')).to_a.map(&:to_i)
+          else
+            result << m[1].to_i
+          end
+        end
+        result.uniq
+      end
+    end
+  end
+end

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -1,7 +1,7 @@
 # -*- 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
@@ -44,6 +44,7 @@ module NewRelic
       # floor after logging a warning.
       def add_to_error_queue(noticed_error)
         return unless enabled?
+
         @lock.synchronize do
           if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
             @errors << noticed_error
@@ -54,7 +55,7 @@ module NewRelic
       # checks the size of the error queue to make sure we are under
       # the maximum limit, and logs a warning if we are over the limit.
       def over_queue_limit?(message)
-        over_limit = (@errors.reject{|err| err.is_internal}.length >= @capacity)
+        over_limit = (@errors.count { |err| !err.is_internal } >= @capacity)
         if over_limit
           ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{@capacity}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}")
         end
@@ -91,7 +92,8 @@ module NewRelic
 
       def register_config_callbacks
         Agent.config.register_callback(:'error_collector.enabled') do |enabled|
-          ::NewRelic::Agent.logger.debug "Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service."
+          reset! if enabled == false
+          ::NewRelic::Agent.logger.debug("Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service.")
         end
       end
     end

data/lib/new_relic/agent/event_aggregator.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/priority_sampled_buffer'
 
@@ -8,37 +8,38 @@ module NewRelic
   module Agent
     class EventAggregator
       class << self
-        # This architecture requires that every aggregator
-        # implementation provide its own `named`, `capacity_key`, and
-        # `enabled_...` settings.  In particular, we do not allow
-        # subclasses to share these values from an intermediate
-        # superclass.
-
-        def inherited(subclass)
-          # Prevent uninitialized variable warnings; we have to do
-          # this as soon as the subclass is defined, before its
-          # implementor calls enabled_key() or enabled_fn().
-          subclass.instance_variable_set(:@enabled_key, nil)
-          subclass.instance_variable_set(:@enabled_fn,  nil)
-        end
-
-        def named named = nil
+        def named(named = nil)
           named ? @named = named.to_s.freeze : @named
         end
 
-        def capacity_key key = nil
+        def capacity_key(key = nil)
           key ? @capacity_key = key : @capacity_key
         end
 
-        def enabled_key key = nil
-          key ? @enabled_key = key : @enabled_key
+        # An aggregator can specify one or more keys to check to see if it is
+        # enabled. Multiple keys will be &&'d and the enabled status of the
+        # aggregator will be reset when agent configuration changes.
+
+        def enabled_keys(*keys)
+          if keys.empty?
+            @enabled_keys ||= []
+          else
+            @enabled_keys = Array(keys)
+            @enabled_fn = ->() { @enabled_keys.all? { |k| Agent.config[k] } }
+          end
         end
 
-        def enabled_fn fn = nil
+        alias_method :enabled_key, :enabled_keys
+
+        # This can be used instead of `enabled_key(s)` for more fine grained
+        # control over whether an aggregator should be enabled. The enabled fn
+        # will be reevaluated after configuration changes
+
+        def enabled_fn(fn = nil)
           fn ? @enabled_fn = fn : @enabled_fn
         end
 
-        def buffer_class klass = nil
+        def buffer_class(klass = nil)
           if klass
             @buffer_class = klass
           else
@@ -47,13 +48,13 @@ module NewRelic
         end
       end
 
-      def initialize
+      def initialize(events)
         @lock = Mutex.new
-        @buffer = self.class.buffer_class.new NewRelic::Agent.config[self.class.capacity_key]
-        @enabled = false
+        @buffer = self.class.buffer_class.new(NewRelic::Agent.config[self.class.capacity_key])
+        @enabled = self.class.enabled_fn ? self.class.enabled_fn.call : false
         @notified_full = false
         register_capacity_callback
-        register_enabled_callback
+        register_enabled_callback(events)
         after_initialize
       end
 
@@ -62,11 +63,10 @@ module NewRelic
       end
 
       # interface method for subclasses to override to provide post harvest functionality
-      def after_harvest metadata
+      def after_harvest(metadata)
       end
 
       def enabled?
-        return self.class.enabled_fn.call if self.class.enabled_fn
         @enabled
       end
 
@@ -78,11 +78,11 @@ module NewRelic
         metadata = nil
         samples = []
         @lock.synchronize do
-          samples.concat @buffer.to_a
+          samples.concat(@buffer.to_a)
           metadata = @buffer.metadata
           reset_buffer!
         end
-        after_harvest metadata
+        after_harvest(metadata)
         [reservoir_metadata(metadata), samples]
       end
 
@@ -90,15 +90,15 @@ module NewRelic
       # the buffer to ensure accuracy of buffer of metadata. We want to make sure not to
       # double count samples being merged back in from a failed harvest, yet we do not
       # want to under-count samples being merged from the PipeService.
-      def merge! payload, adjust_count = true
+      def merge!(payload, adjust_count = true)
         @lock.synchronize do
           _, samples = payload
 
           if adjust_count
-            @buffer.decrement_lifetime_counts_by samples.count
+            @buffer.decrement_lifetime_counts_by(samples.count)
           end
 
-          samples.each { |s| @buffer.append event: s }
+          samples.each { |s| @buffer.append(event: s) }
         end
       end
 
@@ -110,7 +110,7 @@ module NewRelic
 
       private
 
-      def reservoir_metadata metadata
+      def reservoir_metadata(metadata)
         {
           :reservoir_size => metadata[:capacity],
           :events_seen => metadata[:seen]
@@ -119,30 +119,25 @@ module NewRelic
 
       def register_capacity_callback
         NewRelic::Agent.config.register_callback(self.class.capacity_key) do |max_samples|
-          NewRelic::Agent.logger.debug "#{self.class.named} max_samples set to #{max_samples}"
+          NewRelic::Agent.logger.debug("#{self.class.named} max_samples set to #{max_samples}")
           @lock.synchronize do
             @buffer.capacity = max_samples
           end
         end
       end
 
-      def register_enabled_callback
-        unless self.class.enabled_key || self.class.enabled_fn
-          ::NewRelic::Agent.logger.warn "#{self.class.named} needs an enabled_key or an enabled_fn."
-        end
-
-        return if self.class.enabled_fn
-
-        NewRelic::Agent.config.register_callback(self.class.enabled_key) do |enabled|
-          # intentionally unsynchronized for liveness
-          @enabled = enabled
-          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{enabled ? '' : 'not '}be sent to the New Relic service."
-        end
+      def register_enabled_callback(events)
+        events.subscribe(:server_source_configuration_added) {
+          @enabled = self.class.enabled_fn.call
+          reset! if @enabled == false
+          ::NewRelic::Agent.logger.debug("#{self.class.named} will #{@enabled ? '' : 'not '}be sent to the New Relic service.")
+        }
       end
 
       def notify_if_full
         return unless !@notified_full && @buffer.full?
-        NewRelic::Agent.logger.debug "#{self.class.named} capacity of #{@buffer.capacity} reached, beginning sampling"
+
+        NewRelic::Agent.logger.debug("#{self.class.named} capacity of #{@buffer.capacity} reached, beginning sampling")
         @notified_full = true
       end
 

data/lib/new_relic/agent/event_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
 
 # EventBuffer is intended to be an abstract base class. It should not be
 # instantiated directly. Subclasses should define an `append_event` method
@@ -22,22 +22,22 @@ module NewRelic
 
       def initialize(capacity)
         @capacity = capacity
-        @items    = []
-        @seen     = 0
+        @items = []
+        @seen = 0
       end
 
       def reset!
         @items = []
-        @seen  = 0
+        @seen = 0
       end
 
       def capacity=(new_capacity)
         @capacity = new_capacity
         old_items = @items
-        @items    = []
-        old_seen  = @seen
+        @items = []
+        old_seen = @seen
         old_items.each { |i| append(i) }
-        @seen     = old_seen
+        @seen = old_seen
       end
 
       def append(x)
@@ -88,4 +88,3 @@ module NewRelic
     end
   end
 end
-

data/lib/new_relic/agent/event_listener.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::Agent
   # Basic mechanism for the agent instance to provide agent-wide eventing.
@@ -9,7 +9,6 @@ module NewRelic::Agent
   # While an EventListener could be used elsewhere, it's strongly expected
   # your eventing needs should be met by the agent's instance.
   class EventListener
-
     attr_accessor :runaway_threshold
 
     def initialize

data/lib/new_relic/agent/event_loop.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 'thread'
 
@@ -10,11 +10,11 @@ module NewRelic
       class Timer
         attr_reader :next_fire_time, :event, :interval, :last_fired_at
 
-        def initialize(interval, event, repeat=false)
-          @interval      = interval
-          @event         = event
-          @repeat        = repeat
-          @started_at    = Time.now
+        def initialize(interval, event, repeat = false)
+          @interval = interval
+          @event = event
+          @repeat = repeat
+          @started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
           @last_fired_at = nil
           reschedule
         end
@@ -32,8 +32,9 @@ module NewRelic
         end
 
         def calculate_next_fire_time
-          now = Time.now
+          now = Process.clock_gettime(Process::CLOCK_REALTIME)
           return now if @interval == 0
+
           fire_time = @last_fired_at || now
           while fire_time <= now
             fire_time += @interval
@@ -42,10 +43,10 @@ module NewRelic
         end
 
         def set_fired_time
-          @last_fired_at = Time.now
+          @last_fired_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
 
-        def due?(now=Time.now)
+        def due?(now = Process.clock_gettime(Process::CLOCK_REALTIME))
           now >= @next_fire_time
         end
 
@@ -57,19 +58,19 @@ module NewRelic
       def initialize
         @self_pipe_rd, @self_pipe_wr = IO.pipe
         @event_queue = Queue.new
-        @stopped     = false
-        @timers      = {}
+        @stopped = false
+        @timers = {}
 
-        @subscriptions = Hash.new { |h,k| h[k] = [] }
-        @subscriptions[:__add_timer] << Proc.new { |t| set_timer(t) }
-        @subscriptions[:__add_event] << Proc.new { |e, blk| @subscriptions[e] << blk }
+        @subscriptions = Hash.new { |h, k| h[k] = [] }
+        @subscriptions[:__add_timer] << proc { |t| set_timer(t) }
+        @subscriptions[:__add_event] << proc { |e, blk| @subscriptions[e] << blk }
       end
 
       def set_timer(timer)
         existing_timer = @timers[timer.event]
 
         if existing_timer
-          elapsed_interval = Time.now - existing_timer.last_interval_start
+          elapsed_interval = Process.clock_gettime(Process::CLOCK_REALTIME) - existing_timer.last_interval_start
           timer.advance(elapsed_interval)
         end
 
@@ -80,8 +81,9 @@ module NewRelic
 
       def next_timeout
         return nil if @timers.empty?
-        timeout = @timers.values.map(&:next_fire_time).min - Time.now
-        timeout < 0 ? 0 : timeout
+
+        timeout = @timers.values.map(&:next_fire_time).min - Process.clock_gettime(Process::CLOCK_REALTIME)
+        [timeout, 0].max
       end
 
       def stopped?
@@ -94,13 +96,13 @@ module NewRelic
       end
 
       def run
-        ::NewRelic::Agent.logger.debug "Running event loop"
+        ::NewRelic::Agent.logger.debug("Running event loop")
         while !stopped?
           run_once
         end
       end
 
-      def run_once(nonblock=false)
+      def run_once(nonblock = false)
         wait_to_run(nonblock)
 
         prune_timers
@@ -154,7 +156,7 @@ module NewRelic
         end
 
         if !errors.empty?
-          ::NewRelic::Agent.logger.error "#{errors.size} error(s) running task for event '#{event}' in Agent Event Loop:", *errors
+          ::NewRelic::Agent.logger.error("#{errors.size} error(s) running task for event '#{event}' in Agent Event Loop:", *errors)
         end
       end
 
@@ -172,20 +174,20 @@ module NewRelic
       end
 
       def fire_every(interval, event)
-        ::NewRelic::Agent.logger.debug "Firing event #{event} every #{interval} seconds."
+        ::NewRelic::Agent.logger.debug("Firing event #{event} every #{interval} seconds.")
         fire(:__add_timer, Timer.new(interval, event, true))
       end
 
       def fire_after(interval, event)
-        ::NewRelic::Agent.logger.debug "Firing event #{event} after #{interval} seconds."
+        ::NewRelic::Agent.logger.debug("Firing event #{event} after #{interval} seconds.")
         fire(:__add_timer, Timer.new(interval, event, false))
       end
 
       def wakeup
         begin
-          @self_pipe_wr.write_nonblock '.'
+          @self_pipe_wr.write_nonblock('.')
         rescue Errno::EAGAIN
-          ::NewRelic::Agent.logger.debug "Failed to wakeup event loop"
+          ::NewRelic::Agent.logger.debug("Failed to wakeup event loop")
         end
       end
     end