newrelic_rpm 2.8.11 → 2.9.2

data/lib/new_relic/agent/collection_helper.rb

@@ -27,43 +27,32 @@ module NewRelic::Agent::CollectionHelper
   
   def strip_nr_from_backtrace(backtrace)
     if backtrace
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
       # strip newrelic from the trace
       backtrace = backtrace.reject {|line| line =~ /new_relic\/agent\// }
       # rename methods back to their original state
-      backtrace = backtrace.collect {|line| line.gsub /_without_(newrelic|trace)/, ""}
+      backtrace = backtrace.collect {|line| line.gsub(/_without_(newrelic|trace)/, "")}
     end
     backtrace
   end
   
   private
   
-  # Convert any kind of object to a descriptive string
-  # Only call this on unknown objects.  Otherwise call to_s.
+  # Convert any kind of object to a short string.
   def flatten(object)
-    s = 
-      if object.respond_to? :inspect
-        object.inspect
-      elsif object.respond_to? :to_s
-        object.to_s
-      elsif object.nil?
-        "nil"
-      else
-        "#<#{object.class.to_s}>"
-      end
-
-    if !(s.instance_of? String)
-      s = "#<#{object.class.to_s}>"
+    s = case object 
+      when nil then ''
+      when object.instance_of?(String) then object
+      when String then String.new(object)  # convert string subclasses to strings
+      else "#<#{object.class.to_s}>"
     end
-    
-    s
   end
-  
   def truncate(string, len=256)
-    if string.instance_of? Symbol
-      string
-    elsif string.nil?
-      ""
-    elsif string.instance_of? String
+    case string
+    when Symbol then string
+    when nil then ""
+    when String
       string.to_s.gsub(/^(.{#{len}})(.*)/) {$2.blank? ? $1 : $1 + "..."}
     else
       truncate(flatten(string), len)     

data/lib/new_relic/agent/error_collector.rb

@@ -1,13 +1,10 @@
 
 module NewRelic::Agent
   class ErrorCollector
-    include Synchronize
     include CollectionHelper
     
     MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
     
-    attr_accessor :capture_params
-    attr_accessor :capture_source
     attr_accessor :enabled
     
     def initialize(agent = nil)
@@ -16,9 +13,17 @@ module NewRelic::Agent
       # lookup of exception class names to ignore.  Hash for fast access
       @ignore = {}
       @ignore_filter = nil
-      @capture_params = true
-      @capture_source = false
-      @enabled = true
+
+      config = NewRelic::Control.instance.fetch('error_collector', {})
+      
+      @enabled = config.fetch('enabled', true)
+      @capture_source = config.fetch('capture_source', true)
+      
+      ignore_errors = config.fetch('ignore_errors', "")
+      ignore_errors = ignore_errors.split(",")
+      ignore_errors.each { |error| error.strip! } 
+      ignore(ignore_errors)
+      @lock = Mutex.new
     end
     
     def ignore_error_filter(&block)
@@ -33,7 +38,7 @@ module NewRelic::Agent
     end
     
     
-    def notice_error(path, request_uri, params, exception)
+    def notice_error(exception, request=nil, action_path=nil, filtered_params={})
       
       return unless @enabled
       return if @ignore[exception.class.name] 
@@ -48,12 +53,19 @@ module NewRelic::Agent
       
       data = {}
       
-      data[:request_params] = normalize_params(params) if @capture_params
+      action_path ||= ''
+      
+      data[:request_params] = normalize_params(filtered_params) if NewRelic::Control.instance.capture_params
+
       data[:custom_params] = normalize_params(@agent.custom_params) if @agent
       
-      data[:request_uri] = request_uri
+      data[:request_uri] = request.path if request
+      data[:request_uri] ||= ""
+      
+      data[:request_referer] = request.referer if request
+      data[:request_referer] ||= ""
       
-      data[:rails_root] = NewRelic::Config.instance.root
+      data[:rails_root] = NewRelic::Control.instance.root
       
       data[:file_name] = exception.file_name if exception.respond_to?('file_name')
       data[:line_number] = exception.line_number if exception.respond_to?('line_number')
@@ -67,10 +79,12 @@ module NewRelic::Agent
       else
         inside_exception = exception
       end
-      data[:stack_trace] = strip_nr_from_backtrace(inside_exception.backtrace)
-      noticed_error = NewRelic::NoticedError.new(path, data, exception)
+
+      data[:stack_trace] = inside_exception.backtrace
+      
+      noticed_error = NewRelic::NoticedError.new(action_path, data, exception)
       
-      synchronize do
+      @lock.synchronize do
         if @errors.length >= MAX_ERROR_QUEUE_LENGTH
           log.info("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. This error will not be reported to RPM: #{exception.message}")
         else
@@ -86,7 +100,7 @@ module NewRelic::Agent
       if unsent_errors && !unsent_errors.empty?
         return unsent_errors
       else
-        synchronize do
+        @lock.synchronize do
           errors = @errors
           @errors = []
           return errors
@@ -99,7 +113,7 @@ module NewRelic::Agent
       @error_stat ||= NewRelic::Agent.get_stats("Errors/all")
     end
     def log
-      NewRelic::Config.instance.log
+      NewRelic::Control.instance.log
     end
   end
 end

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

@@ -1,95 +1,82 @@
 
 # NewRelic instrumentation for ActiveRecord
-if defined? ActiveRecord::Base
+if defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrumentation']
   
-  ActiveRecord::Base.class_eval do
-    class << self
-      [:find_by_sql, :count].each do |find_method|
-        add_method_tracer find_method, 'ActiveRecord/#{self.name}/find'
-        add_method_tracer find_method, 'ActiveRecord/find', :push_scope => false
-        add_method_tracer find_method, 'ActiveRecord/all', :push_scope => false
+  module NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
+
+    def self.included(instrumented_class)
+      instrumented_class.class_eval do
+        alias_method :log_without_newrelic_instrumentation, :log
+        alias_method :log, :log_with_newrelic_instrumentation
+        protected :log
       end
     end
-    [:save, :save!].each do |save_method|
-      add_method_tracer save_method, 'ActiveRecord/#{self.class.name}/save'
-      add_method_tracer save_method, 'ActiveRecord/save', :push_scope => false
-      add_method_tracer save_method, 'ActiveRecord/all', :push_scope => false
-    end
     
-    add_method_tracer :destroy, 'ActiveRecord/#{self.class.name}/destroy'
-    add_method_tracer :destroy, 'ActiveRecord/destroy', :push_scope => false
-    add_method_tracer :destroy, 'ActiveRecord/all', :push_scope => false
-  end
-  
-  # instrumentation to catch logged SQL statements in sampled transactions
-
-  ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
-    @@my_sql_defined = defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
-    @@postgres_defined = defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    def active_record_all_stats
+      # need to lazy init this
+      @@active_record_all ||= NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ActiveRecord/all")
+    end
     
     def log_with_newrelic_instrumentation(sql, name, &block)
-      # if we aren't in a blamed context, then add one so that we can see that
-      # controllers are calling SQL directly
-      # we check scope_depth vs 2 since the controller is 1, and the 
-      #      
-      if NewRelic::Agent.instance.transaction_sampler.scope_depth < 2
-        self.class.trace_method_execution_with_scope "Database/DirectSQL", true, true do
-          log_with_capture_sql(sql, name, &block)
+      # Capture db config if we are going to try to get the explain plans
+      if (defined? ActiveRecord::ConnectionAdapters::MysqlAdapter && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
+       (defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
+        supported_config = @config
+      end
+      if name && (parts = name.split " ") && parts.size == 2
+        model = parts.first
+        operation = parts.last.downcase
+        metric_name = case operation
+          when 'load' 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
-      else
-        log_with_capture_sql(sql, name, &block)
+        metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+      end      
+      if metric.nil? && sql =~ /^(select|update|insert|delete)/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}"
       end
-    end
-    
-    def log_with_capture_sql(sql, name, &block)
-      if @@my_sql_defined && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
-        config = @config
-      elsif @@postgres_defined && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-        config = @config
+      
+      if !metric
+        log_without_newrelic_instrumentation(sql, name, &block)
       else
-        config = nil
+        self.class.trace_method_execution_with_scope metric, true, true do        
+          t0 = Time.now.to_f
+          result = log_without_newrelic_instrumentation(sql, name, &block)
+          duration = Time.now.to_f - t0
+          
+          NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, duration)
+          # Record in the overall summary metric
+          active_record_all_stats.record_data_point(duration)
+          # Record in the summary metric for this operation
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ActiveRecord/#{metric_name}").record_data_point(duration) if metric_name
+          result
+        end
       end
-      
-      t0 = Time.now
-      result = log_without_newrelic_instrumentation(sql, name, &block)
-      
-      NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, config, Time.now - t0)
-      
-      result
     end
     
-    # Compare with #alias_method_chain, which is not available in 
-    # Rails 1.1:
-    alias_method :log_without_newrelic_instrumentation, :log
-    alias_method :log, :log_with_newrelic_instrumentation
-    protected :log
-    
-    add_method_tracer :log, 'Database/#{adapter_name}/#{args[1]}', :metric => false
-    add_method_tracer :log, 'Database/all', :push_scope => false
-    
-  end
-  ActiveRecord::Associations::ClassMethods.class_eval do
-    add_method_tracer :find_with_associations, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :find_with_associations, 'ActiveRecord/find', :push_scope => false
-    add_method_tracer :find_with_associations, 'ActiveRecord/all', :push_scope => false
   end
   
-  # instrumentation for associations
-  ActiveRecord::Associations::AssociationCollection.class_eval do
-    add_method_tracer :delete, 'ActiveRecord/#{@owner.class.name}/association delete'
+  # instrumentation to catch logged SQL statements in sampled transactions
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+    include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
   end
-=begin
-    # Consider enabling these in the future
-    class HasAndBelongsToManyAssociation
-      add_method_tracer :find, 'ActiveRecord/#{@owner.class.name}/association find'
-      add_method_tracer :create_record, 'ActiveRecord/#{@owner.class.name}/association create'
-      add_method_tracer :insert_record, 'ActiveRecord/#{@owner.class.name}/association insert'
-    end
-    
-    class HasManyAssociation
-      add_method_tracer :find, 'ActiveRecord/#{@owner.class.name}/association find'
-      add_method_tracer :insert_record, 'ActiveRecord/#{@owner.class.name}/association insert'
-      add_method_tracer :create_record, 'ActiveRecord/#{@owner.class.name}/association create'
+
+  # This instrumentation will add an extra scope to the transaction traces
+  # which will show the code surrounding the query, inside the model find_by_sql
+  # method.
+  ActiveRecord::Base.class_eval do
+    class << self
+      add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
     end
-=end
+  end
+ 
 end

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

@@ -28,38 +28,66 @@
 module NewRelic::Agent::Instrumentation
   module ControllerInstrumentation
     
-    @@newrelic_apdex_t = NewRelic::Agent.instance.apdex_t
-    @@newrelic_apdex_overall = NewRelic::Agent.instance.stats_engine.get_stats_no_scope("Apdex")
     def self.included(clazz)
       clazz.extend(ClassMethods)
     end
     
+    # This module is for importing stubs when the agent is disabled
+    module ClassMethodsShim
+      def newrelic_ignore(*args); end
+      def newrelic_ignore_apdex(*args); end
+    end
+    
+    module Shim
+      def self.included(clazz)
+        clazz.extend(ClassMethodsShim)
+      end
+      def newrelic_notice_error(*args); end
+      def new_relic_trace_controller_action(*args); yield; end
+      def newrelic_metric_path; end
+      def perform_action_with_newrelic_trace(*args); yield; end
+    end
+    
     module ClassMethods
       # Have NewRelic ignore actions in this controller.  Specify the actions as hash options
       # using :except and :only.  If no actions are specified, all actions are ignored.
       def newrelic_ignore(specifiers={})
+        newrelic_ignore_aspect('do_not_trace', specifiers)
+      end
+      # Have NewRelic omit apdex measurements on the given actions.  Typically used for 
+      # actions that are not user facing or that skew your overall apdex measurement.
+      # Accepts :except and :only options, as with #newrelic_ignore.
+      def newrelic_ignore_apdex(specifiers={})
+        newrelic_ignore_aspect('ignore_apdex', specifiers)
+      end
+      
+      def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
         if specifiers.empty?
-          self.newrelic_ignore_attr = true
+          self.newrelic_write_attr property, true
         elsif ! (Hash === specifiers)
-          logger.error "newrelic_ignore takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
+          logger.error "newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
         else
-          self.newrelic_ignore_attr = specifiers
+          self.newrelic_write_attr property, specifiers
         end
       end
-      # Should be implemented in the controller class via the inheritable attribute mechanism.
-      def newrelic_ignore_attr=(value); end
-      def newrelic_ignore_attr; end
+      
+      # 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
+      end
+      def newrelic_read_attr(attr_name) # :nodoc:
+        instance_variable_get "@#{attr_name}", value
+      end
     end
     
     # Must be implemented in the controller class:
     # Determine the path that is used in the metric name for
     # the called controller action.  Of the form controller_path/action_name
     # 
-    def newrelic_metric_path(action_name_override = nil)
+    def newrelic_metric_path(action_name_override = nil) # :nodoc:
       raise "Not implemented!"
     end
     
-    @@newrelic_apdex_t = NewRelic::Agent.instance.apdex_t
     # Perform the current action with NewRelic tracing.  Used in a method
     # chain via aliasing.  Call directly if you want to instrument a specifc
     # block as if it were an action.  Pass the block along with the path.
@@ -69,45 +97,30 @@ module NewRelic::Agent::Instrumentation
       agent = NewRelic::Agent.instance
       stats_engine = agent.stats_engine
       
-      ignore_actions = self.class.newrelic_ignore_attr
       # Skip instrumentation based on the value of 'do_not_trace' and if 
       # we aren't calling directly with a block.
-      should_skip = !block_given? && 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))
-      else
-        true
-      end
-      if should_skip
-        begin
-          return perform_action_without_newrelic_trace(*args)
-        ensure
-          # Tell the dispatcher instrumentation that we ignored this action and it shouldn't
-          # be counted for the overall HTTP operations measurement.  The if.. appears here
-          # because we might be ignoring the top level action instrumenting but instrumenting
-          # a direct invocation that already happened, so we need to make sure if this var
-          # has already been set to false we don't reset it.
-          Thread.current[:controller_ignored] = true if Thread.current[:controller_ignored].nil?
-        end
+      if !block_given? && is_filtered?(self.class.newrelic_read_attr('do_not_trace'))
+        # Tell the dispatcher instrumentation that we ignored this action and it shouldn't
+        # be counted for the overall HTTP operations measurement.
+        Thread.current[:controller_ignored] = true
+        
+        return perform_action_without_newrelic_trace(*args)
       end
       
-      Thread.current[:controller_ignored] = false
+      # reset this in case we came through a code path where the top level controller is ignored
+      Thread.current[:controller_ignored] = nil
       
       start = Time.now.to_f
       agent.ensure_worker_thread_started
       
       # generate metrics for all all controllers (no scope)
       self.class.trace_method_execution_no_scope "Controller" do 
-        # generate metrics for this specific action
         # assuming the first argument, if present, is the action name
         path = newrelic_metric_path(args.size > 0 ? args[0] : nil)
-        stats_engine.transaction_name ||= "Controller/#{path}" if stats_engine
+        controller_metric = "Controller/#{path}"
         
-        self.class.trace_method_execution_with_scope "Controller/#{path}", true, true do 
-          # send request and parameter info to the transaction sampler
+        self.class.trace_method_execution_with_scope controller_metric, true, true do 
+          stats_engine.transaction_name = controller_metric
           
           local_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
           
@@ -115,6 +128,8 @@ module NewRelic::Agent::Instrumentation
           
           t = Process.times.utime + Process.times.stime
           
+          failed = false
+          
           begin
             # run the action
             if block_given?
@@ -122,30 +137,57 @@ module NewRelic::Agent::Instrumentation
             else
               perform_action_without_newrelic_trace(*args)
             end
+          rescue Exception => e
+            failed = true
+            raise e
           ensure
             cpu_burn = (Process.times.utime + Process.times.stime) - t
+            stats_engine.get_stats_no_scope("ControllerCPU/#{path}").record_data_point(cpu_burn)
             agent.transaction_sampler.notice_transaction_cpu_time(cpu_burn)
             
-            duration = Time.now.to_f - start
             # do the apdex bucketing
-            if duration <= @@newrelic_apdex_t
-              @@newrelic_apdex_overall.record_apdex_s cpu_burn    # satisfied
-              stats_engine.get_stats_no_scope("Apdex/#{path}").record_apdex_s cpu_burn
-            elsif duration <= (4 * @@newrelic_apdex_t)
-              @@newrelic_apdex_overall.record_apdex_t cpu_burn    # tolerating
-              stats_engine.get_stats_no_scope("Apdex/#{path}").record_apdex_t cpu_burn
-            else
-              @@newrelic_apdex_overall.record_apdex_f cpu_burn    # frustrated
-              stats_engine.get_stats_no_scope("Apdex/#{path}").record_apdex_f cpu_burn
+            #
+            unless is_filtered?(self.class.newrelic_read_attr('ignore_apdex'))
+              duration = Time.now.to_f - start
+              controller_stat = stats_engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+              case
+                when failed
+                apdex_overall_stat.record_apdex_f    # frustrated
+                controller_stat.record_apdex_f
+                when duration <= NewRelic::Control.instance['apdex_t']
+                apdex_overall_stat.record_apdex_s    # satisfied
+                controller_stat.record_apdex_s
+                when duration <= 4 * NewRelic::Control.instance['apdex_t']
+                apdex_overall_stat.record_apdex_t    # tolerating
+                controller_stat.record_apdex_t
+              else
+                apdex_overall_stat.record_apdex_f    # frustrated
+                controller_stat.record_apdex_f
+              end
             end
-            
           end
         end
       end
-      
     ensure
       # clear out the name of the traced transaction under all circumstances
       stats_engine.transaction_name = nil
     end
+    
+    private
+    def apdex_overall_stat
+      @@newrelic_apdex_overall ||= NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)  
+    end
+    
+    def is_filtered?(ignore_actions)
+      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))
+      else
+        true
+      end
+    end
   end 
 end