newrelic_rpm 2.13.0.beta5 → 2.13.1

data/lib/new_relic/agent/busy_calculator.rb

@@ -4,43 +4,43 @@ module NewRelic
     # one harvest period.  It's similar to what you would get if you just added up all the
     # execution times of controller calls, however that will be inaccurate when requests
     # span the minute boundaries.  This module manages accounting of requests not yet
-    # completed. 
+    # completed.
     #
     # Calls are re-entrant.  All start calls must be paired with finish
     # calls, or a reset call.
     module BusyCalculator
-      
+
       extend self
-      
+
       # For testability, add accessors:
       attr_reader :harvest_start, :accumulator
-      
+
       def dispatcher_start(time)
-        Thread.current[:busy_entries] ||= 0 
+        Thread.current[:busy_entries] ||= 0
         callers = Thread.current[:busy_entries] += 1
         return if callers > 1
         @lock.synchronize do
-          @entrypoint_stack.push time      
+          @entrypoint_stack.push time
         end
       end
-      
+
       def dispatcher_finish(end_time = Time.now)
         callers = Thread.current[:busy_entries] -= 1
         # Ignore nested calls
         return if callers > 0
         @lock.synchronize do
           if @entrypoint_stack.empty?
-            NewRelic::Agent.logger.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}") 
+            NewRelic::Agent.logger.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
           else
             @accumulator += (end_time - @entrypoint_stack.pop).to_f
           end
         end
       end
-      
+
       def busy_count
         @entrypoint_stack.size
       end
-      
+
       # Reset the state of the information accumulated by all threads,
       # but only reset the recursion counter for this thread.
       def reset
@@ -50,9 +50,9 @@ module NewRelic
         @accumulator = 0
         @harvest_start = Time.now
       end
-      
+
       self.reset
-      
+
       # Called before uploading to to the server to collect current busy stats.
       def harvest_busy
         busy = 0
@@ -60,32 +60,32 @@ module NewRelic
         @lock.synchronize do
           busy = accumulator
           @accumulator = 0
-          
-          # Walk through the stack and capture all times up to 
+
+          # Walk through the stack and capture all times up to
           # now for entrypoints
-          @entrypoint_stack.size.times do |frame| 
+          @entrypoint_stack.size.times do |frame|
             busy += (t0 - @entrypoint_stack[frame]).to_f
             @entrypoint_stack[frame] = t0
           end
-          
+
         end
-        
+
         busy = 0.0 if busy < 0.0 # don't go below 0%
-        
+
         time_window = (t0 - harvest_start).to_f
         time_window = 1.0 if time_window == 0.0  # protect against divide by zero
-        
+
         busy = busy / time_window
-        
+
         instance_busy_stats.record_data_point busy
         @harvest_start = t0
       end
       private
       def instance_busy_stats
         # Late binding on the Instance/busy stats
-        NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'Instance/Busy'  
+        NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'Instance/Busy'
       end
-      
+
     end
   end
 end

data/lib/new_relic/agent/chained_call.rb

@@ -1,13 +1,13 @@
-# This is used to allow obfuscators to be chained.  
+# 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
+end

data/lib/new_relic/agent/error_collector.rb

@@ -3,15 +3,15 @@ module NewRelic
   module Agent
   class ErrorCollector
     include NewRelic::CollectionHelper
-    
+
     # Defined the methods that need to be stubbed out when the
     # agent is disabled
     module Shim #:nodoc:
       def notice_error(*args); end
     end
-    
+
     MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
-    
+
     attr_accessor :enabled
     attr_reader :config_enabled
 
@@ -22,17 +22,17 @@ module NewRelic
       @ignore_filter = nil
 
       config = NewRelic::Control.instance.fetch('error_collector', {})
-      
+
       @enabled = @config_enabled = config.fetch('enabled', true)
       @capture_source = config.fetch('capture_source', true)
-      
+
       ignore_errors = config.fetch('ignore_errors', "")
       ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
-      ignore_errors.each { |error| error.strip! } 
+      ignore_errors.each { |error| error.strip! }
       ignore(ignore_errors)
       @lock = Mutex.new
     end
-    
+
     def ignore_error_filter(&block)
       if block
         @ignore_filter = block
@@ -40,13 +40,13 @@ module NewRelic
         @ignore_filter
       end
     end
-    
+
     # errors is an array of Exception Class Names
     #
     def ignore(errors)
       errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
     end
-    
+
     # Notice the error with the given available options:
     #
     # * <tt>:uri</tt> => The request path, minus any request params or query string.
@@ -59,7 +59,7 @@ module NewRelic
     # If exception is nil, the error count is bumped and no traced error is recorded
     def notice_error(exception, options={})
       return unless @enabled
-      return if exception && @ignore[exception.class.name] 
+      return if exception && @ignore[exception.class.name]
       if @ignore_filter && exception
         exception = @ignore_filter.call(exception)
         return if exception.nil?
@@ -76,17 +76,17 @@ module NewRelic
       custom_params = options.delete(:custom_params) || {}
       # If anything else is left over, treat it like a custom param:
       custom_params.merge! options
-      
+
       data[:request_params] = normalize_params(request_params) if NewRelic::Control.instance.capture_params && request_params
       data[:custom_params] = normalize_params(custom_params) unless custom_params.empty?
       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')
-      
+
       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
@@ -94,20 +94,20 @@ module NewRelic
       end
 
       data[:stack_trace] = (inside_exception && inside_exception.respond_to?('backtrace')) ? inside_exception.backtrace : '<no stack trace>'
-      
+
       noticed_error = NewRelic::NoticedError.new(action_path, data, exception)
-      
+
       @lock.synchronize do
         if @errors.length == MAX_ERROR_QUEUE_LENGTH
-          log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to RPM until the queued errors have been sent: #{exception.message}")
+          log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to RPM until the queued errors have been sent: #{exception}")
         else
           @errors << noticed_error
         end
       end
       exception
     end
-    
-    # Get the errors currently queued up.  Unsent errors are left 
+
+    # 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)
@@ -121,7 +121,7 @@ module NewRelic
         end
       end
     end
-    
+
     private
     def log
       NewRelic::Agent.logger

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

@@ -6,7 +6,7 @@ if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.
     module Agent
       module Instrumentation
         module ActiveRecordInstrumentation
-          
+
           def self.included(instrumented_class)
             instrumented_class.class_eval do
               alias_method :log_without_newrelic_instrumentation, :log
@@ -14,11 +14,11 @@ if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.
               protected :log
             end
           end
-          
+
           def log_with_newrelic_instrumentation(sql, name, &block)
-            
+
             return log_without_newrelic_instrumentation(sql, name, &block) unless NewRelic::Agent.is_execution_traced?
-            
+
             # 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))
@@ -39,7 +39,7 @@ if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.
                             end
               metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
             end
-            
+
             if metric.nil?
               metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
               if metric.nil?
@@ -53,7 +53,7 @@ if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.
                 end
               end
             end
-            
+
             if !metric
               log_without_newrelic_instrumentation(sql, name, &block)
             else
@@ -62,21 +62,21 @@ if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.
               self.class.trace_execution_scoped(metrics) do
                 t0 = Time.now
                 begin
-                  log_without_newrelic_instrumentation(sql, name, &block) 
+                  log_without_newrelic_instrumentation(sql, name, &block)
                 ensure
-                  NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, (Time.now - t0).to_f) 
+                  NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, (Time.now - t0).to_f)
                 end
               end
             end
           end
-          
+
         end
-        
+
         # instrumentation to catch logged SQL statements in sampled transactions
         ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
           include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
         end
-        
+
         # 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.

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

@@ -1,5 +1,5 @@
 if defined?(::ActsAsSolr)
-  
+
   module NewRelic
     module Instrumentation
       module ActsAsSolrInstrumentation
@@ -13,7 +13,7 @@ if defined?(::ActsAsSolr)
                 NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
               end
             end
-            
+
           end
         end
       end

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

@@ -7,7 +7,7 @@ module NewRelic
   # This instrumentation is applied to the action controller to collect
   # metrics for every web request.
   #
-  # It can also be used to capture performance information for 
+  # It can also be used to capture performance information for
   # background tasks and other non-web transactions, including
   # detailed transaction traces and traced errors.
   #
@@ -16,17 +16,17 @@ module NewRelic
   # #perform_action_with_newrelic_trace
   #
   module ControllerInstrumentation
-    
+
     def self.included(clazz) # :nodoc:
       clazz.extend(ClassMethods)
     end
-    
+
     # This module is for importing stubs when the agent is disabled
     module ClassMethodsShim # :nodoc:
       def newrelic_ignore(*args); end
       def newrelic_ignore_apdex(*args); end
     end
-    
+
     module Shim # :nodoc:
       def self.included(clazz)
         clazz.extend(ClassMethodsShim)
@@ -36,20 +36,20 @@ module NewRelic
       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 
+      # 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_write_attr property, true
@@ -59,7 +59,7 @@ module NewRelic
           self.newrelic_write_attr property, specifiers
         end
       end
-      
+
       # Should be monkey patched into the controller class implemented
       # with the inheritable attribute mechanism.
       def newrelic_write_attr(attr_name, value) # :nodoc:
@@ -68,11 +68,11 @@ module NewRelic
       def newrelic_read_attr(attr_name) # :nodoc:
         instance_variable_get "@#{attr_name}"
       end
-      
+
       # Add transaction tracing to the given method.  This will treat
       # the given method as a main entrypoint for instrumentation, just
       # like controller actions are treated by default.  Useful especially
-      # for background tasks. 
+      # for background tasks.
       #
       # Example for background job:
       #   class Job
@@ -89,7 +89,7 @@ module NewRelic
       # action to invoke operations which you want treated as top
       # level actions, so they aren't all lumped into the invoker
       # action.
-      #      
+      #
       #   MyController < ActionController::Base
       #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
       #     # dispatch the given op to the method given by the service parameter.
@@ -149,22 +149,22 @@ module NewRelic
         NewRelic::Control.instance.log.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
       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) # :nodoc:
       raise "Not implemented!"
     end
-    
-    # Yield to the given block with NewRelic tracing.  Used by 
+
+    # Yield to the given block with NewRelic tracing.  Used by
     # default instrumentation on controller actions in Rails and Merb.
     # But it can also be used in custom instrumentation of controller
     # methods and background tasks.
     #
     # This is the method invoked by instrumentation added by the
-    # <tt>ClassMethods#add_transaction_tracer</tt>.  
+    # <tt>ClassMethods#add_transaction_tracer</tt>.
     #
     # Here's a more verbose version of the example shown in
     # <tt>ClassMethods#add_transaction_tracer</tt> using this method instead of
@@ -176,7 +176,7 @@ module NewRelic
     # the +invoke_operation+ action is ignored but the operation
     # methods show up in RPM as if they were first class controller
     # actions
-    #    
+    #
     #   MyController < ActionController::Base
     #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     #     # dispatch the given op to the method given by the service parameter.
@@ -191,7 +191,7 @@ module NewRelic
     #   end
     #
     #
-    # When invoking this method explicitly as in the example above, pass in a 
+    # When invoking this method explicitly as in the example above, pass in a
     # block to measure with some combination of options:
     #
     # * <tt>:category => :controller</tt> indicates that this is a
@@ -201,7 +201,7 @@ module NewRelic
     #   background task and will show up in RPM with other background
     #   tasks instead of in the controllers list
     # * <tt>:category => :rack</tt> if you are instrumenting a rack
-    #   middleware call.  The <tt>:name</tt> is optional, useful if you 
+    #   middleware call.  The <tt>:name</tt> is optional, useful if you
     #   have more than one potential transaction in the #call.
     # * <tt>:category => :uri</tt> indicates that this is a
     #   web transaction whose name is a normalized URI, where  'normalized'
@@ -224,14 +224,14 @@ module NewRelic
     # * <tt>:path => metric_path</tt> is *deprecated* in the public API.  It
     #   allows you to set the entire metric after the category part.  Overrides
     #   all the other options.
-    # * <tt>:request => Rack::Request#new(env)</tt> is used to pass in a 
+    # * <tt>:request => Rack::Request#new(env)</tt> is used to pass in a
     #   request object that may respond to uri and referer.
     #
     # If a single argument is passed in, it is treated as a metric
     # path.  This form is deprecated.
     def perform_action_with_newrelic_trace(*args, &block)
-      
-      # Skip instrumentation based on the value of 'do_not_trace' and if 
+
+      # Skip instrumentation based on the value of 'do_not_trace' and if
       # we aren't calling directly with a block.
       if !block_given? && _is_filtered?('do_not_trace')
         # Also ignore all instrumentation in the call sequence
@@ -239,11 +239,11 @@ module NewRelic
           return perform_action_without_newrelic_trace(*args)
         end
       end
-      
+
       return perform_action_with_newrelic_profile(args, &block) if NewRelic::Control.instance.profiling?
-      
+
       frame_data = _push_metric_frame(block_given? ? args : [])
-      begin      
+      begin
         NewRelic::Agent.trace_execution_scoped frame_data.recorded_metrics, :force => frame_data.force_flag do
           frame_data.start_transaction
           begin
@@ -270,14 +270,14 @@ module NewRelic
     protected
     # Should be implemented in the dispatcher class
     def newrelic_response_code; end
-    
+
     def newrelic_request_headers
       self.respond_to?(:request) && self.request.respond_to?(:headers) && self.request.headers
     end
-    
+
     private
-    
-    # Profile the instrumented call.  Dev mode only.  Experimental. 
+
+    # Profile the instrumented call.  Dev mode only.  Experimental.
     def perform_action_with_newrelic_profile(args)
       frame_data = _push_metric_frame(block_given? ? args : [])
       val = nil
@@ -299,20 +299,20 @@ module NewRelic
     ensure
       frame_data.pop
     end
-    
+
     # Write a metric frame onto a thread local if there isn't already one there.
     # If there is one, just update it.
     def _push_metric_frame(args) # :nodoc:
       frame_data = NewRelic::Agent::Instrumentation::MetricFrame.current(true)
-      
+
       frame_data.apdex_start ||= _detect_upstream_wait(frame_data.start)
-      _record_queue_length 
+      _record_queue_length
       # If a block was passed in, then the arguments represent options for the instrumentation,
       # not app method arguments.
       if args.any?
         if args.last.is_a?(Hash)
           options = args.last
-          frame_data.force_flag = options[:force] 
+          frame_data.force_flag = options[:force]
           frame_data.request = options[:request] if options[:request]
         end
         category, path, available_params = _convert_args_to_path(args)
@@ -326,7 +326,7 @@ module NewRelic
       frame_data.filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
       frame_data
     end
-        
+
     def _convert_args_to_path(args)
       options =  args.last.is_a?(Hash) ? args.pop : {}
       params = options[:params] || {}
@@ -340,7 +340,7 @@ module NewRelic
         else options[:category].to_s
       end
       unless path = options[:path]
-        action = options[:name] || args.first 
+        action = options[:name] || args.first
         metric_class = options[:class_name] || (self.is_a?(Class) ? self.name : self.class.name)
         path = metric_class
         path += ('/' + action) if action
@@ -348,7 +348,7 @@ module NewRelic
       [category, path, params]
     end
 
-    # Filter out 
+    # Filter out
     def _is_filtered?(key)
       ignore_actions = self.class.newrelic_read_attr(key) if self.class.respond_to? :newrelic_read_attr
       case ignore_actions
@@ -374,7 +374,7 @@ module NewRelic
         NewRelic::Agent.agent.stats_engine.get_stats_no_scope('Mongrel/Queue Length').trace_call(queue_depth) if queue_depth
       end
     end
-    
+
     # Return a Time instance representing the upstream start time.
     # now is a Time instance to fall back on if no other candidate
     # for the start time is found.
@@ -396,14 +396,14 @@ module NewRelic
         total_time = (now - http_entry_time)
         queue_stat.trace_call(total_time.to_f) unless total_time.to_f <= 0.0 # using remote timestamps could lead to negative queue time
       end
-      return http_entry_time ? Time.at(http_entry_time) : now 
+      return http_entry_time ? Time.at(http_entry_time) : now
     end
-    
+
     def _dispatch_stat
-      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'  
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'
     end
-    
-  end 
-end  
+
+  end
+end
 end
 end