honkster-newrelic_rpm 2.13.1

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

@@ -0,0 +1,58 @@
+
+# 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::Resource.class_eval do
+
+    @@my_sql_defined = defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+    @@postgres_defined = defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+
+    for method in [:query] do
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
+      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
+    end
+    for method in [:update, :save] do
+      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer method, 'ActiveRecord/save', :push_scope => false
+    end
+    add_method_tracer :destroy, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+    add_method_tracer :destroy, '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
+      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).to_f)
+
+      result
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
+unless NewRelic::Control.instance['disable_memcache_instrumentation']
+
+  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
+            t0 = Time.now
+            begin
+              #{method_name}_without_newrelic_trace(*args)
+            ensure
+              #{memcache_key_snippet(method_name)}
+            end
+          end
+        end
+        alias #{method_name}_without_newrelic_trace #{method_name}
+        alias #{method_name} #{method_name}_with_newrelic_trace
+    EOD
+      end
+
+      def self.memcache_key_snippet(method_name)
+        return "" unless NewRelic::Control.instance['capture_memcache_keys']
+        "NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil"
+      end
+
+
+
+  %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/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
+    "#{controller_name}/#{action_name}"
+  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,9 @@
+# Hook in the notification to merb
+error_notifier = Proc.new {
+  if request.exceptions #check that there's actually an exception
+    # 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
+Exceptions.before error_notifier

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

@@ -0,0 +1,319 @@
+# 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
+  module Agent
+    module Instrumentation
+      class MetricFrame
+        attr_accessor :start       # A Time instance for the start time, never nil
+        attr_accessor :apdex_start # A Time instance used for calculating the apdex score, which
+        # might end up being @start, or it might be further upstream if
+        # we can find a request header for the queue entry time
+        attr_accessor :exception,
+        :filtered_params, :force_flag,
+        :jruby_cpu_start, :process_cpu_start, :database_metric_name
+
+        # 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.
+        attr_accessor :request
+
+
+        @@check_server_connection = false
+        def self.check_server_connection=(value)
+          @@check_server_connection = value
+        end
+        # 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)
+          f = Thread.current[:newrelic_metric_frame]
+          return f if f || !create_if_empty
+
+          # Reconnect to the server if necessary.  This is only done
+          # for old versions of passenger that don't implement an explicit after_fork
+          # event.
+          NewRelic::Agent.instance.after_fork(:keep_retrying => false) if @@check_server_connection
+
+          Thread.current[:newrelic_metric_frame] = 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
+
+        def self.referer
+          current && current.referer
+        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
+          @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(m)
+          NewRelic::Agent.instance.transaction_sampler.notice_first_scope_push(start)
+          @path_stack.push NewRelic::MetricParser.for_metric_named(m)
+        end
+
+        # Indicate that you don't want to keep the currently saved transaction
+        # information
+        def self.abort_transaction!
+          current.abort_transaction! if current
+        end
+
+        # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
+        def 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
+          @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
+        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 current_metric
+          @path_stack.last
+        end
+
+        # Return the path, the part of the metric after the category
+        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
+          metric = @path_stack.pop
+          if metric.nil?
+            NewRelic::Agent.logger.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 - start).to_f) if metric.is_web_transaction?
+              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.
+        # 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, options)
+          else
+            NewRelic::Agent.instance.error_collector.notice_error(e, options)
+          end
+        end
+
+        # 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
+            result = NewRelic::Agent.instance.error_collector.notice_error(e, options)
+            self.exception = result if result
+          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?
+          t = Time.now
+          self.class.record_apdex(current_metric, t - start, t - apdex_start, !exception.nil?)
+        end
+
+        def metric_name
+          return nil if @path_stack.empty?
+          current_metric.name
+        end
+
+        # Return the array of metrics to record for the current metric frame.
+        def recorded_metrics
+          metrics = [ metric_name ]
+          metrics += current_metric.summary_metrics if @path_stack.size == 1
+          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?
+          current_metric && current_metric.is_web_transaction?
+        end
+
+        def is_web_transaction?(metric)
+          0 == metric.index("Controller")
+        end
+
+        # 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 self.record_apdex(current_metric, action_duration, total_duration, is_error)
+          summary_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
+          controller_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats(current_metric.apdex_metric_path, NewRelic::ApdexStats)
+          update_apdex(summary_stat, total_duration, is_error)
+          update_apdex(controller_stat, action_duration, is_error)
+        end
+
+        # Record an apdex value for the given stat.  when `failed`
+        # the apdex should be recorded as a failure regardless of duration.
+        def self.update_apdex(stat, duration, failed)
+          duration = duration.to_f
+          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
+
+        private
+
+        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
+  end
+end