newrelic_rpm 2.9.9 → 2.10.3

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

@@ -0,0 +1,22 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+if defined?(Delayed::Job) and not NewRelic::Control.instance['disable_dj']
+  module NewRelic
+    module Agent
+      module Instrumentation
+        module DelayedJobInstrumentation
+
+          Delayed::Job.class_eval do
+            include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+            if self.instance_methods.include?('name')
+              add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob', :path => '#{self.name}'
+            else
+              add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob'
+            end
+          end
+          
+        end 
+      end
+    end
+  end
+end

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

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

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

@@ -1,7 +1,8 @@
 # Hook in the notification to merb
 error_notifier = Proc.new {
   if request.exceptions #check that there's actually an exception
-    NewRelic::Agent.agent.error_collector.notice_error(request.exceptions.first, request, "#{params[:controller]}/#{params[:action]}", params)
+    # Note, this assumes we have already captured the other information such as uri and params in the MetricFrame.
+    NewRelic::Agent::Instrumentation::MetricFrame.notice_error(request.exceptions.first)
   end
 }
 Merb::Dispatcher::DefaultException.before error_notifier

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

@@ -0,0 +1,258 @@
+# A struct holding the information required to measure a controller
+# action.  This is put on the thread local.  Handles the issue of
+# re-entrancy, or nested action calls.
+#
+# This class is not part of the public API.  Avoid making calls on it directly.
+#
+module NewRelic::Agent::Instrumentation
+  class MetricFrame 
+    attr_accessor :start, :apdex_start, :exception, 
+                :filtered_params, :force_flag, 
+                :jruby_cpu_start, :process_cpu_start, :database_metric_name
+                
+    # Return the currently active metric frame, or nil.  Call with +true+
+    # to create a new metric frame if one is not already on the thread.
+    def self.current(create_if_empty=nil)
+      Thread.current[:newrelic_metric_frame] ||= create_if_empty && new
+    end
+    
+    # This is the name of the model currently assigned to database 
+    # measurements, overriding the default. 
+    def self.database_metric_name
+      current && current.database_metric_name
+    end
+    
+    @@java_classes_loaded = false
+    
+    if defined? JRuby
+      begin
+        require 'java'
+        include_class 'java.lang.management.ManagementFactory'
+        include_class 'com.sun.management.OperatingSystemMXBean'
+        @@java_classes_loaded = true
+      rescue Exception => e
+      end
+    end
+    
+    attr_reader :depth
+    
+    def initialize
+      @start = Time.now.to_f
+      @path_stack = [] # stack of [controller, path] elements
+      @jruby_cpu_start = jruby_cpu_time
+      @process_cpu_start = process_cpu
+    end
+    
+    # Indicate that we are entering a measured controller action or task.
+    # Make sure you unwind every push with a pop call.
+    def push(category, path)
+      NewRelic::Agent.instance.transaction_sampler.notice_first_scope_push(start)
+      @path_stack.push [category, path]
+    end
+    
+    # Indicate that you don't want to keep the currently saved transaction
+    # information
+    def self.abort_transaction!
+      current.abort_transaction! if current
+    end
+
+    # Give the current metric frame a request context.  Use this to 
+    # get the URI and referer.  The request is interpreted loosely
+    # as a Rack::Request or an ActionController::AbstractRequest.
+    def request=(request)
+      @request = request
+    end
+    
+    # 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?(:url) then @request.url
+        when @request.respond_to?(:uri) then @request.uri
+        when @request.respond_to?(:fullpath) then @request.fullpath
+        when @request.respond_to?(:path) then @request.path
+      end
+      @uri = approximate_uri.split('?').first || '/' if approximate_uri
+    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
+    end
+    
+    # Call this to ensure that the current transaction is not saved
+    def abort_transaction!
+      NewRelic::Agent.instance.transaction_sampler.ignore_transaction
+    end
+    # This needs to be called after entering the call to trace the controller action, otherwise
+    # the controller action blames itself.  It gets reset in the normal #pop call.
+    def start_transaction
+      NewRelic::Agent.instance.stats_engine.start_transaction metric_name
+      # Only push the transaction context info once, on entry:
+      if @path_stack.size == 1
+        NewRelic::Agent.instance.transaction_sampler.notice_transaction(metric_name, uri, filtered_params)
+      end
+    end
+    
+    def category
+      @path_stack.last.first  
+    end
+    
+    def path
+      @path_stack.last.last
+    end
+    
+    # Unwind one stack level.  It knows if it's back at the outermost caller and
+    # does the appropriate wrapup of the context.
+    def pop
+      category, path = @path_stack.pop
+      if category.nil?
+        NewRelic::Control.instance.log.error "Underflow in metric frames: #{caller.join("\n   ")}"
+      end
+      if @path_stack.empty?
+        if NewRelic::Agent.is_execution_traced?
+          cpu_burn = nil
+          if @process_cpu_start
+            cpu_burn = process_cpu - @process_cpu_start
+          elsif @jruby_cpu_start
+            cpu_burn = jruby_cpu_time - @jruby_cpu_start
+            NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).record_data_point(cpu_burn)
+          end
+          NewRelic::Agent.instance.transaction_sampler.notice_transaction_cpu_time(cpu_burn) if cpu_burn
+          NewRelic::Agent.instance.histogram.process(Time.now.to_f - start) if recording_web_transaction?(category)
+          NewRelic::Agent.instance.transaction_sampler.notice_scope_empty      
+        end      
+        NewRelic::Agent.instance.stats_engine.end_transaction
+        Thread.current[:newrelic_metric_frame] = nil
+      else # path stack not empty
+        # change the transaction name back to whatever was on the stack.  
+        NewRelic::Agent.instance.stats_engine.scope_name = metric_name
+      end
+    end
+    
+    # If we have an active metric frame, notice the error and increment the error metric.
+    def self.notice_error(e, custom_params=nil)
+      if current
+        current.notice_error(e, custom_params)
+      else
+        NewRelic::Agent.instance.error_collector.notice_error(e, :custom_params => custom_params)
+      end
+    end
+    
+    def notice_error(e, custom_params=nil)
+      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)
+        self.exception = e
+      end
+    end
+    
+    # Add context parameters to the metric frame.  This information will be passed in to errors
+    # and transaction traces.  Keys and Values should be strings, numbers or date/times.
+    def self.add_custom_parameters(p)
+      current.add_custom_parameters(p) if current
+    end
+    
+    def self.custom_parameters
+     (current && current.custom_parameters) ? current.custom_parameters : {}
+    end
+    
+    def record_apdex
+      return unless recording_web_transaction? && NewRelic::Agent.is_execution_traced?
+      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)
+    end
+    
+    def metric_name
+      return nil if @path_stack.empty?
+      category + '/' + path 
+    end
+    
+    # Return the array of metrics to record for the current metric frame.
+    def recorded_metrics
+      metrics = [ metric_name ]
+      if @path_stack.size == 1
+        if recording_web_transaction?
+          metrics += ["HttpDispatcher"]
+        else
+          metrics += ["#{category}/all", "OtherTransaction/all"]
+        end
+      end
+      metrics
+    end
+    
+    # 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
+    # otherwise know about a model.  This is re-entrant.
+    #
+    # * <tt>model</tt> is the DB model class
+    # * <tt>method</tt> is the name of the finder method or other method to identify the operation with.
+    #
+    def with_database_metric_name(model, method)
+      previous = @database_metric_name
+      model_name = case model
+      when Class
+        model.name
+      when String
+        model
+      else
+        model.to_s
+      end
+      @database_metric_name = "ActiveRecord/#{model_name}/#{method}"
+      yield
+    ensure  
+      @database_metric_name=previous
+    end
+    
+    def custom_parameters
+      @custom_parameters ||= {}
+    end
+    
+    def add_custom_parameters(p)
+      custom_parameters.merge!(p)
+    end
+    
+    def self.recording_web_transaction?
+      if c = Thread.current[:newrelic_metric_frame]
+        c.recording_web_transaction?
+      end
+    end
+    
+    def recording_web_transaction?(cat = category)
+      0 == cat.index("Controller")
+    end
+    
+    private
+    
+    def update_apdex(stat, duration, failed)
+      apdex_t = NewRelic::Control.instance.apdex_t
+      case
+      when failed
+        stat.record_apdex_f
+      when duration <= apdex_t
+        stat.record_apdex_s
+      when duration <= 4 * apdex_t
+        stat.record_apdex_t
+      else
+        stat.record_apdex_f
+      end
+    end  
+    
+    def process_cpu
+      return nil if defined? JRuby
+      p = Process.times
+      p.stime + p.utime
+    end
+    
+    def jruby_cpu_time # :nodoc:
+      return nil unless @@java_classes_loaded
+      threadMBean = ManagementFactory.getThreadMXBean()
+      java_utime = threadMBean.getCurrentThreadUserTime()  # ns
+      -1 == java_utime ? 0.0 : java_utime/1e9
+    end
+    
+  end
+end

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

@@ -1,18 +1,14 @@
 if defined? Net::HTTP
   Net::HTTP.class_eval do
     def request_with_newrelic_trace(*args, &block)
-      if Thread::current[:newrelic_scope_stack].nil?
-        request_without_newrelic_trace(*args, &block)
+      metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}","External/#{@address}/all"]
+      if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+        metrics << "External/allWeb"
       else
-        self.class.trace_method_execution_with_scope("External/#{@address}/Net::HTTP/#{args[0].method}",
-                                                     true,
-                                                     true) do
-          self.class.trace_method_execution_no_scope("External/#{@address}/all") do
-            self.class.trace_method_execution_no_scope("External/allWeb") do
-              request_without_newrelic_trace(*args, &block)
-            end
-          end
-        end
+        metrics << "External/allOther"
+      end
+      self.class.trace_execution_scoped metrics do
+        request_without_newrelic_trace(*args, &block)
       end
     end
     alias request_without_newrelic_trace request

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

@@ -2,7 +2,7 @@ if defined?(PhusionPassenger)
   NewRelic::Control.instance.log.debug "Installing Passenger event hooks."
 
   PhusionPassenger.on_event(:stopping_worker_process) do 
-    NewRelic::Control.instance.log.info "Passenger stopping this process, shutdown the agent."
+    NewRelic::Control.instance.log.debug "Passenger stopping this process, shutdown the agent."
     NewRelic::Agent.instance.shutdown
   end
 

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

@@ -0,0 +1,109 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      # == Instrumentation for Rack
+      #
+      # New Relic will instrument a #call method as if it were a controller
+      # action, collecting transaction traces and errors.  The middleware will
+      # be identified only by it's class, so if you want to instrument multiple
+      # actions in a middleware, you need to use
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
+      #
+      # Example:
+      #   require 'new_relic/agent/instrumentation/rack'
+      #   class Middleware
+      #     def call(env)
+      #       ...
+      #     end
+      #     # Do the include after the call method is defined:
+      #     include NewRelic::Agent::Instrumentation::Rack
+      #   end
+      #
+      # == Instrumenting Metal
+      #
+      # If you are using Metal, be sure and extend the your Metal class with the
+      # Rack instrumentation:
+      #
+      #   require 'new_relic/agent/instrumentation/rack'
+      #   class MetalApp
+      #     def self.call(env)
+      #       ...
+      #     end
+      #     # Do the include after the call method is defined:
+      #     extend NewRelic::Agent::Instrumentation::Rack
+      #   end
+      #
+      # == Overriding the metric name
+      #
+      # 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:
+      #
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class Middleware
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def call(env)
+      #       ...
+      #     end
+      #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
+      #   end
+      #
+      # == Cascading or chained calls
+      #
+      # Calls which return a 404 will not have transactions recorded, but 
+      # any calls to instrumented frameworks like ActiveRecord will still be
+      # captured even if the result is a 404.  To avoid this you need to
+      # instrument only when you are the endpoint.
+      #
+      # In these cases, you should not include or extend the Rack module but instead
+      # include NewRelic::Agent::Instrumentation::ControllerInstrumentation.
+      # Here's how that might look:
+      #
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class MetalApp
+      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def self.call(env)
+      #       if should_do_my_thing?
+      #         perform_action_with_newrelic_trace(:category => :rack) do
+      #           return my_response(env)
+      #         end
+      #       else
+      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
+      #       end
+      #     end
+      #   end
+      #      
+      module Rack
+        def newrelic_request_headers
+          @newrelic_request.env
+        end
+        def call_with_newrelic(*args)
+          @newrelic_request = ::Rack::Request.new(args.first)
+          perform_action_with_newrelic_trace(:category => :rack, :request => @newrelic_request) do
+            result = call_without_newrelic(*args)
+            # Ignore cascaded calls
+            MetricFrame.abort_transaction! if result.first == 404
+            result
+          end
+        end
+        def self.included middleware #:nodoc:
+          middleware.class_eval do
+            alias call_without_newrelic call
+            alias call call_with_newrelic
+          end
+        end
+        include ControllerInstrumentation
+        def self.extended middleware #:nodoc:
+          middleware.class_eval do
+            class << self
+              alias call_without_newrelic call
+              alias call call_with_newrelic
+            end
+          end
+        end
+      end
+    end
+  end
+end