newrelic_rpm 3.9.5.251 → 3.9.6.257

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -37,8 +37,10 @@ module NewRelic
         state = NewRelic::Agent::TransactionState.tl_get
         return yield unless state.is_execution_traced?
 
+        # It's important to set t0 outside the ensured block, otherwise there's
+        # a race condition if we raise after begin but before t0's set.
+        t0 = Time.now
         begin
-          t0 = Time.now
           segment = start_trace(state, t0, request)
           response = yield
         ensure
@@ -91,6 +93,11 @@ module NewRelic
       # * to_hash - Converts response headers to a Hash
       #
       def finish_trace(state, t0, segment, request, response)
+        unless t0
+          NewRelic::Agent.logger.error("HTTP request trace finished without start time. This is probably an agent bug.")
+          return
+        end
+
         t1 = Time.now
         duration = t1.to_f - t0.to_f
 
@@ -237,8 +244,6 @@ module NewRelic
       def response_is_crossapp?( response )
         return false unless cross_app_enabled?
         unless response[NR_APPDATA_HEADER]
-          NewRelic::Agent.logger.debug "Response doesn't have the %p header: %p" %
-            [ NR_APPDATA_HEADER, response.to_hash ]
           return false
         end
 
@@ -254,8 +259,6 @@ module NewRelic
         check_crossapp_id( xp_id )
         check_transaction_name( txn_name )
 
-        NewRelic::Agent.logger.debug "CAT xp_id: %p, txn_name: %p." % [ xp_id, txn_name ]
-
         metrics = []
         metrics << "ExternalApp/#{request.host}/#{xp_id}/all"
         metrics << "ExternalTransaction/#{request.host}/#{xp_id}/#{txn_name}"

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

@@ -58,8 +58,11 @@ module NewRelic
         end
 
         def filter(params)
+          munged_params = params.dup
+          munged_params.delete('controller')
+          munged_params.delete('action')
           filters = Rails.application.config.filter_parameters
-          ActionDispatch::Http::ParameterFilter.new(filters).filter(params)
+          ActionDispatch::Http::ParameterFilter.new(filters).filter(munged_params)
         end
       end
 

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

@@ -0,0 +1,93 @@
+# 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.
+
+DependencyDetection.defer do
+  named :activejob
+
+  depends_on do
+    defined?(::ActiveJob::Base)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing ActiveJob instrumentation'
+
+    ::ActiveJob::Base.around_enqueue do |job, block|
+      ::NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
+    end
+
+    ::ActiveJob::Base.around_perform do |job, block|
+      ::NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
+    end
+  end
+end
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveJobHelper
+        include ::NewRelic::Agent::MethodTracer
+
+        def self.enqueue(job, block)
+          run_in_trace(job, block, :Produce)
+        end
+
+        def self.perform(job, block)
+          state = ::NewRelic::Agent::TransactionState.tl_get
+
+          # Don't nest transactions if we're already in a web transaction.
+          # Probably inline processing the job if that happens, so just trace.
+          if state.in_web_transaction?
+            run_in_trace(job, block, :Consume)
+          elsif state.in_background_transaction?
+            ::NewRelic::Agent::Transaction.set_default_transaction_name(
+              transaction_name_suffix_for_job(job),
+              :category => transaction_category)
+            block.call
+          else
+            run_in_transaction(state, job, block)
+          end
+        end
+
+        def self.run_in_trace(job, block, event)
+          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}") do
+            block.call
+          end
+        end
+
+        def self.run_in_transaction(state, job, block)
+          begin
+            ::NewRelic::Agent::Transaction.start(state, :other,
+              :transaction_name => transaction_name_for_job(job))
+            block.call
+          ensure
+            ::NewRelic::Agent::Transaction.stop(state)
+          end
+        end
+
+        def self.transaction_category
+          "OtherTransaction/#{adapter}"
+        end
+
+        def self.transaction_name_suffix_for_job(job)
+          "#{job.class}/execute"
+        end
+
+        def self.transaction_name_for_job(job)
+          "#{transaction_category}/#{transaction_name_suffix_for_job(job)}"
+        end
+
+        def self.adapter
+          clean_adapter_name(::ActiveJob::Base.queue_adapter.name)
+        end
+
+        ADAPTER_REGEX = /ActiveJob::QueueAdapters::(.*)Adapter/
+
+        def self.clean_adapter_name(name)
+          name = "ActiveJob::#{$1}" if ADAPTER_REGEX =~ name
+          name
+        end
+      end
+    end
+  end
+end

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

@@ -430,7 +430,8 @@ module NewRelic
 
         def create_transaction_options(trace_options, available_params)
           txn_options = {}
-          txn_options[:request] = trace_options[:request] || (respond_to?(:request) && request)
+          txn_options[:request]   = trace_options[:request]
+          txn_options[:request] ||= request if respond_to?(:request)
 
           if available_params
             txn_options[:filtered_params] = (respond_to?(:filter_parameters)) ? filter_parameters(available_params) : available_params

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

@@ -62,9 +62,9 @@ module NewRelic
             end
 
             result
-          rescue => e
+          rescue Exception => e
             NewRelic::Agent.notice_error(e)
-            raise
+            raise e
           ensure
             Transaction.stop(state)
           end

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

@@ -86,8 +86,7 @@ module NewRelic
         module ClassMethods
           def newrelic_middlewares
             [ NewRelic::Rack::AgentHooks,
-              NewRelic::Rack::BrowserMonitoring,
-              NewRelic::Rack::ErrorCollector ]
+              NewRelic::Rack::BrowserMonitoring ]
           end
 
           def build_with_newrelic(*args, &block)

data/lib/new_relic/agent/new_relic_service.rb

@@ -15,7 +15,7 @@ module NewRelic
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
 
-      PROTOCOL_VERSION = 12
+      PROTOCOL_VERSION = 14
       # 1f147a42: v10 (tag 3.5.3.17)
       # cf0d1ff1: v9 (tag 3.5.0)
       # 14105: v8 (tag 2.10.3)

data/lib/new_relic/agent/new_relic_service/json_marshaller.rb

@@ -14,6 +14,20 @@ module NewRelic
           unless self.class.is_supported?
             ::NewRelic::Agent.logger.warn "The JSON marshaller in use (#{NewRelic::JSONWrapper.backend_name}) is not recommended. Ensure the 'json' gem is available in your application for better performance."
           end
+          warn_for_yajl
+        end
+
+        OK_YAJL_VERSION = NewRelic::VersionNumber.new("1.2.1")
+
+        def warn_for_yajl
+          if defined?(::Yajl)
+            require 'yajl/version'
+            if NewRelic::VersionNumber.new(::Yajl::VERSION) < OK_YAJL_VERSION
+              ::NewRelic::Agent.logger.warn "Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available."
+            end
+          end
+        rescue => err
+          ::NewRelic::Agent.logger.warn "Failed trying to watch for problematic yajl-ruby version.", err
         end
 
         def dump(ruby, opts={})
@@ -29,7 +43,12 @@ module NewRelic
         end
 
         def load(data)
-          return_value(NewRelic::JSONWrapper.load(data)) if data && data != ''
+          if data.nil? || data.empty?
+            ::NewRelic::Agent.logger.error "Empty JSON response from collector: '#{data.inspect}'"
+            return nil
+          end
+
+          return_value(NewRelic::JSONWrapper.load(data))
         rescue => e
           ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
           raise

data/lib/new_relic/agent/new_relic_service/pruby_marshaller.rb

@@ -30,7 +30,11 @@ module NewRelic
         end
 
         def load(data)
-          return unless data && data != ''
+          if data.nil? || data.empty?
+            ::NewRelic::Agent.logger.error "Empty pruby response from collector: '#{data.inspect}'"
+            return nil
+          end
+
           NewRelic::LanguageSupport.with_cautious_gc do
             return_value(Marshal.load(data))
           end

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -129,10 +129,19 @@ module NewRelic
 
       class Listener
         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
+        # within the Resque child process, and must be unsynchronized in order
+        # to avoid a potential deadlock in which the PipeChannelManager::Listener
+        # thread in the parent process is holding the @pipes_lock at the time of
+        # the fork.
         attr_accessor :pipes, :timeout, :select_timeout
 
         def initialize
           @pipes = {}
+          @pipes_lock = Mutex.new
+
           @timeout = 360
           @select_timeout = 60
         end
@@ -142,7 +151,10 @@ module NewRelic
         end
 
         def register_pipe(id)
-          @pipes[id] = Pipe.new
+          @pipes_lock.synchronize do
+            @pipes[id] = Pipe.new
+          end
+
           wakeup
         end
 
@@ -153,7 +165,10 @@ module NewRelic
             now = nil
             loop do
               clean_up_pipes
-              pipes_to_listen_to = @pipes.values.map{|pipe| pipe.out} + [wake.out]
+
+              pipes_to_listen_to = @pipes_lock.synchronize do
+                @pipes.values.map{|pipe| pipe.out} + [wake.out]
+              end
 
               NewRelic::Agent.record_metric('Supportability/Listeners',
                 (Time.now - now).to_f) if now
@@ -190,10 +205,12 @@ module NewRelic
         end
 
         def close_all_pipes
-          @pipes.each do |id, pipe|
-            pipe.close if pipe
+          @pipes_lock.synchronize do
+            @pipes.each do |id, pipe|
+              pipe.close if pipe
+            end
+            @pipes = {}
           end
-          @pipes = {}
         end
 
         def wake
@@ -235,20 +252,24 @@ module NewRelic
         end
 
         def should_keep_listening?
-          @started || @pipes.values.find{|pipe| !pipe.in.closed?}
+          @started || @pipes_lock.synchronize { @pipes.values.find{|pipe| !pipe.in.closed?} }
         end
 
         def clean_up_pipes
-          @pipes.values.each do |pipe|
-            if pipe.last_read.to_f + @timeout < Time.now.to_f
-              pipe.close unless pipe.closed?
+          @pipes_lock.synchronize do
+            @pipes.values.each do |pipe|
+              if pipe.last_read.to_f + @timeout < Time.now.to_f
+                pipe.close unless pipe.closed?
+              end
             end
+            @pipes.reject! {|id, pipe| pipe.out.closed? }
           end
-          @pipes.reject! {|id, pipe| pipe.out.closed? }
         end
 
         def find_pipe_for_handle(out_handle)
-          @pipes.values.find{|pipe| pipe.out == out_handle }
+          @pipes_lock.synchronize do
+            @pipes.values.find{|pipe| pipe.out == out_handle }
+          end
         end
       end
     end

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -40,7 +40,7 @@ module NewRelic
             state = TransactionState.tl_state_for(thread)
             if state.in_background_transaction?
               :background
-            elsif state.in_request_transaction?
+            elsif state.in_web_transaction?
               :request
             else
               :other

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -6,6 +6,7 @@ module NewRelic
   module Agent
     module Threading
       MAX_THREAD_PROFILE_DEPTH = 500
+      UNKNOWN_LINE_NUMBER = -1
 
       class BacktraceBase
         attr_reader :children
@@ -108,7 +109,7 @@ module NewRelic
 
           file, method, line = parse_backtrace_frame(@raw_line)
 
-          @as_array << [string(file), string(method), int(line)]
+          @as_array << [string(file), string(method), line ? int(line) : UNKNOWN_LINE_NUMBER]
           @as_array << int(@runnable_count)
           @as_array << 0
           @as_array << child_arrays
@@ -124,8 +125,8 @@ module NewRelic
 
         # Returns [filename, method, line number]
         def parse_backtrace_frame(frame)
-          frame =~ /(.*)\:(\d+)\:in `(.*)'/
-          [$1, $3, $2] # sic
+          frame =~ /([^:]*)(\:(\d+))?\:in `(.*)'/
+          [$1, $4, $3] # sic
         end
       end
 

data/lib/new_relic/agent/transaction.rb

@@ -22,6 +22,7 @@ module NewRelic
       TASK_PREFIX                  = 'OtherTransaction/Background/'.freeze
       RACK_PREFIX                  = 'Controller/Rack/'.freeze
       SINATRA_PREFIX               = 'Controller/Sinatra/'.freeze
+      OTHER_TRANSACTION_PREFIX     = 'OtherTransaction/'.freeze
 
       CONTROLLER_MIDDLEWARE_PREFIX = 'Controller/Middleware/Rack'.freeze
 
@@ -183,7 +184,7 @@ module NewRelic
       end
 
       def self.nested_transaction_name(name)
-        if name.start_with?(CONTROLLER_PREFIX)
+        if name.start_with?(CONTROLLER_PREFIX) || name.start_with?(OTHER_TRANSACTION_PREFIX)
           "#{SUBTRANSACTION_PREFIX}#{name}"
         else
           name
@@ -368,6 +369,7 @@ module NewRelic
       def stop(state, end_time)
         return if !state.is_execution_traced?
         freeze_name_and_execute_if_not_ignored
+        ignore! if user_defined_rules_ignore?
 
         if @name_from_child
           name = Transaction.nested_transaction_name(@default_name)
@@ -399,6 +401,17 @@ module NewRelic
         commit!(state, end_time, name) unless @ignore_this_transaction
       end
 
+      def user_defined_rules_ignore?
+        return if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
+
+        parsed = NewRelic::Agent::HTTPClients::URIUtil.parse_url(uri)
+        filtered_uri = NewRelic::Agent::HTTPClients::URIUtil.filter_uri(parsed)
+
+        rules.any? do |rule|
+          filtered_uri.match(rule)
+        end
+      end
+
       def commit!(state, end_time, outermost_segment_name)
         record_transaction_cpu(state)
         gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
@@ -422,7 +435,7 @@ module NewRelic
       def record_summary_metrics(outermost_segment_name, end_time)
         metrics = summary_metrics
         metrics << @frozen_name unless @frozen_name == outermost_segment_name
-        @metrics.record_unscoped(metrics, end_time - start_time, 0)
+        @metrics.record_unscoped(metrics, end_time.to_f - start_time.to_f, 0)
       end
 
       # This event is fired when the transaction is fully completed. The metric
@@ -557,8 +570,8 @@ module NewRelic
       def self.extract_request_options(options)
         req = options.delete(:request)
         if req
+          options[:uri]     = uri_from_request(req)
           options[:referer] = referer_from_request(req)
-          options[:uri] = uri_from_request(req)
         end
         options
       end
@@ -566,13 +579,13 @@ module NewRelic
 
       # Do not call this.  Invoke the class method instead.
       def notice_error(error, options={}) # :nodoc:
-        options[:referer] = referer if referer
+        options[:uri]     ||= uri     if uri
+        options[:referer] ||= referer if referer
 
         if filtered_params && !filtered_params.empty?
           options[:request_params] = filtered_params
         end
 
-        options[:uri] = uri if uri
         options.merge!(custom_parameters)
 
         if @exceptions[error]
@@ -771,11 +784,19 @@ module NewRelic
         p.stime + p.utime
       end
 
+      JRUBY_CPU_TIME_ERROR = "Error calculating JRuby CPU Time".freeze
       def jruby_cpu_time
         return nil unless @@java_classes_loaded
-        threadMBean = ManagementFactory.getThreadMXBean()
+        threadMBean = Java::JavaLangManagement::ManagementFactory.getThreadMXBean()
+
+        return nil unless threadMBean.isCurrentThreadCpuTimeSupported
         java_utime = threadMBean.getCurrentThreadUserTime()  # ns
+
         -1 == java_utime ? 0.0 : java_utime/1e9
+      rescue => e
+        ::NewRelic::Agent.logger.log_once(:warn, :jruby_cpu_time, JRUBY_CPU_TIME_ERROR, e)
+        ::NewRelic::Agent.logger.debug(JRUBY_CPU_TIME_ERROR, e)
+        nil
       end
 
       def agent