newrelic_rpm 3.9.1.236 → 3.9.2.239

data/lib/new_relic/agent/database/postgres_explain_obfuscator.rb

@@ -11,13 +11,11 @@ module NewRelic
       module PostgresExplainObfuscator
         extend self
 
-        extend ObfuscationHelpers
-
-        SINGLE_OR_DOUBLE_QUOTES = Regexp.new([
-          ObfuscationHelpers::SINGLE_QUOTES.source,
-          ObfuscationHelpers::DOUBLE_QUOTES.source
-        ].join('|')).freeze
-        LABEL_LINE_REGEX   = /^([^:\n]*:\s+).*$/.freeze
+        # Note that this regex can't be shared with the ones in the
+        # Database::Obfuscator class because here we don't look for
+        # backslash-escaped strings (and those regexes are backwards).
+        QUOTED_STRINGS_REGEX = /'(?:[^']|'')*'|"(?:[^"]|"")*"/
+        LABEL_LINE_REGEX     = /^([^:\n]*:\s+).*$/.freeze
 
         def obfuscate(explain)
           # First, we replace all single-quoted strings.
@@ -32,7 +30,7 @@ module NewRelic
           # Note also that we make no special provisions for backslash-escaped
           # single quotes (\') because these are canonicalized to two single
           # quotes ('') in the explain output.
-          explain.gsub!(SINGLE_OR_DOUBLE_QUOTES) do |match|
+          explain.gsub!(QUOTED_STRINGS_REGEX) do |match|
             match.start_with?('"') ? match : '?'
           end
 

data/lib/new_relic/agent/error_collector.rb

@@ -55,24 +55,33 @@ module NewRelic
         !enabled?
       end
 
-      # Returns the error filter proc that is used to check if an
-      # error should be reported. When given a block, resets the
-      # filter to the provided block.  The define_method() is used to
-      # wrap the block in a lambda so return statements don't result in a
-      # LocalJump exception.
-      def ignore_error_filter(&block)
+      # We store the passed block in both an ivar on the class, and implicitly
+      # within the body of the ignore_filter_proc method intentionally here.
+      # The define_method trick is needed to get around the fact that users may
+      # call 'return' from within their filter blocks, which would otherwise
+      # result in a LocalJumpError.
+      #
+      # The raw block is also stored in an instance variable so that we can
+      # return it later in its original form.
+      #
+      # This is all done at the class level in order to avoid the case where
+      # the user sets up an ignore filter on one instance of the ErrorCollector,
+      # and then that instance subsequently gets discarded during agent startup.
+      # (For example, if the agent is initially disabled, and then gets enabled
+      # via a call to manual_start later on.)
+      #
+      def self.ignore_error_filter=(block)
+        @ignore_filter = block
         if block
-          self.class.class_eval { define_method(:ignore_filter_proc, &block) }
-          @ignore_filter = method(:ignore_filter_proc)
-        else
-          @ignore_filter
+          define_method(:ignore_filter_proc, &block)
+        elsif method_defined?(:ignore_filter_proc)
+          undef :ignore_filter_proc
         end
+        @ignore_filter
       end
 
-      # Only used from testing scenarios since can't tell difference between
-      # having a nil filter passed and no block for retrieval on main method.
-      def clear_ignore_error_filter
-        @ignore_filter = nil
+      def self.ignore_error_filter
+        @ignore_filter
       end
 
       # errors is an array of Exception Class Names
@@ -90,8 +99,7 @@ module NewRelic
         # Checks the provided error against the error filter, if there
         # is an error filter
         def filtered_by_error_filter?(error)
-          return unless @ignore_filter
-          !@ignore_filter.call(error)
+          respond_to?(:ignore_filter_proc) && !ignore_filter_proc(error)
         end
 
         # Checks the array of error names and the error filter against

data/lib/new_relic/agent/event_loop.rb

@@ -0,0 +1,189 @@
+# 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 'thread'
+
+module NewRelic
+  module Agent
+    class EventLoop
+      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
+          @last_fired_at = nil
+          reschedule
+        end
+
+        def reschedule
+          @next_fire_time = calculate_next_fire_time
+        end
+
+        def advance(amount)
+          @next_fire_time -= amount
+        end
+
+        def last_interval_start
+          @last_fired_at || @started_at
+        end
+
+        def calculate_next_fire_time
+          now = Time.now
+          return now if @interval == 0
+          fire_time = @last_fired_at || now
+          while fire_time <= now
+            fire_time += @interval
+          end
+          fire_time
+        end
+
+        def set_fired_time
+          @last_fired_at = Time.now
+        end
+
+        def due?(now=Time.now)
+          now >= @next_fire_time
+        end
+
+        def finished?
+          !@repeat && @last_fired_at
+        end
+      end
+
+      def initialize
+        @self_pipe_rd, @self_pipe_wr = IO.pipe
+        @event_queue = Queue.new
+        @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 }
+      end
+
+      def set_timer(timer)
+        existing_timer = @timers[timer.event]
+
+        if existing_timer
+          elapsed_interval = Time.now - existing_timer.last_interval_start
+          timer.advance(elapsed_interval)
+        end
+
+        @timers[timer.event] = timer
+
+        fire_timer(timer)
+      end
+
+      def next_timeout
+        return nil if @timers.empty?
+        timeout = @timers.values.map(&:next_fire_time).min - Time.now
+        timeout < 0 ? 0 : timeout
+      end
+
+      def stopped?
+        @stopped
+      end
+
+      def stop
+        @stopped = true
+        wakeup
+      end
+
+      def run
+        ::NewRelic::Agent.logger.debug "Running event loop"
+        while !stopped?
+          run_once
+        end
+      end
+
+      def run_once(nonblock=false)
+        wait_to_run(nonblock)
+
+        prune_timers
+        fire_timers
+
+        until @event_queue.empty?
+          evt, args = @event_queue.pop
+          dispatch_event(evt, args)
+          reschedule_timer_for_event(evt)
+        end
+      end
+
+      def wait_to_run(nonblock)
+        timeout = nonblock ? 0 : next_timeout
+        ready = select([@self_pipe_rd], nil, nil, timeout)
+
+        if ready && ready[0] && ready[0][0] && ready[0][0] == @self_pipe_rd
+          @self_pipe_rd.read(1)
+        end
+      end
+
+      def fire_timers
+        @timers.each do |event, timer|
+          fire_timer(timer)
+        end
+      end
+
+      def fire_timer(timer)
+        if timer.due?
+          @event_queue << [timer.event]
+          timer.set_fired_time
+        end
+      end
+
+      def prune_timers
+        @timers.delete_if { |e, t| t.finished? }
+      end
+
+      def dispatch_event(event, args)
+        NewRelic::Agent.logger.debug("EventLoop: Dispatching event '#{event}' with #{@subscriptions[event].size} callback(s).")
+
+        errors = []
+        @subscriptions[event].each do |s|
+          begin
+            s.call(*args)
+          rescue NewRelic::Agent::ForceRestartException, NewRelic::Agent::ForceDisconnectException
+            raise
+          rescue => e
+            errors << e
+          end
+        end
+
+        if !errors.empty?
+          ::NewRelic::Agent.logger.error "#{errors.size} error(s) running task for event '#{event}' in Agent Event Loop:", *errors
+        end
+      end
+
+      def reschedule_timer_for_event(e)
+        @timers[e].reschedule if @timers[e]
+      end
+
+      def on(event, &blk)
+        fire(:__add_event, event, blk)
+      end
+
+      def fire(event, *args)
+        @event_queue << [event, args]
+        wakeup
+      end
+
+      def fire_every(interval, event)
+        ::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."
+        fire(:__add_timer, Timer.new(interval, event, false))
+      end
+
+      def wakeup
+        @self_pipe_wr << '.'
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/action_controller_subscriber.rb

@@ -2,6 +2,7 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 require 'new_relic/agent/instrumentation/evented_subscriber'
+require 'new_relic/agent/instrumentation/ignore_actions'
 
 module NewRelic
   module Agent
@@ -92,32 +93,22 @@ module NewRelic
         end
 
         def ignored?
-          _is_filtered?('do_not_trace')
+          _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
         end
 
         def apdex_ignored?
-          _is_filtered?('ignore_apdex')
+          _is_filtered?(ControllerInstrumentation::NR_IGNORE_APDEX_KEY)
         end
 
         def enduser_ignored?
-          _is_filtered?('ignore_enduser')
+          _is_filtered?(ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY)
         end
 
-        # FIXME: shamelessly ripped from ControllerInstrumentation
         def _is_filtered?(key)
-          if @controller_class.respond_to? :newrelic_read_attr
-            ignore_actions = @controller_class.newrelic_read_attr(key)
-          end
-
-          case ignore_actions
-          when nil; false
-          when Hash
-            only_actions = Array(ignore_actions[:only])
-            except_actions = Array(ignore_actions[:except])
-            only_actions.include?(metric_action.to_sym) || (except_actions.any? && !except_actions.include?(metric_action.to_sym))
-          else
-            true
-          end
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+            key,
+            @controller_class,
+            metric_action)
         end
 
         def to_s

data/lib/new_relic/agent/instrumentation/active_record_helper.rb

@@ -8,7 +8,7 @@ module NewRelic
         module_function
 
         def metric_for_name(name)
-          return unless name
+          return unless name && name.respond_to?(:split)
           parts = name.split(' ')
           if parts.size == 2
             model = parts.first

data/lib/new_relic/agent/instrumentation/active_record_subscriber.rb

@@ -84,7 +84,7 @@ module NewRelic
           return unless event.payload[:connection_id]
 
           connections = ::ActiveRecord::Base.connection_handler.connection_pool_list.map { |handler| handler.connections }.flatten
-          connection = connections.detect { |connection| connection.object_id == event.payload[:connection_id] }
+          connection = connections.detect { |cnxn| cnxn.object_id == event.payload[:connection_id] }
 
           connection.instance_variable_get(:@config) if connection
         end

data/lib/new_relic/agent/instrumentation/controller_instrumentation.rb

@@ -4,6 +4,7 @@
 
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/instrumentation/queue_time'
+require 'new_relic/agent/instrumentation/ignore_actions'
 module NewRelic
   module Agent
     # @api public
@@ -45,10 +46,10 @@ module NewRelic
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
-        NR_DO_NOT_TRACE_KEY   = 'do_not_trace'.freeze unless defined?(NR_DO_NOT_TRACE_KEY)
-        NR_IGNORE_APDEX_KEY   = 'ignore_apdex'.freeze unless defined?(NR_IGNORE_APDEX_KEY)
-        NR_IGNORE_ENDUSER_KEY = 'ignore_enduser'.freeze unless defined?(NR_IGNORE_ENDUSER_KEY)
-        NR_DEFAULT_OPTIONS    = {}.freeze unless defined?(NR_DEFAULT_OPTIONS)
+        NR_DO_NOT_TRACE_KEY   = :'@do_not_trace'   unless defined?(NR_DO_NOT_TRACE_KEY  )
+        NR_IGNORE_APDEX_KEY   = :'@ignore_apdex'   unless defined?(NR_IGNORE_APDEX_KEY  )
+        NR_IGNORE_ENDUSER_KEY = :'@ignore_enduser' unless defined?(NR_IGNORE_ENDUSER_KEY)
+        NR_DEFAULT_OPTIONS    = {}.freeze          unless defined?(NR_DEFAULT_OPTIONS   )
 
         # @api public
         module ClassMethods
@@ -88,11 +89,11 @@ module NewRelic
           # Should be monkey patched into the controller class implemented
           # with the inheritable attribute mechanism.
           def newrelic_write_attr(attr_name, value) # :nodoc:
-            instance_variable_set "@#{attr_name}", value
+            instance_variable_set(attr_name, value)
           end
 
           def newrelic_read_attr(attr_name) # :nodoc:
-            instance_variable_get "@#{attr_name}"
+            instance_variable_get(attr_name)
           end
 
           # Add transaction tracing to the given method.  This will treat
@@ -329,7 +330,7 @@ module NewRelic
           state = NewRelic::Agent::TransactionState.tl_get
           state.request = newrelic_request(args)
 
-          # Skip instrumentation based on the value of 'do_not_trace' and if
+          # Skip instrumentation based on the value of 'do_not_trace?' and if
           # we aren't calling directly with a block.
           if !block_given? && do_not_trace?
             state.current_transaction.ignore! if state.current_transaction
@@ -439,18 +440,18 @@ module NewRelic
         end
 
         # Filter out a request if it matches one of our parameters for
-        # ignoring it - the key is either 'do_not_trace' or 'ignore_apdex'
+        # ignoring it - the key is either NR_DO_NOT_TRACE_KEY or NR_IGNORE_APDEX_KEY
         def _is_filtered?(key)
-          ignore_actions = self.class.newrelic_read_attr(key) if self.class.respond_to? :newrelic_read_attr
-          case ignore_actions
-          when nil; false
-          when Hash
-            only_actions   = Array(ignore_actions[:only])
-            except_actions = Array(ignore_actions[:except])
-            only_actions.include?(action_name.to_sym) || (except_actions.any? && !except_actions.include?(action_name.to_sym))
+          name = if respond_to?(:action_name)
+            action_name
           else
-            true
+            :'[action_name_missing]'
           end
+
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+            key,
+            self.class,
+            name)
         end
 
         def detect_queue_start_time(state)

data/lib/new_relic/agent/instrumentation/ignore_actions.rb

@@ -0,0 +1,41 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module IgnoreActions
+        def self.is_filtered?(key, klass, action_name)
+          # We'll walk the superclass chain and see if
+          # any class says 'yes, filter this one'.
+
+          while klass.respond_to? :newrelic_read_attr
+            ignore_actions = klass.newrelic_read_attr(key)
+
+            should_filter = case ignore_actions
+            when Hash
+              only_actions   = Array(ignore_actions[:only])
+              except_actions = Array(ignore_actions[:except])
+              action_name    = action_name.to_sym
+
+              only_actions.include?(action_name) || (!except_actions.empty? && !except_actions.include?(action_name))
+            else
+              !!ignore_actions
+            end
+
+            return true if should_filter
+
+            # Nothing so far says we should filter,
+            # so keep checking up the superclass chain.
+            klass = klass.superclass
+          end
+
+          # Getting here means that no class filtered this.
+          false
+        end
+      end
+    end
+  end
+end
+