newrelic_rpm 3.8.1.221 → 3.9.0.229

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

@@ -26,7 +26,7 @@ DependencyDetection.defer do
         gateway_name = self.name.split('::').last
         [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
           if implemented_methods.include?(operation)
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}", :scoped_metric_only => true
+            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}"
             add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
             add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
           end

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

@@ -26,8 +26,10 @@ module NewRelic
           end
         end
 
-        def log_with_newrelic_instrumentation(*args, &block)
-          if !NewRelic::Agent.is_execution_traced?
+        def log_with_newrelic_instrumentation(*args, &block) #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+
+          if !state.is_execution_traced?
             return log_without_newrelic_instrumentation(*args, &block)
           end
 
@@ -49,10 +51,10 @@ module NewRelic
 
                 NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
                                                       @config, elapsed_time,
-                                                                  &EXPLAINER)
+                                                      state, &EXPLAINER)
                 NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric,
                                                       @config, elapsed_time,
-                                                                  &EXPLAINER)
+                                                      state, &EXPLAINER)
               end
             end
           end

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

@@ -31,8 +31,9 @@ module NewRelic
           end
         end
 
-        def metric_for_sql(sql)
-          metric = NewRelic::Agent::Transaction.database_metric_name
+        def metric_for_sql(sql) #THREAD_LOCAL_ACCESS
+          txn = NewRelic::Agent::Transaction.tl_current
+          metric = txn && txn.database_metric_name
           if metric.nil?
             operation = NewRelic::Agent::Database.parse_operation_from_query(sql)
             if operation

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

@@ -11,18 +11,19 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActiveRecordSubscriber < EventedSubscriber
-        def start(name, id, payload)
-          return unless NewRelic::Agent.is_execution_traced?
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          return unless NewRelic::Agent.tl_is_execution_traced?
           super
         rescue => e
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload)
-          return unless NewRelic::Agent.is_execution_traced?
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+          return unless state.is_execution_traced?
           event = pop_event(id)
           record_metrics(event)
-          notice_sql(event)
+          notice_sql(state, event)
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -37,44 +38,41 @@ module NewRelic
           end
         end
 
-        def notice_sql(event)
+        def notice_sql(state, event)
+          stack  = state.traced_method_stack
           config = active_record_config_for_event(event)
           metric = base_metric(event)
 
           # enter transaction trace segment
-          frame = NewRelic::Agent::TracedMethodStack.push_frame(:active_record, event.time)
+          frame = stack.push_frame(state, :active_record, event.time)
 
           NewRelic::Agent.instance.transaction_sampler \
             .notice_sql(event.payload[:sql], config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        &method(:get_explain_plan))
+                        state, &method(:get_explain_plan))
 
           NewRelic::Agent.instance.sql_sampler \
             .notice_sql(event.payload[:sql], metric, config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        &method(:get_explain_plan))
+                        state, &method(:get_explain_plan))
 
           # exit transaction trace segment
-          NewRelic::Agent::TracedMethodStack.pop_frame(frame, metric, event.end)
+          stack.pop_frame(state, frame, metric, event.end)
         end
 
-        def record_metrics(event)
+        def record_metrics(event) #THREAD_LOCAL_ACCESS
           base = base_metric(event)
-          NewRelic::Agent.instance.stats_engine.record_metrics(base,
-                              Helper.milliseconds_to_seconds(event.duration),
-                              :scoped => true)
 
           other_metrics = ActiveRecordHelper.rollup_metrics_for(base)
-
           if config = active_record_config_for_event(event)
             other_metrics << ActiveRecordHelper.remote_service_metric(config[:adapter], config[:host])
           end
+          other_metrics.compact!
 
-          other_metrics.compact.each do |metric_name|
-            NewRelic::Agent.instance.stats_engine.record_metrics(metric_name,
-                                            Helper.milliseconds_to_seconds(event.duration),
-                                            :scoped => false)
-          end
+          NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+            base, other_metrics,
+            Helper.milliseconds_to_seconds(event.duration)
+          )
         end
 
         def base_metric(event)

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

@@ -45,6 +45,11 @@ module NewRelic
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
+        NR_DO_NOT_TRACE_KEY   = 'do_not_trace'.freeze unless defined?(NR_DO_NOT_TRACE_KEY)
+        NR_IGNORE_APDEX_KEY   = 'ignore_apdex'.freeze unless defined?(NR_IGNORE_APDEX_KEY)
+        NR_IGNORE_ENDUSER_KEY = 'ignore_enduser'.freeze unless defined?(NR_IGNORE_ENDUSER_KEY)
+        NR_DEFAULT_OPTIONS    = {}.freeze unless defined?(NR_DEFAULT_OPTIONS)
+
         # @api public
         module ClassMethods
           # Have NewRelic ignore actions in this controller.  Specify the actions as hash options
@@ -53,7 +58,7 @@ module NewRelic
           # @api public
           #
           def newrelic_ignore(specifiers={})
-            newrelic_ignore_aspect('do_not_trace', specifiers)
+            newrelic_ignore_aspect(NR_DO_NOT_TRACE_KEY, 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.
@@ -62,12 +67,12 @@ module NewRelic
           # @api public
           #
           def newrelic_ignore_apdex(specifiers={})
-            newrelic_ignore_aspect('ignore_apdex', specifiers)
+            newrelic_ignore_aspect(NR_IGNORE_APDEX_KEY, specifiers)
           end
 
           # @api public
           def newrelic_ignore_enduser(specifiers={})
-            newrelic_ignore_aspect('ignore_enduser', specifiers)
+            newrelic_ignore_aspect(NR_IGNORE_ENDUSER_KEY, specifiers)
           end
 
           def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
@@ -207,52 +212,47 @@ module NewRelic
         end
 
         class TransactionNamer
-          def self.category_name(type = nil)
-            type ||= Transaction.current && Transaction.current.type
-            case type
-            when :controller, nil then 'Controller'
-            when :task then 'OtherTransaction/Background'
-            when :rack then 'Controller/Rack'
-            when :uri then 'Controller'
-            when :sinatra then 'Controller/Sinatra'
-              # for internal use only
-            else type.to_s
-            end
+          def self.name(txn, traced_obj, category, options={})
+            "#{prefix_for_category(txn, category)}#{path_name(traced_obj, options)}"
           end
 
-          def initialize(traced_obj)
-            @traced_obj = traced_obj
-            if (@traced_obj.is_a?(Class) || @traced_obj.is_a?(Module))
-              @traced_class_name = @traced_obj.name
-            else
-              @traced_class_name = @traced_obj.class.name
+          def self.prefix_for_category(txn, category = nil)
+            category ||= (txn && txn.best_category)
+            case category
+            when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :task       then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :rack       then ::NewRelic::Agent::Transaction::RACK_PREFIX
+            when :uri        then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :sinatra    then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
+            when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
+            else "#{category.to_s}/" # for internal use only
             end
           end
 
-          def name(options={})
-            name = "#{self.class.category_name(options[:category])}/#{path_name(options)}"
-          end
+          def self.path_name(traced_obj, options={})
+            return options[:path] if options[:path]
 
-          def path_name(options={})
-            # if we have the path, use the path
-            path = options[:path]
-
-            class_name = options[:class_name] || @traced_class_name
-
-            # if we have an explicit action name option, use that
+            class_name = class_name(traced_obj, options)
             if options[:name]
-              path ||= [ class_name, options[:name] ].compact.join('/')
+              if class_name
+                "#{class_name}/#{options[:name]}"
+              else
+                options[:name]
+              end
+            elsif traced_obj.respond_to?(:newrelic_metric_path)
+              traced_obj.newrelic_metric_path
+            else
+              class_name
             end
+          end
 
-            # if newrelic_metric_path() is defined, use that
-            if @traced_obj.respond_to?(:newrelic_metric_path)
-              path ||= @traced_obj.newrelic_metric_path
+          def self.class_name(traced_obj, options={})
+            return options[:class_name] if options[:class_name]
+            if (traced_obj.is_a?(Class) || traced_obj.is_a?(Module))
+              traced_obj.name
+            else
+              traced_obj.class.name
             end
-
-            # fall back on just the traced class name
-            path ||= class_name
-
-            return path
           end
         end
 
@@ -298,7 +298,7 @@ module NewRelic
         # * <tt>:category => :task</tt> indicates that this is a
         #   background task and will show up in New Relic with other background
         #   tasks instead of in the controllers list
-        # * <tt>:category => :rack</tt> if you are instrumenting a rack
+        # * <tt>:category => :middleware</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
@@ -323,34 +323,41 @@ module NewRelic
         # * <tt>:request => Rack::Request#new(env)</tt> is used to pass in a
         #   request object that may respond to uri and referer.
         #
-        # If a single argument is passed in, it is treated as a metric
-        # path.  This form is deprecated.
-        #
         # @api public
         #
-        def perform_action_with_newrelic_trace(*args, &block)
-          NewRelic::Agent::TransactionState.request = newrelic_request(args)
+        def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+          state.request = newrelic_request(args)
 
           # Skip instrumentation based on the value of 'do_not_trace' and if
           # we aren't calling directly with a block.
           if !block_given? && do_not_trace?
-            # Also ignore all instrumentation in the call sequence
+            state.current_transaction.ignore! if state.current_transaction
             NewRelic::Agent.disable_all_tracing do
               return perform_action_without_newrelic_trace(*args)
             end
           end
 
+          return yield unless state.is_execution_traced?
+
           # If a block was passed in, then the arguments represent options for
           # the instrumentation, not app method arguments.
-          txn_options = create_transaction_options(block_given? ? args : [])
-          return yield unless NewRelic::Agent.is_execution_traced?
+          trace_options = NR_DEFAULT_OPTIONS
+
+          if block_given?
+            trace_options    = args.last if args.last.is_a?(Hash)
+            available_params = trace_options[:params]
+          else
+            available_params = respond_to?(:params) && params
+          end
 
-          txn_options[:transaction_name] = TransactionNamer.new(self).name(txn_options)
-          txn_options[:apdex_start_time] = detect_queue_start_time
+          category    = trace_options[:category] || :controller
+          txn_options = create_transaction_options(trace_options, available_params)
+          txn_options[:transaction_name] = TransactionNamer.name(nil, self, category, trace_options)
+          txn_options[:apdex_start_time] = detect_queue_start_time(state)
 
           begin
-            txn = Transaction.start(txn_options[:category], txn_options)
-            _record_queue_length
+            txn = Transaction.start(state, category, txn_options)
 
             begin
               if block_given?
@@ -364,9 +371,11 @@ module NewRelic
             end
 
           ensure
-            Transaction.stop(Time.now,
-                             :ignore_apdex   => ignore_apdex?,
-                             :ignore_enduser => ignore_enduser?)
+            if txn
+              txn.ignore_apdex!   if ignore_apdex?
+              txn.ignore_enduser! if ignore_enduser?
+            end
+            Transaction.stop(state)
           end
         end
 
@@ -377,10 +386,6 @@ module NewRelic
           # passed as a parameter to add_transaction_tracer
           if opts.respond_to?(:keys) && opts.respond_to?(:[]) && opts[:request]
             opts[:request]
-          # in a Rack app
-          elsif opts.respond_to?(:keys) && opts.respond_to?(:[]) &&
-              opts['rack.version']
-            Rack::Request.new(args)
           # in a Rails app
           elsif self.respond_to?(:request)
             self.request
@@ -390,8 +395,8 @@ module NewRelic
         # Should be implemented in the dispatcher class
         def newrelic_response_code; end
 
-        def newrelic_request_headers
-          request = NewRelic::Agent::TransactionState.get.request
+        def newrelic_request_headers(state)
+          request = state.request
           if request
             if request.respond_to?(:headers)
               request.headers
@@ -405,7 +410,7 @@ module NewRelic
         # or not - you may override this in your controller and supply
         # your own logic for ignoring transactions.
         def do_not_trace?
-          _is_filtered?('do_not_trace')
+          _is_filtered?(NR_DO_NOT_TRACE_KEY)
         end
 
         # overrideable method to determine whether to trace an action
@@ -413,29 +418,23 @@ module NewRelic
         # ignore things like api calls or other fast non-user-facing
         # actions
         def ignore_apdex?
-          _is_filtered?('ignore_apdex')
+          _is_filtered?(NR_IGNORE_APDEX_KEY)
         end
 
         def ignore_enduser?
-          _is_filtered?('ignore_enduser')
+          _is_filtered?(NR_IGNORE_ENDUSER_KEY)
         end
 
         private
 
-        def create_transaction_options(txn_args)
+        def create_transaction_options(trace_options, available_params)
           txn_options = {}
-          if txn_args.any?
-            if txn_args.last.is_a?(Hash)
-              txn_options = txn_args.pop
-            end
-            available_params = txn_options[:params] || {}
-            txn_options[:name] ||= txn_args.first
-          else
-            available_params = self.respond_to?(:params) ? self.params : {}
+          txn_options[:request] = trace_options[:request] || (respond_to?(:request) && request)
+
+          if available_params
+            txn_options[:filtered_params] = (respond_to?(:filter_parameters)) ? filter_parameters(available_params) : available_params
           end
 
-          txn_options[:request] ||= self.request if self.respond_to? :request
-          txn_options[:filtered_params] = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
           txn_options
         end
 
@@ -446,31 +445,18 @@ module NewRelic
           case ignore_actions
           when nil; false
           when Hash
-            only_actions = Array(ignore_actions[:only])
+            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
-        # Take a guess at a measure representing the number of requests waiting in mongrel
-        # or heroku.
-        def _record_queue_length
-          if newrelic_request_headers
-            if queue_depth = newrelic_request_headers['HTTP_X_HEROKU_QUEUE_DEPTH']
-              queue_depth = queue_depth.to_i rescue nil
-            elsif mongrel = NewRelic::Control.instance.local_env.mongrel
-              # Always subtrace 1 for the active mongrel
-              queue_depth = [mongrel.workers.list.length.to_i - 1, 0].max rescue nil
-            end
-            NewRelic::Agent.record_metric('Mongrel/Queue Length', queue_depth) if queue_depth
-          end
-        end
 
-        def detect_queue_start_time
-          if newrelic_request_headers
-            QueueTime.parse_frontend_timestamp(newrelic_request_headers)
-          end
+        def detect_queue_start_time(state)
+          headers = newrelic_request_headers(state)
+
+          QueueTime.parse_frontend_timestamp(headers) if headers
         end
       end
     end

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

@@ -92,9 +92,9 @@ DependencyDetection.defer do
       include NewRelic::Agent::MethodTracer
 
       # Add CAT with callbacks if the request is serial
-      def add_with_newrelic( curl )
-        if curl.respond_to?( :_nr_serial ) && curl._nr_serial
-          hook_pending_request( curl ) if NewRelic::Agent.is_execution_traced?
+      def add_with_newrelic(curl) #THREAD_LOCAL_ACCESS
+        if curl.respond_to?(:_nr_serial) && curl._nr_serial
+          hook_pending_request(curl) if NewRelic::Agent.tl_is_execution_traced?
         end
 
         return add_without_newrelic( curl )

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

@@ -191,8 +191,9 @@ module NewRelic
         # 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(msg)
-          return unless NewRelic::Agent.is_execution_traced?
+        def log(msg) #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+          return unless state.is_execution_traced?
           return unless operation = case NewRelic::Helper.correctly_encoded(msg.query)
                                     when /^\s*select/i          then 'find'
                                     when /^\s*(update|insert)/i then 'save'
@@ -204,13 +205,13 @@ module NewRelic
           duration = msg.duration / 1000000.0
 
           # Attach SQL to current segment/scope.
-          NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
+          NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration, state)
 
           # Record query duration associated with each of the desired metrics.
           metric = "ActiveRecord/#{operation}"
           rollup_metrics = ActiveRecordHelper.rollup_metrics_for(metric)
           metrics = [metric] + rollup_metrics
-          NewRelic::Agent.instance.stats_engine.record_metrics(metrics, duration)
+          NewRelic::Agent.instance.stats_engine.tl_record_unscoped_metrics(metrics, duration)
         ensure
           super
         end