newrelic_rpm 2.8.0

data/lib/new_relic/agent/chained_call.rb

@@ -0,0 +1,13 @@
+# This is used to allow obfuscators to be chained.  
+
+class NewRelic::ChainedCall
+  def initialize(block1, block2)
+    @block1 = block1
+    @block2 = block2
+  end
+  
+  def call(sql)
+    sql = @block1.call(sql)
+    @block2.call(sql)
+  end
+end

data/lib/new_relic/agent/collection_helper.rb

@@ -0,0 +1,81 @@
+module NewRelic::Agent::CollectionHelper
+  # Transform parameter hash into a hash whose values are strictly
+  # strings
+  def normalize_params(params)
+    case params
+      when Symbol, FalseClass, TrueClass, nil:
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(params)
+      when Hash:
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),32)] = normalize_params(value)
+      end
+        new_params
+      when Enumerable:
+      # We only want the first 20 values of any enumerable.  Invoking to_a.first(20) works but
+      # the to_a call might be expensive, so we'll just build it manually, even though it's
+      # more verbose.
+        new_values = []
+        count = 1
+        params.each do | item |
+          new_values << normalize_params(item)
+          break if (count += 1) > 20
+        end
+        new_values
+    else
+      truncate(flatten(params))
+    end
+  end
+  
+  # Return an array of strings (backtrace), cleaned up for readability
+  # Return nil if there is no backtrace
+  
+  def strip_nr_from_backtrace(backtrace)
+    if 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)/, ""}
+    end
+    backtrace
+  end
+  
+  private
+  
+  # Convert any kind of object to a descriptive string
+  # Only call this on unknown objects.  Otherwise call to_s.
+  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}>"
+    end
+    
+    s
+  end
+  
+  def truncate(string, len=256)
+    if string.instance_of? Symbol
+      string
+    elsif string.nil?
+      ""
+    elsif string.instance_of? String
+      string.to_s.gsub(/^(.{#{len}})(.*)/) {$2.blank? ? $1 : $1 + "..."}
+    else
+      truncate(flatten(string), len)     
+    end
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,105 @@
+
+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)
+      @agent = agent
+      @errors = []
+      # lookup of exception class names to ignore.  Hash for fast access
+      @ignore = {}
+      @ignore_filter = nil
+      @capture_params = true
+      @capture_source = false
+      @enabled = true
+    end
+    
+    def ignore_error_filter(&block)
+      @ignore_filter = block
+    end
+    
+    
+    # errors is an array of Exception Class Names
+    #
+    def ignore(errors)
+      errors.each { |error| @ignore[error] = true; log.debug("Ignoring error: '#{error}'") }
+    end
+    
+    
+    def notice_error(path, request_uri, params, exception)
+      
+      return unless @enabled
+      return if @ignore[exception.class.name] 
+      
+      if @ignore_filter
+        exception = @ignore_filter.call(exception)
+        
+        return if exception.nil?
+      end
+      
+      error_stat.increment_count
+      
+      data = {}
+      
+      data[:request_params] = normalize_params(params) if @capture_params
+      data[:custom_params] = normalize_params(@agent.custom_params) if @agent
+      
+      data[:request_uri] = request_uri
+      
+      data[:rails_root] = NewRelic::Config.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')
+      
+      if @capture_source && exception.respond_to?('source_extract')
+        data[:source] = exception.source_extract
+      end
+      
+      if exception.respond_to? 'original_exception'
+        inside_exception = exception.original_exception
+      else
+        inside_exception = exception
+      end
+      data[:stack_trace] = strip_nr_from_backtrace(inside_exception.backtrace)
+      noticed_error = NewRelic::NoticedError.new(path, data, exception)
+      
+      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
+          @errors << noticed_error
+        end
+      end
+    end
+    
+    # Get the errors currently queued up.  Unsent errors are left 
+    # over from a previous unsuccessful attempt to send them to the server.
+    # We first clear out all unsent errors before sending the newly queued errors.
+    def harvest_errors(unsent_errors)
+      if unsent_errors && !unsent_errors.empty?
+        return unsent_errors
+      else
+        synchronize do
+          errors = @errors
+          @errors = []
+          return errors
+        end
+      end
+    end
+    
+    private
+    def error_stat
+      @error_stat ||= NewRelic::Agent.get_stats("Errors/all")
+    end
+    def log
+      NewRelic::Config.instance.log
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+
+# NewRelic instrumentation for ActiveRecord
+if defined? ActiveRecord
+  
+  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
+      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 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)
+        end
+      else
+        log_with_capture_sql(sql, name, &block)
+      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
+      else
+        config = nil
+      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'
+  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'
+    end
+=end
+end

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

@@ -0,0 +1,151 @@
+# NewRelic instrumentation for controllers
+#
+# This instrumentation is applied to the action controller by default if the agent
+# is actively collecting statistics.  It will collect statistics for the 
+# given action.
+#
+# In cases where you don't want to instrument the top level action, but instead
+# have other methods which are dispatched to by your action, and you want to treat
+# these as distinct actions, then what you need to do is call newrelic_ignore
+# on the top level action, and manually instrument the called 'actions'.  
+#
+# Here's an example of a controller with a send_message action which dispatches
+# to more specific send_servicename methods.  This results in the controller 
+# action stats showing up for send_servicename.
+#
+# MyController < ActionController::Base
+#   newrelic_ignore :only => 'send_message'
+#   # dispatch this action to the method given by the service parameter.
+#   def send_message
+#     service = params['service']
+#     dispatch_to_method = "send_messge_to_#{service}"
+#     perform_action_with_newrelic_trace(dispatch_to_method) do
+#       send dispatch_to_method, params['message']
+#     end
+#   end
+# end
+
+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
+    
+    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={})
+        if specifiers.empty?
+          self.newrelic_ignore_attr = true
+        elsif ! (Hash === specifiers)
+          logger.error "newrelic_ignore takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
+        else
+          self.newrelic_ignore_attr = 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
+    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)
+      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.
+    # The metric is named according to the action name, or the given path if called
+    # directly.  
+    def perform_action_with_newrelic_trace(*args)
+      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
+      end
+      
+      Thread.current[:controller_ignored] = false
+      
+      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
+        
+        self.class.trace_method_execution_with_scope "Controller/#{path}", true, true do 
+          # send request and parameter info to the transaction sampler
+          
+          local_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+          
+          agent.transaction_sampler.notice_transaction(path, request, local_params)
+          
+          t = Process.times.utime + Process.times.stime
+          
+          begin
+            # run the action
+            if block_given?
+              yield
+            else
+              perform_action_without_newrelic_trace(*args)
+            end
+          ensure
+            cpu_burn = (Process.times.utime + Process.times.stime) - t
+            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
+            end
+            
+          end
+        end
+      end
+      
+    ensure
+      # clear out the name of the traced transaction under all circumstances
+      stats_engine.transaction_name = nil
+    end
+  end 
+end