newrelic_rpm 2.8.0

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

@@ -0,0 +1,90 @@
+
+# NewRelic instrumentation for DataMapper
+# For now, we have to refer to all db metrics as "ActiveRecord"
+if defined? DataMapper
+  
+  DataMapper::Model.class_eval do
+    add_method_tracer :get, 'ActiveRecord/#{self.name}/find'
+    add_method_tracer :first, 'ActiveRecord/#{self.name}/find'
+    add_method_tracer :first_or_create, 'ActiveRecord/#{self.name}/find'
+    add_method_tracer :all, 'ActiveRecord/#{self.name}/find_all'
+  end
+  DataMapper::Adapters::DataObjectsAdapter.class_eval do
+    
+    @@my_sql_defined = defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+    @@postgres_defined = defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    
+    for method in [:read_many, :read_one] do
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/find' # Need to get the model somehow
+      add_method_tracer method, 'ActiveRecord/find', :push_scope => false
+      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
+    end
+    for method in [:execute, :query] do    
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute' # Need to get the model somehow
+      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
+    end
+    for method in [:create, :update]do
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer method, 'ActiveRecord/save', :push_scope => false
+    end
+    add_method_tracer :delete, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+    add_method_tracer :delete, 'ActiveRecord/destroy', :push_scope => false
+    
+    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 "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
+    
+=begin 
+  # instrumentation for associations
+  module Associations
+    class AssociationCollection
+      add_method_tracer :delete, 'ActiveRecord/#{@owner.class.name}/association delete'
+    end
+    
+    def 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
+  end
+end

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

@@ -0,0 +1,105 @@
+# We have to patch the mongrel dispatcher live since the classes
+# aren't defined when our instrumentation loads
+module NewRelic::Agent::Instrumentation
+  module DispatcherInstrumentation
+    
+    @@newrelic_agent = NewRelic::Agent.agent
+    @@newrelic_rails_dispatch_stat = @@newrelic_agent.stats_engine.get_stats 'Rails/HTTP Dispatch'
+    @@newrelic_mongrel_queue_stat = @@newrelic_agent.stats_engine.get_stats('WebFrontend/Mongrel/Average Queue Time')
+    
+    def newrelic_dispatcher_start
+      # Put the current time on the thread.  Can't put in @ivar because this could
+      # be a class or instance context
+      t0 = Time.now.to_f
+      NewRelic::Config.instance.log.warn "Recursive entry into dispatcher_start!\n#{caller.join("\n   ")}" if Thread.current[:newrelic_t0]
+      Thread.current[:newrelic_t0] = t0
+      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_start t0
+      # capture the time spent in the mongrel queue, if running in mongrel.  This is the 
+      # current time less the timestamp placed in 'started_on' by mongrel. 
+      mongrel_start = Thread.current[:started_on]
+      @@newrelic_mongrel_queue_stat.trace_call(t0 - mongrel_start.to_f) if mongrel_start
+      @@newrelic_agent.start_transaction
+      
+      # Reset the flag indicating the controller action should be ignored.
+      # It may be set by the action to either true or false or left nil meaning false
+      Thread.current[:controller_ignored] = nil
+    end
+    
+    def newrelic_dispatcher_finish
+      t0 = Thread.current[:newrelic_t0]
+      if t0.nil?
+        NewRelic::Config.instance.log.warn "Dispatcher finish called twice!\n#{caller.join("\n   ")}" 
+        return
+      end
+      t1 = Time.now.to_f
+      @@newrelic_agent.end_transaction
+      @@newrelic_rails_dispatch_stat.trace_call(t1 - t0) unless Thread.current[:controller_ignored]
+      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_finish t1    
+      Thread.current[:newrelic_t0] = nil
+    end
+    
+    def dispatch_newrelic(*args)
+      newrelic_dispatcher_start
+      begin
+        dispatch_without_newrelic(*args)
+      ensure
+        newrelic_dispatcher_finish
+      end
+    end
+    
+    # This won't work with Rails 2.2 multi-threading
+    module BusyCalculator
+      extend self
+      # the fraction of the sample period that the dispatcher was busy
+      @instance_busy = NewRelic::Agent.agent.stats_engine.get_stats('Instance/Busy')
+      @harvest_start = Time.now.to_f
+      @accumulator = 0
+      @dispatcher_start = nil    
+      def dispatcher_start(time)
+        Thread.critical = true
+        @dispatcher_start = time      
+        Thread.critical = false
+      end
+      
+      def dispatcher_finish(time)
+        Thread.critical = true
+        @accumulator += (time - @dispatcher_start)
+        @dispatcher_start = nil
+        
+        Thread.critical = false
+      end
+      
+      def is_busy?
+        @dispatcher_start
+      end
+      
+      def harvest_busy
+        Thread.critical = true
+        
+        busy = @accumulator
+        @accumulator = 0
+        
+        t0 = Time.now.to_f
+        
+        if @dispatcher_start
+          busy += (t0 - @dispatcher_start)
+          @dispatcher_start = t0
+        end
+        
+        
+        Thread.critical = false
+        
+        busy = 0.0 if busy < 0.0 # don't go below 0%
+        
+        time_window = (t0 - @harvest_start)
+        time_window = 1.0 if time_window == 0.0  # protect against divide by zero
+        
+        busy = busy / time_window
+        
+        busy = 1.0 if busy > 1.0    # cap at 100%
+        @instance_busy.record_data_point busy
+        @harvest_start = t0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# NOTE there are multiple implementations of the MemCache client in Ruby,
+# each with slightly different API's and semantics.  
+# Currently we only cover memcache-client.  Need to cover Ruby-MemCache.
+# See:
+#     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
+#     http://dev.robotcoop.com/Libraries/memcache-client/ (Gem: memcache-client)
+MemCache.class_eval do
+  add_method_tracer :get, 'MemCache/read' if self.method_defined? :get  
+  add_method_tracer :set, 'MemCache/write' if self.method_defined? :set
+  add_method_tracer :get_multi, 'MemCache/read' if self.method_defined? :get_multi
+end if defined? MemCache
+
+# Support for libmemcached through Evan Weaver's memcached wrapper
+# http://blog.evanweaver.com/files/doc/fauna/memcached/classes/Memcached.html    
+Memcached.class_eval do
+  add_method_tracer :get, 'Memcached/read' if self.method_defined? :get
+  add_method_tracer :set, 'Memcached/write' if self.method_defined? :set
+end if defined? Memcached

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

@@ -0,0 +1,17 @@
+require 'set'
+require 'merb-core/controller/abstract_controller'
+
+Merb::AbstractController.class_eval do
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  
+  class_inheritable_accessor :newrelic_ignore_attr
+  
+  protected
+  # determine the path that is used in the metric name for
+  # the called controller action
+  def newrelic_metric_path(action)
+    "#{controller_name}/#{action}"
+  end
+  alias_method :perform_action_without_newrelic_trace, :_dispatch
+  alias_method :_dispatch, :perform_action_with_newrelic_trace
+end

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

@@ -0,0 +1,15 @@
+require 'merb-core/dispatch/dispatcher'
+# NewRelic RPM instrumentation for http request dispatching (Routes mapping)
+# Note, the dispatcher class from no module into into the ActionController modile 
+# in rails 2.0.  Thus we need to check for both
+
+Merb::Request.class_eval do
+  
+  # This is for merb prior to 1.0
+  include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+  alias_method :dispatch_without_newrelic, :handle
+  alias_method :handle, :dispatch_newrelic
+  
+  # After merb 1.0, you can use before and after callbacks
+  # for this?
+end

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

@@ -0,0 +1,6 @@
+# Hook in the notification to merb
+error_notifier = Proc.new {
+  NewRelic::Agent.agent.error_collector.notice_error("#{request.controller.name}/#{params[:action]}", request.path, params, request.exceptions.first)
+}
+Merb::Dispatcher::DefaultException.before error_notifier
+Exceptions.before error_notifier

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -0,0 +1,35 @@
+
+if defined? ActionController 
+
+  ActionController::Base.class_eval do
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    
+    # Compare with #alias_method_chain, which is not available in 
+    # Rails 1.1:
+    alias_method :perform_action_without_newrelic_trace, :perform_action
+    alias_method :perform_action, :perform_action_with_newrelic_trace
+    private :perform_action
+    
+    add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+    
+    def self.newrelic_ignore_attr=(value)
+      write_inheritable_attribute('do_not_trace', value)
+    end
+    def self.newrelic_ignore_attr
+      read_inheritable_attribute('do_not_trace')
+    end
+
+    # determine the path that is used in the metric name for
+    # the called controller action
+    def newrelic_metric_path(action_name_override = nil)
+      action_part = action_name_override || action_name
+      if action_name_override || self.class.action_methods.include?(action_part)
+        "#{self.class.controller_path}/#{action_part}"
+      else
+        "#{self.class.controller_path}/(other)"
+      end
+    end
+  end  
+else
+  NewRelic::Agent.instance.log.debug "WARNING: ActionController instrumentation not added"
+end  

data/lib/new_relic/agent/instrumentation/rails/action_web_service.rb

@@ -0,0 +1,27 @@
+# NewRelic Agent instrumentation for WebServices
+
+# Note Action Web Service is removed from default package in rails 2.0
+if defined? ActionWebService
+  
+  # instrumentation for Web Service martialing - XML RPC
+  ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.class_eval do
+    add_method_tracer :decode_request, "WebService/Xml Rpc/XML Decode"
+    add_method_tracer :encode_request, "WebService/Xml Rpc/XML Encode"
+    add_method_tracer :decode_response, "WebService/Xml Rpc/XML Decode"
+    add_method_tracer :encode_response, "WebService/Xml Rpc/XML Encode"
+  end
+  
+  # instrumentation for Web Service martialing - Soap
+  ActionWebService::Protocol::Soap::SoapProtocol.class_eval do
+    add_method_tracer :decode_request, "WebService/Soap/XML Decode"
+    add_method_tracer :encode_request, "WebService/Soap/XML Encode"
+    add_method_tracer :decode_response, "WebService/Soap/XML Decode"
+    add_method_tracer :encode_response, "WebService/Soap/XML Encode"
+  end
+  
+  ActionController::Base.class_eval do
+    if method_defined? :perform_invocation
+      add_method_tracer :perform_invocation, 'WebService/#{controller_name}/#{args.first}'
+    end
+  end if defined? ActionController::Base
+end

data/lib/new_relic/agent/instrumentation/rails/dispatcher.rb

@@ -0,0 +1,30 @@
+require 'dispatcher'
+
+# NewRelic RPM instrumentation for http request dispatching (Routes mapping)
+# Note, the dispatcher class from no module into into the ActionController module 
+# in Rails 2.0.  Thus we need to check for both
+if defined? ActionController::Dispatcher
+  target = ActionController::Dispatcher
+elsif defined? Dispatcher
+  target = Dispatcher
+else
+  target = nil
+end
+
+if target
+  NewRelic::Agent.instance.log.debug "Adding #{target} instrumentation"
+  
+  # in Rails 2.3 (Rack-based) we don't want to add instrumentation on class level
+  unless defined? ::Rails::Rack
+    target = target.class_eval { class << self; self; end }
+  end
+  
+  target.class_eval do
+    include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+
+    alias_method :dispatch_without_newrelic, :dispatch
+    alias_method :dispatch, :dispatch_newrelic
+  end
+else
+  NewRelic::Agent.instance.log.debug "WARNING: Dispatcher instrumentation not added"
+end

data/lib/new_relic/agent/instrumentation/rails/errors.rb

@@ -0,0 +1,23 @@
+# todo: patch rescue_action and track how many are occuring and capture instances as well
+ActionController::Base.class_eval do
+  
+  def newrelic_notice_error(exception)
+    local_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+    
+    NewRelic::Agent.agent.error_collector.notice_error(newrelic_metric_path, (request) ? request.path : nil,
+    local_params, exception)
+  end
+  
+  def rescue_action_with_newrelic_trace(exception)
+    newrelic_notice_error exception
+    
+    rescue_action_without_newrelic_trace exception
+  end
+  
+  # Compare with #alias_method_chain, which is not available in 
+  # Rails 1.1:
+  alias_method :rescue_action_without_newrelic_trace, :rescue_action
+  alias_method :rescue_action, :rescue_action_with_newrelic_trace
+  protected :rescue_action
+
+end if defined? ActionController

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

@@ -0,0 +1,6 @@
+# Instrument the compilation of ERB files. 
+ERB::Compiler.class_eval do
+  add_method_tracer :compile, 'View/.rhtml Processing'
+end
+
+

data/lib/new_relic/agent/method_tracer.rb

@@ -0,0 +1,171 @@
+
+class Module
+  
+  # Original method preserved for API backward compatibility
+  def trace_method_execution (metric_name, push_scope, produce_metric, deduct_call_time_from_parent, &block)
+    if push_scope
+      trace_method_execution_with_scope(metric_name, produce_metric, deduct_call_time_from_parent, &block)
+    else
+      trace_method_execution_no_scope(metric_name, &block)
+    end
+  end
+  
+  # This is duplicated inline in add_method_tracer
+  def trace_method_execution_no_scope(metric_name)
+    t0 = Time.now.to_f
+    stats = @@newrelic_stats_engine.get_stats_no_scope metric_name
+  
+    result = yield
+    duration = Time.now.to_f - t0              # for some reason this is 3 usec faster than Time - Time
+    stats.trace_call(duration, duration)    
+    result 
+  end
+
+  def trace_method_execution_with_scope(metric_name, produce_metric, deduct_call_time_from_parent)
+  
+    t0 = Time.now.to_f
+    stats = nil
+    
+    begin
+      # Keep a reference to the scope we are pushing so we can do a sanity check making
+      # sure when we pop we get the one we 'expected'
+      expected_scope = @@newrelic_stats_engine.push_scope(metric_name, t0, deduct_call_time_from_parent)
+      
+      stats = @@newrelic_stats_engine.get_stats metric_name, true if produce_metric
+    rescue => e
+      NewRelic::Config.instance.log.error("Caught exception in trace_method_execution header. Metric name = #{metric_name}, exception = #{e}")
+      NewRelic::Config.instance.log.error(e.backtrace.join("\n"))
+    end
+
+    begin
+      yield
+    ensure
+      t1 = Time.now.to_f
+      duration = t1 - t0
+      
+      begin
+        if expected_scope
+          scope = @@newrelic_stats_engine.pop_scope expected_scope, duration, t1
+          
+          exclusive = duration - scope.children_time
+          stats.trace_call(duration, exclusive) if stats
+        end
+      rescue => e
+        NewRelic::Config.instance.log.error("Caught exception in trace_method_execution footer. Metric name = #{metric_name}, exception = #{e}")
+        NewRelic::Config.instance.log.error(e.backtrace.join("\n"))
+      end
+    end
+  end
+
+  # Add a method tracer to the specified method.  
+  # metric_name_code is ruby code that determines the name of the
+  # metric to be collected during tracing.  As such, the code
+  # should be provided in 'single quote' strings rather than
+  # "double quote" strings, so that #{} evaluation happens
+  # at traced method execution time.
+  # Example: tracing a method :foo, where the metric name is
+  # the first argument converted to a string
+  #     add_method_tracer :foo, '#{args.first.to_s}'
+  # statically defined metric names can be specified as regular strings
+  # push_scope specifies whether this method tracer should push
+  # the metric name onto the scope stack.
+  def add_method_tracer (method_name, metric_name_code, options = {})
+    return unless NewRelic::Agent.agent.config.tracers_enabled?
+    
+    @@newrelic_stats_engine ||= NewRelic::Agent.agent.stats_engine
+    
+    if !options.is_a?(Hash)
+      options = {:push_scope => options} 
+    end
+    # options[:push_scope] true if we are noting the scope of this for
+    # stats collection as well as the transaction tracing
+    options[:push_scope] = true if options[:push_scope].nil?
+    # options[:metric] true if you are tracking stats for a metric, otherwise
+    # it's just for transaction tracing.
+    options[:metric] = true if options[:metric].nil?
+    options[:deduct_call_time_from_parent] = false if options[:deduct_call_time_from_parent].nil? && !options[:metric]
+    options[:deduct_call_time_from_parent] = true if options[:deduct_call_time_from_parent].nil?
+    options[:code_header] ||= ""
+    options[:code_footer] ||= ""
+    
+    klass = (self === Module) ? "self" : "self.class"
+    
+    unless method_defined?(method_name) || private_method_defined?(method_name)
+      NewRelic::Config.instance.log.warn("Did not trace #{self}##{method_name} because that method does not exist")
+      return
+    end
+    
+    traced_method_name = _traced_method_name(method_name, metric_name_code)
+    if method_defined? traced_method_name
+      NewRelic::Config.instance.log.warn("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}")
+      return
+    end
+    
+    fail "Can't add a tracer where push_scope is false and metric is false" if options[:push_scope] == false && !options[:metric]
+    
+    if options[:push_scope] == false
+      class_eval "@@newrelic_stats_engine = NewRelic::Agent.agent.stats_engine"
+      code = <<-CODE
+        def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+          #{options[:code_header]}
+
+          t0 = Time.now.to_f
+          stats = @@newrelic_stats_engine.get_stats_no_scope "#{metric_name_code}"
+
+          result = #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
+          duration = Time.now.to_f - t0
+          stats.trace_call(duration, duration)     # for some reason this is 3 usec faster than Time - Time
+          #{options[:code_footer]}
+          result 
+        end
+      CODE
+    else
+      code = <<-CODE
+      def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+        #{options[:code_header]}
+        result = #{klass}.trace_method_execution_with_scope("#{metric_name_code}", #{options[:metric]}, #{options[:deduct_call_time_from_parent]}) do
+          #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
+        end
+        #{options[:code_footer]}
+        result
+      end
+      CODE
+    end
+      
+    class_eval code, __FILE__, __LINE__
+  
+    alias_method _untraced_method_name(method_name, metric_name_code), method_name
+    alias_method method_name, _traced_method_name(method_name, metric_name_code)
+    
+    NewRelic::Config.instance.log.debug("Traced method: class = #{self}, method = #{method_name}, "+
+        "metric = '#{metric_name_code}', options: #{options}, ")
+  end
+
+  # Not recommended for production use, because tracers must be removed in reverse-order
+  # from when they were added, or else other tracers that were added to the same method
+  # may get removed as well.
+  def remove_method_tracer(method_name, metric_name_code)
+    return unless NewRelic::Agent.agent.config.tracers_enabled?
+    
+    if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
+      alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
+      undef_method "#{_traced_method_name(method_name, metric_name_code)}"
+    else
+      raise "No tracer for '#{metric_name_code}' on method '#{method_name}'"
+    end
+  end
+
+private
+
+  def _untraced_method_name(method_name, metric_name)
+    "#{_sanitize_name(method_name)}_without_trace_#{_sanitize_name(metric_name)}" 
+  end
+  
+  def _traced_method_name(method_name, metric_name)
+    "#{_sanitize_name(method_name)}_with_trace_#{_sanitize_name(metric_name)}" 
+  end
+  
+  def _sanitize_name(name)
+    name.to_s.tr('^a-z,A-Z,0-9', '_')
+  end
+end