techarch-newrelic_rpm 2.10.2

data/lib/new_relic/agent/chained_call.rb

@@ -0,0 +1,13 @@
+# This is used to allow obfuscators to be chained.  
+
+class NewRelic::ChainedCall
+  def initialize(block1, block2)
+    @block1 = block1
+    @block2 = block2
+  end
+  
+  def call(sql)
+    sql = @block1.call(sql)
+    @block2.call(sql)
+  end
+end

data/lib/new_relic/agent/collection_helper.rb

@@ -0,0 +1,66 @@
+module NewRelic::Agent::CollectionHelper
+  # Transform parameter hash into a hash whose values are strictly
+  # strings
+  def normalize_params(params)
+    case params
+      when Symbol, FalseClass, TrueClass, nil
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(params)
+      when Hash
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),32)] = normalize_params(value)
+        end
+        new_params
+      when Array
+        params.first(20).map{|item| normalize_params(item)}
+    else
+      truncate(flatten(params))
+    end
+  end
+  
+  # Return an array of strings (backtrace), cleaned up for readability
+  # Return nil if there is no backtrace
+  
+  def strip_nr_from_backtrace(backtrace)
+    if backtrace
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
+      # strip newrelic from the trace
+      backtrace = backtrace.reject {|line| line =~ /new_relic\/agent\// }
+      # rename methods back to their original state
+      backtrace = backtrace.collect {|line| line.gsub(/_without_(newrelic|trace)/, "")}
+    end
+    backtrace
+  end
+  
+  private
+  
+  # Convert any kind of object to a short string.
+  def flatten(object)
+    s = case object 
+      when nil then ''
+      when object.instance_of?(String) then object
+      when String then String.new(object)  # convert string subclasses to strings
+      else "#<#{object.class.to_s}>"
+    end
+  end
+  def truncate(string, len=256)
+    case string
+    when Symbol then string
+    when nil then ""
+    when String
+      real_string = flatten(string)
+      if real_string.size > len
+        real_string = real_string.slice(0...len)
+        real_string << "..."
+      end
+      real_string
+    else
+      truncate(flatten(string), len)     
+    end
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,121 @@
+
+module NewRelic::Agent
+  class ErrorCollector
+    include CollectionHelper
+    
+    # Defined the methods that need to be stubbed out when the
+    # agent is disabled
+    module Shim #:nodoc:
+      def notice_error(*args); end
+    end
+    
+    MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
+    
+    attr_accessor :enabled
+    
+    def initialize(agent = nil)
+      @agent = agent
+      @errors = []
+      # lookup of exception class names to ignore.  Hash for fast access
+      @ignore = {}
+      @ignore_filter = nil
+
+      config = NewRelic::Control.instance.fetch('error_collector', {})
+      
+      @enabled = config.fetch('enabled', true)
+      @capture_source = config.fetch('capture_source', true)
+      
+      ignore_errors = config.fetch('ignore_errors', "")
+      ignore_errors = ignore_errors.split(",")
+      ignore_errors.each { |error| error.strip! } 
+      ignore(ignore_errors)
+      @lock = Mutex.new
+    end
+    
+    def ignore_error_filter(&block)
+      @ignore_filter = block
+    end
+    
+    
+    # errors is an array of Exception Class Names
+    #
+    def ignore(errors)
+      errors.each { |error| @ignore[error] = true; log.debug("Ignoring error: '#{error}'") }
+    end
+    
+    def notice_error(exception, request=nil, action_path=nil, filtered_params={})
+      return unless @enabled
+      return if @ignore[exception.class.name] 
+      if @ignore_filter
+        exception = @ignore_filter.call(exception)
+        return if exception.nil?
+      end
+      
+      error_stat.increment_count
+      
+      data = {}
+      
+      action_path ||= ''
+      
+      data[:request_params] = normalize_params(filtered_params) if NewRelic::Control.instance.capture_params
+
+      data[:custom_params] = normalize_params(@agent.custom_params) if @agent
+      
+      data[:request_uri] = request.path if request
+      data[:request_uri] ||= ""
+      
+      data[:request_referer] = request.referer if request
+      data[:request_referer] ||= ""
+      
+      data[:rails_root] = NewRelic::Control.instance.root
+      
+      data[:file_name] = exception.file_name if exception.respond_to?('file_name')
+      data[:line_number] = exception.line_number if exception.respond_to?('line_number')
+      
+      if @capture_source && exception.respond_to?('source_extract')
+        data[:source] = exception.source_extract
+      end
+      
+      if exception.respond_to? 'original_exception'
+        inside_exception = exception.original_exception
+      else
+        inside_exception = exception
+      end
+
+      data[:stack_trace] = inside_exception ? inside_exception.backtrace : '<no stack trace>'
+      
+      noticed_error = NewRelic::NoticedError.new(action_path, data, exception)
+      
+      @lock.synchronize do
+        if @errors.length >= MAX_ERROR_QUEUE_LENGTH
+          log.info("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. This error will not be reported to RPM: #{exception.message}")
+        else
+          @errors << noticed_error
+        end
+      end
+    end
+    
+    # Get the errors currently queued up.  Unsent errors are left 
+    # over from a previous unsuccessful attempt to send them to the server.
+    # We first clear out all unsent errors before sending the newly queued errors.
+    def harvest_errors(unsent_errors)
+      if unsent_errors && !unsent_errors.empty?
+        return unsent_errors
+      else
+        @lock.synchronize do
+          errors = @errors
+          @errors = []
+          return errors
+        end
+      end
+    end
+    
+    private
+    def error_stat
+      @error_stat ||= NewRelic::Agent.get_stats("Errors/all")
+    end
+    def log
+      NewRelic::Control.instance.log
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# ActiveMerchant Instrumentation.
+
+if defined? ActiveMerchant
+
+  ActiveMerchant::Billing::Gateway.implementations.each do |gateway|
+    gateway.class_eval do
+      implemented_methods = public_instance_methods(false)
+      gateway_name = self.name.split('::').last
+      [:authorize, :purchase, :credit, :void, :capture, :recurring].each do |operation|
+        if implemented_methods.include?(operation.to_s)
+          add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}", :scoped_metric_only => true
+          add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
+          add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+
+# NewRelic instrumentation for ActiveRecord
+if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrumentation']
+
+  module NewRelic
+    module Agent
+      module Instrumentation
+        module ActiveRecordInstrumentation
+          
+          def self.included(instrumented_class)
+            instrumented_class.class_eval do
+              alias_method :log_without_newrelic_instrumentation, :log
+              alias_method :log, :log_with_newrelic_instrumentation
+              protected :log
+            end
+          end
+          
+          def log_with_newrelic_instrumentation(sql, name, &block)
+            
+            return log_without_newrelic_instrumentation(sql, name, &block) unless NewRelic::Agent.is_execution_traced?
+            
+            # Capture db config if we are going to try to get the explain plans
+            if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
+                (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
+              supported_config = @config
+            end
+            if name && (parts = name.split " ") && parts.size == 2
+              model = parts.first
+              operation = parts.last.downcase
+              metric_name = case operation
+                            when 'load' then 'find'
+                            when 'indexes', 'columns' then nil # fall back to DirectSQL
+                            when 'destroy', 'find', 'save', 'create' then operation
+                            when 'update' then 'save'
+                            else
+                              if model == 'Join'
+                                operation
+                              end
+                            end
+              metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+            end
+            
+            if metric.nil?
+              if sql =~ /^(select|update|insert|delete|show)/i
+                # Could not determine the model/operation so let's find a better
+                # metric.  If it doesn't match the regex, it's probably a show
+                # command or some DDL which we'll ignore.
+                metric = "Database/SQL/#{$1.downcase}"
+              else
+                metric = "Database/SQL/other"
+              end
+            end
+            
+            if !metric
+              log_without_newrelic_instrumentation(sql, name, &block)
+            else
+              metrics = [metric, "ActiveRecord/all"]
+              metrics << "ActiveRecord/#{metric_name}" if metric_name
+              self.class.trace_execution_scoped(metrics) do
+                t0 = Time.now.to_f
+                begin
+                  log_without_newrelic_instrumentation(sql, name, &block) 
+                ensure
+                  NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, Time.now.to_f - t0) 
+                end
+              end
+            end
+          end
+          
+        end
+        
+        # instrumentation to catch logged SQL statements in sampled transactions
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+          include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
+        end
+        
+        # This instrumentation will add an extra scope to the transaction traces
+        # which will show the code surrounding the query, inside the model find_by_sql
+        # method.
+        ActiveRecord::Base.class_eval do
+          class << self
+            add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
+          end
+        end unless NewRelic::Control.instance['disable_activerecord_instrumentation']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+if defined? Authlogic::Session::Base
+  Authlogic::Session::Base.class_eval do
+  #  add_method_tracer :record, 'Authlogic/record'
+    class << self
+      add_method_tracer :find, 'Authlogic/find'
+    end
+  end
+end

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

@@ -0,0 +1,437 @@
+
+module NewRelic::Agent::Instrumentation
+  # == NewRelic instrumentation for controllers
+  #
+  # This instrumentation is applied to the action controller by default if the agent
+  # is actively collecting statistics.  It will collect statistics for the 
+  # given action.
+  #
+  # In cases where you don't want to instrument the top level action, but instead
+  # have other methods which are dispatched to by your action, and you want to treat
+  # these as distinct actions, then what you need to do is use
+  # #perform_action_with_newrelic_trace
+  #
+  module ControllerInstrumentation
+    
+    if defined? JRuby
+      @@newrelic_java_classes_missing = false
+      begin
+        require 'java'
+        include_class 'java.lang.management.ManagementFactory'
+        include_class 'com.sun.management.OperatingSystemMXBean'
+      rescue
+        @@newrelic_java_classes_missing = true
+      end
+    end
+    
+    def self.included(clazz) # :nodoc:
+      clazz.extend(ClassMethods)
+    end
+    
+    # This module is for importing stubs when the agent is disabled
+    module ClassMethodsShim # :nodoc:
+      def newrelic_ignore(*args); end
+      def newrelic_ignore_apdex(*args); end
+    end
+    
+    module Shim # :nodoc:
+      def self.included(clazz)
+        clazz.extend(ClassMethodsShim)
+      end
+      def newrelic_notice_error(*args); end
+      def new_relic_trace_controller_action(*args); yield; end
+      def newrelic_metric_path; end
+      def perform_action_with_newrelic_trace(*args); yield; end
+    end
+    
+    module ClassMethods
+      # Have NewRelic ignore actions in this controller.  Specify the actions as hash options
+      # using :except and :only.  If no actions are specified, all actions are ignored.
+      def newrelic_ignore(specifiers={})
+        newrelic_ignore_aspect('do_not_trace', specifiers)
+      end
+      # Have NewRelic omit apdex measurements on the given actions.  Typically used for 
+      # actions that are not user facing or that skew your overall apdex measurement.
+      # Accepts :except and :only options, as with #newrelic_ignore.
+      def newrelic_ignore_apdex(specifiers={})
+        newrelic_ignore_aspect('ignore_apdex', specifiers)
+      end
+      
+      def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
+        if specifiers.empty?
+          self.newrelic_write_attr property, true
+        elsif ! (Hash === specifiers)
+          logger.error "newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
+        else
+          self.newrelic_write_attr property, specifiers
+        end
+      end
+      
+      # Should be monkey patched into the controller class implemented
+      # with the inheritable attribute mechanism.
+      def newrelic_write_attr(attr_name, value) # :nodoc:
+        instance_variable_set "@#{attr_name}", value
+      end
+      def newrelic_read_attr(attr_name) # :nodoc:
+        instance_variable_get "@#{attr_name}"
+      end
+      
+      # Add transaction tracing to the given method.  This will treat
+      # the given method as a main entrypoint for instrumentation, just
+      # like controller actions are treated by default.  Useful especially
+      # for background tasks. 
+      #
+      # Example for background job:
+      #   class Job
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def run(task)
+      #        ...
+      #     end
+      #     # Instrument run so tasks show up under task.name.  Note single
+      #     # quoting to defer eval to runtime.
+      #     add_transaction_tracer :run, :name => '#{args[0].name}'
+      #   end
+      #
+      # Here's an example of a controller that uses a dispatcher
+      # action to invoke operations which you want treated as top
+      # level actions, so they aren't all lumped into the invoker
+      # action.
+      #      
+      #   MyController < ActionController::Base
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     # dispatch the given op to the method given by the service parameter.
+      #     def invoke_operation
+      #       op = params['operation']
+      #       send op
+      #     end
+      #     # Ignore the invoker to avoid double counting
+      #     newrelic_ignore :only => 'invoke_operation'
+      #     # Instrument the operations:
+      #     add_transaction_tracer :print
+      #     add_transaction_tracer :show
+      #     add_transaction_tracer :forward
+      #   end
+      #
+      # Here's an example of how to pass contextual information into the transaction
+      # so it will appear in transaction traces:
+      #
+      #   class Job
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def process(account)
+      #        ...
+      #     end
+      #     # Include the account name in the transaction details.  Note the single
+      #     # quotes to defer eval until call time.
+      #     add_transaction_tracer :process, :params => '{ :account_name => args[0].name }'
+      #   end
+      #
+      # See NewRelic::Agent::Instrumentation::ControllerInstrumentation#perform_action_with_newrelic_trace
+      # for the full list of available options.
+      #
+      def add_transaction_tracer(method, options={})
+        # The metric path:
+        options[:name] ||= method.to_s
+        # create the argument list:
+        options_arg = []
+        options.each do |key, value|
+          valuestr = case
+            when value.is_a?(Symbol)
+              value.inspect
+            when key == :params
+              value.to_s
+            else
+              %Q["#{value.to_s}"]
+          end
+          options_arg << %Q[:#{key} => #{valuestr}]
+        end
+        class_eval <<-EOC
+        def #{method.to_s}_with_newrelic_transaction_trace(*args, &block)
+          NewRelic::Agent::Instrumentation::DispatcherInstrumentation.newrelic_dispatcher_start
+          perform_action_with_newrelic_trace(#{options_arg.join(',')}) do
+            #{method.to_s}_without_newrelic_transaction_trace(*args, &block)
+          end
+        ensure
+          NewRelic::Agent::Instrumentation::DispatcherInstrumentation.newrelic_dispatcher_finish
+        end
+        EOC
+        alias_method "#{method.to_s}_without_newrelic_transaction_trace", method.to_s
+        alias_method method.to_s, "#{method.to_s}_with_newrelic_transaction_trace"
+      end
+    end
+    
+    # Must be implemented in the controller class:
+    # Determine the path that is used in the metric name for
+    # the called controller action.  Of the form controller_path/action_name
+    # 
+    def newrelic_metric_path(action_name_override = nil) # :nodoc:
+      raise "Not implemented!"
+    end
+    
+    # Yield to the given block with NewRelic tracing.  Used by 
+    # default instrumentation on controller actions in Rails and Merb.
+    # But it can also be used in custom instrumentation of controller
+    # methods and background tasks.
+    #
+    # Here's a more verbose version of the example shown in
+    # <tt>ClassMethods#add_transaction_tracer</tt> using this method instead of
+    # #add_transaction_tracer.
+    #
+    # Below is a controller with an +invoke_operation+ action which
+    # dispatches to more specific operation methods based on a
+    # parameter (very dangerous, btw!).  With this instrumentation,
+    # the +invoke_operation+ action is ignored but the operation
+    # methods show up in RPM as if they were first class controller
+    # actions
+    #    
+    #   MyController < ActionController::Base
+    #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    #     # dispatch the given op to the method given by the service parameter.
+    #     def invoke_operation
+    #       op = params['operation']
+    #       perform_action_with_newrelic_trace(:name => op) do
+    #         send op, params['message']
+    #       end
+    #     end
+    #     # Ignore the invoker to avoid double counting
+    #     newrelic_ignore :only => 'invoke_operation'
+    #   end
+    #
+    # By passing a block in combination with specific arguments, you can 
+    # invoke this directly to capture high level information in
+    # several contexts:
+    #
+    # * Pass <tt>:category => :controller</tt> and <tt>:name => actionname</tt>
+    #   to treat the block as if it were a controller action, invoked
+    #   inside a real action.  <tt>:name</tt> is the name of the method, and is
+    #   used in the metric name.
+    #
+    # When invoked directly, pass in a block to measure with some
+    # combination of options:
+    #
+    # * <tt>:category => :controller</tt> indicates that this is a
+    #   controller action and will appear with all the other actions.  This
+    #   is the default.
+    # * <tt>:category => :task</tt> indicates that this is a
+    #   background task and will show up in RPM with other background
+    #   tasks instead of in the controllers list
+    # * <tt>:category => :rack</tt> if you are instrumenting a rack
+    #   middleware call.  The <tt>:name</tt> is optional, useful if you 
+    #   have more than one potential transaction in the #call.
+    # * <tt>:category => :uri</tt> indicates that this is a
+    #   web transaction whose name is a normalized URI, where  'normalized'
+    #   means the URI does not have any elements with data in them such
+    #   as in many REST URIs.
+    # * <tt>:params => {...}</tt> to provide information about the context
+    #   of the call, used in transaction trace display, for example:
+    #   <tt>:params => { :account => @account.name, :file => file.name }</tt>
+    # * <tt>:name => action_name</tt> is used to specify the action
+    #   name used as part of the metric name
+    # * <tt>:force => true</tt> indicates you should capture all
+    #   metrics even if the #newrelic_ignore directive was specified
+    # * <tt>:class_name => aClass.name</tt> is used to override the name
+    #   of the class when used inside the metric name.  Default is the
+    #   current class.
+    # * <tt>:path => metric_path</tt> is *deprecated* in the public API.  It
+    #   allows you to set the entire metric after the category part.  Overrides
+    #   all the other options.
+    #
+    # If a single argument is passed in, it is treated as a metric
+    # path.  This form is deprecated.
+    def perform_action_with_newrelic_trace(*args, &block)
+
+      # Skip instrumentation based on the value of 'do_not_trace' and if 
+      # we aren't calling directly with a block.
+      if !block_given? && _is_filtered?('do_not_trace')
+        # Tell the dispatcher instrumentation that we ignored this action and it shouldn't
+        # be counted for the overall HTTP operations measurement.
+        Thread.current[:newrelic_ignore_controller] = true
+        # Also ignore all instrumentation in the call sequence
+        NewRelic::Agent.disable_all_tracing do
+          return perform_action_without_newrelic_trace(*args)
+        end
+      end
+      agent = NewRelic::Agent.instance
+      stats_engine = agent.stats_engine
+      
+      # reset this in case we came through a code path where the top level controller is ignored
+      Thread.current[:newrelic_ignore_controller] = nil
+      apdex_start = (Thread.current[:started_on] || Thread.current[:newrelic_dispatcher_start] || Time.now).to_f
+      force = false
+      # If a block was passed in, then the arguments represent options for the instrumentation,
+      # not app method arguments.
+      if block_given? && args.any?
+        force = args.last.is_a?(Hash) && args.last[:force]
+        category, path, available_params = _convert_args_to_path(args)
+      else
+        category = 'Controller'
+        path = newrelic_metric_path
+        available_params = self.respond_to?(:params) ? self.params : {} 
+      end
+      metric_name = category + '/' + path 
+
+      return perform_action_with_newrelic_profile(metric_name, path, args, &block) if NewRelic::Control.instance.profiling?
+
+      filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
+
+      agent.ensure_worker_thread_started
+      
+      NewRelic::Agent.trace_execution_scoped [metric_name, "Controller"], :force => force do
+        # Last one (innermost) to set the transaction name on the call stack wins.
+        stats_engine.transaction_name = metric_name
+        available_request = (respond_to? :request) ? request : nil
+        agent.transaction_sampler.notice_transaction(path, available_request, filtered_params)
+        
+        jruby_cpu_start = _jruby_cpu_time
+        process_cpu_start = _process_cpu
+        failed = false
+        
+        begin
+          # run the action
+          if block_given?
+            yield
+          else
+            perform_action_without_newrelic_trace(*args)
+          end
+        rescue Exception => e
+          NewRelic::Agent.instance.error_collector.notice_error(e, nil, metric_name, filtered_params)
+          failed = true
+          raise e
+        ensure
+          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
+              stats_engine.get_stats_no_scope(NewRelic::Metrics::USER_TIME).record_data_point(cpu_burn)
+            end
+            agent.transaction_sampler.notice_transaction_cpu_time(cpu_burn) if cpu_burn
+            
+            # do the apdex bucketing
+            #
+            unless _is_filtered?('ignore_apdex')
+              ending = Time.now.to_f
+              # this uses the start of the dispatcher or the mongrel
+              # thread: causes apdex to show too little capacity
+              apdex_overall(apdex_start, ending, failed)
+              # this uses the start time of the controller action:
+              # does not include capacity problems since those aren't
+              # per controller
+              apdex_controller(apdex_start, ending, failed, path)
+            end
+          end
+        end
+      end
+    end
+    
+    # Experimental
+    def perform_action_with_newrelic_profile(metric_name, path, args)
+      agent = NewRelic::Agent.instance
+      stats_engine = agent.stats_engine
+      NewRelic::Agent.trace_execution_scoped [metric_name, "Controller"] do
+        stats_engine.transaction_name = metric_name
+        NewRelic::Agent.disable_all_tracing do
+          available_params = self.respond_to?(:params) ? params : {} 
+          # Not sure if we need to get the params and request...
+          filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
+          available_request = (respond_to? :request) ? request : nil
+          agent.transaction_sampler.notice_transaction(path, available_request, filtered_params)
+
+          # turn on profiling
+          profile = RubyProf.profile do
+            if block_given?
+              yield
+            else
+              perform_action_without_newrelic_trace(*args)
+            end
+          end
+          agent.transaction_sampler.notice_profile profile
+        end
+      end
+    end
+    
+  private
+  
+    def apdex_overall_stat
+      NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)  
+    end
+    
+    def apdex_overall(start, ending, failed)
+      record_apdex(apdex_overall_stat, (ending - start), failed)
+    end
+    
+    def apdex_controller(start, ending, failed, path)
+      controller_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+      record_apdex(controller_stat, (ending - start), failed)
+    end
+    
+    def record_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
+    
+    protected
+    
+    def _convert_args_to_path(args)
+      options =  args.last.is_a?(Hash) ? args.pop : {}
+      category = 'Controller'
+      params = options[:params] || {}
+      unless path = options[:path]
+        category = case options[:category]
+          when :controller, nil then 'Controller'
+          when :task then 'OtherTransaction/Background' # 'Task'
+          when :rack then 'Controller/Rack' #'WebTransaction/Rack'
+          when :uri then 'Controller' #'WebTransaction/Uri'
+          # for internal use only
+          when :sinatra then 'Controller/Sinatra' #'WebTransaction/Uri'
+        else options[:category].to_s.capitalize
+        end
+        # To be consistent with the ActionController::Base#controller_path used in rails to determine the
+        # metric path, we drop the controller off the end of the path if there is one.
+        action = options[:name] || args.first 
+        force = options[:force]
+        metric_class = options[:class_name] || (self.is_a?(Class) ? self.name : self.class.name)
+        
+        path = metric_class
+        path += ('/' + action) if action
+      end
+      [category, path, params]
+    end
+    # Filter out 
+    def _is_filtered?(key)
+      ignore_actions = self.class.newrelic_read_attr(key) if self.class.respond_to? :newrelic_read_attr
+      case ignore_actions
+        when nil; false
+        when Hash
+        only_actions = Array(ignore_actions[:only])
+        except_actions = Array(ignore_actions[:except])
+        only_actions.include?(action_name.to_sym) || (except_actions.any? && !except_actions.include?(action_name.to_sym))
+      else
+        true
+      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 defined? JRuby and not @@newrelic_java_classes_missing 
+      threadMBean = ManagementFactory.getThreadMXBean()
+      java_utime = threadMBean.getCurrentThreadUserTime()  # ns
+      -1 == java_utime ? 0.0 : java_utime/1e9
+    end
+        
+  end 
+end