newrelic_rpm 2.13.0.beta5 → 2.13.1

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

@@ -1,22 +1,22 @@
 if defined?(PhusionPassenger)
   NewRelic::Agent.logger.debug "Installing Passenger event hooks."
-  
-  PhusionPassenger.on_event(:stopping_worker_process) do 
+
+  PhusionPassenger.on_event(:stopping_worker_process) do
     NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
     NewRelic::Agent.instance.shutdown
   end
-  
+
   PhusionPassenger.on_event(:starting_worker_process) do |forked|
     # We want to reset the stats from the stats engine in case any carried
     # over into the spawned process.  Don't clear them in case any were
     # cached.  We do this even in conservative spawning.
     NewRelic::Agent.after_fork(:force_reconnect => true)
   end
-  
-elsif (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER) 
+
+elsif (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
   # We're on an older version of passenger
   NewRelic::Agent.logger.warn "An older version of Phusion Passenger has been detected.  We recommend using at least release 2.1.1."
-  
+
   NewRelic::Agent::Instrumentation::MetricFrame.check_server_connection = true
-  
-end 
+
+end

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

@@ -47,10 +47,10 @@ module NewRelic
       #       end
       #     end
       #   end
-      #      
+      #
       # == Overriding the metric name
       #
-      # By default the middleware is identified only by its class, but if you want to 
+      # By default the middleware is identified only by its class, but if you want to
       # be more specific and pass in name, then omit including the Rack instrumentation
       # and instead follow this example:
       #

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

@@ -1,12 +1,12 @@
 
 if defined? ActionController
-  
+
   case Rails::VERSION::STRING
 
     when /^(1\.|2\.0)/  # Rails 1.* - 2.0
     ActionController::Base.class_eval do
       add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
-    end  
+    end
 
     when /^2\.1\./  # Rails 2.1
     ActionView::PartialTemplate.class_eval do
@@ -25,24 +25,24 @@ if defined? ActionController
       add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
     end
   end unless NewRelic::Control.instance['disable_view_instrumentation']
-  
+
   ActionController::Base.class_eval do
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    
-    # Compare with #alias_method_chain, which is not available in 
+
+    # 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
-    
+
     def self.newrelic_write_attr(attr_name, value) # :nodoc:
       write_inheritable_attribute(attr_name, value)
     end
-    
+
     def self.newrelic_read_attr(attr_name) # :nodoc:
       read_inheritable_attribute(attr_name)
     end
-    
+
     # determine the path that is used in the metric name for
     # the called controller action
     def newrelic_metric_path(action_name_override = nil)
@@ -53,7 +53,7 @@ if defined? ActionController
         "#{self.class.controller_path}/(other)"
       end
     end
-  end  
+  end
 else
   NewRelic::Agent.instance.log.debug "WARNING: ActionController instrumentation not added"
-end  
+end

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

@@ -2,7 +2,7 @@
 
 # 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"
@@ -10,7 +10,7 @@ if defined? ActionWebService
     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"
@@ -18,7 +18,7 @@ if defined? ActionWebService
     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}'

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

@@ -1,6 +1,6 @@
 
 ActionController::Base.class_eval do
-  
+
   # Make a note of an exception associated with the currently executing
   # controller action.  Note that this used to be available on Object
   # but we replaced that global method with NewRelic::Agent#notice_error.
@@ -8,13 +8,13 @@ ActionController::Base.class_eval do
   def newrelic_notice_error(exception, custom_params = {})
     NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :custom_params => custom_params, :request => request
   end
-  
+
   def rescue_action_with_newrelic_trace(exception)
     rescue_action_without_newrelic_trace exception
-    NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :request => request 
+    NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :request => request
   end
-  
-  # Compare with #alias_method_chain, which is not available in 
+
+  # 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

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

@@ -6,11 +6,11 @@ module NewRelic
           def self.newrelic_write_attr(attr_name, value) # :nodoc:
             write_inheritable_attribute(attr_name, value)
           end
-          
+
           def self.newrelic_read_attr(attr_name) # :nodoc:
             read_inheritable_attribute(attr_name)
           end
-          
+
           # determine the path that is used in the metric name for
           # the called controller action
           def newrelic_metric_path(action_name_override = nil)
@@ -23,12 +23,12 @@ module NewRelic
           end
 
           def process_action(*args)
-            
+
             perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :params => request.filtered_parameters, :class_name => self.class.name)  do
               super
             end
           end
-          
+
         end
       end
     end
@@ -36,7 +36,7 @@ module NewRelic
 end
 
 if defined?(ActionController) && defined?(ActionController::Base)
-  puts "ApplicationController is defined" 
+  puts "ApplicationController is defined"
   class ActionController::Base
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     include NewRelic::Agent::Instrumentation::Rails3::ActionController

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

@@ -3,7 +3,7 @@ if defined?(Sinatra::Base)
   module NewRelic
     module Agent
       module Instrumentation
-        # NewRelic instrumentation for Sinatra applications.  Sinatra actions will 
+        # NewRelic instrumentation for Sinatra applications.  Sinatra actions will
         # appear in the UI similar to controller actions, and have breakdown charts
         # and transaction traces.
         #
@@ -11,9 +11,9 @@ if defined?(Sinatra::Base)
         # 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
@@ -33,13 +33,13 @@ if defined?(Sinatra::Base)
             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
     end
   end

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

@@ -5,7 +5,7 @@ if defined?(::Sunspot)
         add_method_tracer method, 'SolrClient/Sunspot/index'
       end
       add_method_tracer :commit, 'SolrClient/Sunspot/commit'
-      
+
       %w[search more_like_this].each do |method|
         add_method_tracer method, 'SolrClient/Sunspot/query'
       end

data/lib/new_relic/agent/method_tracer.rb

@@ -34,7 +34,7 @@ module Agent
   #     end
 
   module MethodTracer
-    
+
     def self.included clazz #:nodoc:
       clazz.extend ClassMethods
       clazz.send :include, InstanceMethods
@@ -48,21 +48,21 @@ module Agent
     module InstanceMethods
       # 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: 
+      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, 
+          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 
+
+      # 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. 
+      # 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 
+      # * <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={})
@@ -80,20 +80,20 @@ module Agent
           stats.each { |stat| stat.trace_call(duration) }
         end
       end
-      
+
       EMPTY_ARRAY = [].freeze
-      
-      # Deprecated. Use #trace_execution_scoped, a version with an options hash.  
+
+      # 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, &block) #:nodoc:
-        trace_execution_scoped(metric_names, 
-                             :metric => produce_metric, 
-                             :deduct_call_time_from_parent => deduct_call_time_from_parent, 
+        trace_execution_scoped(metric_names,
+                             :metric => produce_metric,
+                             :deduct_call_time_from_parent => deduct_call_time_from_parent,
                              :scoped_metric_only => scoped_metric_only, &block)
       end
-      
+
       alias trace_method_execution_no_scope trace_execution_unscoped #:nodoc:
-      
-      # Trace a given block with stats and keep track of the caller.  
+
+      # Trace a given block with stats and keep track of the caller.
       # See NewRelic::Agent::MethodTracer::ClassMethods#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
@@ -102,11 +102,11 @@ module Agent
       # 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           = produce_metric && options[:scoped_metric_only]
@@ -116,33 +116,33 @@ module Agent
           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) 
+            metric_stats << NewRelic::Agent.instance.stats_engine.get_stats_no_scope(name)
           end
         else
-          first_name = metric_names      
+          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] 
+          NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
           expected_scope = NewRelic::Agent.instance.stats_engine.push_scope(first_name, t0.to_f, 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
           duration = (t1 - t0).to_f
-          
+
           begin
             NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
             if expected_scope
@@ -157,19 +157,19 @@ module Agent
         end
       end
     end
-    
+
     module ClassMethods
       # Add a method tracer to the specified method.
       #
       # === Common Options
       #
-      # * <tt>:push_scope => false</tt> specifies this method tracer should not 
+      # * <tt>:push_scope => false</tt> specifies this method tracer should not
       #   keep track of the caller; it will not show up in controller breakdown
-      #   pie charts. 
+      #   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. 
-      # 
+      #   shown in Developer Mode.
+      #
       # === Uncommon Options
       #
       # * <tt>:scoped_metric_only => true</tt> indicates that the unscoped metric
@@ -181,18 +181,18 @@ module Agent
       #   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 
+      #   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 
+      # * <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 
+      # +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:
       #
@@ -217,22 +217,22 @@ module Agent
       # for actions:
       #
       #     add_method_tracer :foo
-      # 
+      #
       # which is equivalent to:
       #
       #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo', :push_scope => true, :metric => true
       #
       # Instrument the class method +foo+ with the metric name 'Custom/People/fetch':
-      # 
+      #
       #     class << self
       #       add_method_tracer :foo, 'Custom/People/fetch'
       #     end
       #
-      
+
       def add_method_tracer(method_name, metric_name_code=nil, options = {})
         # for backward compatibility:
         if !options.is_a?(Hash)
-          options = {:push_scope => options} 
+          options = {:push_scope => options}
         end
         # in case they omit the metric name code
         if metric_name_code.is_a?(Hash)
@@ -253,24 +253,24 @@ module Agent
         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"
@@ -297,10 +297,10 @@ module Agent
           code = <<-CODE
       def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
         #{options[:code_header]}
-        result = #{klass}.trace_execution_scoped("#{metric_name_code}", 
+        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]}, 
+                  :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
@@ -310,20 +310,20 @@ module Agent
       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}'")
       end
-      
+
       # For tests only 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) # :nodoc:
         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)}"
@@ -332,15 +332,15 @@ module Agent
         end
       end
       private
-      
+
       def _untraced_method_name(method_name, metric_name)
-    "#{_sanitize_name(method_name)}_without_trace_#{_sanitize_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)}" 
+    "#{_sanitize_name(method_name)}_with_trace_#{_sanitize_name(metric_name)}"
       end
-      
+
       def _sanitize_name(name)
         name.to_s.tr_s('^a-zA-Z0-9', '_')
       end