genki-newrelic_rpm 2.10.1

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,132 @@
+# We have to patch the mongrel dispatcher live since the classes
+# aren't defined when our instrumentation loads
+# To use this module, you need to 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
+      # Put the current time on the thread.  Can't put in @ivar because this could
+      # be a class or instance context
+      newrelic_dispatcher_start_time = Time.now.to_f
+      Thread.current[:newrelic_dispatcher_start] = newrelic_dispatcher_start_time
+      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_start newrelic_dispatcher_start_time
+      # capture the time spent in the mongrel queue, if running in mongrel.  This is the 
+      # current time less the timestamp placed in 'started_on' by mongrel. 
+      mongrel_start = Thread.current[:started_on]
+      mongrel_queue_stat.trace_call(newrelic_dispatcher_start_time - mongrel_start.to_f) if mongrel_start
+      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
+      #puts @env.to_a.map{|k,v| "#{'%32s' % k}: #{v.inspect[0..64]}"}.join("\n")
+      dispatcher_end_time = Time.now.to_f
+      NewRelic::Agent.agent.end_transaction
+      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_finish dispatcher_end_time
+      unless Thread.current[:newrelic_ignore_controller]
+        elapsed_time = dispatcher_end_time - Thread.current[:newrelic_dispatcher_start]
+        # Store the response header
+        response_code = newrelic_response_code
+        if 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
+    end
+    # Should be implemented in the dispatcher class
+    def newrelic_response_code; 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 dispatch_stat
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'  
+    end
+    
+    def mongrel_queue_stat
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'WebFrontend/Mongrel/Average Queue Time'  
+    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,21 @@
+# 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)
+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

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,12 @@
+# ActiveMerchant Instrumentation.
+
+if defined? Net::HTTP
+#  operations = %w[request]
+#  for op in operations do
+    Net::HTTP.class_eval do
+      add_method_tracer "request", 'External/#{@address}/Net::HTTP/#{args[0].method}'# + op 
+      add_method_tracer "request", 'External/#{@address}/all', :push_scope => false
+      add_method_tracer "request", 'External/all', :push_scope => false
+    end
+#  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,77 @@
+
+
+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
+      #     def call(env)
+      #       ...
+      #     end
+      #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
+      #   end
+      #
+      module Rack
+        def call_with_newrelic(*args)
+          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

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

@@ -0,0 +1,59 @@
+
+if defined? ActionController
+  
+  case Rails::VERSION::STRING
+
+    when /^(1\.|2\.0)/  # Rails 1.* - 2.0
+    ActionController::Base.class_eval do
+      add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+    end  
+
+    when /^2\.1\./  # Rails 2.1
+    ActionView::PartialTemplate.class_eval do
+      add_method_tracer :render, 'View/#{path_without_extension}.#{@view.template_format}.#{extension}/Partial'
+    end
+    # this is for template rendering, as opposed to partial rendering.
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{path_without_extension}.#{@view.template_format}.#{extension}/Rendering'
+    end
+
+    when /^2\./   # Rails 2.2-2.*
+    ActionView::RenderablePartial.module_eval do
+      add_method_tracer :render_partial, 'View/#{path}/Partial'
+    end
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{path}/Rendering'
+    end
+  end unless NewRelic::Control.instance['disable_view_instrumentation']
+  
+  ActionController::Base.class_eval do
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    
+    # Compare with #alias_method_chain, which is not available in 
+    # Rails 1.1:
+    alias_method :perform_action_without_newrelic_trace, :perform_action
+    alias_method :perform_action, :perform_action_with_newrelic_trace
+    private :perform_action
+    
+    def self.newrelic_write_attr(attr_name, value) # :nodoc:
+      write_inheritable_attribute(attr_name, value)
+    end
+    
+    def self.newrelic_read_attr(attr_name) # :nodoc:
+      read_inheritable_attribute(attr_name)
+    end
+    
+    # determine the path that is used in the metric name for
+    # the called controller action
+    def newrelic_metric_path(action_name_override = nil)
+      action_part = action_name_override || action_name
+      if action_name_override || self.class.action_methods.include?(action_part)
+        "#{self.class.controller_path}/#{action_part}"
+      else
+        "#{self.class.controller_path}/(other)"
+      end
+    end
+  end  
+else
+  NewRelic::Agent.instance.log.debug "WARNING: ActionController instrumentation not added"
+end