wd_newrelic_rpm 3.3.4.1

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

@@ -0,0 +1,238 @@
+## NewRelic instrumentation for DataMapper
+#
+# Instrumenting DM has different key challenges versus AR:
+#
+#   1. The hooking of SQL logging in DM is decoupled from any knowledge of the
+#      Model#method that invoked it.  But on the positive side, the duration is
+#      already calculated for you (and it happens inside the C-based DO code, so
+#      it's faster than a Ruby equivalent).
+#
+#   2. There are a lot more entry points that need to be hooked in order to
+#      understand call flow: DM::Model (model class) vs. DM::Resource (model
+#      instance) vs. DM::Collection (collection of model instances).  And
+#      others.
+#
+#   3. Strategic Eager Loading (SEL) combined with separately-grouped
+#      lazy-loaded attributes presents a unique problem for tying resulting
+#      SEL-invoked SQL calls to their proper scope.
+#
+# NOTE: On using "Database" versus "ActiveRecord" as base metric name
+#
+#   Using "Database" as the metric name base seems to properly identify methods
+#   as being DB-related in call graphs, but certain New Relic views that show
+#   aggregations of DB CPM, etc still seem to rely solely on "ActiveRecord"
+#   being the base name, thus AFAICT "Database" calls to this are lost.  (Though
+#   I haven't yet tested "Database/SQL/{find/save/destroy/all}" yet, as it seems
+#   like an intuitively good name to use.)
+#
+#   So far I think these are the rules:
+#
+#     - ActiveRecord/{find/save/destroy} populates "Database Throughput" and
+#       "Database Response Time" in the Database tab. [non-scoped]
+#
+#     - ActiveRecord/all populates the main Overview tab of DB time.  (still
+#       unsure about this one). [non-scoped]
+#
+#     These metrics are represented as :push_scope => false or included as the
+#     non-first metric in trace_execution_scoped() (docs say only first counts
+#     towards scope) so they don't show up ine normal call graph/trace.
+
+DependencyDetection.defer do
+  @name = :data_mapper
+  
+  depends_on do
+    defined?(::DataMapper)
+  end
+
+  depends_on do
+    defined?(DataMapper::Model)
+  end
+
+  depends_on do
+    defined?(DataMapper::Resource)
+  end
+
+  depends_on do
+    defined?(DataMapper::Collection)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing DataMapper instrumentation'
+  end
+  
+  executes do
+    DataMapper::Model.class_eval do
+      add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
+      add_method_tracer :first,    'ActiveRecord/#{self.name}/first'
+      add_method_tracer :last,     'ActiveRecord/#{self.name}/last'
+      add_method_tracer :all,      'ActiveRecord/#{self.name}/all'
+
+      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+      add_method_tracer :create!,  'ActiveRecord/#{self.name}/create'
+      add_method_tracer :update,   'ActiveRecord/#{self.name}/update'
+      add_method_tracer :update!,  'ActiveRecord/#{self.name}/update'
+      add_method_tracer :destroy,  'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :destroy!, 'ActiveRecord/#{self.name}/destroy'
+
+      # For dm-aggregates and partial dm-ar-finders support:
+      for method in [ :aggregate, :find, :find_by_sql ] do
+        next unless method_defined? method
+        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
+      end
+
+    end
+  end
+
+  executes do
+    DataMapper::Resource.class_eval do
+      add_method_tracer :update,   'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+      add_method_tracer :update!,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+      add_method_tracer :save,     'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer :save!,    'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer :destroy,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+      add_method_tracer :destroy!, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+
+    end
+  end
+
+  executes do
+    DataMapper::Collection.class_eval do
+      # DM's Collection instance methods
+      add_method_tracer :get,       'ActiveRecord/#{self.name}/get'
+      add_method_tracer :first,     'ActiveRecord/#{self.name}/first'
+      add_method_tracer :last,      'ActiveRecord/#{self.name}/last'
+      add_method_tracer :all,       'ActiveRecord/#{self.name}/all'
+
+      add_method_tracer :lazy_load, 'ActiveRecord/#{self.name}/lazy_load'
+
+      add_method_tracer :create,    'ActiveRecord/#{self.name}/create'
+      add_method_tracer :create!,   'ActiveRecord/#{self.name}/create'
+      add_method_tracer :update,    'ActiveRecord/#{self.name}/update'
+      add_method_tracer :update!,   'ActiveRecord/#{self.name}/update'
+      add_method_tracer :destroy,   'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :destroy!,  'ActiveRecord/#{self.name}/destroy'
+
+      # For dm-aggregates support:
+      for method in [ :aggregate ] do
+        next unless method_defined? method
+        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
+      end
+
+    end
+  end
+end
+
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Adapters) && defined?(DataMapper::Adapters::DataObjectsAdapter)
+  end
+
+  executes do
+
+    # Catch the two entry points into DM::Repository::Adapter that bypass CRUD
+    # (for when SQL is run directly).
+    DataMapper::Adapters::DataObjectsAdapter.class_eval do
+
+      add_method_tracer :select,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/select'
+      add_method_tracer :execute, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
+
+    end
+  end
+end
+
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Validations) && defined?(DataMapper::Validations::ClassMethods)
+  end
+
+  # DM::Validations overrides Model#create, but currently in a way that makes it
+  # impossible to instrument from one place.  I've got a patch pending inclusion
+  # to make it instrumentable by putting the create method inside ClassMethods.
+  # This will pick it up if/when that patch is accepted.
+  executes do
+    DataMapper::Validations::ClassMethods.class_eval do
+      next unless method_defined? :create
+      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+    end
+  end
+end
+
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Transaction)
+  end
+
+  # NOTE: DM::Transaction basically calls commit() twice, so as-is it will show
+  # up in traces twice -- second time subordinate to the first's scope.  Works
+  # well enough.
+  executes do
+    DataMapper::Transaction.module_eval do
+      add_method_tracer :commit, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/commit'
+    end
+  end
+end
+
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module DataMapperInstrumentation
+
+        def self.included(klass)
+          klass.class_eval do
+            alias_method :log_without_newrelic_instrumentation, :log
+            alias_method :log, :log_with_newrelic_instrumentation
+          end
+        end
+
+        # Unlike in AR, log is called in DM after the query actually ran,
+        # complete with metrics.  Since DO has already calculated the
+        # duration, there's nothing more to measure, so just record and log.
+        #
+        # We rely on the assumption that all possible entry points have been
+        # hooked with tracers, ensuring that notice_sql attaches this SQL to
+        # the proper call scope.
+        def log_with_newrelic_instrumentation(msg)
+          return unless NewRelic::Agent.is_execution_traced?
+          return unless operation = case msg.query
+                                    when /^\s*select/i          then 'find'
+                                    when /^\s*(update|insert)/i then 'save'
+                                    when /^\s*delete/i          then 'destroy'
+                                    else nil
+                                    end
+
+          # FYI: self.to_s will yield connection URI string.
+          duration = msg.duration / 1000000.0
+
+          # Attach SQL to current segment/scope.
+          NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
+
+          # Record query duration associated with each of the desired metrics.
+          metrics = [ "ActiveRecord/#{operation}", 'ActiveRecord/all' ]
+          metrics.each do |metric|
+            NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric).trace_call(duration)
+          end
+        ensure
+          log_without_newrelic_instrumentation(msg)
+        end
+
+      end # DataMapperInstrumentation
+    end # Instrumentation
+  end # Agent
+end # NewRelic
+
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(DataObjects) && defined?(DataObjects::Connection)
+  end
+
+  executes do
+    DataObjects::Connection.class_eval do
+      include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+DependencyDetection.defer do
+  @name = :delayed_job
+  
+  depends_on do
+    !NewRelic::Control.instance['disable_dj']
+  end
+
+  depends_on do
+    # double check because of old JRuby bug 
+    defined?(::Delayed) && defined?(::Delayed::Job) &&
+      Delayed::Job.method_defined?(:invoke_job)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation'
+  end
+  
+  executes do
+    Delayed::Job.class_eval do
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      if self.instance_methods.include?('name') || 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
+
+  executes do
+    Delayed::Job.instance_eval do
+      if self.respond_to?('after_fork')
+        if method_defined?(:after_fork)
+          def after_fork_with_newrelic
+            NewRelic::Agent.after_fork(:force_reconnect => true)
+            after_fork_without_newrelic
+          end
+
+          alias_method :after_fork_without_newrelic, :after_fork
+          alias_method :after_fork, :after_fork_with_newrelic
+        else
+          def after_fork
+            NewRelic::Agent.after_fork(:force_reconnect => true)
+            super
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,80 @@
+# 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)
+#     http://github.com/mperham/dalli (Gem: dalli)
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Memcache
+        module_function
+        def instrument_methods(the_class, method_names)
+          method_names.each do |method_name|
+            next unless the_class.method_defined? method_name.to_sym
+            the_class.class_eval <<-EOD
+              def #{method_name}_with_newrelic_trace(*args, &block)
+                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, &block)
+                  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      
+        end
+        def 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
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :memcache
+  
+  depends_on do
+    !NewRelic::Control.instance['disable_memcache_instrumentation']
+  end
+
+  depends_on do
+    defined?(::MemCache) || defined?(::Memcached) ||
+      defined?(::Dalli::Client) || defined?(::Spymemcached)
+  end
+    
+  executes do
+    commands = %w[get get_multi set add incr decr delete replace append prepend]
+    if defined? ::MemCache
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::MemCache,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing MemCache instrumentation'
+    end
+    if defined? ::Memcached
+      commands << 'cas'
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing Memcached instrumentation'
+    end
+    if defined? ::Dalli::Client
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing Dalli Memcache instrumentation'
+    end
+    if defined? ::Spymemcached
+      commands << 'multiget'
+      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Spymemcached,
+                                                                    commands)
+      NewRelic::Agent.logger.debug 'Installing Spymemcached instrumentation'
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'set'
+
+DependencyDetection.defer do
+  @name = :merb_controller
+  
+  depends_on do
+    defined?(Merb) && defined?(Merb::Controller)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Merb Controller instrumentation'
+  end
+  
+  executes do
+    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
+  end
+end

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

@@ -0,0 +1,29 @@
+DependencyDetection.defer do
+  @name = :merb_error
+
+  depends_on do
+    defined?(Merb) && defined?(Merb::Dispatcher) && defined?(Merb::Dispatcher::DefaultException)
+  end
+
+  depends_on do
+    Merb::Dispatcher::DefaultException.respond_to?(:before)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Merb Errors instrumentation'
+  end
+  
+  executes do
+
+    # 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
+
+  end
+end

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

@@ -0,0 +1,353 @@
+require 'new_relic/agent/instrumentation/metric_frame/pop'
+
+# 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
+        # helper module refactored out of the `pop` method
+        include Pop
+
+        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.
+          agent.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
+
+        def self.agent
+          NewRelic::Agent.instance
+        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 => 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
+          Thread.current[:last_metric_frame] = self
+        end
+
+        def agent
+          NewRelic::Agent.instance
+        end
+
+        def transaction_sampler
+          agent.transaction_sampler
+        end
+        
+        def sql_sampler
+          agent.sql_sampler
+        end
+
+        private :agent
+        private :transaction_sampler
+        private :sql_sampler        
+
+        # Indicate that we are entering a measured controller action or task.
+        # Make sure you unwind every push with a pop call.
+        def push(m)
+          transaction_sampler.notice_first_scope_push(start)
+          sql_sampler.notice_first_scope_push(start)
+          @path_stack.push NewRelic::MetricParser::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!
+          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
+          agent.stats_engine.start_transaction metric_name
+          # Only push the transaction context info once, on entry:
+          if @path_stack.size == 1
+            transaction_sampler.notice_transaction(metric_name, uri, filtered_params)
+            sql_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
+          log_underflow if metric.nil?
+          if @path_stack.empty?
+            handle_empty_path_stack(metric)
+          else
+            set_new_scope!(current_stack_metric)
+          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={})
+          request = options.delete(:request)
+          if request
+            options[:referer] = referer_from_request(request)
+            options[:uri] = uri_from_request(request)
+          end
+          if current
+            current.notice_error(e, options)
+          else
+            agent.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 = agent.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 self.set_user_attributes(attributes)
+          current.set_user_attributes(attributes) if current 
+        end
+
+        def self.user_attributes
+          (current) ? current.user_attributes : {}
+        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 user_attributes
+          @user_atrributes ||= {}
+        end
+        
+        def queue_time
+          apdex_start - start
+        end
+
+        def add_custom_parameters(p)
+          custom_parameters.merge!(p)
+        end
+        
+        def set_user_attributes(attributes)
+          user_attributes.merge!(attributes)
+        end
+
+        def self.recording_web_transaction?
+          c = Thread.current[:newrelic_metric_frame]
+          if c
+            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 = agent.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
+          controller_stat = agent.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