genki-newrelic_rpm 2.10.1

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,38 @@
+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
+end
+
+# NOTE TODO: maybe this should be done with a middleware?
+if target
+  require 'action_pack/version'
+  NewRelic::Agent.instance.log.debug "Adding #{target} instrumentation"
+  
+  target.class_eval do
+    if ActionPack::VERSION::MAJOR >= 2
+      # In versions later that 1.* the dispatcher callbacks are used
+      include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+      before_dispatch :newrelic_dispatcher_start
+      after_dispatch :newrelic_dispatcher_finish
+      def newrelic_response_code
+        (@response.headers['Status']||'200')[0..2] if @response && ActionPack::VERSION::MAJOR == 2 && ActionPack::VERSION::MINOR < 3 
+      end
+    else
+      # In version 1.2.* the instrumentation is done by method chaining
+      # the static dispatch method on the dispatcher class
+      extend NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+      class << self
+        alias_method :dispatch_without_newrelic, :dispatch
+        alias_method :dispatch, :dispatch_newrelic
+        def newrelic_response_code; end
+      end
+    end
+  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,27 @@
+
+ActionController::Base.class_eval do
+  
+  # Make a note of an exception associated with the currently executin
+  # controller action.  Note that this used to be available on Object
+  # but we replaced that global method with NewRelic::Agent#notice_error.
+  # Use that one outside of controller actions.
+  def newrelic_notice_error(exception, custom_params = {})
+    filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+    filtered_params.merge!(custom_params)
+    NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
+  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/sinatra.rb

@@ -0,0 +1,39 @@
+module NewRelic::Agent::Instrumentation
+  # NewRelic instrumentation for Sinatra applications.  Sinatra actions will 
+  # appear in the UI similar to controller actions, and have breakdown charts
+  # and transaction traces.
+  #
+  # The actions in the UI will correspond to the pattern expression used
+  # to match them.  HTTP operations are not distinguished.  Multiple matches
+  # will all be tracked as separate actions.
+  module Sinatra
+    
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    
+    def route_eval_with_newrelic(&block_arg)
+      path = unescape(@request.path_info)
+      name = path
+      # Go through each route and look for a match
+      if routes = self.class.routes[@request.request_method]
+        routes.detect do |pattern, keys, conditions, block|
+          if block_arg.equal? block
+            name = pattern.source
+          end
+        end
+      end
+      # strip of leading ^ and / chars and trailing $ and /
+      name.gsub!(%r{^[/^]*(.*?)[/\$]*$}, '\1')
+      name = 'root' if name.empty?
+      perform_action_with_newrelic_trace(:category => :sinatra, :name => name) do
+        route_eval_without_newrelic(&block_arg)
+      end
+    end
+  end
+  
+  Sinatra::Base.class_eval do
+    include NewRelic::Agent::Instrumentation::Sinatra
+    alias route_eval_without_newrelic route_eval
+    alias route_eval route_eval_with_newrelic
+  end
+  
+end if defined?(Sinatra::Base)

data/lib/new_relic/agent/method_tracer.rb

@@ -0,0 +1,277 @@
+module NewRelic::Agent
+
+  # These are the class methods added to support installing custom
+  # metric tracers and executing for individual metrics.
+  # This module is included in class Module.
+  module MethodTracer
+    
+    # Deprecated: original method preserved for API backward compatibility.
+    # Use either #trace_execution_scoped or #trace_execution_unscoped
+    def trace_method_execution(metric_names, push_scope, produce_metric, deduct_call_time_from_parent, &block) #:nodoc: 
+      if push_scope
+        trace_execution_scoped(metric_names, :metric => produce_metric, 
+                                                    :deduct_call_time_from_parent => deduct_call_time_from_parent, &block)
+      else
+        trace_execution_unscoped(metric_names, &block)
+      end
+    end
+    
+    # Trace a given block with stats assigned to the given metric_name.  It does not 
+    # provide scoped measurements, meaning whatever is being traced will not 'blame the
+    # Controller'--that is to say appear in the breakdown chart. 
+    # This is code is inlined in #add_method_tracer.
+    # * <tt>metric_names</tt> is a single name or an array of names of metrics
+    # * <tt>:force => true</tt> will force the metric to be captured even when 
+    #   tracing is disabled with NewRelic::Agent#disable_all_tracing
+    #
+    def trace_execution_unscoped(metric_names, options={})
+      return yield unless NewRelic::Agent.is_execution_traced?
+      t0 = Time.now.to_f
+      stats = Array(metric_names).map do | metric_name |
+        NewRelic::Agent.instance.stats_engine.get_stats_no_scope metric_name
+      end
+      begin
+        NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
+        yield
+      ensure
+        NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
+        duration = Time.now.to_f - t0              # for some reason this is 3 usec faster than Time - Time
+        stats.each { |stat| stat.trace_call(duration) }
+      end
+    end
+    
+    EMPTY_ARRAY = [].freeze #:nodoc:
+    
+    # Deprecated. Use #trace_execution_scoped, a version with an options hash.  
+    def trace_method_execution_with_scope(metric_names, produce_metric, deduct_call_time_from_parent, scoped_metric_only=false) #:nodoc
+      trace_execution_scoped(metric_names, 
+                             :metric => produce_metric, 
+                             :deduct_call_time_from_parent => deduct_call_time_from_parent, 
+                             :scoped_metric_only => scoped_metric_only)
+    end
+
+    alias trace_method_execution_no_scope trace_execution_unscoped
+      
+    # Trace a given block with stats and keep track of the caller.  
+    # See #add_method_tracer for a description of the arguments.
+    # +metric_names+ is either a single name or an array of metric names.
+    # If more than one metric is passed, the +produce_metric+ option only applies to the first.  The
+    # others are always recorded.  Only the first metric is pushed onto the scope stack.
+    #
+    # Generally you pass an array of metric names if you want to record the metric under additional
+    # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
+    # on the server.
+    
+    def trace_execution_scoped(metric_names, options={})
+
+      return yield unless NewRelic::Agent.is_execution_traced? || options[:force]
+
+      produce_metric               = options[:metric] != false
+      deduct_call_time_from_parent = options[:deduct_call_time_from_parent] != false
+      scoped_metric_only           = options[:scoped_metric_only]
+      t0 = Time.now.to_f
+      if metric_names.instance_of? Array
+        first_name = metric_names.first
+        metric_stats = []
+        metric_stats << NewRelic::Agent.instance.stats_engine.get_stats(first_name, true, scoped_metric_only) if produce_metric
+        metric_names[1..-1].each do | name |
+          metric_stats << NewRelic::Agent.instance.stats_engine.get_stats_no_scope(name) 
+        end
+      else
+        first_name = metric_names      
+        if produce_metric
+          metric_stats = [NewRelic::Agent.instance.stats_engine.get_stats(first_name, true, scoped_metric_only)]
+        else
+          metric_stats = EMPTY_ARRAY
+        end
+      end
+  
+      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'
+        NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force] 
+        expected_scope = NewRelic::Agent.instance.stats_engine.push_scope(first_name, t0, deduct_call_time_from_parent)
+      rescue => e
+        NewRelic::Control.instance.log.error("Caught exception in trace_method_execution header. Metric name = #{first_name}, exception = #{e}")
+        NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+      end
+      
+      begin
+        yield
+      ensure
+        t1 = Time.now.to_f
+        duration = t1 - t0
+        
+        begin
+          NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
+          if expected_scope
+            scope = NewRelic::Agent.instance.stats_engine.pop_scope expected_scope, duration, t1
+            exclusive = duration - scope.children_time
+            metric_stats.each { |stats| stats.trace_call(duration, exclusive) }
+          end
+        rescue => e
+          NewRelic::Control.instance.log.error("Caught exception in trace_method_execution footer. Metric name = #{first_name}, exception = #{e}")
+          NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+        end
+      end
+    end
+    
+    # Add a method tracer to the specified method.  
+    #
+    # === Common Options
+    #
+    # * <tt>:push_scope => false</tt> specifies this method tracer should not 
+    #   keep track of the caller; it will show up in controller breakdown
+    #   pie charts. 
+    # * <tt>:metric => false</tt> specifies that no metric will be recorded.
+    #   Instead the call will show up in transaction traces as well as traces
+    #   shown in Developer Mode. 
+    # 
+    # === Uncommon Options
+    #
+    # * <tt>:scoped_metric_only => true</tt> indicates that the unscoped metric
+    #   should not be recorded.  Normally two metrics are potentially created
+    #   on every invocation: the aggregate method where statistics for all calls
+    #   of that metric are stored, and the "scoped metric" which records the
+    #   statistics for invocations in a particular scope--generally a controller
+    #   action.  This option indicates that only the second type should be recorded.
+    #   The effect is similar to <tt>:metric => false</tt> but in addition you
+    #   will also see the invocation in breakdown pie charts.
+    # * <tt>:deduct_call_time_from_parent => false</tt> indicates that the method invocation
+    #   time should never be deducted from the time reported as 'exclusive' in the 
+    #   caller.  You would want to use this if you are tracing a recursive method
+    #   or a method that might be called inside another traced method.
+    # * <tt>:code_header</tt> and <tt>:code_footer</tt> specify ruby code that 
+    #   is inserted into the tracer before and after the call.
+    # * <tt>:force = true</tt> will ensure the metric is captured even if called inside
+    #   an untraced execution call.  (See NewRelic::Agent#disable_all_tracing)
+    #
+    # === Overriding the metric name
+    #
+    # +metric_name_code+ is a string that is eval'd to get the 
+    # name of the metric associated with the call, so if you want to 
+    # use interpolaion evaluated at call time, then single quote
+    # the value like this:
+    #
+    #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo'
+    #
+    # This would name the metric according to the class of the runtime
+    # intance, as opposed to the class where +foo+ is defined.
+    #
+    # If not provided, the metric name will be <tt>Custom/ClassName/method_name</tt>.
+
+    def add_method_tracer(method_name, metric_name_code=nil, options = {})
+      # for backward compatibility:
+      if !options.is_a?(Hash)
+        options = {:push_scope => options} 
+      end
+      if (unrecognized = options.keys - [:force, :metric, :push_scope, :deduct_call_time_from_parent, :code_header, :code_footer, :scoped_metric_only]).any?
+        fail "Unrecognized options in add_method_tracer_call: #{unrecognized.join(', ')}"
+      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[:force] = false if options[:force].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] ||= ""
+      options[:scoped_metric_only] ||= false
+      
+      klass = (self === Module) ? "self" : "self.class"
+      # Default to the class where the method is defined.
+      metric_name_code = "Custom/#{self.name}/#{method_name.to_s}" unless metric_name_code
+      
+      unless method_defined?(method_name) || private_method_defined?(method_name)
+        NewRelic::Control.instance.log.warn("Did not trace #{self.name}##{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::Control.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]
+      
+      header = ""
+      if !options[:force]
+        header << "return #{_untraced_method_name(method_name, metric_name_code)}(*args, &block) unless NewRelic::Agent.is_execution_traced?\n"
+      end
+      header << options[:code_header] if options[:code_header]
+      if options[:push_scope] == false
+        code = <<-CODE
+        def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+          #{header}
+          t0 = Time.now.to_f
+          stats = NewRelic::Agent.instance.stats_engine.get_stats_no_scope "#{metric_name_code}"
+          begin
+            #{"NewRelic::Agent.instance.push_trace_execution_flag(true)\n" if options[:force]}
+            #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)\n
+          ensure
+            #{"NewRelic::Agent.instance.pop_trace_execution_flag\n" if options[:force] }
+            duration = Time.now.to_f - t0
+            stats.trace_call(duration)
+            #{options[:code_footer]}
+          end
+        end
+      CODE
+      else
+        code = <<-CODE
+      def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+        #{options[:code_header]}
+        result = #{klass}.trace_execution_scoped("#{metric_name_code}", 
+                  :metric => #{options[:metric]},
+                  :forced => #{options[:force]}, 
+                  :deduct_call_time_from_parent => #{options[:deduct_call_time_from_parent]}, 
+                  :scoped_metric_only => #{options[:scoped_metric_only]}) 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::Control.instance.log.debug("Traced method: class = #{self.name}, method = #{method_name}, "+
+        "metric = '#{metric_name_code}', options: #{options.inspect}, ")
+    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::Control.instance.agent_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
+end

data/lib/new_relic/agent/patch_const_missing.rb

@@ -0,0 +1,125 @@
+# This class is for debugging purposes only.
+# It inserts instrumentation into class loading to verify
+# that no classes are being loaded on the new relic thread,
+# which can cause problems in the class loader code. 
+# It is only loaded by agent.rb when a particular newrelic.yml
+# option is set.
+
+module ClassLoadingWatcher # :nodoc: all
+  
+  extend self
+  @@background_thread = nil
+  @@flag_const_missing = nil
+  
+  def background_thread
+    @@background_thread
+  end
+  def flag_const_missing
+    @@flag_const_missing
+  end
+  def flag_const_missing=(val)
+    @@flag_const_missing = val
+  end
+  
+  def background_thread=(thread)
+    @@background_thread = thread
+    
+    # these tests verify that check is working
+=begin
+        @@background_thread = nil
+        bad = ConstMissingInForegroundThread rescue nil
+        @@background_thread = thread
+        bad = ConstMissingInBackgroundThread rescue nil
+        require 'new_relic/agent/patch_const_missing'
+        load 'new_relic/agent/patch_const_missing.rb'
+=end
+  end
+  module SanityCheck 
+    def nr_check_for_classloading(*args)
+      
+      if Thread.current == ClassLoadingWatcher.background_thread    
+        nr_error "Agent background thread shouldn't be loading classes (#{args.inspect})"  
+      end
+    end
+    # 
+    def nr_check_for_constmissing(*args)
+      if ClassLoadingWatcher.flag_const_missing
+        nr_error "Classes in Agent should not be loaded via const_missing (#{args.inspect})"        
+      end
+    end
+    private
+    def nr_error(msg)
+      exception = NewRelic::Agent::BackgroundLoadingError.new(msg)
+      backtrace = caller
+      backtrace.shift
+      exception.set_backtrace(backtrace)
+      NewRelic::Agent.instance.error_collector.notice_error(exception, nil)
+      msg << "\n" << backtrace.join("\n")
+      NewRelic::Control.instance.log.error msg
+    end
+  end
+  def enable_warning
+    Object.class_eval do
+      if !defined?(non_new_relic_require)
+        alias_method :non_new_relic_require, :require
+        alias_method :require, :new_relic_require
+      end
+      
+      if !defined?(non_new_relic_load)
+        alias_method :non_new_relic_load, :load
+        alias_method :load, :new_relic_load
+      end
+    end
+    Module.class_eval do
+      if !defined?(non_new_relic_const_missing)
+        alias_method :non_new_relic_const_missing, :const_missing
+        alias_method :const_missing, :new_relic_const_missing
+      end
+    end
+  end
+  
+  def disable_warning
+    Object.class_eval do
+      if defined?(non_new_relic_require)
+        alias_method :require, :non_new_relic_require
+        undef non_new_relic_require
+      end
+      
+      if defined?(non_new_relic_load)
+        alias_method :load, :non_new_relic_load
+        undef non_new_relic_load
+      end
+    end
+    Module.class_eval do
+      if defined?(non_new_relic_const_missing)
+        alias_method :const_missing, :non_new_relic_const_missing
+        undef non_new_relic_const_missing
+      end
+    end
+  end
+end
+
+class Object # :nodoc:
+  include ClassLoadingWatcher::SanityCheck
+  
+  def new_relic_require(*args)
+    nr_check_for_classloading("Object require", *args)    
+    non_new_relic_require(*args)
+  end
+  
+  def new_relic_load(*args)
+    nr_check_for_classloading("Object load", *args)
+    non_new_relic_load(*args)
+  end
+end
+
+
+class Module # :nodoc:
+  include ClassLoadingWatcher::SanityCheck
+  
+  def new_relic_const_missing(*args)
+    nr_check_for_constmissing("Module #{self.name} const_missing", *args)
+    nr_check_for_classloading("Module #{self.name} const_missing", *args)
+    non_new_relic_const_missing(*args)
+  end
+end