newrelic_rpm 2.10.5 → 2.10.6

data/CHANGELOG

@@ -1,9 +1,15 @@
+v2.10.6
+  * fix missing URL and referer on some traced errors and transactions
+  * gather traced errors *after* executing the rescue chain in ActionController
+  * always load controller instrumentation
+  * pick up token validation from newrelic.yml
+  
 v2.10.5
-  * Fix bug in delayed_job instrumentation occurring when there was no DJ log
+  * fix bug in delayed_job instrumentation occurring when there was no DJ log
   
 v2.10.4
-  * Fix incompatibility with Capistrano 2.5.16
-  * Strip down URLs reported in transactions and errors to path only
+  * fix incompatibility with Capistrano 2.5.16
+  * strip down URLs reported in transactions and errors to path only
   
 v2.10.3
   * optimization to reduce overhead: move background samplers into foreground thread

data/lib/new_relic/agent.rb

@@ -100,6 +100,8 @@ module NewRelic
     require 'new_relic/agent/error_collector'
     require 'new_relic/agent/busy_calculator'
     require 'new_relic/agent/sampler'
+
+    require 'new_relic/agent/instrumentation/controller_instrumentation'
     
     require 'new_relic/agent/samplers/cpu_sampler'
     require 'new_relic/agent/samplers/memory_sampler'
@@ -285,11 +287,17 @@ module NewRelic
     # if there is one.
     # 
     # * <tt>exception</tt> is the exception which will be recorded
-    # * <tt>extra_params</tt> is a hash of name value pairs to appear alongside
-    #   the exception in RPM.
+    # Options:
+    # * <tt>:uri</tt> => The request path, minus any request params or query string.
+    # * <tt>:referer</tt> => The URI of the referer
+    # * <tt>:metric</tt> => The metric name associated with the transaction
+    # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+    # * <tt>:custom_params</tt> => Custom parameters
+    #
+    # Anything left over is treated as custom params
     #
-    def notice_error(exception, extra_params = nil)
-      NewRelic::Agent::Instrumentation::MetricFrame.notice_error(exception, extra_params)
+    def notice_error(exception, options={})
+      NewRelic::Agent::Instrumentation::MetricFrame.notice_error(exception, options)
     end
 
     # Add parameters to the current transaction trace on the call stack.
@@ -298,7 +306,9 @@ module NewRelic
       NewRelic::Agent::Instrumentation::MetricFrame.add_custom_parameters(params)
     end
     
-    alias add_request_parameters add_custom_parameters
+    # The #add_request_parameters method is aliased to #add_custom_parameters
+    # and is now deprecated.
+    alias add_request_parameters add_custom_parameters #:nodoc:
     
     # Yield to a block that is run with a database metric name context.  This means
     # the Database instrumentation will use this for the metric name if it does not

data/lib/new_relic/agent/agent.rb

@@ -326,8 +326,8 @@ module NewRelic
           :agent_version => NewRelic::VERSION::STRING, 
           :environment => environment,
           :settings => control.settings,
-          :validate_seed => ENV['NR_VALIDATE_SEED'],
-          :validate_token => ENV['NR_VALIDATE_TOKEN'] }
+          :validate_seed => control.validate_seed,
+          :validate_token => control.validate_token }
         
         host = invoke_remote(:get_redirect_host)
         

data/lib/new_relic/agent/error_collector.rb

@@ -45,11 +45,13 @@ module NewRelic
     
     # Notice the error with the given available options:
     #
-    # * :uri => The request path, minus any request params or query string.
-    # * :referer => The URI of the referer
-    # * :metric => The metric name associated with the transaction
-    # * :request_params => Request parameters, already filtered if necessary
-    # * :custom_params => Custom parameters
+    # * <tt>:uri</tt> => The request path, minus any request params or query string.
+    # * <tt>:referer</tt> => The URI of the referer
+    # * <tt>:metric</tt> => The metric name associated with the transaction
+    # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+    # * <tt>:custom_params</tt> => Custom parameters
+    #
+    # If anything is left over, it's added to custom params
     def notice_error(exception, options={})
       return unless @enabled
       return if @ignore[exception.class.name] 
@@ -58,23 +60,22 @@ module NewRelic
         return if exception.nil?
       end
 
-      action_path     = options[:metric] || NewRelic::Agent.instance.stats_engine.scope_name || ''
-      filtered_params = options[:request_params] || {}
-
       NewRelic::Agent.get_stats("Errors/all").increment_count
       return unless NewRelic::Agent.instance.should_send_errors
-      
+
       data = {}
-      
-      data[:request_params] = normalize_params(options[:request_params]) if NewRelic::Control.instance.capture_params && options[:request_params]
+      data[:request_uri] = options.delete(:uri) || ''
+      data[:request_referer] = options.delete(:referer) || ''
 
-      data[:custom_params] = normalize_params(options[:custom_params]) if options[:custom_params]
-      
-      data[:request_uri] = options[:uri] || ''
-      data[:request_referer] = options[:referer] || ''
+      action_path     = options.delete(:metric) || NewRelic::Agent.instance.stats_engine.scope_name || ''
+      request_params = options.delete(:request_params)
+      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')
       

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

@@ -2,23 +2,29 @@
 # each with slightly different API's and semantics.  
 # See:
 #     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
-#     http://dev.robotcoop.com/Libraries/memcache-client/ (Gem: memcache-client)
+#     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
 unless NewRelic::Control.instance['disable_memcache_instrumentation']
-  MemCache.class_eval do
-    add_method_tracer :get, 'MemCache/read' if self.method_defined? :get
-    add_method_tracer :get_multi, 'MemCache/read' if self.method_defined? :get_multi
-  %w[set add incr decr delete].each do | method |
-      add_method_tracer method, 'MemCache/write' if self.method_defined? method
-    end
-  end if defined? MemCache 
   
+  # This is in the memcache-client implementation and has never existed in Ruby-MemCache
+  def self.instrument_method(the_class, method_name)
+    return unless the_class.method_defined? method_name.to_sym
+    the_class.class_eval <<-EOD
+        def #{method_name}_with_newrelic_trace(*args)
+          metrics = ["MemCache/#{method_name}", 
+                     (NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction? ? 'MemCache/allWeb' : 'MemCache/allOther')]
+          self.class.trace_execution_scoped(metrics) do
+            #{method_name}_without_newrelic_trace(*args)
+          end
+        end
+        alias #{method_name}_without_newrelic_trace #{method_name}
+        alias #{method_name} #{method_name}_with_newrelic_trace
+    EOD
+  end
   # 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, 'MemCache/read' if self.method_defined? :get
-  %w[set add increment decrement delete replace append prepend cas].each do | method |
-      add_method_tracer method, "MemCache/write" if self.method_defined? method
-    end
-  end if defined? Memcached
+  %w[get get_multi set add incr decr delete replace append prepand cas].each do | method_name |
+    instrument_method(::MemCache, method_name) if defined? ::MemCache  
+    instrument_method(::Memcached, method_name) if defined? ::Memcached  
+  end
 
 end

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

@@ -63,22 +63,14 @@ module NewRelic::Agent::Instrumentation
     
     # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
     def uri
-      return @uri if @uri || @request.nil?
-      approximate_uri = case
-        when @request.respond_to?(:fullpath) then @request.fullpath
-        when @request.respond_to?(:path) then @request.path
-        when @request.respond_to?(:uri) then @request.uri
-        when @request.respond_to?(:url) then @request.url
-      end
-      @uri = approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
+      @uri ||= self.class.uri_from_request(@request) unless @request.nil?
     end
     
     # For the current web transaction, return the full referer, minus the host string, or nil.
     def referer
-      return @referer if @referer || @request.nil? || !@request.respond_to?(:referer) || !@request.referer 
-      @referer = @request.referer.split('?').first
+      @referer ||= self.class.referer_from_request(@request)
     end
-    
+   
     # Call this to ensure that the current transaction is not saved
     def abort_transaction!
       NewRelic::Agent.instance.transaction_sampler.ignore_transaction
@@ -130,17 +122,37 @@ module NewRelic::Agent::Instrumentation
     end
     
     # If we have an active metric frame, notice the error and increment the error metric.
-    def self.notice_error(e, custom_params=nil)
+    # Options:
+    # * <tt>:request</tt> => Request object to get the uri and referer
+    # * <tt>:uri</tt> => The request path, minus any request params or query string.
+    # * <tt>:referer</tt> => The URI of the referer
+    # * <tt>:metric</tt> => The metric name associated with the transaction
+    # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+    # * <tt>:custom_params</tt> => Custom parameters
+    # Anything left over is treated as custom params
+
+    def self.notice_error(e, options={})
+      if request = options.delete(:request)
+        options[:referer] = referer_from_request(request)
+        options[:uri] = uri_from_request(request)
+      end
       if current
-        current.notice_error(e, custom_params)
+        current.notice_error(e, options)
       else
-        NewRelic::Agent.instance.error_collector.notice_error(e, :custom_params => custom_params)
+        NewRelic::Agent.instance.error_collector.notice_error(e, options)
       end
     end
     
-    def notice_error(e, custom_params=nil)
+    # Do not call this.  Invoke the class method instead.
+    def notice_error(e, options={}) # :nodoc:
+      params = custom_parameters
+      options[:referer] = referer if referer
+      options[:request_params] = filtered_params if filtered_params 
+      options[:uri] = uri if uri
+      options[:metric] = metric_name
+      options.merge!(custom_parameters)
       if exception != e
-        NewRelic::Agent.instance.error_collector.notice_error(e, :referer => referer, :uri => uri, :metric => metric_name, :request_params => filtered_params, :custom_params => custom_params)
+        NewRelic::Agent.instance.error_collector.notice_error(e, options)
         self.exception = e
       end
     end
@@ -160,8 +172,8 @@ module NewRelic::Agent::Instrumentation
       ending = Time.now.to_f
       summary_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
       controller_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
-      update_apdex(summary_stat, ending - apdex_start, exception)
-      update_apdex(controller_stat, ending - start, exception)
+      self.class.update_apdex(summary_stat, ending - apdex_start, exception)
+      self.class.update_apdex(controller_stat, ending - start, exception)
     end
     
     def metric_name
@@ -223,9 +235,29 @@ module NewRelic::Agent::Instrumentation
       0 == cat.index("Controller")
     end
     
-    private
+    # Make a safe attempt to get the referer from a request object, generally successful when
+    # it's a Rack request.
+    def self.referer_from_request(request)
+      if request && request.respond_to?(:referer)
+        request.referer.to_s.split('?').first
+      end
+    end
+    
+    # Make a safe attempt to get the URI, without the host and query string.
+    def self.uri_from_request(request)
+      approximate_uri = case
+        when request.respond_to?(:fullpath) then request.fullpath
+        when request.respond_to?(:path) then request.path
+        when request.respond_to?(:request_uri) then request.request_uri
+        when request.respond_to?(:uri) then request.uri
+        when request.respond_to?(:url) then request.url
+      end
+      return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
+    end 
     
-    def update_apdex(stat, duration, failed)
+    # Record an apdex value for the given stat.  non-nil 'failed'
+    # the apdex should be recorded as a failure regardless of duration.
+    def self.update_apdex(stat, duration, failed)
       apdex_t = NewRelic::Control.instance.apdex_t
       case
       when failed
@@ -239,6 +271,8 @@ module NewRelic::Agent::Instrumentation
       end
     end  
     
+    private
+    
     def process_cpu
       return nil if defined? JRuby
       p = Process.times

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

@@ -12,6 +12,7 @@ module NewRelic
       # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
       #
       # Example:
+      #   require 'newrelic_rpm'
       #   require 'new_relic/agent/instrumentation/rack'
       #   class Middleware
       #     def call(env)
@@ -26,6 +27,7 @@ module NewRelic
       # If you are using Metal, be sure and extend the your Metal class with the
       # Rack instrumentation:
       #
+      #   require 'newrelic_rpm'
       #   require 'new_relic/agent/instrumentation/rack'
       #   class MetalApp
       #     def self.call(env)
@@ -41,6 +43,7 @@ module NewRelic
       # be more specific and pass in name, then omit including the Rack instrumentation
       # and instead follow this example:
       #
+      #   require 'newrelic_rpm'
       #   require 'new_relic/agent/instrumentation/controller_instrumentation'
       #   class Middleware
       #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation

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

@@ -1,17 +1,17 @@
 
 ActionController::Base.class_eval do
   
-  # Make a note of an exception associated with the currently executin
+  # 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.
   # Use that one outside of controller actions.
   def newrelic_notice_error(exception, custom_params = {})
-    NewRelic::Agent::Instrumentation::MetricFrame.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)
-    NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception
     rescue_action_without_newrelic_trace exception
+    NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :request => request 
   end
   
   # Compare with #alias_method_chain, which is not available in 

data/lib/new_relic/control.rb

@@ -214,6 +214,12 @@ module NewRelic
     def app_names
       self['app_name'] ? self['app_name'].split(';') : []
     end
+    def validate_seed
+      self['validate_seed'] || ENV['NR_VALIDATE_SEED']   
+    end
+    def validate_token
+      self['validate_token'] || ENV['NR_VALIDATE_TOKEN']
+    end
     
     def use_ssl?
       @use_ssl ||= fetch('ssl', false)
@@ -440,7 +446,10 @@ module NewRelic
         require File.join(newrelic_root, "test", "config", "test_control.rb")
         NewRelic::Control::Test.new @local_env
       else
-        require "new_relic/control/#{@local_env.framework}.rb"
+        begin
+          require "new_relic/control/#{@local_env.framework}.rb"
+        rescue LoadError
+        end
         NewRelic::Control.const_get(@local_env.framework.to_s.capitalize).new @local_env
       end
     end

data/lib/new_relic/delayed_job_injection.rb

@@ -15,9 +15,7 @@ Delayed::Worker.class_eval do
     when self.class.respond_to?(:default_name) then self.class.default_name
     end
     dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
-    if self.class.logger
-      self.class.logger.info "RPM Monitoring DJ worker #{dispatcher_instance_id}"
-    end
+    say "RPM Monitoring DJ worker #{dispatcher_instance_id}"
     NewRelic::Agent.manual_start :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
     NewRelic::DelayedJobInjection.worker_name = worker_name
   end

data/lib/new_relic/local_environment.rb

@@ -23,6 +23,13 @@ module NewRelic
     alias environment dispatcher
     
     def initialize
+      # Extend self with any any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new framworks and dispatchers.  
+      NewRelic::LocalEnvironment.constants.each do | const |
+        mod = NewRelic::LocalEnvironment.const_get const
+        self.extend mod if mod.instance_of? Module
+      end
+      
       discover_framework
       discover_dispatcher
       @dispatcher = nil if @dispatcher == :none
@@ -155,7 +162,7 @@ module NewRelic
     # Although you can override the framework with NEWRELIC_DISPATCHER this
     # is not advisable since it implies certain api's being available.
     def discover_dispatcher
-      @dispatcher = ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
+      @dispatcher ||= ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
       dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
       while dispatchers.any? && @dispatcher.nil?
         send 'check_for_'+(dispatchers.shift)
@@ -168,7 +175,7 @@ module NewRelic
       #
       # Note that the odd defined? sequence is necessary to work around a bug in an older version
       # of JRuby.
-      @framework = case
+      @framework ||= case
         when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
         when defined?(::NewRelic::TEST) then :test
         when defined?(::Merb) && defined?(::Merb::Plugins) then :merb

data/lib/new_relic/metric_parser.rb

@@ -99,6 +99,7 @@ module NewRelic
     def segment_2; segments[2]; end
     def segment_3; segments[3]; end
     def segment_4; segments[4]; end
+    def segment_5; segments[5]; end
     def last_segment; segments.last; end
     
     # This is the suffix used for call rate or throughput.  By default, it's cpm

data/lib/new_relic/metric_parser/mem_cache.rb

@@ -9,4 +9,42 @@ class NewRelic::MetricParser::MemCache < NewRelic::MetricParser
   def developer_name
     "MemCache #{segments[1..-1].join '/'}"
   end
+
+  def all?
+    segments[1]['all'] == 0
+  end
+  def operation
+    all? ? 'All Operations' : segments[1]
+  end
+  def legend_name
+    case segments[1]
+    when 'allWeb'
+      "MemCache"
+    when 'allOther'
+      "Non-web MemCache"
+    else
+      "MemCache #{operation} operations"
+    end
+  end
+  def tooltip_name
+    case segments[1]
+    when 'allWeb'
+      "MemCache calls from web transactions"
+    when 'allOther'
+      "MemCache calls from non-web transactions"
+    else
+      "MemCache #{operation} operations"
+    end
+
+  end
+  def developer_name
+    case segments[1]
+    when 'allWeb'
+      "Web MemCache"
+    when 'allOther'
+      "Non-web MemCache"
+    else
+      "MemCache #{operation}"
+    end
+  end
 end

data/lib/new_relic/stats.rb

@@ -26,7 +26,24 @@ module NewRelic
       return 0 if call_count == 0
       total_exclusive_time / call_count
     end
-    
+
+    # merge by adding to average response time
+    # - used to compose multiple metrics e.g. dispatcher time + mongrel queue time
+    def sum_merge! (other_stats)
+      Array(other_stats).each do |s|
+        self.total_call_time += s.total_call_time
+        self.total_exclusive_time += s.total_exclusive_time
+        self.min_call_time += s.min_call_time
+        self.max_call_time += s.max_call_time
+        #self.call_count += s.call_count - do not add call count because we are stacking these times on top of each other
+        self.sum_of_squares += s.sum_of_squares if s.sum_of_squares
+        self.begin_time = s.begin_time if s.begin_time.to_f < begin_time.to_f || begin_time.to_f == 0.0
+        self.end_time = s.end_time if s.end_time.to_f > end_time.to_f
+      end
+
+      self
+    end
+
     def merge! (other_stats)
       Array(other_stats).each do |s|
         self.total_call_time += s.total_call_time
@@ -172,7 +189,7 @@ module NewRelic
     # Summary string to facilitate testing
     def summary
       format = "%m/%d %I:%M%p"
-      "[#{Time.at(begin_time).strftime(format)}, #{duration}s. #{call_count} calls; #{to_ms(average_call_time)}ms]"
+      "[#{Time.at(begin_time).strftime(format)}, #{'%2.3fs' % duration}; #{'%4i' % call_count} calls #{'%4i' % to_ms(average_call_time)} ms]"
     end
     
     # round all of the values to n decimal points

data/lib/new_relic/version.rb

@@ -3,7 +3,7 @@ module NewRelic
   module VERSION #:nodoc:
     MAJOR = 2
     MINOR = 10
-    TINY  = 5
+    TINY  = 6
     EXPERIMENTAL = nil 
     STRING = [MAJOR, MINOR, TINY, EXPERIMENTAL].compact.join('.')
   end

data/newrelic_rpm.gemspec

@@ -0,0 +1,210 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{newrelic_rpm}
+  s.version = "2.10.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Bill Kayser"]
+  s.date = %q{2010-03-05}
+  s.description = %q{New Relic RPM is a Ruby performance management system, developed by
+New Relic, Inc (http://www.newrelic.com).  RPM provides you with deep
+information about the performance of your Ruby on Rails or Merb
+application as it runs in production. The New Relic Agent is
+dual-purposed as a either a Rails plugin or a Gem, hosted on
+http://github.com/newrelic/rpm/tree/master.
+}
+  s.email = %q{support@newrelic.com}
+  s.executables = ["mongrel_rpm", "newrelic_cmd"]
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+     "LICENSE"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README.md",
+     "bin/mongrel_rpm",
+     "bin/newrelic_cmd",
+     "cert/cacert.pem",
+     "install.rb",
+     "lib/new_relic/agent.rb",
+     "lib/new_relic/agent/agent.rb",
+     "lib/new_relic/agent/busy_calculator.rb",
+     "lib/new_relic/agent/chained_call.rb",
+     "lib/new_relic/agent/collection_helper.rb",
+     "lib/new_relic/agent/error_collector.rb",
+     "lib/new_relic/agent/instrumentation/active_merchant.rb",
+     "lib/new_relic/agent/instrumentation/active_record_instrumentation.rb",
+     "lib/new_relic/agent/instrumentation/authlogic.rb",
+     "lib/new_relic/agent/instrumentation/controller_instrumentation.rb",
+     "lib/new_relic/agent/instrumentation/data_mapper.rb",
+     "lib/new_relic/agent/instrumentation/delayed_job_instrumentation.rb",
+     "lib/new_relic/agent/instrumentation/memcache.rb",
+     "lib/new_relic/agent/instrumentation/merb/controller.rb",
+     "lib/new_relic/agent/instrumentation/merb/errors.rb",
+     "lib/new_relic/agent/instrumentation/metric_frame.rb",
+     "lib/new_relic/agent/instrumentation/net.rb",
+     "lib/new_relic/agent/instrumentation/passenger_instrumentation.rb",
+     "lib/new_relic/agent/instrumentation/rack.rb",
+     "lib/new_relic/agent/instrumentation/rails/action_controller.rb",
+     "lib/new_relic/agent/instrumentation/rails/action_web_service.rb",
+     "lib/new_relic/agent/instrumentation/rails/errors.rb",
+     "lib/new_relic/agent/instrumentation/sinatra.rb",
+     "lib/new_relic/agent/method_tracer.rb",
+     "lib/new_relic/agent/sampler.rb",
+     "lib/new_relic/agent/samplers/cpu_sampler.rb",
+     "lib/new_relic/agent/samplers/delayed_job_lock_sampler.rb",
+     "lib/new_relic/agent/samplers/memory_sampler.rb",
+     "lib/new_relic/agent/samplers/object_sampler.rb",
+     "lib/new_relic/agent/shim_agent.rb",
+     "lib/new_relic/agent/stats_engine.rb",
+     "lib/new_relic/agent/stats_engine/metric_stats.rb",
+     "lib/new_relic/agent/stats_engine/samplers.rb",
+     "lib/new_relic/agent/stats_engine/transactions.rb",
+     "lib/new_relic/agent/transaction_sampler.rb",
+     "lib/new_relic/agent/worker_loop.rb",
+     "lib/new_relic/commands/deployments.rb",
+     "lib/new_relic/commands/new_relic_commands.rb",
+     "lib/new_relic/control.rb",
+     "lib/new_relic/control/external.rb",
+     "lib/new_relic/control/merb.rb",
+     "lib/new_relic/control/rails.rb",
+     "lib/new_relic/control/ruby.rb",
+     "lib/new_relic/control/sinatra.rb",
+     "lib/new_relic/delayed_job_injection.rb",
+     "lib/new_relic/histogram.rb",
+     "lib/new_relic/local_environment.rb",
+     "lib/new_relic/merbtasks.rb",
+     "lib/new_relic/metric_data.rb",
+     "lib/new_relic/metric_parser.rb",
+     "lib/new_relic/metric_parser/action_mailer.rb",
+     "lib/new_relic/metric_parser/active_merchant.rb",
+     "lib/new_relic/metric_parser/active_record.rb",
+     "lib/new_relic/metric_parser/controller.rb",
+     "lib/new_relic/metric_parser/controller_cpu.rb",
+     "lib/new_relic/metric_parser/errors.rb",
+     "lib/new_relic/metric_parser/external.rb",
+     "lib/new_relic/metric_parser/mem_cache.rb",
+     "lib/new_relic/metric_parser/other_transaction.rb",
+     "lib/new_relic/metric_parser/view.rb",
+     "lib/new_relic/metric_parser/web_frontend.rb",
+     "lib/new_relic/metric_parser/web_service.rb",
+     "lib/new_relic/metric_spec.rb",
+     "lib/new_relic/metrics.rb",
+     "lib/new_relic/noticed_error.rb",
+     "lib/new_relic/rack/metric_app.rb",
+     "lib/new_relic/rack/mongrel_rpm.ru",
+     "lib/new_relic/rack/newrelic.yml",
+     "lib/new_relic/rack_app.rb",
+     "lib/new_relic/recipes.rb",
+     "lib/new_relic/stats.rb",
+     "lib/new_relic/transaction_analysis.rb",
+     "lib/new_relic/transaction_sample.rb",
+     "lib/new_relic/version.rb",
+     "lib/new_relic_api.rb",
+     "lib/newrelic_rpm.rb",
+     "lib/tasks/all.rb",
+     "lib/tasks/install.rake",
+     "lib/tasks/tests.rake",
+     "newrelic.yml",
+     "newrelic_rpm.gemspec",
+     "recipes/newrelic.rb",
+     "test/active_record_fixtures.rb",
+     "test/config/newrelic.yml",
+     "test/config/test_control.rb",
+     "test/new_relic/agent/active_record_instrumentation_test.rb",
+     "test/new_relic/agent/agent_controller_test.rb",
+     "test/new_relic/agent/agent_test_controller.rb",
+     "test/new_relic/agent/busy_calculator_test.rb",
+     "test/new_relic/agent/collection_helper_test.rb",
+     "test/new_relic/agent/error_collector_test.rb",
+     "test/new_relic/agent/memcache_instrumentation_test.rb",
+     "test/new_relic/agent/method_tracer_test.rb",
+     "test/new_relic/agent/metric_data_test.rb",
+     "test/new_relic/agent/metric_frame_test.rb",
+     "test/new_relic/agent/mock_ar_connection.rb",
+     "test/new_relic/agent/mock_scope_listener.rb",
+     "test/new_relic/agent/net_instrumentation_test.rb",
+     "test/new_relic/agent/rpm_agent_test.rb",
+     "test/new_relic/agent/stats_engine/metric_stats_test.rb",
+     "test/new_relic/agent/stats_engine/samplers_test.rb",
+     "test/new_relic/agent/stats_engine/stats_engine_test.rb",
+     "test/new_relic/agent/task_instrumentation_test.rb",
+     "test/new_relic/agent/testable_agent.rb",
+     "test/new_relic/agent/transaction_sample_builder_test.rb",
+     "test/new_relic/agent/transaction_sample_test.rb",
+     "test/new_relic/agent/transaction_sampler_test.rb",
+     "test/new_relic/agent/worker_loop_test.rb",
+     "test/new_relic/control_test.rb",
+     "test/new_relic/deployments_api_test.rb",
+     "test/new_relic/environment_test.rb",
+     "test/new_relic/metric_parser_test.rb",
+     "test/new_relic/metric_spec_test.rb",
+     "test/new_relic/shim_agent_test.rb",
+     "test/new_relic/stats_test.rb",
+     "test/new_relic/version_number_test.rb",
+     "test/test_helper.rb",
+     "test/ui/newrelic_controller_test.rb",
+     "test/ui/newrelic_helper_test.rb",
+     "ui/controllers/newrelic_controller.rb",
+     "ui/helpers/google_pie_chart.rb",
+     "ui/helpers/newrelic_helper.rb",
+     "ui/views/layouts/newrelic_default.rhtml",
+     "ui/views/newrelic/_explain_plans.rhtml",
+     "ui/views/newrelic/_sample.rhtml",
+     "ui/views/newrelic/_segment.rhtml",
+     "ui/views/newrelic/_segment_limit_message.rhtml",
+     "ui/views/newrelic/_segment_row.rhtml",
+     "ui/views/newrelic/_show_sample_detail.rhtml",
+     "ui/views/newrelic/_show_sample_sql.rhtml",
+     "ui/views/newrelic/_show_sample_summary.rhtml",
+     "ui/views/newrelic/_sql_row.rhtml",
+     "ui/views/newrelic/_stack_trace.rhtml",
+     "ui/views/newrelic/_table.rhtml",
+     "ui/views/newrelic/explain_sql.rhtml",
+     "ui/views/newrelic/images/arrow-close.png",
+     "ui/views/newrelic/images/arrow-open.png",
+     "ui/views/newrelic/images/blue_bar.gif",
+     "ui/views/newrelic/images/file_icon.png",
+     "ui/views/newrelic/images/gray_bar.gif",
+     "ui/views/newrelic/images/new-relic-rpm-desktop.gif",
+     "ui/views/newrelic/images/new_relic_rpm_desktop.gif",
+     "ui/views/newrelic/images/textmate.png",
+     "ui/views/newrelic/index.rhtml",
+     "ui/views/newrelic/javascript/prototype-scriptaculous.js",
+     "ui/views/newrelic/javascript/transaction_sample.js",
+     "ui/views/newrelic/sample_not_found.rhtml",
+     "ui/views/newrelic/show_sample.rhtml",
+     "ui/views/newrelic/show_source.rhtml",
+     "ui/views/newrelic/stylesheets/style.css",
+     "ui/views/newrelic/threads.rhtml"
+  ]
+  s.homepage = %q{http://www.github.com/newrelic/rpm}
+  s.post_install_message = %q{
+Please see http://support.newrelic.com/faqs/docs/ruby-agent-release-notes
+for a complete description of the features and enhancements available
+in version 2.10 of the Ruby Agent.
+
+For details on this specific release, refer to the CHANGELOG file.
+
+}
+  s.rdoc_options = ["--charset=UTF-8", "--line-numbers", "--inline-source", "--title", "New Relic RPM"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{New Relic Ruby Performance Monitoring Agent}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  
+  # This implementation: http://seattlerb.rubyforge.org/memcache-client/
+  def using_memcache_client?
+    ::MemCache.method_defined? :cache_get
+  end
+  
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+    
+    if using_memcache_client?
+      @cache = ::MemCache.new('localhost')
+    else
+      server = ::MemCache::Server.new('localhost')
+      @cache = ::MemCache.new(server)
+    end
+    @key = 'schluessel'
+  end
+  
+  def _call_test_method_in_web_transaction(method, *args)
+    @engine.clear_stats
+    begin
+      perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
+        @cache.send(method.to_sym, *[@key, *args])
+      end
+    rescue ::MemCache::MemCacheError
+      # There's probably no memcached around
+    end
+  end
+  
+  def _call_test_method_in_background_task(method, *args)
+    @engine.clear_stats
+    begin
+      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+        @cache.send(method.to_sym, *[@key, *args])
+      end
+    rescue ::MemCache::MemCacheError
+      # There's probably no memcached around
+    end
+  end
+  
+  def test_reads__web
+    %w[get get_multi].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        compare_metrics ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+  def test_writes__web
+    %w[incr decr delete].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        expected_metrics = ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+    
+    %w[set add].each do |method|
+      if @cache.class.method_defined?(method)
+        expected_metrics = ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        _call_test_method_in_web_transaction(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+  def test_reads__background
+    %w[get get_multi].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+  def test_writes__background
+    
+    %w[incr decr delete].each do |method|
+      expected_metrics = ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+    
+    %w[set add].each do |method|
+      expected_metrics = ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+end if defined? MemCache

data/test/new_relic/agent/task_instrumentation_test.rb

@@ -130,6 +130,21 @@ class TaskInstrumentationTest < Test::Unit::TestCase
     end
   end
   
+  def test_custom_params
+    NewRelic::Agent.instance.stubs(:should_send_errors).returns(true)
+    @agent.error_collector.ignore_error_filter
+    @agent.error_collector.harvest_errors([])
+    assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+    assert_raise RuntimeError do
+      run_task_exception
+    end
+    error = @agent.error_collector.harvest_errors([]).first
+    assert_equal "Controller/TaskInstrumentationTest/run_task_exception", error.path
+    assert_not_nil error.params[:stack_trace]
+    assert_not_nil error.params[:custom_params]
+    
+  end
+  
   def test_instrument_bg
     run_background_job
     stat_names = %w[OtherTransaction/Background/TaskInstrumentationTest/run_background_job
@@ -160,6 +175,7 @@ class TaskInstrumentationTest < Test::Unit::TestCase
   end
   
   def run_task_exception
+    NewRelic::Agent.add_custom_parameters(:custom_one => 'one custom val')
     assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
     raise "This is an error"
   end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -102,12 +102,12 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     
     run_sample_trace
     run_sample_trace
-    run_sample_trace { sleep 0.5 }
+    run_sample_trace { sleep 0.51 }
     run_sample_trace
     run_sample_trace
     
     slowest = @sampler.harvest(nil, 0)[0]
-    assert slowest.duration >= 0.5
+    assert slowest.duration >= 0.5, "sample duration: #{slowest.duration}"
     
     run_sample_trace { sleep 0.2 }
     not_as_slow = @sampler.harvest(slowest, 0)[0]

data/ui/controllers/newrelic_controller.rb

@@ -47,7 +47,7 @@ class NewrelicController < ActionController::Base
   end
   
   def file
-    file_name=params[:file].join
+    file_name=Array(params[:file]).join
     file_name=~/^.*[.]([^.]*)$/
     ext=$1
     case ext

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: newrelic_rpm
 version: !ruby/object:Gem::Version 
-  version: 2.10.5
+  prerelease: false
+  segments: 
+  - 2
+  - 10
+  - 6
+  version: 2.10.6
 platform: ruby
 authors: 
 - Bill Kayser
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-19 00:00:00 -08:00
+date: 2010-03-05 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +35,6 @@ extensions: []
 extra_rdoc_files: 
 - CHANGELOG
 - LICENSE
-- README.md
 files: 
 - CHANGELOG
 - LICENSE
@@ -119,6 +123,7 @@ files:
 - lib/tasks/install.rake
 - lib/tasks/tests.rake
 - newrelic.yml
+- newrelic_rpm.gemspec
 - recipes/newrelic.rb
 - test/active_record_fixtures.rb
 - test/config/newrelic.yml
@@ -129,6 +134,7 @@ files:
 - test/new_relic/agent/busy_calculator_test.rb
 - test/new_relic/agent/collection_helper_test.rb
 - test/new_relic/agent/error_collector_test.rb
+- test/new_relic/agent/memcache_instrumentation_test.rb
 - test/new_relic/agent/method_tracer_test.rb
 - test/new_relic/agent/metric_data_test.rb
 - test/new_relic/agent/metric_frame_test.rb
@@ -212,18 +218,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: New Relic Ruby Performance Monitoring Agent