factorylabs-newrelic_rpm 2.10.2.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/delayed_job_instrumentation.rb

@@ -0,0 +1,12 @@
+if defined?(Delayed::Job)
+  Delayed::Job.class_eval do
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    
+    if self.instance_methods.include?('name')
+      add_transaction_tracer "invoke_job", :category => :task, :name => '#{self.name}'
+    else
+      add_transaction_tracer "invoke_job", :category => :task
+    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/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/metric_frame.rb

@@ -0,0 +1,199 @@
+# 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.
+#
+class NewRelic::Agent::Instrumentation::MetricFrame 
+  attr_accessor :start, :apdex_start, :exception, 
+                :filtered_params, :available_request, :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)
+    @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
+  
+  # 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, available_request, filtered_params)
+    end
+  end
+  
+  def category
+    @path_stack.last.first  
+  end
+  def path
+    @path_stack.last.last
+  end
+  
+  def pop
+    category, path = @path_stack.pop
+    if category.nil?
+      NewRelic::Control.instance.log.error "Underflow in metric frames: #{caller.join("\n   ")}"
+    end
+    # change the transaction name back to whatever was on the stack.  
+    if @path_stack.empty?
+      Thread.current[:newrelic_metric_frame] = nil
+      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)
+      end      
+    end
+    NewRelic::Agent.instance.stats_engine.scope_name = metric_name 
+  end
+  
+  # If we have an active metric frame, notice the error and increment the error metric.
+  def self.notice_error(e, custom_params={})
+    if current
+      current.notice_error(e, custom_params)
+    else
+      NewRelic::Agent.instance.error_collector.notice_error(e, nil, nil, custom_params)
+    end
+  end
+  
+  def notice_error(e, custom_params={})
+    if exception != e
+      NewRelic::Agent.instance.error_collector.notice_error(e, nil, metric_name, filtered_params.merge(custom_params))
+      self.exception = e
+    end
+  end
+  def record_apdex
+    return unless recording_web_transaction?
+    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 += ["Controller", "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
+  
+  private
+  
+  def recording_web_transaction?(cat = category)
+    0 == cat.index("Controller")
+  end
+  
+  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

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

@@ -0,0 +1,21 @@
+if defined? Net::HTTP
+  Net::HTTP.class_eval do
+    def request_with_newrelic_trace(*args, &block)
+      if Thread::current[:newrelic_scope_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,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
+      #
+      # 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, :params => {:uri => @newrelic_env['REQUEST_PATH']}) 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