newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -26,9 +26,11 @@ module NewRelic
             end
           end
 
-          def process_action(*args)
+          def process_action(*args) #THREAD_LOCAL_ACCESS
             # skip instrumentation if we are in an ignored action
             if _is_filtered?('do_not_trace')
+              txn = NewRelic::Agent::Transaction.tl_current
+              txn.ignore! if txn
               NewRelic::Agent.disable_all_tracing do
                 return super
               end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/instrumentation/middleware_proxy'
+
+DependencyDetection.defer do
+  named :rails_middleware
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= 3
+  end
+
+  depends_on do
+    !::NewRelic::Agent.config[:disable_middleware_instrumentation]
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info("Installing Rails 3+ middleware instrumentation")
+    module ActionDispatch
+      class MiddlewareStack
+        class Middleware
+          def build_with_new_relic(app)
+            # MiddlewareProxy.wrap guards against double-wrapping here.
+            # We need to instrument the innermost app (usually a RouteSet),
+            # which will never itself be the return value from #build, but will
+            # instead be the initial value of the app argument.
+            wrapped_app = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+            result = build_without_new_relic(wrapped_app)
+            ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(result)
+          end
+
+          alias_method :build_without_new_relic, :build
+          alias_method :build, :build_with_new_relic
+        end
+      end
+    end
+  end
+end

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

@@ -11,14 +11,14 @@ DependencyDetection.defer do
 
   executes do
     NewRelic::Agent.instance.events.subscribe(:start_transaction) do
-      if NewRelic::Agent.config[:'profiling.enabled']
+      if NewRelic::Rack::DeveloperMode.profiling_enabled?
         ::RubyProf.start
       end
     end
 
     NewRelic::Agent.instance.events.subscribe(:transaction_finished) do
-      if NewRelic::Agent.config[:'profiling.enabled']
-        trace = NewRelic::Agent::TransactionState.get.most_recent_transaction.transaction_trace
+      if NewRelic::Rack::DeveloperMode.profiling_enabled?
+        trace = NewRelic::Agent::Transaction.tl_current.transaction_trace
         trace.profile = ::RubyProf.stop
       end
     end

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

@@ -20,18 +20,41 @@ DependencyDetection.defer do
       # Client middleware has additional parameters, and our tests use the
       # middleware client-side to work inline.
       def call(worker, msg, queue, *_)
-        perform_action_with_newrelic_trace(
-          :name => 'perform',
-          :class_name => msg['class'],
-          :category => 'OtherTransaction/SidekiqJob') do
+        trace_args = if worker.respond_to?(:newrelic_trace_args)
+          worker.newrelic_trace_args(msg, queue)
+        else
+          self.class.default_trace_args(msg)
+        end
 
+        perform_action_with_newrelic_trace(trace_args) do
           if NewRelic::Agent.config[:'sidekiq.capture_params']
             NewRelic::Agent.add_custom_parameters(:job_arguments => msg['args'])
           end
-
           yield
         end
       end
+
+      def self.default_trace_args(msg)
+        {
+          :name => 'perform',
+          :class_name => msg['class'],
+          :category => 'OtherTransaction/SidekiqJob'
+        }
+      end
+    end
+
+    class Sidekiq::Extensions::DelayedClass
+      def newrelic_trace_args(msg, queue)
+        (target, method_name, args) = YAML.load(msg['args'][0])
+        {
+          :name => method_name,
+          :class_name => target.name,
+          :category => 'OtherTransaction/SidekiqJob'
+        }
+      rescue => e
+        NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+        NewRelic::SidekiqInstrumentation.default_trace_args(msg)
+      end
     end
 
     Sidekiq.configure_server do |config|

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

@@ -75,7 +75,7 @@ module NewRelic
         include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
         # Expected method for supporting ControllerInstrumentation
-        def newrelic_request_headers
+        def newrelic_request_headers(_)
           request.env
         end
 
@@ -136,12 +136,12 @@ module NewRelic
           route_eval_without_newrelic(*args, &block)
         end
 
-        def dispatch_with_newrelic
+        def dispatch_with_newrelic #THREAD_LOCAL_ACCESS
           if ignore_request?
             env['newrelic.ignored'] = true
+            txn = ::NewRelic::Agent::Transaction.tl_current
+            txn.ignore! if txn
             return dispatch_without_newrelic
-          elsif NewRelic::Agent::Transaction.current
-            return dispatch_and_notice_errors_with_newrelic
           end
 
           name = TransactionNamer.initial_transaction_name(request)

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

@@ -60,8 +60,8 @@ module NewRelic::Agent::Instrumentation::TyphoeusTracing
     request.respond_to?(:hydra) && request.hydra
   end
 
-  def self.trace(request)
-    if NewRelic::Agent.is_execution_traced? && !request_is_hydra_enabled?(request)
+  def self.trace(request) #THREAD_LOCAL_ACCESS
+    if NewRelic::Agent.tl_is_execution_traced? && !request_is_hydra_enabled?(request)
       wrapped_request = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
       t0, segment = ::NewRelic::Agent::CrossAppTracing.start_trace(wrapped_request)
       callback = Proc.new do
@@ -70,5 +70,7 @@ module NewRelic::Agent::Instrumentation::TyphoeusTracing
       end
       request.on_complete.unshift(callback)
     end
+  rescue => e
+    NewRelic::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
   end
 end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -35,11 +35,7 @@ module NewRelic
         @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:license_key], RUM_KEY_LENGTH)
       end
 
-      def current_transaction
-        NewRelic::Agent::TransactionState.get.most_recent_transaction
-      end
-
-      def insert_js?
+      def js_enabled_and_ready?
         if !enabled?
           ::NewRelic::Agent.logger.log_once(:debug, :js_agent_disabled,
                                             "JS agent instrumentation is disabled.")
@@ -56,16 +52,25 @@ module NewRelic
           ::NewRelic::Agent.logger.log_once(:debug, :missing_browser_key,
                                             "Browser key is not set. Skipping browser instrumentation.")
           false
-        elsif !current_transaction
+        else
+          true
+        end
+      rescue => e
+        ::NewRelic::Agent.logger.debug "Failure during 'js_enabled_and_ready?'", e
+        false
+      end
+
+      def insert_js?(state)
+        if !state.current_transaction
           ::NewRelic::Agent.logger.debug "Not in transaction. Skipping browser instrumentation."
           false
-        elsif !::NewRelic::Agent.is_transaction_traced?
+        elsif !state.is_transaction_traced?
           ::NewRelic::Agent.logger.debug "Transaction is not traced. Skipping browser instrumentation."
           false
-        elsif !::NewRelic::Agent.is_execution_traced?
+        elsif !state.is_execution_traced?
           ::NewRelic::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
           false
-        elsif ::NewRelic::Agent::TransactionState.get.request_ignore_enduser
+        elsif state.current_transaction.ignore_enduser?
           ::NewRelic::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
           false
         else
@@ -81,29 +86,31 @@ module NewRelic
         value.nil? || value.empty?
       end
 
-      def browser_timing_header
-        return "" unless insert_js?
-        bt_config = browser_timing_config
+      def browser_timing_header #THREAD_LOCAL_ACCESS
+        return '' unless js_enabled_and_ready? # fast exit
+
+        state = NewRelic::Agent::TransactionState.tl_get
+        return '' unless insert_js?(state) # slower exit
+
+        bt_config = browser_timing_config(state)
         return '' if bt_config.empty?
 
         bt_config + browser_timing_loader
       rescue => e
         ::NewRelic::Agent.logger.debug "Failure during RUM browser_timing_header construction", e
-        ""
+        ''
       end
 
-      # NOTE: Internal prototyping often overrides this, so leave name stable!
       def browser_timing_loader
         html_safe_if_needed("\n<script type=\"text/javascript\">#{Agent.config[:js_agent_loader]}</script>")
       end
 
-      # NOTE: Internal prototyping often overrides this, so leave name stable!
-      def browser_timing_config
-        txn = TransactionState.get.most_recent_transaction
+      def browser_timing_config(state)
+        txn = state.current_transaction
         return '' if txn.nil?
 
         txn.freeze_name_and_execute_if_not_ignored do
-          data = data_for_js_agent
+          data = data_for_js_agent(state)
           json = NewRelic::JSONWrapper.dump(data)
           return html_safe_if_needed("\n<script type=\"text/javascript\">window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
         end
@@ -125,8 +132,7 @@ module NewRelic
       SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
 
       # NOTE: Internal prototyping may override this, so leave name stable!
-      def data_for_js_agent
-        state = NewRelic::Agent::TransactionState.get
+      def data_for_js_agent(state)
         timings = state.timings
 
         data = {
@@ -143,7 +149,7 @@ module NewRelic
         }
 
         add_ssl_for_http(data)
-        add_user_attributes(data)
+        add_user_attributes(data, state.current_transaction)
 
         data
       end
@@ -155,10 +161,10 @@ module NewRelic
         end
       end
 
-      def add_user_attributes(data)
-        return unless include_custom_parameters?
+      def add_user_attributes(data, txn)
+        return unless include_custom_parameters?(txn)
 
-        params = event_params(current_transaction.custom_parameters)
+        params = event_params(txn.custom_parameters)
         json = NewRelic::JSONWrapper.dump(params)
         data[USER_ATTRIBUTES_KEY] = obfuscator.obfuscate(json)
       end
@@ -166,16 +172,14 @@ module NewRelic
       # Still support deprecated capture_attributes.page_view_events for
       # clients that use it. Could potentially be removed if we don't have
       # anymore users with it set according to zeitgeist.
-      def include_custom_parameters?
-        has_custom_parameters? &&
+      def include_custom_parameters?(txn)
+        has_custom_parameters?(txn) &&
           (NewRelic::Agent.config[:'browser_monitoring.capture_attributes'] ||
            NewRelic::Agent.config[:'capture_attributes.page_view_events'])
       end
 
-      def has_custom_parameters?
-        current_transaction &&
-          current_transaction.custom_parameters &&
-          !current_transaction.custom_parameters.empty?
+      def has_custom_parameters?(txn)
+        txn && txn.custom_parameters && !txn.custom_parameters.empty?
       end
 
       def html_safe_if_needed(string)

data/lib/new_relic/agent/memory_logger.rb

@@ -17,24 +17,24 @@ module NewRelic
 
       attr_accessor :messages, :level
 
-      def fatal(*msgs)
-        messages << [:fatal, msgs]
+      def fatal(*msgs, &blk)
+        messages << [:fatal, msgs, blk]
       end
 
-      def error(*msgs)
-        messages << [:error, msgs]
+      def error(*msgs, &blk)
+        messages << [:error, msgs, blk]
       end
 
-      def warn(*msgs)
-        messages << [:warn, msgs]
+      def warn(*msgs, &blk)
+        messages << [:warn, msgs, blk]
       end
 
-      def info(*msgs)
-        messages << [:info, msgs]
+      def info(*msgs, &blk)
+        messages << [:info, msgs, blk]
       end
 
-      def debug(*msgs)
-        messages << [:debug, msgs]
+      def debug(*msgs, &blk)
+        messages << [:debug, msgs, blk]
       end
 
       def log_exception(level, e, backtrace_level=level)
@@ -42,8 +42,8 @@ module NewRelic
       end
 
       def dump(logger)
-        messages.each do |(method, args)|
-          logger.send(method, *args)
+        messages.each do |(method, args, blk)|
+          logger.send(method, *args, &blk)
         end
         messages.clear
       end

data/lib/new_relic/agent/method_tracer.rb

@@ -72,14 +72,14 @@ module NewRelic
       #
       # @api public
       #
-      def trace_execution_unscoped(metric_names, options={})
-        return yield unless NewRelic::Agent.is_execution_traced?
+      def trace_execution_unscoped(metric_names, options={}) #THREAD_LOCAL_ACCESS
+        return yield unless NewRelic::Agent.tl_is_execution_traced?
         t0 = Time.now
         begin
           yield
         ensure
           duration = (Time.now - t0).to_f              # for some reason this is 3 usec faster than Time - Time
-          stat_engine.record_metrics(metric_names, duration)
+          stat_engine.tl_record_unscoped_metrics(metric_names, duration)
         end
       end
 
@@ -107,11 +107,6 @@ module NewRelic
           NewRelic::Agent.instance
         end
 
-        # Shorthand to return the status of tracing
-        def traced?
-          NewRelic::Agent.is_execution_traced?
-        end
-
         # Shorthand to return the current statistics engine
         def stat_engine
           agent_instance.stats_engine
@@ -149,41 +144,28 @@ module NewRelic
         # the frame so that we can check for it later, to maintain
         # sanity. If the frame stack becomes unbalanced, this
         # transaction loses meaning.
-        def trace_execution_scoped_header(options, t0=Time.now.to_f)
-          frame = log_errors("trace_execution_scoped header") do
-            NewRelic::Agent::TracedMethodStack.push_frame(:method_tracer, t0, options[:deduct_call_time_from_parent])
+        def trace_execution_scoped_header(state, t0)
+          log_errors(:trace_execution_scoped_header) do
+            stack = state.traced_method_stack
+            stack.push_frame(state, :method_tracer, t0)
           end
-          # needed in case we have an error, above, to always return
-          # the start time.
-          [t0, frame]
         end
 
-        def metrics_for_current_transaction(first_name, other_names, options)
+        def record_metrics(state, first_name, other_names, duration, exclusive, options)
           # The default value for :scoped_metric is true, so set it as true
           # if it was unset.
-          options[:scoped_metric] = true if options[:scoped_metric].nil?
-
-          metrics = []
-
-          if !options[:scoped_metric_only]
-            metrics += other_names.map { |n| NewRelic::MetricSpec.new(n) }
-          end
+          record_scoped_metric = options.has_key?(:scoped_metric) ? options[:scoped_metric] : true
 
           if options[:metric]
-            if !options[:scoped_metric_only]
-              metrics << NewRelic::MetricSpec.new(first_name)
-            end
-            if NewRelic::Agent::Transaction.in_transaction? && options[:scoped_metric]
-              metrics << NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
+            if record_scoped_metric
+              stat_engine.record_scoped_and_unscoped_metrics(state, first_name, other_names, duration, exclusive)
+            else
+              metrics = [first_name].concat(other_names)
+              stat_engine.record_unscoped_metrics(state, metrics, duration, exclusive)
             end
+          else
+            stat_engine.record_unscoped_metrics(state, other_names, duration, exclusive)
           end
-
-          metrics
-        end
-
-        def record_metrics(first_name, other_names, duration, exclusive, options)
-          metrics = metrics_for_current_transaction(first_name, other_names, options)
-          stat_engine.record_metrics_internal(metrics, duration, exclusive)
         end
 
         # Handles the end of the #trace_execution_scoped method -
@@ -194,13 +176,14 @@ module NewRelic
         # this method fails safely if the header does not manage to
         # push the scope onto the stack - it simply does not trace
         # any metrics.
-        def trace_execution_scoped_footer(t0, first_name, metric_names, expected_frame, options, t1=Time.now.to_f)
-          log_errors("trace_method_execution footer") do
+        def trace_execution_scoped_footer(state, t0, first_name, metric_names, expected_frame, options, t1=Time.now.to_f)
+          log_errors(:trace_method_execution_footer) do
             if expected_frame
-              frame = NewRelic::Agent::TracedMethodStack.pop_frame(expected_frame, first_name, t1)
+              stack = state.traced_method_stack
+              frame = stack.pop_frame(state, expected_frame, first_name, t1, !!options[:metric])
               duration = t1 - t0
               exclusive = duration - frame.children_time
-              record_metrics(first_name, metric_names, duration, exclusive, options)
+              record_metrics(state, first_name, metric_names, duration, exclusive, options)
             end
           end
         end
@@ -219,24 +202,25 @@ module NewRelic
       #
       # @api public
       #
-      def trace_execution_scoped(metric_names, options={})
-        return yield unless traced?
+      def trace_execution_scoped(metric_names, options={}) #THREAD_LOCAL_ACCESS
+        state = NewRelic::Agent::TransactionState.tl_get
+        return yield unless state.is_execution_traced?
 
         metric_names = Array(metric_names)
         first_name = metric_names.shift
         return yield if first_name.nil?
 
         set_if_nil(options, :metric)
-        set_if_nil(options, :deduct_call_time_from_parent)
         additional_metrics_callback = options[:additional_metrics_callback]
-        start_time, expected_scope = trace_execution_scoped_header(options)
+        start_time = Time.now.to_f
+        expected_scope = trace_execution_scoped_header(state, start_time)
 
         begin
           result = yield
           metric_names += Array(additional_metrics_callback.call) if additional_metrics_callback
           result
         ensure
-          trace_execution_scoped_footer(start_time, first_name, metric_names, expected_scope, options)
+          trace_execution_scoped_footer(state, start_time, first_name, metric_names, expected_scope, options)
         end
       end
 
@@ -245,9 +229,9 @@ module NewRelic
       module ClassMethods
         # contains methods refactored out of the #add_method_tracer method
         module AddMethodTracer
-          ALLOWED_KEYS = [:force, :metric, :push_scope, :deduct_call_time_from_parent, :code_header, :code_footer, :scoped_metric_only].freeze
+          ALLOWED_KEYS = [:force, :metric, :push_scope, :code_header, :code_footer].freeze
 
-          DEPRECATED_KEYS = [:force].freeze
+          DEPRECATED_KEYS = [:force, :scoped_metric_only, :deduct_call_time_from_parent].freeze
 
           # raises an error when the
           # NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer
@@ -268,16 +252,6 @@ module NewRelic
             end
           end
 
-          # Sets the options for deducting call time from
-          # parents. This defaults to true if we are recording a metric, but
-          # can be overridden by the user if desired.
-          #
-          # has the effect of not allowing overlapping times, and
-          # should generally be true
-          def set_deduct_call_time_based_on_metric(options)
-            {:deduct_call_time_from_parent => !!options[:metric]}.merge(options)
-          end
-
           # validity checking - add_method_tracer must receive either
           # push scope or metric, or else it would record no
           # data. Raises an error if this is the case
@@ -287,7 +261,7 @@ module NewRelic
             end
           end
 
-          DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => "", :scoped_metric_only => false}.freeze
+          DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => "" }.freeze
 
           # Checks the provided options to make sure that they make
           # sense. Raises an error if the options are incorrect to
@@ -298,7 +272,7 @@ module NewRelic
               raise TypeError.new("Error adding method tracer to #{method_name}: provided options must be a Hash")
             end
             check_for_illegal_keys!(method_name, options)
-            options = set_deduct_call_time_based_on_metric(DEFAULT_SETTINGS.merge(options))
+            options = DEFAULT_SETTINGS.merge(options)
             check_for_push_scope_and_metric(options)
             options
           end
@@ -335,7 +309,7 @@ module NewRelic
           # instrumentation into effectively one method call overhead
           # when the agent is disabled
           def assemble_code_header(method_name, metric_name_code, options)
-              header = "return #{_untraced_method_name(method_name, metric_name_code)}(*args, &block) unless NewRelic::Agent.is_execution_traced?\n"
+              header = "return #{_untraced_method_name(method_name, metric_name_code)}(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?\n"
 
               header += options[:code_header].to_s
 
@@ -385,9 +359,7 @@ module NewRelic
             "def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
               #{options[:code_header]}
               result = #{klass}.trace_execution_scoped(\"#{metric_name_code}\",
-                        :metric => #{options[:metric]},
-                        :deduct_call_time_from_parent => #{options[:deduct_call_time_from_parent]},
-                        :scoped_metric_only => #{options[:scoped_metric_only]}) do
+                        :metric => #{options[:metric]}) do
                 #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
               end
               #{options[:code_footer]}
@@ -412,7 +384,7 @@ module NewRelic
 
         # Add a method tracer to the specified method.
         #
-        # === Common Options
+        # === Options
         #
         # * <tt>:push_scope => false</tt> specifies this method tracer should not
         #   keep track of the caller; it will not show up in controller breakdown
@@ -423,18 +395,6 @@ module NewRelic
         #
         # === Uncommon Options
         #
-        # * <tt>:scoped_metric_only => true</tt> indicates that the unscoped metric
-        #   should not be recorded.  Normally two metrics are potentially created
-        #   on every invocation: the aggregate method where statistics for all calls
-        #   of that metric are stored, and the "scoped metric" which records the
-        #   statistics for invocations in a particular scope--generally a controller
-        #   action.  This option indicates that only the second type should be recorded.
-        #   The effect is similar to <tt>:metric => false</tt> but in addition you
-        #   will also see the invocation in breakdown pie charts.
-        # * <tt>:deduct_call_time_from_parent => false</tt> indicates that the method invocation
-        #   time should never be deducted from the time reported as 'exclusive' in the
-        #   caller.  You would want to use this if you are tracing a recursive method
-        #   or a method that might be called inside another traced method.
         # * <tt>:code_header</tt> and <tt>:code_footer</tt> specify ruby code that
         #   is inserted into the tracer before and after the call.
         #