newrelic_rpm 3.6.6.147 → 3.6.7.152

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

@@ -17,6 +17,8 @@ module NewRelic
             event.scope = NewRelic::Agent.instance.stats_engine \
               .push_scope(:action_view, event.time)
           end
+        rescue => e
+          log_notification_error(e, name, 'start')
         end
 
         def finish(name, id, payload)
@@ -27,6 +29,8 @@ module NewRelic
             NewRelic::Agent.instance.stats_engine \
               .pop_scope(event.scope, event.metric_name, event.end)
           end
+        rescue => e
+          log_notification_error(e, name, 'finish')
         end
 
         def record_metrics(event)

data/lib/new_relic/agent/instrumentation/{rails4/active_record.rb → active_record_4.rb}

@@ -4,7 +4,7 @@
 require 'new_relic/agent/instrumentation/active_record_subscriber'
 
 DependencyDetection.defer do
-  @name = :active_record
+  named :active_record_4
 
   depends_on do
     defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&

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

@@ -2,6 +2,7 @@
 # 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/active_record_helper'
+require 'new_relic/agent/instrumentation/evented_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActiveRecord query
 # events.  Write metric data, transaction trace segments and slow sql
@@ -9,22 +10,21 @@ require 'new_relic/agent/instrumentation/active_record_helper'
 module NewRelic
   module Agent
     module Instrumentation
-      class ActiveRecordSubscriber
-        include NewRelic::Agent::Instrumentation
-
-        def self.subscribed?
-          # TODO: need to talk to Rails core about an API for this,
-          # rather than digging through Listener ivars
-          ActiveSupport::Notifications.notifier.listeners_for('sql.active_record') \
-            .find{|l| l.instance_variable_get(:@delegate).class == self }
+      class ActiveRecordSubscriber < EventedSubscriber
+        def start(name, id, payload)
+          return unless NewRelic::Agent.is_execution_traced?
+          super
+        rescue => e
+          log_notification_error(e, name, 'start')
         end
 
-        def call(*args)
+        def finish(name, id, payload)
           return unless NewRelic::Agent.is_execution_traced?
-
-          event = ActiveSupport::Notifications::Event.new(*args)
+          event = pop_event(id)
           record_metrics(event)
           notice_sql(event)
+        rescue => e
+          log_notification_error(e, name, 'finish')
         end
 
         def get_explain_plan( config, query )

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

@@ -6,18 +6,20 @@ DependencyDetection.defer do
   @name = :authlogic
 
   depends_on do
-    defined?(AuthLogic) &&
-      defined?(AuthLogic::Session) &&
-      defined?(AuthLogic::Session::Base)
+    defined?(Authlogic) &&
+      defined?(Authlogic::Session) &&
+      defined?(Authlogic::Session::Base)
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing AuthLogic instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Authlogic instrumentation'
   end
 
   executes do
-    AuthLogic::Session::Base.class_eval do
-      add_method_tracer :find, 'Custom/Authlogic/find'
+    Authlogic::Session::Base.class_eval do
+      class << self
+        add_method_tracer :find, 'Custom/Authlogic/find'
+      end
     end
   end
 end

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

@@ -150,6 +150,14 @@ module NewRelic
             traced_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
             visibility = NewRelic::Helper.instance_method_visibility self, method
 
+            without_method_name = "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}"
+            with_method_name = "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}"
+
+            if NewRelic::Helper.instance_methods_include?(self, with_method_name)
+              ::NewRelic::Agent.logger.warn("Transaction tracer already in place for class = #{self.name}, method = #{method.to_s}, skipping")
+              return
+            end
+
             class_eval <<-EOC
               def #{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}(*args, &block)
                 perform_action_with_newrelic_trace(#{options_arg.join(',')}) do
@@ -157,8 +165,6 @@ module NewRelic
                  end
               end
             EOC
-            without_method_name = "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}"
-            with_method_name = "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}"
             alias_method without_method_name, method.to_s
             alias_method method.to_s, with_method_name
             send visibility, method
@@ -290,7 +296,7 @@ module NewRelic
         # path.  This form is deprecated.
         def perform_action_with_newrelic_trace(*args, &block)
           request = newrelic_request(args)
-          NewRelic::Agent::TransactionInfo.reset(request)
+          NewRelic::Agent::TransactionState.reset(request)
 
           # Skip instrumentation based on the value of 'do_not_trace' and if
           # we aren't calling directly with a block.
@@ -310,7 +316,7 @@ module NewRelic
             return yield if !(NewRelic::Agent.is_execution_traced? || options[:force])
             options[:metric] = true if options[:metric].nil?
             options[:deduct_call_time_from_parent] = true if options[:deduct_call_time_from_parent].nil?
-            _, expected_scope = NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped.trace_execution_scoped_header(options, txn.start_time.to_f)
+            _, expected_scope = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header(options, txn.start_time.to_f)
 
             begin
               NewRelic::Agent::BusyCalculator.dispatcher_start txn.start_time
@@ -337,12 +343,12 @@ module NewRelic
             metric_names = Array(recorded_metrics(txn))
             txn_name = metric_names.shift
 
-            NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped.trace_execution_scoped_footer(txn.start_time.to_f, txn_name, metric_names, expected_scope, options, end_time.to_f)
+            NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_footer(txn.start_time.to_f, txn_name, metric_names, expected_scope, options, end_time.to_f)
             NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
             txn.record_apdex(end_time) unless ignore_apdex?
             txn = Transaction.stop(txn_name, end_time)
 
-            NewRelic::Agent::TransactionInfo.get.ignore_end_user = true if ignore_enduser?
+            NewRelic::Agent::TransactionState.get.request_ignore_enduser = true if ignore_enduser?
           end
         end
 

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

@@ -73,9 +73,18 @@ DependencyDetection.defer do
 
       # We override this method in order to ensure access to header_str even
       # though we use an on_header callback
-      def header_str
-        self._nr_header_str
+      def header_str_with_newrelic
+        if self._nr_serial
+          self._nr_header_str
+        else
+          # Since we didn't install a header callback for a non-serial request,
+          # just fall back to the original implementation.
+          header_str_without_newrelic
+        end
       end
+
+      alias_method :header_str_without_newrelic, :header_str
+      alias_method :header_str, :header_str_with_newrelic
     end # class Curl::Easy
 
 

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

@@ -32,9 +32,7 @@ DependencyDetection.defer do
         if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job)
           ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
           install_newrelic_job_tracer
-
-          dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
-          NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+          NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
         else
           NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
         end

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

@@ -33,10 +33,19 @@ module NewRelic
           pop_event(id)
         end
 
+        def log_notification_error(error, name, event_type)
+          # These are important enough failures that we want the backtraces
+          # logged at error level, hence the explicit log_exception call.
+          NewRelic::Agent.logger.error("Error during #{event_type} callback for event '#{name}':")
+          NewRelic::Agent.logger.log_exception(:error, error)
+        end
+
         def push_event(event)
           parent = event_stack[event.transaction_id].last
-          event.parent = parent
-          parent << event if parent
+          if parent && event.respond_to?(:parent=)
+            event.parent = parent
+            parent << event
+          end
           event_stack[event.transaction_id].push event
         end
 

data/lib/new_relic/agent/instrumentation/excon/middleware.rb

@@ -5,15 +5,23 @@
 module ::Excon
   module Middleware
     class NewRelicCrossAppTracing
+      TRACE_DATA_IVAR = :@newrelic_trace_data
+
       def initialize(stack)
         @stack = stack
       end
 
       def request_call(datum)
         begin
-          wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
-          t0, segment = ::NewRelic::Agent::CrossAppTracing.start_trace(wrapped_request)
-          datum[:newrelic_trace_data] = [t0, segment, wrapped_request]
+          # Only instrument this request if we haven't already done so, because
+          # we can get request_call multiple times for requests marked as
+          # :idempotent in the options, but there will be only a single
+          # accompanying response_call/error_call.
+          if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
+            t0, segment = ::NewRelic::Agent::CrossAppTracing.start_trace(wrapped_request)
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, segment, wrapped_request])
+          end
         rescue => e
           NewRelic::Agent.logger.debug(e)
         end
@@ -31,8 +39,9 @@ module ::Excon
       end
 
       def finish_trace(datum)
-        trace_data = datum.delete(:newrelic_trace_data)
+        trace_data = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
         if trace_data
+          datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
           t0, segment, wrapped_request = trace_data
           if datum[:response]
             wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])

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

@@ -8,7 +8,8 @@ DependencyDetection.defer do
   depends_on do
     defined?(::Puma) &&
       defined?(::Puma::Const::VERSION) &&
-      NewRelic::VersionNumber.new(::Puma::Const::VERSION) > NewRelic::VersionNumber.new("2.0.0")
+      NewRelic::VersionNumber.new(::Puma::Const::VERSION) > NewRelic::VersionNumber.new("2.0.0") &&
+      ::Puma.respond_to?(:cli_config)
   end
 
   executes do

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

@@ -114,28 +114,26 @@ DependencyDetection.defer do
   end
 
   executes do
-    unless ::Rack::Builder.respond_to?(:_nr_deferred_detection_ran)
-      class ::Rack::Builder
+    class ::Rack::Builder
 
-        class << self
-          attr_accessor :_nr_deferred_detection_ran
-        end
-        self._nr_deferred_detection_ran = false
-
-        def to_app_with_newrelic_deferred_dependency_detection
-          unless Rack::Builder._nr_deferred_detection_ran
-            NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
-            DependencyDetection.detect!
-            Rack::Builder._nr_deferred_detection_ran = true
-          end
+      class << self
+        attr_accessor :_nr_deferred_detection_ran
+      end
+      self._nr_deferred_detection_ran = false
 
-          to_app_without_newrelic
+      def to_app_with_newrelic_deferred_dependency_detection
+        unless Rack::Builder._nr_deferred_detection_ran
+          NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
+          DependencyDetection.detect!
+          Rack::Builder._nr_deferred_detection_ran = true
         end
 
-        alias_method :to_app_without_newrelic, :to_app
-        alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
-
+        to_app_without_newrelic
       end
+
+      alias_method :to_app_without_newrelic, :to_app
+      alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
+
     end
   end
 end

data/lib/new_relic/agent/method_tracer.rb

@@ -41,240 +41,230 @@ module NewRelic
 
       def self.included clazz #:nodoc:
         clazz.extend ClassMethods
-        clazz.send :include, InstanceMethods
       end
 
       def self.extended clazz #:nodoc:
         clazz.extend ClassMethods
-        clazz.extend InstanceMethods
       end
 
-      # Defines modules used at instrumentation runtime, to do the
-      # actual tracing of time spent
-      module InstanceMethods
-        # Deprecated: original method preserved for API backward compatibility.
-        # Use either #trace_execution_scoped or #trace_execution_unscoped
-        def trace_method_execution(metric_names, push_scope, produce_metric, deduct_call_time_from_parent, &block) #:nodoc:
-          if push_scope
-            trace_execution_scoped(metric_names, :metric => produce_metric,
-                                   :deduct_call_time_from_parent => deduct_call_time_from_parent, &block)
-          else
-            trace_execution_unscoped(metric_names, &block)
-          end
+      # Deprecated: original method preserved for API backward compatibility.
+      # Use either #trace_execution_scoped or #trace_execution_unscoped
+      def trace_method_execution(metric_names, push_scope, produce_metric, deduct_call_time_from_parent, &block) #:nodoc:
+        if push_scope
+          trace_execution_scoped(metric_names, :metric => produce_metric,
+                                 :deduct_call_time_from_parent => deduct_call_time_from_parent, &block)
+        else
+          trace_execution_unscoped(metric_names, &block)
         end
+      end
 
-        # Trace a given block with stats assigned to the given metric_name.  It does not
-        # provide scoped measurements, meaning whatever is being traced will not 'blame the
-        # Controller'--that is to say appear in the breakdown chart.
-        # This is code is inlined in #add_method_tracer.
-        # * <tt>metric_names</tt> is a single name or an array of names of metrics
-        # * <tt>:force => true</tt> will force the metric to be captured even when
-        #   tracing is disabled with NewRelic::Agent#disable_all_tracing
-        #
-        def trace_execution_unscoped(metric_names, options={})
-          return yield unless NewRelic::Agent.is_execution_traced?
-          t0 = Time.now
-          begin
-            NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
-            yield
-          ensure
-            NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
-            duration = (Time.now - t0).to_f              # for some reason this is 3 usec faster than Time - Time
-            stat_engine.record_metrics(metric_names, duration)
-          end
+      # Trace a given block with stats assigned to the given metric_name.  It does not
+      # provide scoped measurements, meaning whatever is being traced will not 'blame the
+      # Controller'--that is to say appear in the breakdown chart.
+      # This is code is inlined in #add_method_tracer.
+      # * <tt>metric_names</tt> is a single name or an array of names of metrics
+      # * <tt>:force => true</tt> will force the metric to be captured even when
+      #   tracing is disabled with NewRelic::Agent#disable_all_tracing
+      #
+      def trace_execution_unscoped(metric_names, options={})
+        return yield unless NewRelic::Agent.is_execution_traced?
+        t0 = Time.now
+        begin
+          NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
+          yield
+        ensure
+          NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
+          duration = (Time.now - t0).to_f              # for some reason this is 3 usec faster than Time - Time
+          stat_engine.record_metrics(metric_names, duration)
         end
+      end
 
-        # Deprecated. Use #trace_execution_scoped, a version with an options hash.
-        def trace_method_execution_with_scope(metric_names, produce_metric, deduct_call_time_from_parent, scoped_metric_only=false, &block) #:nodoc:
-          trace_execution_scoped(metric_names,
-                                 :metric => produce_metric,
-                                 :deduct_call_time_from_parent => deduct_call_time_from_parent,
-                                 :scoped_metric_only => scoped_metric_only, &block)
-        end
+      # Deprecated. Use #trace_execution_scoped, a version with an options hash.
+      def trace_method_execution_with_scope(metric_names, produce_metric, deduct_call_time_from_parent, scoped_metric_only=false, &block) #:nodoc:
+        trace_execution_scoped(metric_names,
+                               :metric => produce_metric,
+                               :deduct_call_time_from_parent => deduct_call_time_from_parent,
+                               :scoped_metric_only => scoped_metric_only, &block)
+      end
 
-        alias trace_method_execution_no_scope trace_execution_unscoped #:nodoc:
+      alias trace_method_execution_no_scope trace_execution_unscoped #:nodoc:
 
-        # Refactored out of the previous trace_execution_scoped
-        # method, most methods in this module relate to code used in
-        # the #trace_execution_scoped method in this module
-        module TraceExecutionScoped
-          extend self
+      # Refactored out of the previous trace_execution_scoped
+      # method, most methods in this module relate to code used in
+      # the #trace_execution_scoped method in this module
+      module TraceExecutionScoped
+        extend self
 
-          # Shorthand to return the NewRelic::Agent.instance
-          def agent_instance
-            NewRelic::Agent.instance
-          end
+        # Shorthand to return the NewRelic::Agent.instance
+        def agent_instance
+          NewRelic::Agent.instance
+        end
 
-          # Shorthand to return the status of tracing
-          def traced?
-            NewRelic::Agent.is_execution_traced?
-          end
+        # Shorthand to return the status of tracing
+        def traced?
+          NewRelic::Agent.is_execution_traced?
+        end
 
-          # Tracing is disabled if we are not in a traced context and
-          # no force option is supplied
-          def trace_disabled?(options)
-            !(traced? || options[:force])
-          end
+        # Tracing is disabled if we are not in a traced context and
+        # no force option is supplied
+        def trace_disabled?(options)
+          !(traced? || options[:force])
+        end
 
-          # Shorthand to return the current statistics engine
-          def stat_engine
-            agent_instance.stats_engine
-          end
+        # Shorthand to return the current statistics engine
+        def stat_engine
+          agent_instance.stats_engine
+        end
 
-          # returns a scoped metric stat for the specified name
-          def get_stats_scoped(first_name, scoped_metric_only)
-            stat_engine.get_stats(first_name, true, scoped_metric_only)
-          end
-          # Shorthand method to get stats from the stat engine
-          def get_stats_unscoped(name)
-            stat_engine.get_stats_no_scope(name)
-          end
+        # returns a scoped metric stat for the specified name
+        def get_stats_scoped(first_name, scoped_metric_only)
+          stat_engine.get_stats(first_name, true, scoped_metric_only)
+        end
+        # Shorthand method to get stats from the stat engine
+        def get_stats_unscoped(name)
+          stat_engine.get_stats_no_scope(name)
+        end
 
-          # Helper for setting a hash key if the hash key is nil,
-          # instead of the default ||= behavior which sets if it is
-          # false as well
-          def set_if_nil(hash, key)
-            hash[key] = true if hash[key].nil?
-          end
+        # Helper for setting a hash key if the hash key is nil,
+        # instead of the default ||= behavior which sets if it is
+        # false as well
+        def set_if_nil(hash, key)
+          hash[key] = true if hash[key].nil?
+        end
 
-          # delegates to #agent_instance to push a trace execution
-          # flag, only if execution of this metric is forced.
-          #
-          # This causes everything scoped inside this metric to be
-          # recorded, even if the parent transaction is generally not.
-          def push_flag!(forced)
-            agent_instance.push_trace_execution_flag(true) if forced
-          end
+        # delegates to #agent_instance to push a trace execution
+        # flag, only if execution of this metric is forced.
+        #
+        # This causes everything scoped inside this metric to be
+        # recorded, even if the parent transaction is generally not.
+        def push_flag!(forced)
+          agent_instance.push_trace_execution_flag(true) if forced
+        end
 
-          # delegates to #agent_instance to pop the trace execution
-          # flag, only if execution of this metric is
-          # forced. otherwise this is taken care of for us
-          # automatically.
-          #
-          # This ends the forced recording of metrics within the
-          # #trace_execution_scoped block
-          def pop_flag!(forced)
-            agent_instance.pop_trace_execution_flag if forced
-          end
+        # delegates to #agent_instance to pop the trace execution
+        # flag, only if execution of this metric is
+        # forced. otherwise this is taken care of for us
+        # automatically.
+        #
+        # This ends the forced recording of metrics within the
+        # #trace_execution_scoped block
+        def pop_flag!(forced)
+          agent_instance.pop_trace_execution_flag if forced
+        end
 
-          # helper for logging errors to the newrelic_agent.log
-          # properly. Logs the error at error level
-          def log_errors(code_area)
-            yield
-          rescue => e
-            ::NewRelic::Agent.logger.error("Caught exception in #{code_area}.", e)
-          end
+        # helper for logging errors to the newrelic_agent.log
+        # properly. Logs the error at error level
+        def log_errors(code_area)
+          yield
+        rescue => e
+          ::NewRelic::Agent.logger.error("Caught exception in #{code_area}.", e)
+        end
 
-          # provides the header for our traced execution scoped
-          # method - gets the initial time, sets the tracing flag if
-          # needed, and pushes the scope onto the metric stack
-          # logs any errors that occur and returns the start time and
-          # the scope so that we can check for it later, to maintain
-          # sanity. If the scope stack becomes unbalanced, this
-          # transaction loses meaning.
-          def trace_execution_scoped_header(options, t0=Time.now.to_f)
-            scope = log_errors("trace_execution_scoped header") do
-              push_flag!(options[:force])
-              scope = stat_engine.push_scope(:method_tracer, t0, options[:deduct_call_time_from_parent])
-            end
-            # needed in case we have an error, above, to always return
-            # the start time.
-            [t0, scope]
-          end
+        # provides the header for our traced execution scoped
+        # method - gets the initial time, sets the tracing flag if
+        # needed, and pushes the scope onto the metric stack
+        # logs any errors that occur and returns the start time and
+        # the scope so that we can check for it later, to maintain
+        # sanity. If the scope stack becomes unbalanced, this
+        # transaction loses meaning.
+        def trace_execution_scoped_header(options, t0=Time.now.to_f)
+          scope = log_errors("trace_execution_scoped header") do
+            push_flag!(options[:force])
+            scope = stat_engine.push_scope(:method_tracer, t0, options[:deduct_call_time_from_parent])
+          end
+          # needed in case we have an error, above, to always return
+          # the start time.
+          [t0, scope]
+        end
 
-          def metrics_for_current_transaction(first_name, other_names, options)
-            metrics = []
+        def metrics_for_current_transaction(first_name, other_names, options)
+          metrics = []
 
+          if !options[:scoped_metric_only]
+            metrics += other_names.map { |n| NewRelic::MetricSpec.new(n) }
+          end
+
+          if options[:metric]
             if !options[:scoped_metric_only]
-              metrics += other_names.map { |n| NewRelic::MetricSpec.new(n) }
+              metrics << NewRelic::MetricSpec.new(first_name)
             end
-
-            if options[:metric]
-              if !options[:scoped_metric_only]
-                metrics << NewRelic::MetricSpec.new(first_name)
-              end
-              if in_transaction? && !options[:transaction]
-                metrics << NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
-              end
+            if NewRelic::Agent::Transaction.in_transaction? && !options[:transaction]
+              metrics << NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
             end
-
-            metrics
           end
 
-          def in_transaction?
-            NewRelic::Agent::Transaction.in_transaction?
-          end
+          metrics
+        end
 
-          def has_parent?
-            !NewRelic::Agent::Transaction.parent.nil?
-          end
+        def has_parent?
+          !NewRelic::Agent::Transaction.parent.nil?
+        end
 
-          def metrics_for_parent_transaction(first_name, options)
-            if has_parent? && options[:metric] && options[:transaction]
-              [NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)]
-            else
-              []
-            end
+        def metrics_for_parent_transaction(first_name, options)
+          if has_parent? && options[:metric] && options[:transaction]
+            [NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)]
+          else
+            []
           end
+        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)
+        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)
 
-            parent_metrics = metrics_for_parent_transaction(first_name, options)
-            parent_metrics.each do |metric|
-              parent_txn = NewRelic::Agent::Transaction.parent
-              parent_txn.stats_hash.record(metric, duration, exclusive)
-            end
+          parent_metrics = metrics_for_parent_transaction(first_name, options)
+          parent_metrics.each do |metric|
+            parent_txn = NewRelic::Agent::Transaction.parent
+            parent_txn.stats_hash.record(metric, duration, exclusive)
           end
+        end
 
-          # Handles the end of the #trace_execution_scoped method -
-          # calculating the time taken, popping the tracing flag if
-          # needed, deducting time taken by children, and tracing the
-          # subsidiary unscoped metrics if any
-          #
-          # 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_scope, options, t1=Time.now.to_f)
-            log_errors("trace_method_execution footer") do
-              pop_flag!(options[:force])
-              if expected_scope
-                scope = stat_engine.pop_scope(expected_scope, first_name, t1)
-                duration = t1 - t0
-                exclusive = duration - scope.children_time
-                record_metrics(first_name, metric_names, duration, exclusive, options)
-              end
+        # Handles the end of the #trace_execution_scoped method -
+        # calculating the time taken, popping the tracing flag if
+        # needed, deducting time taken by children, and tracing the
+        # subsidiary unscoped metrics if any
+        #
+        # 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_scope, options, t1=Time.now.to_f)
+          log_errors("trace_method_execution footer") do
+            pop_flag!(options[:force])
+            if expected_scope
+              scope = stat_engine.pop_scope(expected_scope, first_name, t1)
+              duration = t1 - t0
+              exclusive = duration - scope.children_time
+              record_metrics(first_name, metric_names, duration, exclusive, options)
             end
           end
+        end
 
-          # Trace a given block with stats and keep track of the caller.
-          # See NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer for a description of the arguments.
-          # +metric_names+ is either a single name or an array of metric names.
-          # If more than one metric is passed, the +produce_metric+ option only applies to the first.  The
-          # others are always recorded.  Only the first metric is pushed onto the scope stack.
-          #
-          # Generally you pass an array of metric names if you want to record the metric under additional
-          # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
-          # on the server.
-          def trace_execution_scoped(metric_names, options={})
-            return yield if trace_disabled?(options)
-            set_if_nil(options, :metric)
-            set_if_nil(options, :deduct_call_time_from_parent)
-            metric_names = Array(metric_names)
-            first_name = metric_names.shift
-            start_time, expected_scope = trace_execution_scoped_header(options)
-            begin
-              yield
-            ensure
-              trace_execution_scoped_footer(start_time, first_name, metric_names, expected_scope, options)
-            end
+        # Trace a given block with stats and keep track of the caller.
+        # See NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer for a description of the arguments.
+        # +metric_names+ is either a single name or an array of metric names.
+        # If more than one metric is passed, the +produce_metric+ option only applies to the first.  The
+        # others are always recorded.  Only the first metric is pushed onto the scope stack.
+        #
+        # Generally you pass an array of metric names if you want to record the metric under additional
+        # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
+        # on the server.
+        def trace_execution_scoped(metric_names, options={})
+          return yield if trace_disabled?(options)
+          set_if_nil(options, :metric)
+          set_if_nil(options, :deduct_call_time_from_parent)
+          metric_names = Array(metric_names)
+          first_name = metric_names.shift
+          start_time, expected_scope = trace_execution_scoped_header(options)
+          begin
+            yield
+          ensure
+            trace_execution_scoped_footer(start_time, first_name, metric_names, expected_scope, options)
           end
-
         end
-        include TraceExecutionScoped
 
       end
+      include TraceExecutionScoped
+
 
       # Defines methods used at the class level, for adding instrumentation
       module ClassMethods