ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

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

@@ -0,0 +1,138 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecord
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
+              alias_method :log_without_newrelic_instrumentation, :log
+              alias_method :log, :log_with_newrelic_instrumentation
+              protected :log
+            end
+          end
+        end
+                
+        def log_with_newrelic_instrumentation(*args, &block)
+          if !NewRelic::Agent.is_execution_traced?
+            return log_without_newrelic_instrumentation(*args, &block)
+          end
+          
+          sql, name, binds = args
+          metric = metric_for_name(NewRelic::Helper.correctly_encoded(name)) ||
+            metric_for_sql(NewRelic::Helper.correctly_encoded(sql))
+          
+          if !metric
+            log_without_newrelic_instrumentation(*args, &block)
+          else
+            metrics = [metric, remote_service_metric].compact
+            metrics += rollup_metrics_for(metric)
+            self.class.trace_execution_scoped(metrics) do
+              t0 = Time.now
+              begin
+                log_without_newrelic_instrumentation(*args, &block)
+              ensure
+                elapsed_time = (Time.now - t0).to_f
+                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
+                                                         @config, elapsed_time)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric,
+                                                         @config, elapsed_time)
+              end
+            end
+          end
+        end
+        
+        def remote_service_metric
+          if @config && @config[:adapter]
+            type = @config[:adapter].sub(/\d*/, '')
+            host = @config[:host] || 'localhost'
+            "RemoteService/sql/#{type}/#{host}"
+          end                      
+        end
+        
+        def metric_for_name(name)
+          if name && (parts = name.split " ") && parts.size == 2
+            model = parts.first
+            operation = parts.last.downcase
+            op_name = case operation
+                          when 'load', 'count', 'exists' then 'find'
+                          when 'indexes', 'columns' then nil # fall back to DirectSQL
+                          when 'destroy', 'find', 'save', 'create' then operation
+                          when 'update' then 'save'
+                          else
+                            if model == 'Join'
+                              operation
+                            end
+                          end
+            "ActiveRecord/#{model}/#{op_name}" if op_name
+          end
+        end
+
+        def metric_for_sql(sql)
+          metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+          if metric.nil?
+            if sql =~ /^(select|update|insert|delete|show)/i
+              # Could not determine the model/operation so let's find a better
+              # metric.  If it doesn't match the regex, it's probably a show
+              # command or some DDL which we'll ignore.
+              metric = "Database/SQL/#{$1.downcase}"
+            else
+              metric = "Database/SQL/other"
+            end
+          end
+          metric
+        end
+        
+        def rollup_metrics_for(metric)
+          metrics = ["ActiveRecord/all"]
+          metrics << "ActiveRecord/#{$1}" if metric =~ /ActiveRecord\/\w+\/(\w+)/
+          metrics
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :active_record
+  
+  depends_on do
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['skip_ar_instrumentation']
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_activerecord_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing ActiveRecord instrumentation'
+  end
+  
+  executes do
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+      Rails.configuration.after_initialize do
+        insert_instrumentation
+      end
+    else
+      insert_instrumentation
+    end
+  end
+
+  def insert_instrumentation
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::NewRelic::Agent::Instrumentation::ActiveRecord
+    end
+    
+    ActiveRecord::Base.class_eval do
+      class << self
+        add_method_tracer(:find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql',
+                          :metric => false)
+        add_method_tracer(:transaction, 'ActiveRecord/#{self.name}/transaction',
+                          :metric => false)
+      end
+    end          
+  end
+end

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

@@ -18,6 +18,8 @@ module NewRelic
 end
 
 DependencyDetection.defer do
+  @name = :acts_as_solr
+  
   depends_on do
     defined?(ActsAsSolr)
   end
@@ -33,7 +35,11 @@ DependencyDetection.defer do
   depends_on do
     defined?(ActsAsSolr::CommonMethods)
   end
-
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing ActsAsSolr instrumentation'
+  end
+  
   executes do
     ActsAsSolr::ParserMethods.module_eval do
       include NewRelic::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation

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

@@ -1,10 +1,16 @@
 DependencyDetection.defer do
+  @name = :authlogic
+  
   depends_on do
     defined?(AuthLogic) &&
       defined?(AuthLogic::Session) &&
       defined?(AuthLogic::Session::Base)
   end
 
+  executes do
+    NewRelic::Agent.logger.debug 'Installing AuthLogic instrumentation'
+  end  
+  
   executes do
     AuthLogic::Session::Base.class_eval do
       add_method_tracer :find, 'Custom/Authlogic/find'

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

@@ -138,15 +138,17 @@ module NewRelic
                          end
               options_arg << %Q[:#{key} => #{valuestr}]
             end
+            traced_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+
             class_eval <<-EOC
-              def #{method.to_s}_with_newrelic_transaction_trace(*args, &block)
+              def #{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}(*args, &block)
                 perform_action_with_newrelic_trace(#{options_arg.join(',')}) do
-                  #{method.to_s}_without_newrelic_transaction_trace(*args, &block)
+                  #{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}(*args, &block)
                  end
               end
             EOC
-            alias_method "#{method.to_s}_without_newrelic_transaction_trace", method.to_s
-            alias_method method.to_s, "#{method.to_s}_with_newrelic_transaction_trace"
+            alias_method "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}", method.to_s
+            alias_method method.to_s, "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}"
             NewRelic::Control.instance.log.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
           end
         end
@@ -231,6 +233,8 @@ module NewRelic
         # If a single argument is passed in, it is treated as a metric
         # path.  This form is deprecated.
         def perform_action_with_newrelic_trace(*args, &block)
+          request = newrelic_request(args)
+          NewRelic::Agent::TransactionInfo.reset(request)
 
           # Skip instrumentation based on the value of 'do_not_trace' and if
           # we aren't calling directly with a block.
@@ -254,7 +258,7 @@ module NewRelic
                 else
                   perform_action_without_newrelic_trace(*args)
                 end
-              rescue Exception => e
+              rescue => e
                 frame_data.notice_error(e)
                 raise
               end
@@ -270,24 +274,48 @@ module NewRelic
         end
 
         protected
+
+        def newrelic_request(args)
+          opts = args.first
+          # passed as a parameter to add_transaction_tracer
+          if opts.respond_to?(:keys) && opts.respond_to?(:[]) && opts[:request]
+            opts[:request]
+          # in a Rack app
+          elsif opts.respond_to?(:keys) && opts.respond_to?(:[]) &&
+              opts['rack.version']
+            Rack::Request.new(args)
+          # in a Rails app
+          elsif self.respond_to?(:request)
+            self.request
+          end
+        end
+
         # Should be implemented in the dispatcher class
         def newrelic_response_code; end
 
         def newrelic_request_headers
           self.respond_to?(:request) && self.request.respond_to?(:headers) && self.request.headers
         end
-
+        
+        # overrideable method to determine whether to trace an action
+        # or not - you may override this in your controller and supply
+        # your own logic for ignoring transactions.
         def do_not_trace?
           _is_filtered?('do_not_trace')
         end
-
+        
+        # overrideable method to determine whether to trace an action
+        # for purposes of apdex measurement - you can use this to
+        # ignore things like api calls or other fast non-user-facing
+        # actions
         def ignore_apdex?
           _is_filtered?('ignore_apdex')
         end
 
         private
 
-        # Profile the instrumented call.  Dev mode only.  Experimental.
+        # Profile the instrumented call.  Dev mode only.  Experimental
+        # - should definitely not be used on production applications
         def perform_action_with_newrelic_profile(args)
           frame_data = _push_metric_frame(block_given? ? args : [])
           val = nil
@@ -332,7 +360,9 @@ module NewRelic
             available_params = self.respond_to?(:params) ? self.params : {}
           end
           frame_data.request ||= self.request if self.respond_to? :request
-          frame_data.push(category + '/'+ path)
+          transaction_name = category + '/' + path
+          frame_data.push(transaction_name)
+          NewRelic::Agent::TransactionInfo.get.transaction_name = transaction_name
           frame_data.filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
           frame_data
         end
@@ -351,14 +381,15 @@ module NewRelic
                      end
           unless path = options[:path]
             action = options[:name] || args.first
-            metric_class = options[:class_name] || (self.is_a?(Class) ? self.name : self.class.name)
+            metric_class = options[:class_name] || ((self.is_a?(Class)||self.is_a?(Module)) ? self.name : self.class.name)
             path = metric_class
             path += ('/' + action) if action
           end
           [category, path, params]
         end
 
-        # Filter out
+        # Filter out a request if it matches one of our parameters for
+        # ignoring it - the key is either 'do_not_trace' or 'ignore_apdex'
         def _is_filtered?(key)
           ignore_actions = self.class.newrelic_read_attr(key) if self.class.respond_to? :newrelic_read_attr
           case ignore_actions
@@ -394,15 +425,16 @@ module NewRelic
           queue_start = nil
           if newrelic_request_headers
             queue_start = parse_frontend_headers(newrelic_request_headers)
-            Thread.current[:newrelic_queue_time] = (now.to_f - queue_start.to_f) if queue_start
           end
           queue_start || now
-        rescue Exception => e
+        rescue => e
           NewRelic::Control.instance.log.error("Error detecting upstream wait time: #{e}")
           NewRelic::Control.instance.log.debug("#{e.backtrace[0..20]}")
           now
         end
-
+        
+        # returns the NewRelic::MethodTraceStats object associated
+        # with the dispatcher time measurement
         def _dispatch_stat
           NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'
         end

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

@@ -38,6 +38,8 @@
 #     towards scope) so they don't show up ine normal call graph/trace.
 
 DependencyDetection.defer do
+  @name = :data_mapper
+  
   depends_on do
     defined?(::DataMapper)
   end
@@ -53,7 +55,11 @@ DependencyDetection.defer do
   depends_on do
     defined?(DataMapper::Collection)
   end
-
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing DataMapper instrumentation'
+  end
+  
   executes do
     DataMapper::Model.class_eval do
       add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
@@ -191,7 +197,7 @@ module NewRelic
         # the proper call scope.
         def log_with_newrelic_instrumentation(msg)
           return unless NewRelic::Agent.is_execution_traced?
-          return unless operation = case msg.query
+          return unless operation = case NewRelic::Helper.correctly_encoded(msg.query)
                                     when /^\s*select/i          then 'find'
                                     when /^\s*(update|insert)/i then 'save'
                                     when /^\s*delete/i          then 'destroy'

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

@@ -1,18 +1,26 @@
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
 DependencyDetection.defer do
+  @name = :delayed_job
+  
   depends_on do
     !NewRelic::Control.instance['disable_dj']
   end
 
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Job)
+    # double check because of old JRuby bug 
+    defined?(::Delayed) && defined?(::Delayed::Job) &&
+      Delayed::Job.method_defined?(:invoke_job)
   end
-
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation'
+  end
+  
   executes do
     Delayed::Job.class_eval do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      if self.instance_methods.include?('name')
+      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'

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

@@ -10,24 +10,26 @@ module NewRelic
     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
+        def instrument_methods(the_class, method_names)
+          method_names.each do |method_name|
+            next unless the_class.method_defined? method_name.to_sym
+            the_class.class_eval <<-EOD
+              def #{method_name}_with_newrelic_trace(*args, &block)
+                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, &block)
+                  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      
         end
         def memcache_key_snippet(method_name)
           return "" unless NewRelic::Control.instance['capture_memcache_keys']
@@ -38,19 +40,41 @@ module NewRelic
   end
 end
 
-
-
-
 DependencyDetection.defer do
+  @name = :memcache
+  
   depends_on do
     !NewRelic::Control.instance['disable_memcache_instrumentation']
   end
 
+  depends_on do
+    defined?(::MemCache) || defined?(::Memcached) ||
+      defined?(::Dalli::Client) || defined?(::Spymemcached)
+  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
+    commands = %w[get get_multi set add incr decr delete replace append prepend]
+    if defined? ::MemCache
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::MemCache,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing MemCache instrumentation'
+    end
+    if defined? ::Memcached
+      commands << 'cas'
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing Memcached instrumentation'
+    end
+    if defined? ::Dalli::Client
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing Dalli Memcache instrumentation'
+    end
+    if defined? ::Spymemcached
+      commands << 'multiget'
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Spymemcached,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing Spymemcached instrumentation'
     end
   end
 end