techarch-newrelic_rpm 2.10.2

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

@@ -0,0 +1,90 @@
+
+# NewRelic instrumentation for DataMapper
+# For now, we have to refer to all db metrics as "ActiveRecord"
+if defined? DataMapper
+  
+  DataMapper::Model.class_eval do
+    add_method_tracer :get, 'ActiveRecord/#{self.name}/find'
+    add_method_tracer :first, 'ActiveRecord/#{self.name}/find'
+    add_method_tracer :first_or_create, 'ActiveRecord/#{self.name}/find'
+    add_method_tracer :all, 'ActiveRecord/#{self.name}/find_all'
+  end
+  DataMapper::Adapters::DataObjectsAdapter.class_eval do
+    
+    @@my_sql_defined = defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+    @@postgres_defined = defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    
+    for method in [:read_many, :read_one] do
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/find' # Need to get the model somehow
+      add_method_tracer method, 'ActiveRecord/find', :push_scope => false
+      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
+    end
+    for method in [:execute, :query] do    
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute' # Need to get the model somehow
+      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
+    end
+    for method in [:create, :update]do
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer method, 'ActiveRecord/save', :push_scope => false
+    end
+    add_method_tracer :delete, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+    add_method_tracer :delete, 'ActiveRecord/destroy', :push_scope => false
+    
+    def log_with_newrelic_instrumentation(sql, name, &block)
+      # if we aren't in a blamed context, then add one so that we can see that
+      # controllers are calling SQL directly
+      # we check scope_depth vs 2 since the controller is 1, and the 
+      #      
+      if NewRelic::Agent.instance.transaction_sampler.scope_depth < 2
+        self.class.trace_method_execution "Database/DirectSQL", true, true do
+          log_with_capture_sql(sql, name, &block)
+        end
+      else
+        log_with_capture_sql(sql, name, &block)
+      end
+    end
+    
+    def log_with_capture_sql(sql, name, &block)
+      if @@my_sql_defined && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
+        config = @config
+      elsif @@postgres_defined && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+        config = @config
+      else
+        config = nil
+      end
+      
+      t0 = Time.now
+      result = log_without_newrelic_instrumentation(sql, name, &block)
+      
+      NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, config, Time.now - t0)
+      
+      result
+    end
+    
+    # Compare with #alias_method_chain, which is not available in 
+    # Rails 1.1:
+    #alias_method :log_without_newrelic_instrumentation, :log
+    #alias_method :log, :log_with_newrelic_instrumentation
+    
+=begin 
+  # instrumentation for associations
+  module Associations
+    class AssociationCollection
+      add_method_tracer :delete, 'ActiveRecord/#{@owner.class.name}/association delete'
+    end
+    
+    def HasAndBelongsToManyAssociation
+      add_method_tracer :find, 'ActiveRecord/#{@owner.class.name}/association find'
+      add_method_tracer :create_record, 'ActiveRecord/#{@owner.class.name}/association create'
+      add_method_tracer :insert_record, 'ActiveRecord/#{@owner.class.name}/association insert'
+    end
+    
+    class HasManyAssociation
+      # add_method_tracer :find, 'ActiveRecord/#{@owner.class.name}/association find'
+      # add_method_tracer :insert_record, 'ActiveRecord/#{@owner.class.name}/association insert'
+      # add_method_tracer :create_record, 'ActiveRecord/#{@owner.class.name}/association create'
+    end
+  end
+=end
+  end
+end

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

@@ -0,0 +1,167 @@
+# We have to patch the mongrel dispatcher live since the classes
+# aren't defined when our instrumentation loads.
+# To use this module, you should monkey patch a method newrelic_response_code
+# which will return the response status code when the dispatcher finishes.
+module NewRelic::Agent::Instrumentation
+  module DispatcherInstrumentation
+    extend self
+    def newrelic_dispatcher_start
+      # This call might be entered twice in the same call sequence so we ignore subsequent calls.
+      return if _dispatcher_start_time
+      # Put the current time on the thread.  Can't put in @ivar because this could
+      # be a class or instance context
+      start = Time.now.to_f
+      self._dispatcher_start_time = start
+      BusyCalculator.dispatcher_start start
+      _detect_upstream_wait
+      
+      NewRelic::Agent.agent.start_transaction
+      
+      # Reset the flag indicating the controller action should be ignored.
+      # It may be set by the action to either true or false or left nil meaning false
+      Thread.current[:newrelic_ignore_controller] = nil
+    end
+    
+    def newrelic_dispatcher_finish
+      NewRelic::Agent.agent.end_transaction
+      return unless started = _dispatcher_start_time
+      dispatcher_end_time = Time.now.to_f
+      BusyCalculator.dispatcher_finish dispatcher_end_time
+      unless Thread.current[:newrelic_ignore_controller]
+        elapsed_time = dispatcher_end_time - started
+        # Store the response header
+        if response_code = newrelic_response_code 
+          NewRelic::Agent.agent.stats_engine.get_stats_no_scope("HTTP/Response/#{response_code}").trace_call(elapsed_time)
+        end
+        # Store the response time
+        _dispatch_stat.trace_call(elapsed_time)
+        NewRelic::Agent.instance.histogram.process(elapsed_time)
+      end
+      # ensure we don't record it twice
+      self._dispatcher_start_time = nil
+      self._request_start_time = nil
+    end
+    # 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
+      
+    # Used only when no before/after callbacks are available with
+    # the dispatcher, such as Rails before 2.0
+    def dispatch_newrelic(*args)
+      newrelic_dispatcher_start
+      begin
+        dispatch_without_newrelic(*args)
+      ensure
+        newrelic_dispatcher_finish
+      end
+    end
+    
+    private
+    
+    def _dispatcher_start_time
+      Thread.current[:newrelic_dispatcher_start]
+    end
+    
+    def _dispatcher_start_time= newval
+      Thread.current[:newrelic_dispatcher_start] = newval
+    end
+
+    def _request_start_time
+      Thread.current[:newrelic_request_start]
+    end
+    def _request_start_time=(newval)
+      Thread.current[:newrelic_request_start] = newval
+    end
+    
+    def _detect_upstream_wait
+      return if _request_start_time
+      if newrelic_request_headers
+        entry_time = newrelic_request_headers['HTTP_X_REQUEST_START'] and
+        entry_time = entry_time[/t=(\d+)/, 1 ] and 
+        http_entry_time = entry_time.to_f/1e6
+      end
+      # If we didn't find the custom header, look for the mongrel timestamp:a
+      http_entry_time ||= Thread.current[:started_on] and http_entry_time = http_entry_time.to_f
+
+      if http_entry_time
+        self._request_start_time = http_entry_time
+        queue_stat = NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'WebFrontend/Mongrel/Average Queue Time'  
+        queue_stat.trace_call(_dispatcher_start_time - http_entry_time)
+      end
+    end
+    
+    
+    def _dispatch_stat
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'  
+    end
+    
+    # This won't work with Rails 2.2 multi-threading
+    module BusyCalculator
+      extend self
+      # the fraction of the sample period that the dispatcher was busy
+      
+      def dispatcher_start(time)
+        @lock.synchronize do
+          @entrypoint_stack.push time      
+        end
+      end
+      
+      def dispatcher_finish(time)
+        @lock.synchronize do
+          NewRelic::Control.instance.log.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}") and return if @entrypoint_stack.empty?
+          @accumulator += (time - @entrypoint_stack.pop)
+        end
+      end
+      
+      def busy_count
+        @entrypoint_stack.size
+      end
+      def reset
+        @entrypoint_stack = []
+        @lock = Mutex.new
+        @accumulator = 0
+        @harvest_start = Time.now.to_f
+      end
+      
+      self.reset
+      
+      # Called before uploading to to the server to collect current busy stats.
+      def harvest_busy
+        busy = 0
+        t0 = Time.now.to_f
+        @lock.synchronize do
+          busy = @accumulator
+          @accumulator = 0
+          
+          # Walk through the stack and capture all times up to 
+          # now for entrypoints
+          @entrypoint_stack.size.times do |frame| 
+            busy += (t0 - @entrypoint_stack[frame])
+            @entrypoint_stack[frame] = t0
+          end
+          
+        end
+        
+        busy = 0.0 if busy < 0.0 # don't go below 0%
+        
+        time_window = (t0 - @harvest_start)
+        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 unless busy == 0
+        @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'  
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,24 @@
+# NOTE there are multiple implementations of the MemCache client in Ruby,
+# 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)
+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
+
+end

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

@@ -0,0 +1,26 @@
+require 'set'
+require 'merb-core/controller/merb_controller'
+
+Merb::Controller.class_eval do
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  
+  class_inheritable_accessor :do_not_trace
+  class_inheritable_accessor :ignore_apdex
+  
+  def self.newrelic_write_attr(attr_name, value) # :nodoc:
+    self.send "#{attr_name}=", attr_name, value
+  end
+  
+  def self.newrelic_read_attr(attr_name) # :nodoc:
+    self.send attr_name
+  end
+  
+  protected
+  # determine the path that is used in the metric name for
+  # the called controller action
+  def newrelic_metric_path(action)
+    "#{controller_name}/#{action}"
+  end
+  alias_method :perform_action_without_newrelic_trace, :_dispatch
+  alias_method :_dispatch, :perform_action_with_newrelic_trace
+end

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

@@ -0,0 +1,13 @@
+require 'merb-core/dispatch/dispatcher'
+# NewRelic RPM instrumentation for http request dispatching (Routes mapping)
+Merb::Request.class_eval do
+  
+  include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+
+  alias_method :dispatch_without_newrelic, :handle
+  alias_method :handle, :dispatch_newrelic
+  def newrelic_response_code
+    # Don't have an easy way to get the HTTP status from here yet
+    nil
+  end
+end

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

@@ -0,0 +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)
+  end
+}
+Merb::Dispatcher::DefaultException.before error_notifier
+Exceptions.before error_notifier

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

@@ -0,0 +1,23 @@
+# ActiveMerchant Instrumentation.
+
+if defined? Net::HTTP
+  Net::HTTP.class_eval do
+    def request_with_newrelic_trace(*args, &block)
+      if Thread::current[:newrelic_transaction_name].nil?
+        self.class.trace_execution_unscoped(["External/#{@address}/Net::HTTP/#{args[0].method}", 
+                                             "External/#{@address}/all",
+                                             "External/allOther"]) do
+          request_without_newrelic_trace(*args, &block)
+        end
+      else
+        self.class.trace_execution_scoped(["External/#{@address}/Net::HTTP/#{args[0].method}",
+                                           "External/#{@address}/all",
+                                           "External/allWeb"]) do
+          request_without_newrelic_trace(*args, &block)
+        end
+      end
+    end
+    alias request_without_newrelic_trace request
+    alias request request_with_newrelic_trace
+  end
+end

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

@@ -0,0 +1,20 @@
+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::Agent.instance.shutdown
+  end
+
+  PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    if 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.
+      NewRelic::Agent.instance.stats_engine.reset_stats
+    else 
+      # We're in conservative spawning mode. We don't need to do anything.
+    end
+  end
+  
+end 

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

@@ -0,0 +1,108 @@
+
+
+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
+      #
+      # You should avoid instrumenting nested calls.  So if you are using Rack::Cascade
+      # to fall through the action, or you are chaining through to the next middleware 
+      # which will have it's own controller instrumentation, then you will want 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_env
+        end
+        def call_with_newrelic(*args)
+          @newrelic_env = args.first
+          perform_action_with_newrelic_trace(:category => :rack) do
+            call_without_newrelic(*args)
+          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