newrelic_rpm 3.6.5.130 → 3.6.6.147

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

@@ -34,6 +34,8 @@ module NewRelic
             # transaction are also ignored
             NewRelic::Agent.instance.push_trace_execution_flag(false)
           end
+        rescue => e
+          handle_tracing_error('ActionControllerSubscriber#start', e)
         end
 
         def finish(name, id, payload)
@@ -52,6 +54,15 @@ module NewRelic
           else
             Agent.instance.pop_trace_execution_flag
           end
+        rescue => e
+          handle_tracing_error('ActionControllerSubscriber#finish', e)
+        end
+
+        def handle_tracing_error(identifier, e)
+          # This is an important enough failure that we want the backtrace logged
+          # at error level, hence the explicit log_exception call.
+          NewRelic::Agent.logger.error("Tracing error during #{identifier}:")
+          NewRelic::Agent.logger.log_exception(:error, e)
         end
 
         def set_enduser_ignore
@@ -102,6 +113,7 @@ module NewRelic
         def stop_transaction(event)
           Agent.instance.stats_engine \
             .pop_scope(event.scope, event.metric_name, event.end)
+        ensure
           Transaction.stop
         end
 

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

@@ -4,17 +4,17 @@
 
 DependencyDetection.defer do
   @name = :active_merchant
-  
+
   depends_on do
     defined?(ActiveMerchant) && defined?(ActiveMerchant::Billing) &&
       defined?(ActiveMerchant::Billing::Gateway) &&
       ActiveMerchant::Billing::Gateway.respond_to?(:implementations)
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing ActiveMerchant instrumentation'
   end
-  
+
   executes do
     ActiveMerchant::Billing::Gateway.implementations.each do |gateway|
       gateway.class_eval do

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

@@ -23,7 +23,7 @@ end
 
 DependencyDetection.defer do
   @name = :acts_as_solr
-  
+
   depends_on do
     defined?(ActsAsSolr)
   end
@@ -39,11 +39,11 @@ DependencyDetection.defer do
   depends_on do
     defined?(ActsAsSolr::CommonMethods)
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing ActsAsSolr instrumentation'
   end
-  
+
   executes do
     ActsAsSolr::ParserMethods.module_eval do
       include NewRelic::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation

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

@@ -4,7 +4,7 @@
 
 DependencyDetection.defer do
   @name = :authlogic
-  
+
   depends_on do
     defined?(AuthLogic) &&
       defined?(AuthLogic::Session) &&
@@ -13,8 +13,8 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing AuthLogic instrumentation'
-  end  
-  
+  end
+
   executes do
     AuthLogic::Session::Base.class_eval do
       add_method_tracer :find, 'Custom/Authlogic/find'

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

@@ -0,0 +1,179 @@
+# 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 :curb
+
+  CURB_MIN_VERSION = ::NewRelic::VersionNumber.new("0.8.1")
+
+  depends_on do
+    defined?(::Curl) && defined?(::Curl::CURB_VERSION) &&
+      ::NewRelic::VersionNumber.new(::Curl::CURB_VERSION) >= CURB_MIN_VERSION
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Curb instrumentation'
+    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/http_clients/curb_wrappers'
+  end
+
+  executes do
+    class Curl::Easy
+
+      attr_accessor :_nr_instrumented,
+                    :_nr_http_verb,
+                    :_nr_header_str,
+                    :_nr_original_on_header,
+                    :_nr_original_on_complete,
+                    :_nr_serial
+
+      # We have to hook these three methods separately, as they don't use
+      # Curl::Easy#http
+      def http_head_with_newrelic(*args, &blk)
+        self._nr_http_verb = :HEAD
+        http_head_without_newrelic(*args, &blk)
+      end
+      alias_method :http_head_without_newrelic, :http_head
+      alias_method :http_head, :http_head_with_newrelic
+
+      def http_post_with_newrelic(*args, &blk)
+        self._nr_http_verb = :POST
+        http_post_without_newrelic(*args, &blk)
+      end
+      alias_method :http_post_without_newrelic, :http_post
+      alias_method :http_post, :http_post_with_newrelic
+
+      def http_put_with_newrelic(url, data, &blk)
+        self._nr_http_verb = :PUT
+        http_put_with_newrelic(url, data, &blk)
+      end
+      alias_method :http_put_without_newrelic, :http_put
+      alias_method :http_put, :http_put_with_newrelic
+
+
+      # Hook the #http method to set the verb.
+      def http_with_newrelic( verb )
+        self._nr_http_verb = verb.to_s.upcase
+        http_without_newrelic( verb )
+      end
+
+      alias_method :http_without_newrelic, :http
+      alias_method :http, :http_with_newrelic
+
+
+      # Hook the #perform method to mark the request as non-parallel.
+      def perform_with_newrelic
+        self._nr_serial = true
+        perform_without_newrelic
+      end
+
+      alias_method :perform_without_newrelic, :perform
+      alias_method :perform, :perform_with_newrelic
+
+      # We override this method in order to ensure access to header_str even
+      # though we use an on_header callback
+      def header_str
+        self._nr_header_str
+      end
+    end # class Curl::Easy
+
+
+    class Curl::Multi
+      include NewRelic::Agent::MethodTracer
+
+      # Add CAT with callbacks if the request is serial
+      def add_with_newrelic( curl )
+        if curl.respond_to?( :_nr_serial ) && curl._nr_serial
+          hook_pending_request( curl ) if NewRelic::Agent.is_execution_traced?
+        end
+
+        return add_without_newrelic( curl )
+      end
+
+      alias_method :add_without_newrelic, :add
+      alias_method :add, :add_with_newrelic
+
+
+      # Trace as an External/Multiple call if the first request isn't serial.
+      def perform_with_newrelic(&blk)
+        return perform_without_newrelic if
+          self.requests.first &&
+          self.requests.first.respond_to?( :_nr_serial ) &&
+          self.requests.first._nr_serial
+
+        trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
+          perform_without_newrelic(&blk)
+        end
+      end
+
+      alias_method :perform_without_newrelic, :perform
+      alias_method :perform, :perform_with_newrelic
+
+
+      # Instrument the specified +request+ (a Curl::Easy object) and set up cross-application
+      # tracing if it's enabled.
+      def hook_pending_request( request )
+        wrapped_request, wrapped_response = wrap_request( request )
+        t0, segment = NewRelic::Agent::CrossAppTracing.start_trace( wrapped_request )
+
+        unless request._nr_instrumented
+          install_header_callback( request, wrapped_response )
+          install_completion_callback( request, t0, segment, wrapped_request, wrapped_response )
+          request._nr_instrumented = true
+        end
+      rescue => err
+        NewRelic::Agent.logger.error( "Untrapped exception", err )
+      end
+
+
+      # Create request and response adapter objects for the specified +request+
+      def wrap_request( request )
+        return NewRelic::Agent::HTTPClients::CurbRequest.new( request ),
+               NewRelic::Agent::HTTPClients::CurbResponse.new( request )
+      end
+
+
+      # Install a callback that will record the response headers to enable
+      # CAT linking
+      def install_header_callback( request, wrapped_response )
+        original_callback = request.on_header
+        request._nr_original_on_header = original_callback
+        request._nr_header_str = ''
+        request.on_header do |header_data|
+          wrapped_response.append_header_data( header_data )
+
+          if original_callback
+            original_callback.call( header_data )
+          else
+            header_data.length
+          end
+        end
+      end
+
+      # Install a callback that will finish the trace.
+      def install_completion_callback( request, t0, segment, wrapped_request, wrapped_response )
+        original_callback = request.on_complete
+        request._nr_original_on_complete = original_callback
+        request.on_complete do |finished_request|
+          begin
+            NewRelic::Agent::CrossAppTracing.finish_trace( t0, segment, wrapped_request, wrapped_response )
+          ensure
+            # Make sure the existing completion callback is run, and restore the
+            # on_complete callback to how it was before.
+            original_callback.call( finished_request ) if original_callback
+            remove_instrumentation_callbacks( request )
+          end
+        end
+      end
+
+      def remove_instrumentation_callbacks( request )
+        request.on_complete(&request._nr_original_on_complete)
+        request.on_header(&request._nr_original_on_header)
+        request._nr_instrumented = false
+      end
+
+    end # class Curl::Multi
+
+  end
+end

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

@@ -43,7 +43,7 @@
 
 DependencyDetection.defer do
   @name = :data_mapper
-  
+
   depends_on do
     defined?(::DataMapper)
   end
@@ -59,11 +59,11 @@ DependencyDetection.defer do
   depends_on do
     defined?(DataMapper::Collection)
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing DataMapper instrumentation'
   end
-  
+
   executes do
     DataMapper::Model.class_eval do
       add_method_tracer :get,      'ActiveRecord/#{self.name}/get'

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

@@ -6,44 +6,53 @@ require 'new_relic/agent/instrumentation/controller_instrumentation'
 
 DependencyDetection.defer do
   @name = :delayed_job
-  
+
   depends_on do
     !NewRelic::Agent.config[:disable_dj]
   end
 
   depends_on do
-    # double check because of old JRuby bug 
-    defined?(::Delayed) && defined?(::Delayed::Job) &&
-      Delayed::Job.method_defined?(:invoke_job)
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
   end
-  
+
   executes do
-    ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 1/2]'
   end
-  
+
   executes do
-    Delayed::Job.class_eval do
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      if self.instance_methods.include?('name') || self.instance_methods.include?(:name)
-        add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob', :path => '#{self.name}'
-      else
-        add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob'
+    Delayed::Worker.class_eval do
+      def initialize_with_new_relic(*args)
+        initialize_without_new_relic(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        NewRelic::DelayedJobInjection.worker_name = worker_name
+
+        if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job)
+          ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+          install_newrelic_job_tracer
+
+          dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+          NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+        else
+          NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+        end
       end
-    end
-  end
 
-  executes do
-    Delayed::Job.instance_eval do
-      # alias_method is for instance, not class methods. But we still want to
-      # call any existing class method we're redefining, so do it the hard way.
-      @original_after_fork = method(:after_fork) if respond_to?(:after_fork)
-
-      def after_fork
-        NewRelic::Agent.after_fork(:force_reconnect => true)
-        @original_after_fork.call() if @original_after_fork
-        super
+      alias initialize_without_new_relic initialize
+      alias initialize initialize_with_new_relic
+
+      def install_newrelic_job_tracer
+        Delayed::Job.class_eval do
+          include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+          if self.instance_methods.include?('name') || self.instance_methods.include?(:name)
+            add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob', :path => '#{self.name}'
+          else
+            add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob'
+          end
+        end
       end
     end
   end
 end
-

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

@@ -0,0 +1,46 @@
+# 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 :httpclient
+
+  HTTPCLIENT_MIN_VERSION = '2.2.0'
+
+  depends_on do
+    defined?(HTTPClient) && defined?(HTTPClient::VERSION)
+  end
+
+  depends_on do
+    minimum_supported_version = NewRelic::VersionNumber.new(HTTPCLIENT_MIN_VERSION)
+    current_version = NewRelic::VersionNumber.new(HTTPClient::VERSION)
+
+    current_version >= minimum_supported_version
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing HTTPClient instrumentation'
+    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/http_clients/httpclient_wrappers'
+  end
+
+  executes do
+    class HTTPClient
+      def do_get_block_with_newrelic(req, proxy, conn, &block)
+        wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(req)
+
+        response = nil
+        ::NewRelic::Agent::CrossAppTracing.trace_http_request(wrapped_request) do
+          do_get_block_without_newrelic(req, proxy, conn, &block)
+          response = conn.pop
+          conn.push response
+          ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
+        end
+        response
+      end
+
+      alias do_get_block_without_newrelic do_get_block
+      alias do_get_block do_get_block_with_newrelic
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/merb/controller.rb

@@ -6,15 +6,15 @@ require 'set'
 
 DependencyDetection.defer do
   @name = :merb_controller
-  
+
   depends_on do
     defined?(Merb) && defined?(Merb::Controller)
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Merb Controller instrumentation'
   end
-  
+
   executes do
     require 'merb-core/controller/merb_controller'