newrelic_rpm 2.13.5.beta4 → 2.13.6.beta1

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

@@ -37,145 +37,166 @@
 #     non-first metric in trace_execution_scoped() (docs say only first counts
 #     towards scope) so they don't show up ine normal call graph/trace.
 
-if defined? ::DataMapper
-
-  # DM::Model class methods
-  ::DataMapper::Model.class_eval do
-
-    add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
-    add_method_tracer :first,    'ActiveRecord/#{self.name}/first'
-    add_method_tracer :last,     'ActiveRecord/#{self.name}/last'
-    add_method_tracer :all,      'ActiveRecord/#{self.name}/all'
-
-    add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
-    add_method_tracer :create!,  'ActiveRecord/#{self.name}/create'
-    add_method_tracer :update,   'ActiveRecord/#{self.name}/update'
-    add_method_tracer :update!,  'ActiveRecord/#{self.name}/update'
-    add_method_tracer :destroy,  'ActiveRecord/#{self.name}/destroy'
-    add_method_tracer :destroy!, 'ActiveRecord/#{self.name}/destroy'
-
-    # For dm-aggregates and partial dm-ar-finders support:
-    for method in [ :aggregate, :find, :find_by_sql ] do
-      next unless method_defined? method
-      add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
-    end
-
+DependencyDetector.defer do
+  depends_on do
+    defined?(::DataMapper)
   end
+  
+  executes_on(:'DataMapper::Model') do
+    class_eval do
+      add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
+      add_method_tracer :first,    'ActiveRecord/#{self.name}/first'
+      add_method_tracer :last,     'ActiveRecord/#{self.name}/last'
+      add_method_tracer :all,      'ActiveRecord/#{self.name}/all'
+
+      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+      add_method_tracer :create!,  'ActiveRecord/#{self.name}/create'
+      add_method_tracer :update,   'ActiveRecord/#{self.name}/update'
+      add_method_tracer :update!,  'ActiveRecord/#{self.name}/update'
+      add_method_tracer :destroy,  'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :destroy!, 'ActiveRecord/#{self.name}/destroy'
+
+      # For dm-aggregates and partial dm-ar-finders support:
+      for method in [ :aggregate, :find, :find_by_sql ] do
+        next unless method_defined? method
+        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
+      end
 
-  # DM's Model instance (Resource) methods
-  ::DataMapper::Resource.class_eval do
-
-    add_method_tracer :update,   'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
-    add_method_tracer :update!,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
-    add_method_tracer :save,     'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
-    add_method_tracer :save!,    'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
-    add_method_tracer :destroy,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
-    add_method_tracer :destroy!, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+    end
+  end
+  
+  executes_on(:'DataMapper::Resource') do
+    class_eval do
+      add_method_tracer :update,   'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+      add_method_tracer :update!,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+      add_method_tracer :save,     'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer :save!,    'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer :destroy,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+      add_method_tracer :destroy!, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
 
+    end
   end
 
-  # DM's Collection instance methods
-  ::DataMapper::Collection.class_eval do
+  executes_on(:'DataMapper::Collection') do
+    class_eval do
+      # DM's Collection instance methods
+      add_method_tracer :get,       'ActiveRecord/#{self.name}/get'
+      add_method_tracer :first,     'ActiveRecord/#{self.name}/first'
+      add_method_tracer :last,      'ActiveRecord/#{self.name}/last'
+      add_method_tracer :all,       'ActiveRecord/#{self.name}/all'
+
+      add_method_tracer :lazy_load, 'ActiveRecord/#{self.name}/lazy_load'
+
+      add_method_tracer :create,    'ActiveRecord/#{self.name}/create'
+      add_method_tracer :create!,   'ActiveRecord/#{self.name}/create'
+      add_method_tracer :update,    'ActiveRecord/#{self.name}/update'
+      add_method_tracer :update!,   'ActiveRecord/#{self.name}/update'
+      add_method_tracer :destroy,   'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :destroy!,  'ActiveRecord/#{self.name}/destroy'
+
+      # For dm-aggregates support:
+      for method in [ :aggregate ] do
+        next unless method_defined? method
+        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
+      end
 
-    add_method_tracer :get,       'ActiveRecord/#{self.name}/get'
-    add_method_tracer :first,     'ActiveRecord/#{self.name}/first'
-    add_method_tracer :last,      'ActiveRecord/#{self.name}/last'
-    add_method_tracer :all,       'ActiveRecord/#{self.name}/all'
+    end
+  end
+end
 
-    add_method_tracer :lazy_load, 'ActiveRecord/#{self.name}/lazy_load'
+DependencyDetection.defer do
+  executes_on(:'DataMapper::Adapters::DataObjectsAdapter') do
+    # Catch the two entry points into DM::Repository::Adapter that bypass CRUD
+    # (for when SQL is run directly).
+    class_eval do
 
-    add_method_tracer :create,    'ActiveRecord/#{self.name}/create'
-    add_method_tracer :create!,   'ActiveRecord/#{self.name}/create'
-    add_method_tracer :update,    'ActiveRecord/#{self.name}/update'
-    add_method_tracer :update!,   'ActiveRecord/#{self.name}/update'
-    add_method_tracer :destroy,   'ActiveRecord/#{self.name}/destroy'
-    add_method_tracer :destroy!,  'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :select,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/select'
+      add_method_tracer :execute, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
 
-    # For dm-aggregates support:
-    for method in [ :aggregate ] do
-      next unless method_defined? method
-      add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
     end
-
   end
+end
 
-  # Catch the two entry points into DM::Repository::Adapter that bypass CRUD
-  # (for when SQL is run directly).
-  ::DataMapper::Adapters::DataObjectsAdapter.class_eval do
-
-    add_method_tracer :select,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/select'
-    add_method_tracer :execute, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
-
-  end if defined? ::DataMapper::Adapters::DataObjectsAdapter
+DependencyDetection.defer do
 
   # DM::Validations overrides Model#create, but currently in a way that makes it
   # impossible to instrument from one place.  I've got a patch pending inclusion
   # to make it instrumentable by putting the create method inside ClassMethods.
   # This will pick it up if/when that patch is accepted.
-  ::DataMapper::Validations::ClassMethods.class_eval do
-
-    next unless method_defined? :create
-    add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
-
-  end if defined? ::DataMapper::Validations::ClassMethods
-
-  # NOTE: DM::Transaction basically calls commit() twice, so as-is it will show
-  # up in traces twice -- second time subordinate to the first's scope.  Works
-  # well enough.
-  ::DataMapper::Transaction.module_eval do
-    add_method_tracer :commit, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/commit'
-  end if defined? ::DataMapper::Transaction
-
-  module NewRelic
-    module Agent
-      module Instrumentation
-        module DataMapperInstrumentation
-
-          def self.included(klass)
-            klass.class_eval do
-              alias_method :log_without_newrelic_instrumentation, :log
-              alias_method :log, :log_with_newrelic_instrumentation
-            end
-          end
+  executes_on(:'DataMapper::Validations::ClassMethods') do
+    class_eval do
 
-          # Unlike in AR, log is called in DM after the query actually ran,
-          # complete with metrics.  Since DO has already calculated the
-          # duration, there's nothing more to measure, so just record and log.
-          #
-          # We rely on the assumption that all possible entry points have been
-          # hooked with tracers, ensuring that notice_sql attaches this SQL to
-          # the proper call scope.
-          def log_with_newrelic_instrumentation(msg)
-            return unless NewRelic::Agent.is_execution_traced?
-            return unless operation = case msg.query
-              when /^\s*select/i          then 'find'
-              when /^\s*(update|insert)/i then 'save'
-              when /^\s*delete/i          then 'destroy'
-              else nil
-            end
-
-            # FYI: self.to_s will yield connection URI string.
-            duration = msg.duration / 1000000.0
-
-            # Attach SQL to current segment/scope.
-            NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
-
-            # Record query duration associated with each of the desired metrics.
-            metrics = [ "ActiveRecord/#{operation}", 'ActiveRecord/all' ]
-            metrics.each do |metric|
-              NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric).trace_call(duration)
-            end
-          ensure
-            log_without_newrelic_instrumentation(msg)
-          end
+      next unless method_defined? :create
+      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
 
-        end # DataMapperInstrumentation
-      end # Instrumentation
-    end # Agent
-  end # NewRelic
+    end
+  end
+end
+
+DependencyDetection.defer do
+# NOTE: DM::Transaction basically calls commit() twice, so as-is it will show
+# up in traces twice -- second time subordinate to the first's scope.  Works
+# well enough.
+  executes_on(:'DataMapper::Transaction') do
+    module_eval do
+      add_method_tracer :commit, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/commit'
+    end
+  end
+end
 
-  ::DataObjects::Connection.class_eval do
-    include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
-  end if defined? ::DataObjects::Connection
 
-end # if defined? DataMapper
+module NewRelic
+  module Agent
+    module Instrumentation
+      module DataMapperInstrumentation
+
+        def self.included(klass)
+          klass.class_eval do
+            alias_method :log_without_newrelic_instrumentation, :log
+            alias_method :log, :log_with_newrelic_instrumentation
+          end
+        end
+
+        # Unlike in AR, log is called in DM after the query actually ran,
+        # complete with metrics.  Since DO has already calculated the
+        # duration, there's nothing more to measure, so just record and log.
+        #
+        # We rely on the assumption that all possible entry points have been
+        # hooked with tracers, ensuring that notice_sql attaches this SQL to
+        # the proper call scope.
+        def log_with_newrelic_instrumentation(msg)
+          return unless NewRelic::Agent.is_execution_traced?
+          return unless operation = case msg.query
+                                    when /^\s*select/i          then 'find'
+                                    when /^\s*(update|insert)/i then 'save'
+                                    when /^\s*delete/i          then 'destroy'
+                                    else nil
+                                    end
+
+          # FYI: self.to_s will yield connection URI string.
+          duration = msg.duration / 1000000.0
+
+          # Attach SQL to current segment/scope.
+          NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
+
+          # Record query duration associated with each of the desired metrics.
+          metrics = [ "ActiveRecord/#{operation}", 'ActiveRecord/all' ]
+          metrics.each do |metric|
+            NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric).trace_call(duration)
+          end
+        ensure
+          log_without_newrelic_instrumentation(msg)
+        end
+
+      end # DataMapperInstrumentation
+    end # Instrumentation
+  end # Agent
+end # NewRelic
+
+DependencyDetection.defer do
+  executes_on(:'DataObjects::Connection') do
+    class_eval do
+      include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
+    end
+  end
+end

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

@@ -1,22 +1,23 @@
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
-if defined?(Delayed::Job) and not NewRelic::Control.instance['disable_dj']
-  module NewRelic
-    module Agent
-      module Instrumentation
-        module DelayedJobInstrumentation
-
-          Delayed::Job.class_eval do
-            include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-            if 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
+DependencyDetection.defer do
+  depends_on do
+    !NewRelic::Control.instance['disable_dj']
+  end
 
-        end
-      end
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Job)
+  end
+  
+  executes do
+    Delayed::Job.class_eval do
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    if 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
+

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

@@ -4,39 +4,53 @@
 #     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
 #     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
 #     http://github.com/mperham/dalli (Gem: dalli)
-unless NewRelic::Control.instance['disable_memcache_instrumentation']
 
-  def self.instrument_method(the_class, method_name)
-    return unless the_class.method_defined? method_name.to_sym
-    the_class.class_eval <<-EOD
-        def #{method_name}_with_newrelic_trace(*args)
-          metrics = ["MemCache/#{method_name}",
-                     (NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction? ? 'MemCache/allWeb' : 'MemCache/allOther')]
-          self.class.trace_execution_scoped(metrics) do
-            t0 = Time.now
-            begin
-              #{method_name}_without_newrelic_trace(*args)
-            ensure
-              #{memcache_key_snippet(method_name)}
-            end
-          end
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Memcache
+        module_function
+        def instrument_method(the_class, method_name)
+          return unless the_class.method_defined? method_name.to_sym          
+                     the_class.class_eval <<-EOD
+                       def #{method_name}_with_newrelic_trace(*args)
+                         metrics = ["MemCache/#{method_name}",
+                                    (NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction? ? 'MemCache/allWeb' : 'MemCache/allOther')]
+                         self.class.trace_execution_scoped(metrics) do
+                           t0 = Time.now
+                           begin
+                             #{method_name}_without_newrelic_trace(*args)
+                           ensure
+                             #{memcache_key_snippet(method_name)}
+                           end
+                         end
+                       end
+                       alias #{method_name}_without_newrelic_trace #{method_name}
+                       alias #{method_name} #{method_name}_with_newrelic_trace
+                       EOD
+        end
+        def memcache_key_snippet(method_name)
+          return "" unless NewRelic::Control.instance['capture_memcache_keys']
+          "NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil"
         end
-        alias #{method_name}_without_newrelic_trace #{method_name}
-        alias #{method_name} #{method_name}_with_newrelic_trace
-    EOD
       end
+    end
+  end
+end
 
-      def self.memcache_key_snippet(method_name)
-        return "" unless NewRelic::Control.instance['capture_memcache_keys']
-        "NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil"
-      end
 
 
 
-  %w[get get_multi set add incr decr delete replace append prepend cas].each do | method_name |
-    instrument_method(::MemCache, method_name) if defined? ::MemCache
-    instrument_method(::Memcached, method_name) if defined? ::Memcached
-    instrument_method(::Dalli::Client, method_name) if defined? ::Dalli::Client
+DependencyDetection.defer do
+  depends_on do
+    !NewRelic::Control.instance['disable_memcache_instrumentation']
   end
 
+  executes do
+    %w[get get_multi set add incr decr delete replace append prepend cas].each do | method_name |
+      NewRelic::Agent::Instrumentation::Memcache.instrument_method(::MemCache, method_name) if defined? ::MemCache
+      NewRelic::Agent::Instrumentation::Memcache.instrument_method(::Memcached, method_name) if defined? ::Memcached
+      NewRelic::Agent::Instrumentation::Memcache.instrument_method(::Dalli::Client, method_name) if defined? ::Dalli::Client
+    end
+  end
 end

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

@@ -1,17 +1,23 @@
-if defined? Net::HTTP
-  Net::HTTP.class_eval do
-    def request_with_newrelic_trace(*args, &block)
-      metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}","External/#{@address}/all"]
-      if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
-        metrics << "External/allWeb"
-      else
-        metrics << "External/allOther"
-      end
-      self.class.trace_execution_scoped metrics do
-        request_without_newrelic_trace(*args, &block)
+DependencyDetection.defer do
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  executes do
+    Net::HTTP.class_eval do
+      def request_with_newrelic_trace(*args, &block)
+        metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}","External/#{@address}/all"]
+        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+        self.class.trace_execution_scoped metrics do
+          request_without_newrelic_trace(*args, &block)
+        end
       end
+      alias request_without_newrelic_trace request
+      alias request request_with_newrelic_trace
     end
-    alias request_without_newrelic_trace request
-    alias request request_with_newrelic_trace
   end
 end

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

@@ -1,22 +1,34 @@
-if defined?(PhusionPassenger)
-  NewRelic::Agent.logger.debug "Installing Passenger event hooks."
-
-  PhusionPassenger.on_event(:stopping_worker_process) do
-    NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
-    NewRelic::Agent.instance.shutdown
+DependencyDetection.defer do
+  depends_on do
+    defined?(PhusionPassenger)
   end
 
-  PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    # We want to reset the stats from the stats engine in case any carried
-    # over into the spawned process.  Don't clear them in case any were
-    # cached.  We do this even in conservative spawning.
-    NewRelic::Agent.after_fork(:force_reconnect => true)
+  executes do
+    NewRelic::Agent.logger.debug "Installing Passenger event hooks."
+
+    PhusionPassenger.on_event(:stopping_worker_process) do
+      NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
+      NewRelic::Agent.instance.shutdown
+    end
+
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+      # We want to reset the stats from the stats engine in case any carried
+      # over into the spawned process.  Don't clear them in case any were
+      # cached.  We do this even in conservative spawning.
+      NewRelic::Agent.after_fork(:force_reconnect => true)
+    end
   end
+end
 
-elsif (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
-  # We're on an older version of passenger
-  NewRelic::Agent.logger.warn "An older version of Phusion Passenger has been detected.  We recommend using at least release 2.1.1."
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Passenger) && defined?(::Passenger::AbstractServer) || defined?(::IN_PHUSION_PASSENGER)
+  end
 
-  NewRelic::Agent::Instrumentation::MetricFrame.check_server_connection = true
+  executes do
+    # We're on an older version of passenger
+    NewRelic::Agent.logger.warn "An older version of Phusion Passenger has been detected.  We recommend using at least release 2.1.1."
 
+    NewRelic::Agent::Instrumentation::MetricFrame.check_server_connection = true
+  end
 end